@cimplify/sdk 0.6.6 → 0.6.7

package/dist/react.js

@@ -406,9 +406,11 @@ function CimplifyCheckout({
   const elementsRef = react.useRef(null);
   const activeCheckoutRef = react.useRef(null);
   const initialAppearanceRef = react.useRef(appearance);
+  const hasWarnedInlineAppearanceRef = react.useRef(false);
   const isMountedRef = react.useRef(true);
   const demoRunRef = react.useRef(0);
   const isDemoCheckout = demoMode ?? client.getPublicKey().trim().length === 0;
+  const isTestMode = client.isTestMode();
   const emitStatus = react.useCallback(
     (nextStatus, context = {}) => {
       setStatus(nextStatus);
@@ -422,6 +424,14 @@ function CimplifyCheckout({
       setOrderType(resolvedOrderTypes[0] || "pickup");
     }
   }, [resolvedOrderTypes, orderType]);
+  react.useEffect(() => {
+    if (appearance && appearance !== initialAppearanceRef.current && !hasWarnedInlineAppearanceRef.current) {
+      hasWarnedInlineAppearanceRef.current = true;
+      console.warn(
+        "[Cimplify] `appearance` prop reference changed after mount. Elements keep the initial appearance to avoid iframe remount. Memoize appearance with useMemo() to remove this warning."
+      );
+    }
+  }, [appearance]);
   react.useEffect(() => {
     let cancelled = false;
     async function bootstrap() {
@@ -628,6 +638,19 @@ function CimplifyCheckout({
     return /* @__PURE__ */ jsxRuntime.jsx("div", { className, "data-cimplify-checkout": "", children: /* @__PURE__ */ jsxRuntime.jsx("p", { "data-cimplify-error": "", style: { fontSize: "14px", color: "#b91c1c" }, children: errorMessage || "Unable to initialize checkout. Please refresh and try again." }) });
   }
   return /* @__PURE__ */ jsxRuntime.jsxs("div", { className, "data-cimplify-checkout": "", children: [
+    isTestMode && !isDemoCheckout && /* @__PURE__ */ jsxRuntime.jsx(
+      "p",
+      {
+        "data-cimplify-test-mode": "",
+        style: {
+          marginBottom: "10px",
+          fontSize: "12px",
+          fontWeight: 600,
+          color: "#92400e"
+        },
+        children: "Test mode - no real charges"
+      }
+    ),
     /* @__PURE__ */ jsxRuntime.jsx("div", { "data-cimplify-section": "auth", children: /* @__PURE__ */ jsxRuntime.jsx("div", { ref: isDemoCheckout ? void 0 : authMountRef }) }),
     /* @__PURE__ */ jsxRuntime.jsx("div", { "data-cimplify-section": "order-type", style: { marginTop: "12px" }, children: /* @__PURE__ */ jsxRuntime.jsx(
       "div",
@@ -695,12 +718,74 @@ var ErrorCode = {
   UNKNOWN_ERROR: "UNKNOWN_ERROR",
   NETWORK_ERROR: "NETWORK_ERROR",
   TIMEOUT: "TIMEOUT",
+  UNAUTHORIZED: "UNAUTHORIZED",
   NOT_FOUND: "NOT_FOUND"};
+var DOCS_ERROR_BASE_URL = "https://docs.cimplify.io/reference/error-codes";
+function docsUrlForCode(code) {
+  return `${DOCS_ERROR_BASE_URL}#${code.toLowerCase().replace(/_/g, "-")}`;
+}
+var ERROR_SUGGESTIONS = {
+  UNKNOWN_ERROR: "An unexpected error occurred. Capture the request/response payload and retry with exponential backoff.",
+  NETWORK_ERROR: "Check the shopper's connection and retry. If this persists, inspect CORS, DNS, and API reachability.",
+  TIMEOUT: "The request exceeded the timeout. Retry once, then poll order status before charging again.",
+  UNAUTHORIZED: "Authentication is missing or expired. Ensure a valid access token is set and refresh the session if needed.",
+  FORBIDDEN: "The key/session lacks permission for this resource. Verify business ownership and API key scope.",
+  NOT_FOUND: "The requested resource does not exist or is not visible in this environment.",
+  VALIDATION_ERROR: "One or more fields are invalid. Validate required fields and enum values before retrying.",
+  CART_EMPTY: "The cart has no items. Redirect back to menu/catalogue and require at least one line item.",
+  CART_EXPIRED: "This cart is no longer active. Recreate a new cart and re-add shopper selections.",
+  CART_NOT_FOUND: "Cart could not be located. It may have expired or belongs to a different key/location.",
+  ITEM_UNAVAILABLE: "The selected item is unavailable at this location/time. Prompt the shopper to pick an alternative.",
+  VARIANT_NOT_FOUND: "The requested variant no longer exists. Refresh product data and require re-selection.",
+  VARIANT_OUT_OF_STOCK: "The selected variant is out of stock. Show in-stock variants and block checkout for this line.",
+  ADDON_REQUIRED: "A required add-on is missing. Ensure required modifier groups are completed before add-to-cart.",
+  ADDON_MAX_EXCEEDED: "Too many add-ons were selected. Enforce max selections client-side before submission.",
+  CHECKOUT_VALIDATION_FAILED: "Checkout payload failed validation. Verify customer, order type, and address fields are complete.",
+  DELIVERY_ADDRESS_REQUIRED: "Delivery orders require an address. Collect and pass address info before processing checkout.",
+  CUSTOMER_INFO_REQUIRED: "Customer details are required. Ensure name/email/phone are available before checkout.",
+  PAYMENT_FAILED: "Payment provider rejected or failed processing. Show retry/change-method options to the shopper.",
+  PAYMENT_CANCELLED: "Payment was cancelled by the shopper or provider flow. Allow a safe retry path.",
+  INSUFFICIENT_FUNDS: "Payment method has insufficient funds. Prompt shopper to use another method.",
+  CARD_DECLINED: "Card was declined. Ask shopper to retry or switch payment method.",
+  INVALID_OTP: "Authorization code is invalid. Let shopper re-enter OTP/PIN and retry.",
+  OTP_EXPIRED: "Authorization code expired. Request a new OTP and re-submit authorization.",
+  AUTHORIZATION_FAILED: "Additional payment authorization failed. Retry authorization or change payment method.",
+  PAYMENT_ACTION_NOT_COMPLETED: "Required payment action was not completed. Resume provider flow and poll for status.",
+  SLOT_UNAVAILABLE: "Selected schedule slot is unavailable. Refresh available slots and ask shopper to reselect.",
+  BOOKING_CONFLICT: "The requested booking conflicts with an existing reservation. Pick another slot/resource.",
+  SERVICE_NOT_FOUND: "Requested service no longer exists. Refresh service catalogue and retry selection.",
+  OUT_OF_STOCK: "Inventory is depleted for this item. Remove it or reduce quantity before checkout.",
+  INSUFFICIENT_QUANTITY: "Requested quantity exceeds available inventory. Reduce quantity and retry.",
+  BUSINESS_ID_REQUIRED: "Business context could not be resolved. Verify the public key and business bootstrap call.",
+  INVALID_CART: "Cart is invalid for checkout. Sync cart state, ensure items exist, then retry.",
+  ORDER_TYPE_REQUIRED: "Order type is required. Provide one of delivery, pickup, or dine_in before checkout.",
+  NO_PAYMENT_ELEMENT: "PaymentElement is required for processCheckout(). Mount it before triggering checkout.",
+  PAYMENT_NOT_MOUNTED: "PaymentElement iframe is not mounted. Mount it in the DOM before processCheckout().",
+  AUTH_INCOMPLETE: "AuthElement has not completed authentication. Wait for AUTHENTICATED before checkout.",
+  AUTH_LOST: "Session was cleared during checkout. Re-authenticate and restart checkout safely.",
+  ALREADY_PROCESSING: "Checkout is already in progress. Disable duplicate submits until completion.",
+  CHECKOUT_NOT_READY: "Checkout elements are still initializing. Wait for readiness before submit.",
+  CANCELLED: "Checkout was cancelled. Preserve cart state and allow shopper to retry.",
+  REQUEST_TIMEOUT: "Provider call timed out. Poll payment/order status before issuing another charge attempt.",
+  POPUP_BLOCKED: "Browser blocked provider popup. Ask shopper to enable popups and retry.",
+  FX_QUOTE_FAILED: "Failed to lock FX quote. Retry currency quote or fallback to base currency."
+};
+var ERROR_HINTS = Object.fromEntries(
+  Object.entries(ERROR_SUGGESTIONS).map(([code, suggestion]) => [
+    code,
+    {
+      docs_url: docsUrlForCode(code),
+      suggestion
+    }
+  ])
+);
 var CimplifyError = class extends Error {
-  constructor(code, message, retryable = false) {
+  constructor(code, message, retryable = false, docs_url, suggestion) {
     super(message);
     this.code = code;
     this.retryable = retryable;
+    this.docs_url = docs_url;
+    this.suggestion = suggestion;
     this.name = "CimplifyError";
   }
   /** User-friendly message safe to display */
@@ -708,6 +793,28 @@ var CimplifyError = class extends Error {
     return this.message;
   }
 };
+function getErrorHint(code) {
+  return ERROR_HINTS[code];
+}
+function enrichError(error, options = {}) {
+  const hint = getErrorHint(error.code);
+  if (hint) {
+    if (!error.docs_url) {
+      error.docs_url = hint.docs_url;
+    }
+    if (!error.suggestion) {
+      error.suggestion = hint.suggestion;
+    }
+  } else if (!error.docs_url) {
+    error.docs_url = docsUrlForCode(error.code || ErrorCode.UNKNOWN_ERROR);
+  }
+  if (options.isTestMode && !error.message.includes("pk_test_")) {
+    error.message = `${error.message}
+
+\u2139 Your API key is a test-mode key (pk_test_...). Verify test data/session before retrying.`;
+  }
+  return error;
+}
 
 // src/types/result.ts
 function ok(value) {
@@ -719,11 +826,11 @@ function err(error) {
 
 // src/catalogue.ts
 function toCimplifyError(error) {
-  if (error instanceof CimplifyError) return error;
+  if (error instanceof CimplifyError) return enrichError(error);
   if (error instanceof Error) {
-    return new CimplifyError("UNKNOWN_ERROR", error.message, false);
+    return enrichError(new CimplifyError(ErrorCode.UNKNOWN_ERROR, error.message, false));
   }
-  return new CimplifyError("UNKNOWN_ERROR", String(error), false);
+  return enrichError(new CimplifyError(ErrorCode.UNKNOWN_ERROR, String(error), false));
 }
 async function safe(promise) {
   try {
@@ -1018,11 +1125,11 @@ var CatalogueQueries = class {
 
 // src/cart.ts
 function toCimplifyError2(error) {
-  if (error instanceof CimplifyError) return error;
+  if (error instanceof CimplifyError) return enrichError(error);
   if (error instanceof Error) {
-    return new CimplifyError("UNKNOWN_ERROR", error.message, false);
+    return enrichError(new CimplifyError(ErrorCode.UNKNOWN_ERROR, error.message, false));
   }
-  return new CimplifyError("UNKNOWN_ERROR", String(error), false);
+  return enrichError(new CimplifyError(ErrorCode.UNKNOWN_ERROR, String(error), false));
 }
 async function safe2(promise) {
   try {
@@ -1182,6 +1289,19 @@ var ORDER_MUTATION = {
   UPDATE_CUSTOMER: "order.update_order_customer"
 };
 
+// src/utils/price.ts
+function parsePrice(value) {
+  if (value === void 0 || value === null) {
+    return 0;
+  }
+  if (typeof value === "number") {
+    return isNaN(value) ? 0 : value;
+  }
+  const cleaned = value.replace(/[^\d.-]/g, "");
+  const parsed = parseFloat(cleaned);
+  return isNaN(parsed) ? 0 : parsed;
+}
+
 // src/utils/payment.ts
 var PAYMENT_SUCCESS_STATUSES = /* @__PURE__ */ new Set([
   "success",
@@ -1861,11 +1981,11 @@ var CheckoutResolver = class {
 
 // src/checkout.ts
 function toCimplifyError3(error) {
-  if (error instanceof CimplifyError) return error;
+  if (error instanceof CimplifyError) return enrichError(error);
   if (error instanceof Error) {
-    return new CimplifyError("UNKNOWN_ERROR", error.message, false);
+    return enrichError(new CimplifyError(ErrorCode.UNKNOWN_ERROR, error.message, false));
   }
-  return new CimplifyError("UNKNOWN_ERROR", String(error), false);
+  return enrichError(new CimplifyError(ErrorCode.UNKNOWN_ERROR, String(error), false));
 }
 async function safe3(promise) {
   try {
@@ -2041,11 +2161,11 @@ var CheckoutService = class {
 
 // src/orders.ts
 function toCimplifyError4(error) {
-  if (error instanceof CimplifyError) return error;
+  if (error instanceof CimplifyError) return enrichError(error);
   if (error instanceof Error) {
-    return new CimplifyError("UNKNOWN_ERROR", error.message, false);
+    return enrichError(new CimplifyError(ErrorCode.UNKNOWN_ERROR, error.message, false));
   }
-  return new CimplifyError("UNKNOWN_ERROR", String(error), false);
+  return enrichError(new CimplifyError(ErrorCode.UNKNOWN_ERROR, String(error), false));
 }
 async function safe4(promise) {
   try {
@@ -2302,11 +2422,11 @@ var AuthService = class {
 
 // src/business.ts
 function toCimplifyError7(error) {
-  if (error instanceof CimplifyError) return error;
+  if (error instanceof CimplifyError) return enrichError(error);
   if (error instanceof Error) {
-    return new CimplifyError("UNKNOWN_ERROR", error.message, false);
+    return enrichError(new CimplifyError(ErrorCode.UNKNOWN_ERROR, error.message, false));
   }
-  return new CimplifyError("UNKNOWN_ERROR", String(error), false);
+  return enrichError(new CimplifyError(ErrorCode.UNKNOWN_ERROR, String(error), false));
 }
 async function safe7(promise) {
   try {
@@ -2653,12 +2773,15 @@ var FxService = class {
 
 // src/elements.ts
 function toCheckoutError(code, message, recoverable) {
+  const hint = getErrorHint(code);
   return {
     success: false,
     error: {
       code,
       message,
-      recoverable
+      recoverable,
+      docs_url: hint?.docs_url,
+      suggestion: hint?.suggestion
     }
   };
 }
@@ -2699,6 +2822,7 @@ var CimplifyElements = class {
     this.paymentData = null;
     this.checkoutInProgress = false;
     this.activeCheckoutAbort = null;
+    this.hasWarnedMissingAuthElement = false;
     this.businessIdResolvePromise = null;
     this.client = client;
     this.businessId = businessId ?? null;
@@ -2794,6 +2918,12 @@ var CimplifyElements = class {
         );
       }
       const authElement = this.elements.get(ELEMENT_TYPES.AUTH);
+      if (!authElement && !this.hasWarnedMissingAuthElement) {
+        this.hasWarnedMissingAuthElement = true;
+        console.warn(
+          "[Cimplify] processCheckout() called without AuthElement mounted. For best conversion and Link enrollment, mount <AuthElement> before checkout."
+        );
+      }
       if (authElement && !this.accessToken) {
         return toCheckoutError(
           "AUTH_INCOMPLETE",
@@ -3230,28 +3360,37 @@ function isRetryable(error) {
   }
   return false;
 }
-function toNetworkError(error) {
+function toNetworkError(error, isTestMode) {
   if (error instanceof DOMException && error.name === "AbortError") {
-    return new CimplifyError(
-      ErrorCode.TIMEOUT,
-      "Request timed out. Please check your connection and try again.",
-      true
+    return enrichError(
+      new CimplifyError(
+        ErrorCode.TIMEOUT,
+        "Request timed out. Please check your connection and try again.",
+        true
+      ),
+      { isTestMode }
     );
   }
   if (error instanceof TypeError && error.message.includes("fetch")) {
-    return new CimplifyError(
-      ErrorCode.NETWORK_ERROR,
-      "Network error. Please check your internet connection.",
-      true
+    return enrichError(
+      new CimplifyError(
+        ErrorCode.NETWORK_ERROR,
+        "Network error. Please check your internet connection.",
+        true
+      ),
+      { isTestMode }
     );
   }
   if (error instanceof CimplifyError) {
-    return error;
+    return enrichError(error, { isTestMode });
   }
-  return new CimplifyError(
-    ErrorCode.UNKNOWN_ERROR,
-    error instanceof Error ? error.message : "An unknown error occurred",
-    false
+  return enrichError(
+    new CimplifyError(
+      ErrorCode.UNKNOWN_ERROR,
+      error instanceof Error ? error.message : "An unknown error occurred",
+      false
+    ),
+    { isTestMode }
   );
 }
 function deriveUrls() {
@@ -3313,6 +3452,9 @@ var CimplifyClient = class {
   getPublicKey() {
     return this.publicKey;
   }
+  isTestMode() {
+    return this.publicKey.trim().startsWith("pk_test_");
+  }
   setAccessToken(token) {
     const previous = this.accessToken;
     this.accessToken = token;
@@ -3462,7 +3604,7 @@ var CimplifyClient = class {
         return response;
       } catch (error) {
         lastError = error;
-        const networkError = toNetworkError(error);
+        const networkError = toNetworkError(error, this.isTestMode());
         const errorRetryable = isRetryable(error);
         if (!errorRetryable || attempt >= this.maxRetries) {
           this.hooks.onRequestError?.({
@@ -3485,7 +3627,7 @@ var CimplifyClient = class {
         await sleep(delay);
       }
     }
-    const finalError = toNetworkError(lastError);
+    const finalError = toNetworkError(lastError, this.isTestMode());
     this.hooks.onRequestError?.({
       ...context,
       error: finalError,
@@ -3603,22 +3745,40 @@ var CimplifyClient = class {
   async handleRestResponse(response) {
     const json = await response.json();
     if (!response.ok) {
-      throw new CimplifyError(
-        json.error?.error_code || "API_ERROR",
-        json.error?.error_message || "An error occurred",
-        false
+      const error = enrichError(
+        new CimplifyError(
+          json.error?.error_code || "API_ERROR",
+          json.error?.error_message || "An error occurred",
+          false
+        ),
+        { isTestMode: this.isTestMode() }
       );
+      if (response.status === 401 || error.code === ErrorCode.UNAUTHORIZED) {
+        console.warn(
+          "[Cimplify] Received 401 Unauthorized. Access token may be missing/expired. Refresh authentication and retry the request."
+        );
+      }
+      throw error;
     }
     return json.data;
   }
   async handleResponse(response) {
     const json = await response.json();
     if (!json.success || json.error) {
-      throw new CimplifyError(
-        json.error?.code || "UNKNOWN_ERROR",
-        json.error?.message || "An unknown error occurred",
-        json.error?.retryable || false
+      const error = enrichError(
+        new CimplifyError(
+          json.error?.code || "UNKNOWN_ERROR",
+          json.error?.message || "An unknown error occurred",
+          json.error?.retryable || false
+        ),
+        { isTestMode: this.isTestMode() }
       );
+      if (response.status === 401 || error.code === ErrorCode.UNAUTHORIZED) {
+        console.warn(
+          "[Cimplify] Received 401 Unauthorized. Access token may be missing/expired. Refresh authentication and retry the request."
+        );
+      }
+      throw error;
     }
     return json.data;
   }
@@ -3805,6 +3965,9 @@ function CimplifyProvider({
       const nextLocations = locationsResult.ok && Array.isArray(locationsResult.value) ? locationsResult.value : [];
       const initialLocation = resolveInitialLocation(nextLocations);
       setBusiness(nextBusiness);
+      if (nextBusiness?.id) {
+        resolvedClient.setBusinessId(nextBusiness.id);
+      }
       setLocations(nextLocations);
       if (initialLocation) {
         setCurrentLocationState(initialLocation);
@@ -3863,6 +4026,1065 @@ function useCimplify() {
   }
   return context;
 }
+function useOptionalCimplify() {
+  return react.useContext(CimplifyContext);
+}
+var productsCache = /* @__PURE__ */ new Map();
+var productsInflight = /* @__PURE__ */ new Map();
+function buildProductsCacheKey(client, locationId, options) {
+  return JSON.stringify({
+    key: client.getPublicKey(),
+    location_id: locationId || "__none__",
+    options
+  });
+}
+function useProducts(options = {}) {
+  const context = useOptionalCimplify();
+  const client = options.client ?? context?.client;
+  if (!client) {
+    throw new Error("useProducts 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 queryOptions = react.useMemo(
+    () => ({
+      category: options.category,
+      collection: options.collection,
+      search: options.search,
+      featured: options.featured,
+      limit: options.limit
+    }),
+    [options.category, options.collection, options.featured, options.limit, options.search]
+  );
+  const cacheKey = react.useMemo(
+    () => buildProductsCacheKey(client, locationId, queryOptions),
+    [client, locationId, queryOptions]
+  );
+  const cached = productsCache.get(cacheKey);
+  const [products, setProducts] = react.useState(cached?.products ?? []);
+  const [isLoading, setIsLoading] = react.useState(enabled && !cached);
+  const [error, setError] = react.useState(null);
+  react.useEffect(() => {
+    if (previousLocationIdRef.current !== locationId) {
+      productsCache.clear();
+      productsInflight.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 = productsCache.get(cacheKey);
+        if (cacheEntry) {
+          setProducts(cacheEntry.products);
+          setIsLoading(false);
+          return;
+        }
+      }
+      setIsLoading(true);
+      try {
+        const existing = productsInflight.get(cacheKey);
+        const promise = existing ?? (async () => {
+          const result = await client.catalogue.getProducts(queryOptions);
+          if (!result.ok) {
+            throw result.error;
+          }
+          return result.value;
+        })();
+        if (!existing) {
+          productsInflight.set(
+            cacheKey,
+            promise.finally(() => {
+              productsInflight.delete(cacheKey);
+            })
+          );
+        }
+        const value = await promise;
+        productsCache.set(cacheKey, { products: value });
+        if (nextRequestId === requestIdRef.current) {
+          setProducts(value);
+          setError(null);
+        }
+      } catch (loadError) {
+        if (nextRequestId === requestIdRef.current) {
+          setError(loadError);
+        }
+      } finally {
+        if (nextRequestId === requestIdRef.current) {
+          setIsLoading(false);
+        }
+      }
+    },
+    [cacheKey, client, enabled, queryOptions]
+  );
+  react.useEffect(() => {
+    void load(false);
+  }, [load]);
+  const refetch = react.useCallback(async () => {
+    productsCache.delete(cacheKey);
+    await load(true);
+  }, [cacheKey, load]);
+  return { products, isLoading, error, refetch };
+}
+var productCache = /* @__PURE__ */ new Map();
+var productInflight = /* @__PURE__ */ new Map();
+function isLikelySlug(value) {
+  return /^[a-z0-9-]+$/.test(value);
+}
+function buildProductCacheKey(client, locationId, slugOrId) {
+  return JSON.stringify({
+    key: client.getPublicKey(),
+    location_id: locationId || "__none__",
+    slug_or_id: slugOrId
+  });
+}
+function useProduct(slugOrId, options = {}) {
+  const context = useOptionalCimplify();
+  const client = options.client ?? context?.client;
+  if (!client) {
+    throw new Error("useProduct 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 normalizedSlugOrId = react.useMemo(() => (slugOrId || "").trim(), [slugOrId]);
+  const cacheKey = react.useMemo(
+    () => buildProductCacheKey(client, locationId, normalizedSlugOrId),
+    [client, locationId, normalizedSlugOrId]
+  );
+  const cached = productCache.get(cacheKey);
+  const [product, setProduct] = react.useState(cached?.product ?? null);
+  const [isLoading, setIsLoading] = react.useState(
+    enabled && normalizedSlugOrId.length > 0 && !cached
+  );
+  const [error, setError] = react.useState(null);
+  react.useEffect(() => {
+    if (previousLocationIdRef.current !== locationId) {
+      productCache.clear();
+      productInflight.clear();
+      previousLocationIdRef.current = locationId;
+    }
+  }, [locationId]);
+  const load = react.useCallback(
+    async (force = false) => {
+      if (!enabled || normalizedSlugOrId.length === 0) {
+        setProduct(null);
+        setIsLoading(false);
+        return;
+      }
+      const nextRequestId = ++requestIdRef.current;
+      setError(null);
+      if (!force) {
+        const cacheEntry = productCache.get(cacheKey);
+        if (cacheEntry) {
+          setProduct(cacheEntry.product);
+          setIsLoading(false);
+          return;
+        }
+      }
+      setIsLoading(true);
+      try {
+        const existing = productInflight.get(cacheKey);
+        const promise = existing ?? (async () => {
+          const result = isLikelySlug(normalizedSlugOrId) ? await client.catalogue.getProductBySlug(normalizedSlugOrId) : await client.catalogue.getProduct(normalizedSlugOrId);
+          if (!result.ok) {
+            throw result.error;
+          }
+          return result.value;
+        })();
+        if (!existing) {
+          productInflight.set(
+            cacheKey,
+            promise.finally(() => {
+              productInflight.delete(cacheKey);
+            })
+          );
+        }
+        const value = await promise;
+        productCache.set(cacheKey, { product: value });
+        if (nextRequestId === requestIdRef.current) {
+          setProduct(value);
+          setError(null);
+        }
+      } catch (loadError) {
+        if (nextRequestId === requestIdRef.current) {
+          setError(loadError);
+        }
+      } finally {
+        if (nextRequestId === requestIdRef.current) {
+          setIsLoading(false);
+        }
+      }
+    },
+    [cacheKey, client, enabled, normalizedSlugOrId]
+  );
+  react.useEffect(() => {
+    void load(false);
+  }, [load]);
+  const refetch = react.useCallback(async () => {
+    productCache.delete(cacheKey);
+    await load(true);
+  }, [cacheKey, load]);
+  return { product, isLoading, error, refetch };
+}
+var categoriesCache = /* @__PURE__ */ new Map();
+var categoriesInflight = /* @__PURE__ */ new Map();
+function buildCategoriesCacheKey(client) {
+  return client.getPublicKey() || "__demo__";
+}
+function useCategories(options = {}) {
+  const context = useOptionalCimplify();
+  const client = options.client ?? context?.client;
+  if (!client) {
+    throw new Error("useCategories must be used within CimplifyProvider or passed { client }.");
+  }
+  const enabled = options.enabled ?? true;
+  const cacheKey = react.useMemo(() => buildCategoriesCacheKey(client), [client]);
+  const cached = categoriesCache.get(cacheKey);
+  const [categories, setCategories] = react.useState(cached ?? []);
+  const [isLoading, setIsLoading] = react.useState(enabled && !cached);
+  const [error, setError] = react.useState(null);
+  const load = react.useCallback(
+    async (force = false) => {
+      if (!enabled) {
+        setIsLoading(false);
+        return;
+      }
+      setError(null);
+      if (!force) {
+        const cachedCategories = categoriesCache.get(cacheKey);
+        if (cachedCategories) {
+          setCategories(cachedCategories);
+          setIsLoading(false);
+          return;
+        }
+      }
+      setIsLoading(true);
+      try {
+        const existing = categoriesInflight.get(cacheKey);
+        const promise = existing ?? (async () => {
+          const result = await client.catalogue.getCategories();
+          if (!result.ok) {
+            throw result.error;
+          }
+          return result.value;
+        })();
+        if (!existing) {
+          categoriesInflight.set(
+            cacheKey,
+            promise.finally(() => {
+              categoriesInflight.delete(cacheKey);
+            })
+          );
+        }
+        const value = await promise;
+        categoriesCache.set(cacheKey, value);
+        setCategories(value);
+      } catch (loadError) {
+        setError(loadError);
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [cacheKey, client, enabled]
+  );
+  react.useEffect(() => {
+    void load(false);
+  }, [load]);
+  const refetch = react.useCallback(async () => {
+    categoriesCache.delete(cacheKey);
+    await load(true);
+  }, [cacheKey, load]);
+  return { categories, isLoading, error, refetch };
+}
+var CART_STORAGE_PREFIX = "cimplify:cart:v2";
+var DEFAULT_TAX_RATE = 0.08875;
+var cartStores = /* @__PURE__ */ new Map();
+function toNumber(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  if (typeof value === "string") {
+    const parsed = Number.parseFloat(value);
+    return Number.isFinite(parsed) ? parsed : 0;
+  }
+  return 0;
+}
+function roundMoney(value) {
+  return Math.max(0, Number(value.toFixed(2)));
+}
+function clampQuantity(quantity) {
+  if (!Number.isFinite(quantity)) {
+    return 1;
+  }
+  return Math.max(1, Math.floor(quantity));
+}
+function normalizeOptionIds(value) {
+  if (!value || value.length === 0) {
+    return void 0;
+  }
+  const normalized = Array.from(
+    new Set(
+      value.map((entry) => entry.trim()).filter((entry) => entry.length > 0)
+    )
+  ).sort();
+  return normalized.length > 0 ? normalized : void 0;
+}
+function buildLineKey(productId, options) {
+  const parts = [productId];
+  if (options.locationId) {
+    parts.push(`l:${options.locationId}`);
+  }
+  if (options.variantId) {
+    parts.push(`v:${options.variantId}`);
+  }
+  const addOnOptionIds = normalizeOptionIds(options.addOnOptionIds);
+  if (addOnOptionIds && addOnOptionIds.length > 0) {
+    parts.push(`a:${addOnOptionIds.join(",")}`);
+  }
+  if (options.bundleSelections && options.bundleSelections.length > 0) {
+    parts.push(`b:${JSON.stringify(options.bundleSelections)}`);
+  }
+  if (options.compositeSelections && options.compositeSelections.length > 0) {
+    parts.push(`c:${JSON.stringify(options.compositeSelections)}`);
+  }
+  if (options.quoteId) {
+    parts.push(`q:${options.quoteId}`);
+  }
+  return parts.join("|");
+}
+function calculateLineSubtotal(item) {
+  let unitPrice = parsePrice(item.product.default_price);
+  if (item.variant?.price_adjustment) {
+    unitPrice += parsePrice(item.variant.price_adjustment);
+  }
+  for (const option of item.addOnOptions || []) {
+    if (option.default_price) {
+      unitPrice += parsePrice(option.default_price);
+    }
+  }
+  return roundMoney(unitPrice * item.quantity);
+}
+function calculateSummary(items) {
+  const subtotal = roundMoney(items.reduce((sum, item) => sum + calculateLineSubtotal(item), 0));
+  const tax = roundMoney(subtotal * DEFAULT_TAX_RATE);
+  return {
+    subtotal,
+    tax,
+    total: roundMoney(subtotal + tax)
+  };
+}
+function toProductFromServerItem(item, businessId) {
+  return {
+    id: item.item_id,
+    business_id: businessId,
+    category_id: item.category_id,
+    name: item.name,
+    slug: item.item_id,
+    description: item.description,
+    image_url: item.image_url,
+    default_price: item.base_price,
+    product_type: "product",
+    inventory_type: "none",
+    variant_strategy: "fetch_all",
+    is_active: item.is_available,
+    created_at: item.created_at,
+    updated_at: item.updated_at,
+    metadata: {
+      from_sdk: true
+    }
+  };
+}
+function mapServerCart(serverCart) {
+  const items = serverCart.items.map((item) => {
+    const variant = item.variant_info || item.variant_name ? {
+      id: item.variant_info?.id || item.variant_id || "",
+      name: item.variant_info?.name || item.variant_name || "Variant",
+      price_adjustment: item.variant_info?.price_adjustment
+    } : void 0;
+    const quoteId = typeof item.metadata?.quote_id === "string" ? item.metadata.quote_id : void 0;
+    return {
+      id: item.id,
+      product: toProductFromServerItem(item, serverCart.business_id),
+      quantity: clampQuantity(item.quantity),
+      locationId: serverCart.location_id,
+      variantId: item.variant_id,
+      variant,
+      quoteId,
+      addOnOptionIds: item.add_on_option_ids || void 0,
+      addOnOptions: (item.add_on_options || []).map((option) => ({
+        id: option.id,
+        name: option.name,
+        default_price: option.price
+      })),
+      bundleSelections: item.bundle_selections || void 0,
+      compositeSelections: item.composite_selections || void 0,
+      specialInstructions: item.special_instructions
+    };
+  });
+  return {
+    items,
+    subtotal: roundMoney(toNumber(serverCart.pricing.subtotal)),
+    tax: roundMoney(toNumber(serverCart.pricing.tax_amount)),
+    total: roundMoney(toNumber(serverCart.pricing.total_price)),
+    currency: serverCart.pricing.currency || "USD"
+  };
+}
+function buildStorageKey(storeKey) {
+  return `${CART_STORAGE_PREFIX}:${storeKey}`;
+}
+function createEmptySnapshot(currency) {
+  return {
+    items: [],
+    subtotal: 0,
+    tax: 0,
+    total: 0,
+    currency,
+    isLoading: true
+  };
+}
+function createCartStore(params) {
+  const { client, storeKey, locationId, isDemoMode, currency } = params;
+  const storageKey = buildStorageKey(storeKey);
+  const listeners = /* @__PURE__ */ new Set();
+  let snapshot = createEmptySnapshot(currency);
+  let initialized = false;
+  let initializePromise = null;
+  function emit() {
+    listeners.forEach((listener) => {
+      listener();
+    });
+  }
+  function setSnapshot(nextSnapshot) {
+    snapshot = nextSnapshot;
+    persistSnapshot();
+    emit();
+  }
+  function updateSnapshot(updater) {
+    setSnapshot(updater(snapshot));
+  }
+  function persistSnapshot() {
+    if (typeof window === "undefined" || !window.localStorage) {
+      return;
+    }
+    try {
+      window.localStorage.setItem(
+        storageKey,
+        JSON.stringify({
+          items: snapshot.items,
+          subtotal: snapshot.subtotal,
+          tax: snapshot.tax,
+          total: snapshot.total,
+          currency: snapshot.currency
+        })
+      );
+    } catch {
+    }
+  }
+  function hydrateFromStorage() {
+    if (typeof window === "undefined" || !window.localStorage) {
+      return;
+    }
+    try {
+      const raw = window.localStorage.getItem(storageKey);
+      if (!raw) {
+        return;
+      }
+      const parsed = JSON.parse(raw);
+      if (!parsed || !Array.isArray(parsed.items)) {
+        return;
+      }
+      snapshot = {
+        items: parsed.items,
+        subtotal: toNumber(parsed.subtotal),
+        tax: toNumber(parsed.tax),
+        total: toNumber(parsed.total),
+        currency: typeof parsed.currency === "string" && parsed.currency ? parsed.currency : currency,
+        isLoading: !isDemoMode
+      };
+      emit();
+    } catch {
+    }
+  }
+  async function sync() {
+    if (isDemoMode) {
+      updateSnapshot((current) => ({
+        ...current,
+        isLoading: false
+      }));
+      return;
+    }
+    updateSnapshot((current) => ({
+      ...current,
+      isLoading: true
+    }));
+    const result = await client.cart.get();
+    if (!result.ok) {
+      updateSnapshot((current) => ({
+        ...current,
+        isLoading: false
+      }));
+      throw result.error;
+    }
+    const next = mapServerCart(result.value);
+    setSnapshot({
+      ...next,
+      isLoading: false
+    });
+  }
+  async function maybeResolveQuoteId(product, quantity, options) {
+    if (options.quoteId) {
+      return options.quoteId;
+    }
+    const addOnOptionIds = normalizeOptionIds(options.addOnOptionIds);
+    const requiresQuote = Boolean(
+      options.variantId || addOnOptionIds && addOnOptionIds.length > 0 || options.bundleSelections && options.bundleSelections.length > 0 || options.compositeSelections && options.compositeSelections.length > 0
+    );
+    if (!requiresQuote || isDemoMode) {
+      return void 0;
+    }
+    const quoteResult = await client.catalogue.fetchQuote({
+      product_id: product.id,
+      quantity,
+      location_id: options.locationId || locationId || void 0,
+      variant_id: options.variantId,
+      add_on_option_ids: addOnOptionIds,
+      bundle_selections: options.bundleSelections,
+      composite_selections: options.compositeSelections
+    });
+    if (!quoteResult.ok) {
+      throw quoteResult.error;
+    }
+    return quoteResult.value.quote_id;
+  }
+  async function addItem(product, quantity = 1, options = {}) {
+    const resolvedQuantity = clampQuantity(quantity);
+    const normalizedOptions = {
+      ...options,
+      locationId: options.locationId || locationId || void 0,
+      addOnOptionIds: normalizeOptionIds(options.addOnOptionIds)
+    };
+    const maybeProductWithVariants = product;
+    if (Array.isArray(maybeProductWithVariants.variants) && maybeProductWithVariants.variants.length > 0 && !normalizedOptions.variantId) {
+      console.warn(
+        "[Cimplify] addItem() called without variantId for a product that has variants. Default variant pricing will be used."
+      );
+    }
+    const previousSnapshot = snapshot;
+    const lineKey = buildLineKey(product.id, normalizedOptions);
+    const optimisticItem = {
+      id: `tmp_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`,
+      product,
+      quantity: resolvedQuantity,
+      locationId: normalizedOptions.locationId,
+      variantId: normalizedOptions.variantId,
+      variant: normalizedOptions.variant,
+      quoteId: normalizedOptions.quoteId,
+      addOnOptionIds: normalizedOptions.addOnOptionIds,
+      addOnOptions: normalizedOptions.addOnOptions,
+      bundleSelections: normalizedOptions.bundleSelections,
+      compositeSelections: normalizedOptions.compositeSelections,
+      specialInstructions: normalizedOptions.specialInstructions
+    };
+    updateSnapshot((current) => {
+      const existingIndex = current.items.findIndex((item) => {
+        const itemKey = buildLineKey(item.product.id, {
+          locationId: item.locationId,
+          variantId: item.variantId,
+          quoteId: item.quoteId,
+          addOnOptionIds: item.addOnOptionIds,
+          bundleSelections: item.bundleSelections,
+          compositeSelections: item.compositeSelections
+        });
+        return itemKey === lineKey;
+      });
+      const nextItems = [...current.items];
+      if (existingIndex >= 0) {
+        const existing = nextItems[existingIndex];
+        nextItems[existingIndex] = {
+          ...existing,
+          quantity: existing.quantity + resolvedQuantity
+        };
+      } else {
+        nextItems.push(optimisticItem);
+      }
+      const summary = calculateSummary(nextItems);
+      return {
+        ...current,
+        items: nextItems,
+        subtotal: summary.subtotal,
+        tax: summary.tax,
+        total: summary.total
+      };
+    });
+    if (isDemoMode) {
+      return;
+    }
+    try {
+      const quoteId = await maybeResolveQuoteId(product, resolvedQuantity, normalizedOptions);
+      const result = await client.cart.addItem({
+        item_id: product.id,
+        quantity: resolvedQuantity,
+        variant_id: normalizedOptions.variantId,
+        quote_id: quoteId,
+        add_on_options: normalizedOptions.addOnOptionIds,
+        special_instructions: normalizedOptions.specialInstructions,
+        bundle_selections: normalizedOptions.bundleSelections,
+        composite_selections: normalizedOptions.compositeSelections
+      });
+      if (!result.ok) {
+        throw result.error;
+      }
+      await sync();
+    } catch (error) {
+      snapshot = previousSnapshot;
+      persistSnapshot();
+      emit();
+      throw error;
+    }
+  }
+  async function removeItem(itemId) {
+    const previousSnapshot = snapshot;
+    updateSnapshot((current) => {
+      const nextItems = current.items.filter((item) => item.id !== itemId);
+      const summary = calculateSummary(nextItems);
+      return {
+        ...current,
+        items: nextItems,
+        subtotal: summary.subtotal,
+        tax: summary.tax,
+        total: summary.total
+      };
+    });
+    if (isDemoMode) {
+      return;
+    }
+    try {
+      const result = await client.cart.removeItem(itemId);
+      if (!result.ok) {
+        throw result.error;
+      }
+      await sync();
+    } catch (error) {
+      snapshot = previousSnapshot;
+      persistSnapshot();
+      emit();
+      throw error;
+    }
+  }
+  async function updateQuantity(itemId, quantity) {
+    if (quantity <= 0) {
+      await removeItem(itemId);
+      return;
+    }
+    const resolvedQuantity = clampQuantity(quantity);
+    const previousSnapshot = snapshot;
+    updateSnapshot((current) => {
+      const nextItems = current.items.map(
+        (item) => item.id === itemId ? {
+          ...item,
+          quantity: resolvedQuantity
+        } : item
+      );
+      const summary = calculateSummary(nextItems);
+      return {
+        ...current,
+        items: nextItems,
+        subtotal: summary.subtotal,
+        tax: summary.tax,
+        total: summary.total
+      };
+    });
+    if (isDemoMode) {
+      return;
+    }
+    try {
+      const result = await client.cart.updateQuantity(itemId, resolvedQuantity);
+      if (!result.ok) {
+        throw result.error;
+      }
+      await sync();
+    } catch (error) {
+      snapshot = previousSnapshot;
+      persistSnapshot();
+      emit();
+      throw error;
+    }
+  }
+  async function clearCart() {
+    const previousSnapshot = snapshot;
+    updateSnapshot((current) => ({
+      ...current,
+      items: [],
+      subtotal: 0,
+      tax: 0,
+      total: 0
+    }));
+    if (isDemoMode) {
+      return;
+    }
+    try {
+      const result = await client.cart.clear();
+      if (!result.ok) {
+        throw result.error;
+      }
+      await sync();
+    } catch (error) {
+      snapshot = previousSnapshot;
+      persistSnapshot();
+      emit();
+      throw error;
+    }
+  }
+  async function initialize() {
+    if (initialized) {
+      if (initializePromise) {
+        await initializePromise;
+      }
+      return;
+    }
+    initialized = true;
+    hydrateFromStorage();
+    if (isDemoMode) {
+      updateSnapshot((current) => ({
+        ...current,
+        isLoading: false
+      }));
+      return;
+    }
+    initializePromise = sync().catch(() => {
+      updateSnapshot((current) => ({
+        ...current,
+        isLoading: false
+      }));
+    });
+    await initializePromise;
+    initializePromise = null;
+  }
+  return {
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    getSnapshot() {
+      return snapshot;
+    },
+    initialize,
+    addItem,
+    removeItem,
+    updateQuantity,
+    clearCart,
+    sync
+  };
+}
+function getStoreKey(client, locationId, isDemoMode) {
+  return [
+    client.getPublicKey() || "__demo__",
+    locationId || "__no_location__",
+    isDemoMode ? "demo" : "live"
+  ].join(":");
+}
+function getOrCreateStore(params) {
+  const { client, locationId, isDemoMode, currency } = params;
+  const storeKey = getStoreKey(client, locationId, isDemoMode);
+  const existing = cartStores.get(storeKey);
+  if (existing) {
+    return existing;
+  }
+  const created = createCartStore({
+    client,
+    storeKey,
+    locationId,
+    isDemoMode,
+    currency
+  });
+  cartStores.set(storeKey, created);
+  return created;
+}
+function useCart(options = {}) {
+  const context = useOptionalCimplify();
+  const client = options.client ?? context?.client;
+  if (!client) {
+    throw new Error("useCart must be used within CimplifyProvider or passed { client }.");
+  }
+  const locationId = options.locationId ?? client.getLocationId();
+  const isDemoMode = options.demoMode ?? context?.isDemoMode ?? client.getPublicKey().trim().length === 0;
+  const currency = options.currency ?? context?.currency ?? "USD";
+  const store = react.useMemo(
+    () => getOrCreateStore({
+      client,
+      locationId,
+      isDemoMode,
+      currency
+    }),
+    [client, currency, isDemoMode, locationId]
+  );
+  const snapshot = react.useSyncExternalStore(
+    store.subscribe,
+    store.getSnapshot,
+    store.getSnapshot
+  );
+  react.useEffect(() => {
+    void store.initialize();
+  }, [store]);
+  const addItem = react.useCallback(
+    async (product, quantity, addOptions) => {
+      await store.addItem(product, quantity, addOptions);
+    },
+    [store]
+  );
+  const removeItem = react.useCallback(
+    async (itemId) => {
+      await store.removeItem(itemId);
+    },
+    [store]
+  );
+  const updateQuantity = react.useCallback(
+    async (itemId, quantity) => {
+      await store.updateQuantity(itemId, quantity);
+    },
+    [store]
+  );
+  const clearCart = react.useCallback(async () => {
+    await store.clearCart();
+  }, [store]);
+  const sync = react.useCallback(async () => {
+    try {
+      await store.sync();
+    } catch (syncError) {
+      throw syncError;
+    }
+  }, [store]);
+  const itemCount = react.useMemo(
+    () => snapshot.items.reduce((sum, item) => sum + item.quantity, 0),
+    [snapshot.items]
+  );
+  return {
+    items: snapshot.items,
+    itemCount,
+    subtotal: snapshot.subtotal,
+    tax: snapshot.tax,
+    total: snapshot.total,
+    currency: snapshot.currency,
+    isEmpty: itemCount === 0,
+    isLoading: snapshot.isLoading,
+    addItem,
+    removeItem,
+    updateQuantity,
+    clearCart,
+    sync
+  };
+}
+var orderCache = /* @__PURE__ */ new Map();
+var orderInflight = /* @__PURE__ */ new Map();
+function buildOrderCacheKey(client, orderId) {
+  return `${client.getPublicKey() || "__demo__"}:${orderId}`;
+}
+function useOrder(orderId, options = {}) {
+  const context = useOptionalCimplify();
+  const client = options.client ?? context?.client;
+  if (!client) {
+    throw new Error("useOrder must be used within CimplifyProvider or passed { client }.");
+  }
+  const normalizedOrderId = react.useMemo(() => (orderId || "").trim(), [orderId]);
+  const enabled = options.enabled ?? true;
+  const poll = options.poll ?? false;
+  const pollInterval = options.pollInterval ?? 5e3;
+  const requestIdRef = react.useRef(0);
+  const cacheKey = react.useMemo(
+    () => buildOrderCacheKey(client, normalizedOrderId),
+    [client, normalizedOrderId]
+  );
+  const cached = orderCache.get(cacheKey);
+  const [order, setOrder] = react.useState(cached?.order ?? null);
+  const [isLoading, setIsLoading] = react.useState(
+    enabled && normalizedOrderId.length > 0 && !cached
+  );
+  const [error, setError] = react.useState(null);
+  const load = react.useCallback(
+    async (force = false) => {
+      if (!enabled || normalizedOrderId.length === 0) {
+        setOrder(null);
+        setIsLoading(false);
+        return;
+      }
+      const nextRequestId = ++requestIdRef.current;
+      setError(null);
+      if (!force) {
+        const cacheEntry = orderCache.get(cacheKey);
+        if (cacheEntry) {
+          setOrder(cacheEntry.order);
+          setIsLoading(false);
+          return;
+        }
+      }
+      setIsLoading(true);
+      try {
+        const existing = orderInflight.get(cacheKey);
+        const promise = existing ?? (async () => {
+          const result = await client.orders.get(normalizedOrderId);
+          if (!result.ok) {
+            throw result.error;
+          }
+          return result.value;
+        })();
+        if (!existing) {
+          orderInflight.set(
+            cacheKey,
+            promise.finally(() => {
+              orderInflight.delete(cacheKey);
+            })
+          );
+        }
+        const value = await promise;
+        orderCache.set(cacheKey, { order: value });
+        if (nextRequestId === requestIdRef.current) {
+          setOrder(value);
+          setError(null);
+        }
+      } catch (loadError) {
+        if (nextRequestId === requestIdRef.current) {
+          setError(loadError);
+        }
+      } finally {
+        if (nextRequestId === requestIdRef.current) {
+          setIsLoading(false);
+        }
+      }
+    },
+    [cacheKey, client, enabled, normalizedOrderId]
+  );
+  react.useEffect(() => {
+    void load(false);
+  }, [load]);
+  react.useEffect(() => {
+    if (!poll || !enabled || normalizedOrderId.length === 0) {
+      return;
+    }
+    const timer = window.setInterval(() => {
+      void load(true);
+    }, Math.max(1e3, pollInterval));
+    return () => {
+      window.clearInterval(timer);
+    };
+  }, [enabled, load, normalizedOrderId.length, poll, pollInterval]);
+  const refetch = react.useCallback(async () => {
+    orderCache.delete(cacheKey);
+    await load(true);
+  }, [cacheKey, load]);
+  return { order, isLoading, error, refetch };
+}
+var LOCATION_STORAGE_KEY2 = "cimplify_location_id";
+function readStoredLocationId() {
+  if (typeof window === "undefined" || !window.localStorage) {
+    return null;
+  }
+  const value = window.localStorage.getItem(LOCATION_STORAGE_KEY2);
+  if (!value) {
+    return null;
+  }
+  const normalized = value.trim();
+  return normalized.length > 0 ? normalized : null;
+}
+function writeStoredLocationId(locationId) {
+  if (typeof window === "undefined" || !window.localStorage) {
+    return;
+  }
+  if (!locationId) {
+    window.localStorage.removeItem(LOCATION_STORAGE_KEY2);
+    return;
+  }
+  window.localStorage.setItem(LOCATION_STORAGE_KEY2, locationId);
+}
+function resolveLocation(locations, preferredId) {
+  if (locations.length === 0) {
+    return null;
+  }
+  if (preferredId) {
+    const found = locations.find((location) => location.id === preferredId);
+    if (found) {
+      return found;
+    }
+  }
+  return locations[0];
+}
+function useLocations(options = {}) {
+  const context = useOptionalCimplify();
+  if (context && (!options.client || context.client === options.client)) {
+    return {
+      locations: context.locations,
+      currentLocation: context.currentLocation,
+      setCurrentLocation: context.setCurrentLocation,
+      isLoading: !context.isReady
+    };
+  }
+  const client = options.client;
+  const [locations, setLocations] = react.useState([]);
+  const [currentLocation, setCurrentLocationState] = react.useState(null);
+  const [isLoading, setIsLoading] = react.useState(true);
+  const setCurrentLocation = react.useCallback(
+    (location) => {
+      setCurrentLocationState(location);
+      if (client) {
+        client.setLocationId(location.id);
+      }
+      writeStoredLocationId(location.id);
+    },
+    [client]
+  );
+  react.useEffect(() => {
+    if (!client) {
+      setLocations([]);
+      setCurrentLocationState(null);
+      setIsLoading(false);
+      return;
+    }
+    const activeClient = client;
+    let cancelled = false;
+    async function loadLocations() {
+      setIsLoading(true);
+      const result = await activeClient.business.getLocations();
+      if (cancelled) {
+        return;
+      }
+      if (!result.ok) {
+        setLocations([]);
+        setCurrentLocationState(null);
+        setIsLoading(false);
+        return;
+      }
+      const nextLocations = result.value;
+      const preferredId = activeClient.getLocationId() ?? readStoredLocationId();
+      const resolved = resolveLocation(nextLocations, preferredId);
+      setLocations(nextLocations);
+      setCurrentLocationState(resolved);
+      activeClient.setLocationId(resolved?.id || null);
+      writeStoredLocationId(resolved?.id || null);
+      setIsLoading(false);
+    }
+    void loadLocations();
+    return () => {
+      cancelled = true;
+    };
+  }, [client]);
+  return {
+    locations,
+    currentLocation,
+    setCurrentLocation,
+    isLoading
+  };
+}
 var ElementsContext = react.createContext({
   elements: null,
   isReady: false
@@ -4032,7 +5254,14 @@ exports.CimplifyProvider = CimplifyProvider;
 exports.ElementsProvider = ElementsProvider;
 exports.PaymentElement = PaymentElement;
 exports.useAds = useAds;
+exports.useCart = useCart;
+exports.useCategories = useCategories;
 exports.useCheckout = useCheckout;
 exports.useCimplify = useCimplify;
 exports.useElements = useElements;
 exports.useElementsReady = useElementsReady;
+exports.useLocations = useLocations;
+exports.useOptionalCimplify = useOptionalCimplify;
+exports.useOrder = useOrder;
+exports.useProduct = useProduct;
+exports.useProducts = useProducts;