@findlane/browser 0.14.0 → 0.15.0

package/dist/index.d.ts

@@ -74,6 +74,9 @@ export type SearchResponse<T> = {
     totalRelation?: "eq" | "gte";
     hasMore?: boolean;
     facets: Record<string, Record<string, number>>;
+    /** True when the facet counts are estimates: on an index of 100,000 records or more, a search with more
+     * than 2,000 matches counts its facets on a sample of them, scaled to the total. */
+    facetsEstimated?: boolean;
     /** With `facetStats`: each field's smallest and largest value across the matches, without the field's
      * own filter. A field no match has is left out. */
     facetStats?: Record<string, {
@@ -170,6 +173,45 @@ export type RecommendationsResponse<T> = {
     /** What `together`'s counts are of. */
     togetherBasis?: "orders";
 };
+/** One of an index's lists, which its owner sets up in the dashboard: a row of products, such as Popular or
+ * New arrivals, from a filter and a sort, with products pinned first and others hidden; or a facet field's
+ * values with how many products each has, for a menu. `updatedAt` is when what the lists hold last changed. */
+export type ProductList<T = Record<string, unknown>> = {
+    id: string;
+    title: string;
+    kind: "products";
+    hits: {
+        id: string;
+        record: T;
+    }[];
+    /** The list's filters and sort, for a "See all" link to the same products as a search. */
+    browse: {
+        sort: string;
+        filters: Record<string, unknown>;
+    };
+    updatedAt: string;
+};
+export type ValueList = {
+    id: string;
+    title: string;
+    kind: "values";
+    /** The facet field the values are of. */
+    field: string;
+    values: {
+        value: string;
+        count: number;
+    }[];
+    browse: {
+        filters: Record<string, unknown>;
+    };
+    updatedAt: string;
+};
+export type List<T = Record<string, unknown>> = ProductList<T> | ValueList;
+export type ListOptions = {
+    /** At most this many products or values from each list (each list's own limit otherwise). */
+    limit?: number;
+    signal?: AbortSignal;
+};
 export declare class FindlaneError extends Error {
     status: number;
     constructor(status: number, message: string);
@@ -251,6 +293,7 @@ export declare class SearchBrowserClient {
     private popular;
     constructor(options: BrowserClientOptions);
     private post;
+    private get;
     search<T = Record<string, unknown>>(request: SearchRequest, options?: {
         signal?: AbortSignal;
     }): Promise<SearchResponse<T>>;
@@ -280,5 +323,12 @@ export declare class SearchBrowserClient {
     recommendations<T = Record<string, unknown>>(objectID: string, request?: RecommendationsRequest, options?: {
         signal?: AbortSignal;
     }): Promise<RecommendationsResponse<T>>;
+    /** One of the index's lists, by its ID: a row of products, such as Popular, or a facet field's values for
+     * a menu. Built ahead and answered from a cache near the shopper, so it isn't a search and isn't counted.
+     * Throws a FindlaneError with status 404 when the index has no such list. */
+    list<T = Record<string, unknown>>(id: string, options?: ListOptions): Promise<List<T>>;
+    /** Several of the index's lists in one request (up to 10), in the order asked; IDs the index has no list
+     * for are left out. Without IDs, all of its lists, in the owner's order. Not counted as searches. */
+    lists<T = Record<string, unknown>>(ids?: string[], options?: ListOptions): Promise<List<T>[]>;
 }
 export {};

package/dist/index.js

@@ -186,6 +186,15 @@ export class SearchBrowserClient {
             throw new FindlaneError(response.status, data.error ?? `HTTP ${response.status}`);
         return data;
     }
+    // Lists are read with GET, which browsers send without a preflight and may keep for 30 seconds.
+    async get(path, params, signal) {
+        const query = new URLSearchParams(params).toString();
+        const response = await this.fetcher(`${this.url}/${path}${query ? `?${query}` : ""}`, { method: "GET", signal });
+        const data = await response.json();
+        if (!response.ok)
+            throw new FindlaneError(response.status, data.error ?? `HTTP ${response.status}`);
+        return data;
+    }
     search(request, options = {}) {
         return this.post("search", request, options.signal);
     }
@@ -219,4 +228,16 @@ export class SearchBrowserClient {
     recommendations(objectID, request = {}, options = {}) {
         return this.post("recommendations", { objectID, ...request }, options.signal);
     }
+    /** One of the index's lists, by its ID: a row of products, such as Popular, or a facet field's values for
+     * a menu. Built ahead and answered from a cache near the shopper, so it isn't a search and isn't counted.
+     * Throws a FindlaneError with status 404 when the index has no such list. */
+    list(id, options = {}) {
+        return this.get(`lists/${encodeURIComponent(id)}`, options.limit ? { limit: String(options.limit) } : {}, options.signal);
+    }
+    /** Several of the index's lists in one request (up to 10), in the order asked; IDs the index has no list
+     * for are left out. Without IDs, all of its lists, in the owner's order. Not counted as searches. */
+    async lists(ids, options = {}) {
+        return (await this.get("lists", { ...(ids ? { ids: ids.join(",") } : {}),
+            ...(options.limit ? { limit: String(options.limit) } : {}) }, options.signal)).lists;
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@findlane/browser",
-  "version": "0.14.0",
+  "version": "0.15.0",
   "description": "Findlane browser SDK: fast, typo-tolerant public search from the browser with an index's public ID, plus React hooks and components.",
   "keywords": ["findlane", "search", "full-text search", "typo tolerance", "instant search", "ecommerce search", "browser", "react", "autocomplete"],
   "license": "MIT",