awfull hack for numeric facets

packages/pagefind-instantsearch/src/adaptRequest.ts

@@ -1,17 +1,47 @@
 import { MultipleQueriesQuery } from "@algolia/client-search";
 import { Schema } from "./Facets";
+export type FacetsResponse = Record<string, Record<string, number>>;
+type NumericFilter = Record<string, { from?: number; to?: number }>;
 
 export function adaptRequest<S extends Schema>(
   request: MultipleQueriesQuery,
+  initialFacets: FacetsResponse,
   _schema?: S
 ) {
-  adaptNumericFilters(request.params?.numericFilters as any);
   return {
     sort: adaptSort(request.indexName),
-    filters: adaptFacetFilters(request.params?.facetFilters as any),
+    filters: {
+      ...adaptFacetFilters(request.params?.facetFilters as any),
+      ...mapNumericFilter(
+        adaptNumericFilters(request.params?.numericFilters as any),
+        initialFacets
+      ),
+    },
   };
 }
 
+// this is awfull hack, because there are no numeric filters in pagefind
+// I take all values from numeric facet and put in filter
+function mapNumericFilter(
+  filter: NumericFilter,
+  initialFacets: FacetsResponse
+) {
+  if (!initialFacets) return {};
+
+  return Object.keys(filter).reduce((acc, key) => {
+    acc[key] = {
+      any: Object.keys(initialFacets[key]).filter(
+        (x) =>
+          // @ts-ignore
+          (filter[key].from === undefined || x >= filter[key].from) &&
+          // @ts-ignore
+          (filter[key].to === undefined || x <= filter[key].to)
+      ),
+    };
+    return acc;
+  }, {} as Record<string, { any: any[] }>);
+}
+
 export function adaptSort(indexName?: string) {
   if (!indexName) return;
   const parts = indexName.split("_");
@@ -59,8 +89,7 @@ export function adaptFacetFilter(facet: string, filter: Record<string, any>) {
 export function adaptNumericFilters(
   numericFilters: string | string[] | string[][] | undefined
 ) {
-  const filter: Record<string, { from?: number; to?: number }> =
-    Object.create(null);
+  const filter: NumericFilter = Object.create(null);
 
   if (!numericFilters) return filter;
   if (typeof numericFilters === "string") {

packages/pagefind-instantsearch/src/index.ts

@@ -11,17 +11,18 @@ import { Schema as S } from "./Facets";
 export type Schema = S;
 
 import { adaptHit, adaptFacets } from "./adaptResponse";
-import { adaptRequest } from "./adaptRequest";
+import { FacetsResponse, adaptRequest } from "./adaptRequest";
 
 const isEmpty = (o: any) => !o || Object.keys(o).length === 0;
 
 export function getSearchClient<S extends Schema>(
   clientPromise: Promise<any>,
   schema: S
 ): SearchClient {
+  let initialFacets: Promise<FacetsResponse>;
   const indexPromise = clientPromise.then(async (pagefind) => {
     pagefind.init();
-    // pagefind.filters();
+    initialFacets = pagefind.filters();
     return pagefind;
   });
 
@@ -35,7 +36,7 @@ export function getSearchClient<S extends Schema>(
             requests.map(async (request) => {
               // need to pass null in order to filter without search
               const query = request.params?.query?.trim() || null;
-              const filters = adaptRequest(request);
+              const filters = adaptRequest(request, await initialFacets);
               const empty = isEmpty(filters.filters) && !query;
               Object.entries(schema).forEach(([key, field]) => {
                 if (!filters.filters[key] && field.facet) {
@@ -84,7 +85,7 @@ export function getSearchClient<S extends Schema>(
         Promise.all(
           requests.map(async (request) => {
             const query = request.params?.query?.trim() || null;
-            const filters = adaptRequest(request);
+            const filters = adaptRequest(request, await initialFacets);
             const empty = isEmpty(filters.filters) && !query;
             Object.entries(schema).forEach(([key, field]) => {
               if (!filters.filters[key] && field.facet) {