@findlane/browser 0.5.0 → 0.6.0

package/dist/index.js

@@ -20,7 +20,9 @@ export class SearchBrowserClient {
     async post(operation, request, signal) {
         const response = await this.fetcher(`${this.url}/${operation}`, {
             method: "POST",
-            headers: { "content-type": "application/json" },
+            // JSON as text/plain: browsers send it without asking the API first (a CORS preflight), which
+            // saves a round trip.
+            headers: { "content-type": "text/plain" },
             body: JSON.stringify(request),
             signal,
         });

package/dist/react/cache.d.ts

@@ -4,4 +4,6 @@ import type { SearchBrowserClient, SearchRequest, SearchResponse } from "../inde
 export declare function searchKey(request: SearchRequest): string;
 /** A cached response, if there's a recent one. */
 export declare function peek<T>(client: SearchBrowserClient, request: SearchRequest): SearchResponse<T> | null;
+/** The search's response: from memory, from the same search in flight, or a new request. A caller's
+ * signal stops its own wait; the request stops once every caller waiting for it has. */
 export declare function cachedSearch<T>(client: SearchBrowserClient, request: SearchRequest, signal?: AbortSignal): Promise<SearchResponse<T>>;

package/dist/react/cache.js

@@ -2,6 +2,7 @@ import { canonical } from "./state.js";
 const size = 50;
 const maxAge = 5 * 60_000;
 const caches = new WeakMap();
+const flights = new WeakMap();
 /** Requests the API answers the same way share a key, as at the edge (workers/api/src/edge.ts):
  * the query's first eight lowercase words, defaults left out, and list order ignored. */
 export function searchKey(request) {
@@ -24,19 +25,56 @@ export function peek(client, request) {
     const entry = caches.get(client)?.get(searchKey(request));
     return entry && Date.now() - entry.at < maxAge ? entry.response : null;
 }
-export async function cachedSearch(client, request, signal) {
+/** The search's response: from memory, from the same search in flight, or a new request. A caller's
+ * signal stops its own wait; the request stops once every caller waiting for it has. */
+export function cachedSearch(client, request, signal) {
     const found = peek(client, request);
     if (found)
-        return found;
-    const response = await client.search(request, { signal });
+        return Promise.resolve(found);
+    if (signal?.aborted)
+        return Promise.reject(signal.reason);
+    const key = searchKey(request);
+    let inFlight = flights.get(client);
+    if (!inFlight)
+        flights.set(client, (inFlight = new Map()));
+    let flight = inFlight.get(key);
+    if (!flight) {
+        const controller = new AbortController();
+        const started = {
+            controller,
+            waiting: 0,
+            response: client.search(request, { signal: controller.signal }).then((response) => {
+                remember(client, key, response);
+                return response;
+            }).finally(() => { if (inFlight.get(key) === started)
+                inFlight.delete(key); }),
+        };
+        inFlight.set(key, (flight = started));
+    }
+    const shared = flight;
+    shared.waiting++;
+    return new Promise((resolve, reject) => {
+        const leave = () => {
+            reject(signal.reason);
+            if (--shared.waiting > 0)
+                return;
+            // A later caller starts a new request rather than joining a stopped one.
+            if (inFlight.get(key) === shared)
+                inFlight.delete(key);
+            shared.controller.abort();
+        };
+        signal?.addEventListener("abort", leave, { once: true });
+        shared.response.then((response) => resolve(response), reject)
+            .finally(() => signal?.removeEventListener("abort", leave));
+    });
+}
+function remember(client, key, response) {
     let cache = caches.get(client);
     if (!cache)
         caches.set(client, (cache = new Map()));
-    const key = searchKey(request);
     cache.delete(key);
     cache.set(key, { at: Date.now(), response });
     // A Map keeps insertion order, so the first key is the oldest.
     if (cache.size > size)
         cache.delete(cache.keys().next().value);
-    return response;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@findlane/browser",
-  "version": "0.5.0",
+  "version": "0.6.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",