@cimplify/sdk 0.6.7 → 0.6.8

package/dist/react.js

@@ -713,6 +713,15 @@ function CimplifyCheckout({
 }
 
 // src/types/common.ts
+function money(value) {
+  return value;
+}
+function moneyFromNumber(value) {
+  return value.toFixed(2);
+}
+function currencyCode(value) {
+  return value;
+}
 var ErrorCode = {
   // General
   UNKNOWN_ERROR: "UNKNOWN_ERROR",
@@ -824,6 +833,11 @@ function err(error) {
   return { ok: false, error };
 }
 
+// src/query/builder.ts
+function escapeQueryValue(value) {
+  return value.replace(/'/g, "\\'");
+}
+
 // src/catalogue.ts
 function toCimplifyError(error) {
   if (error instanceof CimplifyError) return enrichError(error);
@@ -904,7 +918,7 @@ var CatalogueQueries = class {
     let query = "products";
     const filters = [];
     if (options?.category) {
-      filters.push(`@.category_id=='${options.category}'`);
+      filters.push(`@.category_id=='${escapeQueryValue(options.category)}'`);
     }
     if (options?.featured !== void 0) {
       filters.push(`@.featured==${options.featured}`);
@@ -913,7 +927,7 @@ var CatalogueQueries = class {
       filters.push(`@.in_stock==${options.in_stock}`);
     }
     if (options?.search) {
-      filters.push(`@.name contains '${options.search}'`);
+      filters.push(`@.name contains '${escapeQueryValue(options.search)}'`);
     }
     if (options?.min_price !== void 0) {
       filters.push(`@.price>=${options.min_price}`);
@@ -944,7 +958,9 @@ var CatalogueQueries = class {
   }
   async getProductBySlug(slug) {
     const filteredResult = await safe(
-      this.client.query(`products[?(@.slug=='${slug}')]`)
+      this.client.query(
+        `products[?(@.slug=='${escapeQueryValue(slug)}')]`
+      )
     );
     if (!filteredResult.ok) return filteredResult;
     const exactMatch = findProductBySlug(filteredResult.value, slug);
@@ -996,7 +1012,7 @@ var CatalogueQueries = class {
   }
   async getCategoryBySlug(slug) {
     const result = await safe(
-      this.client.query(`categories[?(@.slug=='${slug}')]`)
+      this.client.query(`categories[?(@.slug=='${escapeQueryValue(slug)}')]`)
     );
     if (!result.ok) return result;
     if (!result.value.length) {
@@ -1005,7 +1021,11 @@ var CatalogueQueries = class {
     return ok(result.value[0]);
   }
   async getCategoryProducts(categoryId) {
-    return safe(this.client.query(`products[?(@.category_id=='${categoryId}')]`));
+    return safe(
+      this.client.query(
+        `products[?(@.category_id=='${escapeQueryValue(categoryId)}')]`
+      )
+    );
   }
   async getCollections() {
     return safe(this.client.query("collections"));
@@ -1015,7 +1035,9 @@ var CatalogueQueries = class {
   }
   async getCollectionBySlug(slug) {
     const result = await safe(
-      this.client.query(`collections[?(@.slug=='${slug}')]`)
+      this.client.query(
+        `collections[?(@.slug=='${escapeQueryValue(slug)}')]`
+      )
     );
     if (!result.ok) return result;
     if (!result.value.length) {
@@ -1028,7 +1050,9 @@ var CatalogueQueries = class {
   }
   async searchCollections(query, limit = 20) {
     return safe(
-      this.client.query(`collections[?(@.name contains '${query}')]#limit(${limit})`)
+      this.client.query(
+        `collections[?(@.name contains '${escapeQueryValue(query)}')]#limit(${limit})`
+      )
     );
   }
   async getBundles() {
@@ -1039,7 +1063,9 @@ var CatalogueQueries = class {
   }
   async getBundleBySlug(slug) {
     const result = await safe(
-      this.client.query(`bundles[?(@.slug=='${slug}')]`)
+      this.client.query(
+        `bundles[?(@.slug=='${escapeQueryValue(slug)}')]`
+      )
     );
     if (!result.ok) return result;
     if (!result.value.length) {
@@ -1049,7 +1075,9 @@ var CatalogueQueries = class {
   }
   async searchBundles(query, limit = 20) {
     return safe(
-      this.client.query(`bundles[?(@.name contains '${query}')]#limit(${limit})`)
+      this.client.query(
+        `bundles[?(@.name contains '${escapeQueryValue(query)}')]#limit(${limit})`
+      )
     );
   }
   async getComposites(options) {
@@ -1089,9 +1117,9 @@ var CatalogueQueries = class {
   }
   async search(query, options) {
     const limit = options?.limit ?? 20;
-    let searchQuery = `products[?(@.name contains '${query}')]`;
+    let searchQuery = `products[?(@.name contains '${escapeQueryValue(query)}')]`;
     if (options?.category) {
-      searchQuery = `products[?(@.name contains '${query}' && @.category_id=='${options.category}')]`;
+      searchQuery = `products[?(@.name contains '${escapeQueryValue(query)}' && @.category_id=='${escapeQueryValue(options.category)}')]`;
     }
     searchQuery += `#limit(${limit})`;
     return safe(this.client.query(searchQuery));
@@ -1108,7 +1136,7 @@ var CatalogueQueries = class {
   async getMenu(options) {
     let query = "menu";
     if (options?.category) {
-      query = `menu[?(@.category=='${options.category}')]`;
+      query = `menu[?(@.category=='${escapeQueryValue(options.category)}')]`;
     }
     if (options?.limit) {
       query += `#limit(${options.limit})`;
@@ -1402,6 +1430,8 @@ function normalizeStatusResponse(response) {
   }
   const res = response;
   const normalizedStatus = normalizePaymentStatusValue(res.status ?? void 0);
+  const normalizedAmount = typeof res.amount === "string" ? money(res.amount) : typeof res.amount === "number" && Number.isFinite(res.amount) ? moneyFromNumber(res.amount) : void 0;
+  const normalizedCurrency = typeof res.currency === "string" && res.currency.trim().length > 0 ? currencyCode(res.currency) : void 0;
   const paidValue = res.paid === true;
   const derivedPaid = paidValue || [
     "success",
@@ -1414,8 +1444,8 @@ function normalizeStatusResponse(response) {
   return {
     status: normalizedStatus,
     paid: derivedPaid,
-    amount: res.amount,
-    currency: res.currency,
+    amount: normalizedAmount,
+    currency: normalizedCurrency,
     reference: res.reference,
     message: res.message || ""
   };
@@ -2107,14 +2137,17 @@ var CheckoutService = class {
       pay_currency: data.pay_currency,
       fx_quote_id: data.fx_quote_id
     };
-    const baseCurrency = (cart.pricing.currency || checkoutData.pay_currency || "GHS").toUpperCase();
+    const baseCurrency = currencyCode(
+      (cart.pricing.currency || checkoutData.pay_currency || "GHS").toUpperCase()
+    );
     const payCurrency = data.pay_currency?.trim().toUpperCase();
+    const payCurrencyCode = payCurrency ? currencyCode(payCurrency) : void 0;
     const cartTotalAmount = Number.parseFloat(cart.pricing.total_price || "0");
-    if (payCurrency && payCurrency !== baseCurrency && !checkoutData.fx_quote_id && Number.isFinite(cartTotalAmount) && cartTotalAmount > 0) {
+    if (payCurrencyCode && payCurrencyCode !== baseCurrency && !checkoutData.fx_quote_id && Number.isFinite(cartTotalAmount) && cartTotalAmount > 0) {
       const fxQuoteResult = await this.client.fx.lockQuote({
         from: baseCurrency,
-        to: payCurrency,
-        amount: cartTotalAmount
+        to: payCurrencyCode,
+        amount: cart.pricing.total_price
       });
       if (!fxQuoteResult.ok) {
         return ok(
@@ -2125,7 +2158,7 @@ var CheckoutService = class {
           )
         );
       }
-      checkoutData.pay_currency = payCurrency;
+      checkoutData.pay_currency = payCurrencyCode;
       checkoutData.fx_quote_id = fxQuoteResult.value.id;
     }
     data.on_status_change?.("processing", {});
@@ -3576,7 +3609,7 @@ var CimplifyClient = class {
           signal: controller.signal
         });
         clearTimeout(timeoutId);
-        if (response.ok || response.status >= 400 && response.status < 500) {
+        if (response.ok) {
           this.hooks.onRequestSuccess?.({
             ...context,
             status: response.status,
@@ -3584,6 +3617,21 @@ var CimplifyClient = class {
           });
           return response;
         }
+        if (response.status >= 400 && response.status < 500) {
+          this.hooks.onRequestError?.({
+            ...context,
+            error: new CimplifyError(
+              `HTTP_${response.status}`,
+              `Request failed with status ${response.status}`,
+              false
+            ),
+            status: response.status,
+            durationMs: Date.now() - startTime,
+            retryCount,
+            retryable: false
+          });
+          return response;
+        }
         if (response.status >= 500 && attempt < this.maxRetries) {
           retryCount++;
           const delay = this.retryDelay * Math.pow(2, attempt);
@@ -3596,10 +3644,17 @@ var CimplifyClient = class {
           await sleep(delay);
           continue;
         }
-        this.hooks.onRequestSuccess?.({
+        this.hooks.onRequestError?.({
           ...context,
+          error: new CimplifyError(
+            "SERVER_ERROR",
+            `Server error ${response.status} after ${retryCount} retries`,
+            false
+          ),
           status: response.status,
-          durationMs: Date.now() - startTime
+          durationMs: Date.now() - startTime,
+          retryCount,
+          retryable: false
         });
         return response;
       } catch (error) {
@@ -5085,6 +5140,750 @@ function useLocations(options = {}) {
     isLoading
   };
 }
+var collectionsCache = /* @__PURE__ */ new Map();
+var collectionsInflight = /* @__PURE__ */ new Map();
+function buildCollectionsCacheKey(client, locationId) {
+  return JSON.stringify({
+    key: client.getPublicKey(),
+    location_id: locationId || "__none__"
+  });
+}
+function useCollections(options = {}) {
+  const context = useOptionalCimplify();
+  const client = options.client ?? context?.client;
+  if (!client) {
+    throw new Error("useCollections must be used within CimplifyProvider or passed { client }.");
+  }
+  const enabled = options.enabled ?? true;
+  const locationId = client.getLocationId();
+  const previousLocationIdRef = react.useRef(locationId);
+  const requestIdRef = react.useRef(0);
+  const cacheKey = react.useMemo(
+    () => buildCollectionsCacheKey(client, locationId),
+    [client, locationId]
+  );
+  const cached = collectionsCache.get(cacheKey);
+  const [collections, setCollections] = react.useState(cached?.collections ?? []);
+  const [isLoading, setIsLoading] = react.useState(enabled && !cached);
+  const [error, setError] = react.useState(null);
+  react.useEffect(() => {
+    if (previousLocationIdRef.current !== locationId) {
+      collectionsCache.clear();
+      collectionsInflight.clear();
+      previousLocationIdRef.current = locationId;
+    }
+  }, [locationId]);
+  const load = react.useCallback(
+    async (force = false) => {
+      if (!enabled) {
+        setIsLoading(false);
+        return;
+      }
+      const nextRequestId = ++requestIdRef.current;
+      setError(null);
+      if (!force) {
+        const cacheEntry = collectionsCache.get(cacheKey);
+        if (cacheEntry) {
+          setCollections(cacheEntry.collections);
+          setIsLoading(false);
+          return;
+        }
+      }
+      setIsLoading(true);
+      try {
+        const existing = collectionsInflight.get(cacheKey);
+        const promise = existing ?? (async () => {
+          const result = await client.catalogue.getCollections();
+          if (!result.ok) {
+            throw result.error;
+          }
+          return result.value;
+        })();
+        if (!existing) {
+          collectionsInflight.set(cacheKey, promise);
+          promise.finally(() => {
+            collectionsInflight.delete(cacheKey);
+          }).catch(() => void 0);
+        }
+        const value = await promise;
+        collectionsCache.set(cacheKey, { collections: value });
+        if (nextRequestId === requestIdRef.current) {
+          setCollections(value);
+          setError(null);
+        }
+      } catch (loadError) {
+        if (nextRequestId === requestIdRef.current) {
+          setError(loadError);
+        }
+      } finally {
+        if (nextRequestId === requestIdRef.current) {
+          setIsLoading(false);
+        }
+      }
+    },
+    [cacheKey, client, enabled]
+  );
+  react.useEffect(() => {
+    void load(false);
+  }, [load]);
+  const refetch = react.useCallback(async () => {
+    collectionsCache.delete(cacheKey);
+    await load(true);
+  }, [cacheKey, load]);
+  return { collections, isLoading, error, refetch };
+}
+var collectionCache = /* @__PURE__ */ new Map();
+var collectionInflight = /* @__PURE__ */ new Map();
+function isLikelySlug2(value) {
+  return /^[a-z0-9-]+$/.test(value);
+}
+function buildCollectionCacheKey(client, locationId, idOrSlug) {
+  return JSON.stringify({
+    key: client.getPublicKey(),
+    location_id: locationId || "__none__",
+    collection: idOrSlug
+  });
+}
+function useCollection(idOrSlug, options = {}) {
+  const context = useOptionalCimplify();
+  const client = options.client ?? context?.client;
+  if (!client) {
+    throw new Error("useCollection must be used within CimplifyProvider or passed { client }.");
+  }
+  const enabled = options.enabled ?? true;
+  const locationId = client.getLocationId();
+  const previousLocationIdRef = react.useRef(locationId);
+  const requestIdRef = react.useRef(0);
+  const normalizedIdOrSlug = react.useMemo(() => (idOrSlug || "").trim(), [idOrSlug]);
+  const cacheKey = react.useMemo(
+    () => buildCollectionCacheKey(client, locationId, normalizedIdOrSlug),
+    [client, locationId, normalizedIdOrSlug]
+  );
+  const cached = collectionCache.get(cacheKey);
+  const [collection, setCollection] = react.useState(cached?.collection ?? null);
+  const [products, setProducts] = react.useState(cached?.products ?? []);
+  const [isLoading, setIsLoading] = react.useState(
+    enabled && normalizedIdOrSlug.length > 0 && !cached
+  );
+  const [error, setError] = react.useState(null);
+  react.useEffect(() => {
+    if (previousLocationIdRef.current !== locationId) {
+      collectionCache.clear();
+      collectionInflight.clear();
+      previousLocationIdRef.current = locationId;
+    }
+  }, [locationId]);
+  const load = react.useCallback(
+    async (force = false) => {
+      if (!enabled || normalizedIdOrSlug.length === 0) {
+        setCollection(null);
+        setProducts([]);
+        setIsLoading(false);
+        return;
+      }
+      const nextRequestId = ++requestIdRef.current;
+      setError(null);
+      if (!force) {
+        const cacheEntry = collectionCache.get(cacheKey);
+        if (cacheEntry) {
+          setCollection(cacheEntry.collection);
+          setProducts(cacheEntry.products);
+          setIsLoading(false);
+          return;
+        }
+      }
+      setIsLoading(true);
+      try {
+        const existing = collectionInflight.get(cacheKey);
+        const promise = existing ?? (async () => {
+          const collectionResult = isLikelySlug2(normalizedIdOrSlug) ? await client.catalogue.getCollectionBySlug(normalizedIdOrSlug) : await client.catalogue.getCollection(normalizedIdOrSlug);
+          if (!collectionResult.ok) {
+            throw collectionResult.error;
+          }
+          const productsResult = await client.catalogue.getCollectionProducts(
+            collectionResult.value.id
+          );
+          if (!productsResult.ok) {
+            throw productsResult.error;
+          }
+          return {
+            collection: collectionResult.value,
+            products: productsResult.value
+          };
+        })();
+        if (!existing) {
+          collectionInflight.set(cacheKey, promise);
+          promise.finally(() => {
+            collectionInflight.delete(cacheKey);
+          }).catch(() => void 0);
+        }
+        const value = await promise;
+        collectionCache.set(cacheKey, value);
+        if (nextRequestId === requestIdRef.current) {
+          setCollection(value.collection);
+          setProducts(value.products);
+          setError(null);
+        }
+      } catch (loadError) {
+        if (nextRequestId === requestIdRef.current) {
+          setError(loadError);
+        }
+      } finally {
+        if (nextRequestId === requestIdRef.current) {
+          setIsLoading(false);
+        }
+      }
+    },
+    [cacheKey, client, enabled, normalizedIdOrSlug]
+  );
+  react.useEffect(() => {
+    void load(false);
+  }, [load]);
+  const refetch = react.useCallback(async () => {
+    collectionCache.delete(cacheKey);
+    await load(true);
+  }, [cacheKey, load]);
+  return { collection, products, isLoading, error, refetch };
+}
+var bundleCache = /* @__PURE__ */ new Map();
+var bundleInflight = /* @__PURE__ */ new Map();
+function isLikelySlug3(value) {
+  return /^[a-z0-9-]+$/.test(value);
+}
+function buildBundleCacheKey(client, locationId, idOrSlug) {
+  return JSON.stringify({
+    key: client.getPublicKey(),
+    location_id: locationId || "__none__",
+    bundle: idOrSlug
+  });
+}
+function useBundle(idOrSlug, options = {}) {
+  const context = useOptionalCimplify();
+  const client = options.client ?? context?.client;
+  if (!client) {
+    throw new Error("useBundle must be used within CimplifyProvider or passed { client }.");
+  }
+  const enabled = options.enabled ?? true;
+  const locationId = client.getLocationId();
+  const previousLocationIdRef = react.useRef(locationId);
+  const requestIdRef = react.useRef(0);
+  const normalizedIdOrSlug = react.useMemo(() => (idOrSlug || "").trim(), [idOrSlug]);
+  const cacheKey = react.useMemo(
+    () => buildBundleCacheKey(client, locationId, normalizedIdOrSlug),
+    [client, locationId, normalizedIdOrSlug]
+  );
+  const cached = bundleCache.get(cacheKey);
+  const [bundle, setBundle] = react.useState(cached?.bundle ?? null);
+  const [isLoading, setIsLoading] = react.useState(
+    enabled && normalizedIdOrSlug.length > 0 && !cached
+  );
+  const [error, setError] = react.useState(null);
+  react.useEffect(() => {
+    if (previousLocationIdRef.current !== locationId) {
+      bundleCache.clear();
+      bundleInflight.clear();
+      previousLocationIdRef.current = locationId;
+    }
+  }, [locationId]);
+  const load = react.useCallback(
+    async (force = false) => {
+      if (!enabled || normalizedIdOrSlug.length === 0) {
+        setBundle(null);
+        setIsLoading(false);
+        return;
+      }
+      const nextRequestId = ++requestIdRef.current;
+      setError(null);
+      if (!force) {
+        const cacheEntry = bundleCache.get(cacheKey);
+        if (cacheEntry) {
+          setBundle(cacheEntry.bundle);
+          setIsLoading(false);
+          return;
+        }
+      }
+      setIsLoading(true);
+      try {
+        const existing = bundleInflight.get(cacheKey);
+        const promise = existing ?? (async () => {
+          const result = isLikelySlug3(normalizedIdOrSlug) ? await client.catalogue.getBundleBySlug(normalizedIdOrSlug) : await client.catalogue.getBundle(normalizedIdOrSlug);
+          if (!result.ok) {
+            throw result.error;
+          }
+          return result.value;
+        })();
+        if (!existing) {
+          bundleInflight.set(cacheKey, promise);
+          promise.finally(() => {
+            bundleInflight.delete(cacheKey);
+          }).catch(() => void 0);
+        }
+        const value = await promise;
+        bundleCache.set(cacheKey, { bundle: value });
+        if (nextRequestId === requestIdRef.current) {
+          setBundle(value);
+          setError(null);
+        }
+      } catch (loadError) {
+        if (nextRequestId === requestIdRef.current) {
+          setError(loadError);
+        }
+      } finally {
+        if (nextRequestId === requestIdRef.current) {
+          setIsLoading(false);
+        }
+      }
+    },
+    [cacheKey, client, enabled, normalizedIdOrSlug]
+  );
+  react.useEffect(() => {
+    void load(false);
+  }, [load]);
+  const refetch = react.useCallback(async () => {
+    bundleCache.delete(cacheKey);
+    await load(true);
+  }, [cacheKey, load]);
+  return { bundle, isLoading, error, refetch };
+}
+var compositeCache = /* @__PURE__ */ new Map();
+var compositeInflight = /* @__PURE__ */ new Map();
+function shouldFetchByProductId(idOrProductId, byProductId) {
+  if (typeof byProductId === "boolean") {
+    return byProductId;
+  }
+  return idOrProductId.startsWith("prod_");
+}
+function buildCompositeCacheKey(client, locationId, idOrProductId, byProductId) {
+  return JSON.stringify({
+    key: client.getPublicKey(),
+    location_id: locationId || "__none__",
+    composite: idOrProductId,
+    by_product_id: byProductId
+  });
+}
+function useComposite(idOrProductId, options = {}) {
+  const context = useOptionalCimplify();
+  const client = options.client ?? context?.client;
+  if (!client) {
+    throw new Error("useComposite must be used within CimplifyProvider or passed { client }.");
+  }
+  const enabled = options.enabled ?? true;
+  const locationId = client.getLocationId();
+  const previousLocationIdRef = react.useRef(locationId);
+  const requestIdRef = react.useRef(0);
+  const priceRequestIdRef = react.useRef(0);
+  const normalizedIdOrProductId = react.useMemo(
+    () => (idOrProductId || "").trim(),
+    [idOrProductId]
+  );
+  const byProductId = react.useMemo(
+    () => shouldFetchByProductId(normalizedIdOrProductId, options.byProductId),
+    [normalizedIdOrProductId, options.byProductId]
+  );
+  const cacheKey = react.useMemo(
+    () => buildCompositeCacheKey(client, locationId, normalizedIdOrProductId, byProductId),
+    [byProductId, client, locationId, normalizedIdOrProductId]
+  );
+  const cached = compositeCache.get(cacheKey);
+  const [composite, setComposite] = react.useState(cached?.composite ?? null);
+  const [isLoading, setIsLoading] = react.useState(
+    enabled && normalizedIdOrProductId.length > 0 && !cached
+  );
+  const [error, setError] = react.useState(null);
+  const [priceResult, setPriceResult] = react.useState(null);
+  const [isPriceLoading, setIsPriceLoading] = react.useState(false);
+  react.useEffect(() => {
+    if (previousLocationIdRef.current !== locationId) {
+      compositeCache.clear();
+      compositeInflight.clear();
+      previousLocationIdRef.current = locationId;
+    }
+  }, [locationId]);
+  const load = react.useCallback(
+    async (force = false) => {
+      if (!enabled || normalizedIdOrProductId.length === 0) {
+        setComposite(null);
+        setPriceResult(null);
+        setIsLoading(false);
+        return;
+      }
+      const nextRequestId = ++requestIdRef.current;
+      setError(null);
+      if (!force) {
+        const cacheEntry = compositeCache.get(cacheKey);
+        if (cacheEntry) {
+          setComposite(cacheEntry.composite);
+          setIsLoading(false);
+          return;
+        }
+      }
+      setIsLoading(true);
+      try {
+        const existing = compositeInflight.get(cacheKey);
+        const promise = existing ?? (async () => {
+          const result = byProductId ? await client.catalogue.getCompositeByProductId(normalizedIdOrProductId) : await client.catalogue.getComposite(normalizedIdOrProductId);
+          if (!result.ok) {
+            throw result.error;
+          }
+          return result.value;
+        })();
+        if (!existing) {
+          compositeInflight.set(cacheKey, promise);
+          promise.finally(() => {
+            compositeInflight.delete(cacheKey);
+          }).catch(() => void 0);
+        }
+        const value = await promise;
+        compositeCache.set(cacheKey, { composite: value });
+        if (nextRequestId === requestIdRef.current) {
+          setComposite(value);
+          setPriceResult(null);
+          setError(null);
+        }
+      } catch (loadError) {
+        if (nextRequestId === requestIdRef.current) {
+          setError(loadError);
+        }
+      } finally {
+        if (nextRequestId === requestIdRef.current) {
+          setIsLoading(false);
+        }
+      }
+    },
+    [byProductId, cacheKey, client, enabled, normalizedIdOrProductId]
+  );
+  react.useEffect(() => {
+    void load(false);
+  }, [load]);
+  const calculatePrice = react.useCallback(
+    async (selections, overrideLocationId) => {
+      if (!composite) {
+        return null;
+      }
+      const nextRequestId = ++priceRequestIdRef.current;
+      setIsPriceLoading(true);
+      try {
+        const result = await client.catalogue.calculateCompositePrice(
+          composite.id,
+          selections,
+          overrideLocationId
+        );
+        if (!result.ok) {
+          throw result.error;
+        }
+        if (nextRequestId === priceRequestIdRef.current) {
+          setPriceResult(result.value);
+          setError(null);
+        }
+        return result.value;
+      } catch (loadError) {
+        if (nextRequestId === priceRequestIdRef.current) {
+          setError(loadError);
+        }
+        return null;
+      } finally {
+        if (nextRequestId === priceRequestIdRef.current) {
+          setIsPriceLoading(false);
+        }
+      }
+    },
+    [client, composite]
+  );
+  const refetch = react.useCallback(async () => {
+    compositeCache.delete(cacheKey);
+    await load(true);
+  }, [cacheKey, load]);
+  return { composite, isLoading, error, refetch, calculatePrice, priceResult, isPriceLoading };
+}
+function useSearch(options = {}) {
+  const context = useOptionalCimplify();
+  const client = options.client ?? context?.client;
+  if (!client) {
+    throw new Error("useSearch must be used within CimplifyProvider or passed { client }.");
+  }
+  const minLength = Math.max(0, options.minLength ?? 2);
+  const debounceMs = Math.max(0, options.debounceMs ?? 300);
+  const limit = Math.max(1, options.limit ?? 20);
+  const [query, setQueryState] = react.useState("");
+  const [results, setResults] = react.useState([]);
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const requestIdRef = react.useRef(0);
+  const timerRef = react.useRef(null);
+  react.useEffect(() => {
+    if (timerRef.current) {
+      clearTimeout(timerRef.current);
+      timerRef.current = null;
+    }
+    const trimmedQuery = query.trim();
+    if (trimmedQuery.length < minLength) {
+      setResults([]);
+      setError(null);
+      setIsLoading(false);
+      return;
+    }
+    const nextRequestId = ++requestIdRef.current;
+    setError(null);
+    setIsLoading(true);
+    timerRef.current = setTimeout(() => {
+      void (async () => {
+        try {
+          const result = await client.catalogue.searchProducts(trimmedQuery, {
+            limit,
+            category: options.category
+          });
+          if (!result.ok) {
+            throw result.error;
+          }
+          if (nextRequestId === requestIdRef.current) {
+            setResults(result.value);
+            setError(null);
+          }
+        } catch (loadError) {
+          if (nextRequestId === requestIdRef.current) {
+            setError(loadError);
+          }
+        } finally {
+          if (nextRequestId === requestIdRef.current) {
+            setIsLoading(false);
+          }
+        }
+      })();
+    }, debounceMs);
+    return () => {
+      if (timerRef.current) {
+        clearTimeout(timerRef.current);
+        timerRef.current = null;
+      }
+    };
+  }, [client, debounceMs, limit, minLength, options.category, query]);
+  const setQuery = react.useCallback((nextQuery) => {
+    setQueryState(nextQuery);
+  }, []);
+  const clear = react.useCallback(() => {
+    requestIdRef.current += 1;
+    if (timerRef.current) {
+      clearTimeout(timerRef.current);
+      timerRef.current = null;
+    }
+    setQueryState("");
+    setResults([]);
+    setError(null);
+    setIsLoading(false);
+  }, []);
+  return { results, isLoading, error, query, setQuery, clear };
+}
+var quoteCache = /* @__PURE__ */ new Map();
+var quoteInflight = /* @__PURE__ */ new Map();
+function buildQuoteCacheKey(client, locationId, inputSignature) {
+  return JSON.stringify({
+    key: client.getPublicKey(),
+    location_id: locationId || "__none__",
+    input: inputSignature
+  });
+}
+function isQuoteExpired(quote) {
+  if (!quote?.expires_at) {
+    return false;
+  }
+  const expiresAt = Date.parse(quote.expires_at);
+  if (!Number.isFinite(expiresAt)) {
+    return false;
+  }
+  return expiresAt <= Date.now();
+}
+function normalizeInput(input, fallbackLocationId) {
+  const productId = input.productId.trim();
+  const variantId = input.variantId?.trim();
+  const locationId = input.locationId?.trim() || fallbackLocationId || void 0;
+  return {
+    product_id: productId,
+    variant_id: variantId && variantId.length > 0 ? variantId : void 0,
+    location_id: locationId && locationId.length > 0 ? locationId : void 0,
+    quantity: input.quantity,
+    add_on_option_ids: input.addOnOptionIds,
+    bundle_selections: input.bundleSelections,
+    composite_selections: input.compositeSelections
+  };
+}
+function useQuote(input, options = {}) {
+  const context = useOptionalCimplify();
+  const client = options.client ?? context?.client;
+  if (!client) {
+    throw new Error("useQuote must be used within CimplifyProvider or passed { client }.");
+  }
+  const enabled = options.enabled ?? true;
+  const autoRefresh = options.autoRefresh ?? true;
+  const refreshBeforeExpiryMs = Math.max(0, options.refreshBeforeExpiryMs ?? 3e4);
+  const locationId = client.getLocationId();
+  const requestIdRef = react.useRef(0);
+  const refreshTimerRef = react.useRef(null);
+  const expiryTimerRef = react.useRef(null);
+  const inputSignature = react.useMemo(() => JSON.stringify(input ?? null), [input]);
+  const normalizedInput = react.useMemo(() => {
+    if (!input) {
+      return null;
+    }
+    const normalized = normalizeInput(input, locationId);
+    return normalized.product_id.length > 0 ? normalized : null;
+  }, [inputSignature, locationId]);
+  const cacheKey = react.useMemo(
+    () => buildQuoteCacheKey(client, locationId, inputSignature),
+    [client, inputSignature, locationId]
+  );
+  const cached = quoteCache.get(cacheKey);
+  const [quote, setQuote] = react.useState(cached?.quote ?? null);
+  const [isLoading, setIsLoading] = react.useState(enabled && normalizedInput !== null && !cached);
+  const [error, setError] = react.useState(null);
+  const [isExpired, setIsExpired] = react.useState(isQuoteExpired(cached?.quote ?? null));
+  const [messages, setMessages] = react.useState(cached?.quote?.ui_messages ?? []);
+  const load = react.useCallback(
+    async (force = false) => {
+      if (!enabled || !normalizedInput) {
+        setQuote(null);
+        setMessages([]);
+        setIsExpired(false);
+        setError(null);
+        setIsLoading(false);
+        return;
+      }
+      const nextRequestId = ++requestIdRef.current;
+      setError(null);
+      if (!force) {
+        const cacheEntry = quoteCache.get(cacheKey);
+        if (cacheEntry) {
+          setQuote(cacheEntry.quote);
+          setMessages(cacheEntry.quote?.ui_messages ?? []);
+          setIsExpired(isQuoteExpired(cacheEntry.quote));
+          setIsLoading(false);
+          return;
+        }
+      }
+      setIsLoading(true);
+      try {
+        const existing = quoteInflight.get(cacheKey);
+        const promise = existing ?? (async () => {
+          const result = await client.catalogue.fetchQuote(normalizedInput);
+          if (!result.ok) {
+            throw result.error;
+          }
+          return result.value;
+        })();
+        if (!existing) {
+          quoteInflight.set(cacheKey, promise);
+          promise.finally(() => {
+            quoteInflight.delete(cacheKey);
+          }).catch(() => void 0);
+        }
+        const value = await promise;
+        quoteCache.set(cacheKey, { quote: value });
+        if (nextRequestId === requestIdRef.current) {
+          setQuote(value);
+          setMessages(value.ui_messages ?? []);
+          setIsExpired(isQuoteExpired(value));
+          setError(null);
+        }
+      } catch (loadError) {
+        if (nextRequestId === requestIdRef.current) {
+          setError(loadError);
+        }
+      } finally {
+        if (nextRequestId === requestIdRef.current) {
+          setIsLoading(false);
+        }
+      }
+    },
+    [cacheKey, client, enabled, normalizedInput]
+  );
+  react.useEffect(() => {
+    void load(false);
+  }, [load]);
+  const refresh = react.useCallback(async () => {
+    if (!enabled || !normalizedInput) {
+      return;
+    }
+    if (!quote?.quote_id) {
+      await load(true);
+      return;
+    }
+    const nextRequestId = ++requestIdRef.current;
+    setError(null);
+    setIsLoading(true);
+    try {
+      const result = await client.catalogue.refreshQuote({
+        quote_id: quote.quote_id,
+        ...normalizedInput
+      });
+      if (!result.ok) {
+        throw result.error;
+      }
+      const refreshed = result.value.quote;
+      quoteCache.set(cacheKey, { quote: refreshed });
+      if (nextRequestId === requestIdRef.current) {
+        setQuote(refreshed);
+        setMessages(refreshed.ui_messages ?? []);
+        setIsExpired(isQuoteExpired(refreshed));
+        setError(null);
+      }
+    } catch (refreshError) {
+      if (nextRequestId === requestIdRef.current) {
+        setError(refreshError);
+      }
+    } finally {
+      if (nextRequestId === requestIdRef.current) {
+        setIsLoading(false);
+      }
+    }
+  }, [cacheKey, client, enabled, load, normalizedInput, quote]);
+  react.useEffect(() => {
+    if (expiryTimerRef.current) {
+      clearTimeout(expiryTimerRef.current);
+      expiryTimerRef.current = null;
+    }
+    const expiresAt = quote?.expires_at ? Date.parse(quote.expires_at) : NaN;
+    if (!Number.isFinite(expiresAt)) {
+      setIsExpired(false);
+      return;
+    }
+    const expired = expiresAt <= Date.now();
+    setIsExpired(expired);
+    if (!expired) {
+      expiryTimerRef.current = setTimeout(() => {
+        setIsExpired(true);
+      }, Math.max(0, expiresAt - Date.now()));
+    }
+    return () => {
+      if (expiryTimerRef.current) {
+        clearTimeout(expiryTimerRef.current);
+        expiryTimerRef.current = null;
+      }
+    };
+  }, [quote?.expires_at, quote?.quote_id]);
+  react.useEffect(() => {
+    if (refreshTimerRef.current) {
+      clearTimeout(refreshTimerRef.current);
+      refreshTimerRef.current = null;
+    }
+    if (!autoRefresh || !enabled || !quote?.expires_at) {
+      return;
+    }
+    const expiresAt = Date.parse(quote.expires_at);
+    if (!Number.isFinite(expiresAt)) {
+      return;
+    }
+    const delay = Math.max(0, expiresAt - Date.now() - refreshBeforeExpiryMs);
+    refreshTimerRef.current = setTimeout(() => {
+      void refresh();
+    }, delay);
+    return () => {
+      if (refreshTimerRef.current) {
+        clearTimeout(refreshTimerRef.current);
+        refreshTimerRef.current = null;
+      }
+    };
+  }, [autoRefresh, enabled, quote?.expires_at, quote?.quote_id, refresh, refreshBeforeExpiryMs]);
+  return { quote, isLoading, error, refresh, isExpired, messages };
+}
 var ElementsContext = react.createContext({
   elements: null,
   isReady: false
@@ -5254,10 +6053,14 @@ exports.CimplifyProvider = CimplifyProvider;
 exports.ElementsProvider = ElementsProvider;
 exports.PaymentElement = PaymentElement;
 exports.useAds = useAds;
+exports.useBundle = useBundle;
 exports.useCart = useCart;
 exports.useCategories = useCategories;
 exports.useCheckout = useCheckout;
 exports.useCimplify = useCimplify;
+exports.useCollection = useCollection;
+exports.useCollections = useCollections;
+exports.useComposite = useComposite;
 exports.useElements = useElements;
 exports.useElementsReady = useElementsReady;
 exports.useLocations = useLocations;
@@ -5265,3 +6068,5 @@ exports.useOptionalCimplify = useOptionalCimplify;
 exports.useOrder = useOrder;
 exports.useProduct = useProduct;
 exports.useProducts = useProducts;
+exports.useQuote = useQuote;
+exports.useSearch = useSearch;