@viu/emporix-sdk-react 1.0.0

package/dist/index.cjs

@@ -0,0 +1,1849 @@
+'use strict';
+
+var react = require('react');
+var reactQuery = require('@tanstack/react-query');
+var emporixSdk = require('@viu/emporix-sdk');
+var jsxRuntime = require('react/jsx-runtime');
+
+// src/provider.tsx
+
+// src/storage/local-storage.ts
+var DEFAULT_TOKEN_KEY = "emporix.customerToken";
+var CART_KEY = "emporix.cartId";
+var ANON_KEY = "emporix.anonymousSession";
+var SITE_KEY = "emporix.siteCode";
+var ACTIVE_LE_KEY = "emporix.activeLegalEntityId";
+var REFRESH_KEY = "emporix.refreshToken";
+function createLocalStorageStorage(opts = {}) {
+  const tokenKey = opts.key ?? DEFAULT_TOKEN_KEY;
+  const available = typeof globalThis !== "undefined" && typeof globalThis.localStorage !== "undefined";
+  if (!available) {
+    console.warn("[emporix] localStorage unavailable; falling back to in-memory storage");
+    return createMemoryStorage();
+  }
+  const ls = globalThis.localStorage;
+  const tokenListeners = /* @__PURE__ */ new Set();
+  const all = createListenerSet();
+  return {
+    getCustomerToken: () => ls.getItem(tokenKey),
+    setCustomerToken: (t) => {
+      if (t === null) ls.removeItem(tokenKey);
+      else ls.setItem(tokenKey, t);
+      for (const l of tokenListeners) l(t);
+      all.notify("customerToken");
+    },
+    subscribe: (l) => {
+      tokenListeners.add(l);
+      return () => tokenListeners.delete(l);
+    },
+    getCartId: () => ls.getItem(CART_KEY),
+    setCartId: (id) => {
+      if (id === null) ls.removeItem(CART_KEY);
+      else ls.setItem(CART_KEY, id);
+      all.notify("cartId");
+    },
+    getAnonymousSession: () => parseAnonymousSession(ls.getItem(ANON_KEY)),
+    setAnonymousSession: (s) => {
+      if (s === null) ls.removeItem(ANON_KEY);
+      else ls.setItem(ANON_KEY, JSON.stringify({ refreshToken: s.refreshToken, sessionId: s.sessionId }));
+      all.notify("anonymousSession");
+    },
+    getSiteCode: () => ls.getItem(SITE_KEY),
+    setSiteCode: (code) => {
+      if (code === null) ls.removeItem(SITE_KEY);
+      else ls.setItem(SITE_KEY, code);
+      all.notify("siteCode");
+    },
+    getActiveLegalEntityId: () => ls.getItem(ACTIVE_LE_KEY),
+    setActiveLegalEntityId: (id) => {
+      if (id === null) ls.removeItem(ACTIVE_LE_KEY);
+      else ls.setItem(ACTIVE_LE_KEY, id);
+      all.notify("activeLegalEntityId");
+    },
+    getRefreshToken: () => ls.getItem(REFRESH_KEY),
+    setRefreshToken: (t) => {
+      if (t === null) ls.removeItem(REFRESH_KEY);
+      else ls.setItem(REFRESH_KEY, t);
+      all.notify("refreshToken");
+    },
+    subscribeAll: (l) => all.add(l)
+  };
+}
+
+// src/storage/cookie.ts
+var DEFAULT_TOKEN_NAME = "emporix.customerToken";
+var CART_NAME = "emporix.cartId";
+var ANON_NAME = "emporix.anonymousSession";
+var SITE_NAME = "emporix.siteCode";
+var ACTIVE_LE_NAME = "emporix.activeLegalEntityId";
+var REFRESH_NAME = "emporix.refreshToken";
+function createCookieStorage(opts = {}) {
+  const tokenName = opts.name ?? DEFAULT_TOKEN_NAME;
+  const sameSite = opts.sameSite ?? "lax";
+  const secure = opts.secure ?? false;
+  if (typeof document === "undefined") {
+    console.warn("[emporix] document unavailable; cookie storage falling back to in-memory");
+    return createMemoryStorage();
+  }
+  const attrs = `path=/; SameSite=${sameSite}${secure ? "; Secure" : ""}`;
+  const readCookie = (name) => {
+    for (const part of document.cookie.split("; ")) {
+      const [k, ...v] = part.split("=");
+      if (k === name) return decodeURIComponent(v.join("=")) || null;
+    }
+    return null;
+  };
+  const writeCookie = (name, value) => {
+    document.cookie = value === null ? `${name}=; expires=Thu, 01 Jan 1970 00:00:00 GMT; ${attrs}` : `${name}=${encodeURIComponent(value)}; ${attrs}`;
+  };
+  const all = createListenerSet();
+  return {
+    getCustomerToken: () => readCookie(tokenName),
+    setCustomerToken: (t) => {
+      writeCookie(tokenName, t);
+      all.notify("customerToken");
+    },
+    getCartId: () => readCookie(CART_NAME),
+    setCartId: (id) => {
+      writeCookie(CART_NAME, id);
+      all.notify("cartId");
+    },
+    getAnonymousSession: () => parseAnonymousSession(readCookie(ANON_NAME)),
+    setAnonymousSession: (s) => {
+      writeCookie(
+        ANON_NAME,
+        s === null ? null : JSON.stringify({ refreshToken: s.refreshToken, sessionId: s.sessionId })
+      );
+      all.notify("anonymousSession");
+    },
+    getSiteCode: () => readCookie(SITE_NAME),
+    setSiteCode: (code) => {
+      writeCookie(SITE_NAME, code);
+      all.notify("siteCode");
+    },
+    getActiveLegalEntityId: () => readCookie(ACTIVE_LE_NAME),
+    setActiveLegalEntityId: (id) => {
+      writeCookie(ACTIVE_LE_NAME, id);
+      all.notify("activeLegalEntityId");
+    },
+    getRefreshToken: () => readCookie(REFRESH_NAME),
+    setRefreshToken: (t) => {
+      writeCookie(REFRESH_NAME, t);
+      all.notify("refreshToken");
+    },
+    subscribeAll: (l) => all.add(l)
+  };
+}
+
+// src/storage/index.ts
+function createListenerSet() {
+  const listeners = /* @__PURE__ */ new Set();
+  return {
+    add(l) {
+      listeners.add(l);
+      return () => listeners.delete(l);
+    },
+    notify(value) {
+      for (const l of listeners) {
+        try {
+          l(value);
+        } catch {
+        }
+      }
+    }
+  };
+}
+function parseAnonymousSession(raw) {
+  if (!raw) return null;
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.refreshToken === "string" && typeof parsed.sessionId === "string") {
+      return { refreshToken: parsed.refreshToken, sessionId: parsed.sessionId };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+// src/storage/memory.ts
+function createMemoryStorage(opts = {}) {
+  let token = opts.initial ?? null;
+  let cartId = null;
+  let anon = null;
+  let siteCode = null;
+  let activeLegalEntityId = null;
+  let refreshToken = null;
+  const tokenListeners = /* @__PURE__ */ new Set();
+  const all = createListenerSet();
+  return {
+    getCustomerToken: () => token,
+    setCustomerToken: (t) => {
+      token = t;
+      for (const l of tokenListeners) l(token);
+      all.notify("customerToken");
+    },
+    subscribe: (l) => {
+      tokenListeners.add(l);
+      return () => tokenListeners.delete(l);
+    },
+    getCartId: () => cartId,
+    setCartId: (id) => {
+      cartId = id;
+      all.notify("cartId");
+    },
+    getAnonymousSession: () => anon,
+    setAnonymousSession: (s) => {
+      anon = s;
+      all.notify("anonymousSession");
+    },
+    getSiteCode: () => siteCode,
+    setSiteCode: (code) => {
+      siteCode = code;
+      all.notify("siteCode");
+    },
+    getActiveLegalEntityId: () => activeLegalEntityId,
+    setActiveLegalEntityId: (id) => {
+      activeLegalEntityId = id;
+      all.notify("activeLegalEntityId");
+    },
+    getRefreshToken: () => refreshToken,
+    setRefreshToken: (t) => {
+      refreshToken = t;
+      all.notify("refreshToken");
+    },
+    subscribeAll: (l) => all.add(l)
+  };
+}
+var EmporixTelemetryContext = react.createContext(null);
+function useEmporixTelemetry() {
+  const ctx = react.useContext(EmporixTelemetryContext);
+  if (!ctx) {
+    throw new Error("useEmporixTelemetry must be used within an EmporixProvider");
+  }
+  return ctx;
+}
+var NULL_CTX = {
+  activeCompany: null,
+  myCompanies: [],
+  mode: "b2c",
+  status: "idle",
+  error: null,
+  setActiveCompany: async () => {
+    throw new Error("CompanyContextProvider not mounted");
+  },
+  refetchMyCompanies: async () => {
+  }
+};
+var EmporixCompanyContext = react.createContext(NULL_CTX);
+function useActiveCompany() {
+  return react.useContext(EmporixCompanyContext);
+}
+function CompanyContextProvider({
+  client,
+  storage,
+  initialActiveLegalEntityId,
+  children
+}) {
+  const qc = reactQuery.useQueryClient();
+  const { emit } = useEmporixTelemetry();
+  const [myCompanies, setMyCompanies] = react.useState([]);
+  const [activeCompany, setActive] = react.useState(null);
+  const [status, setStatus] = react.useState("idle");
+  const [error, setError] = react.useState(null);
+  const activeRef = react.useRef(null);
+  activeRef.current = activeCompany;
+  const switchTo = react.useCallback(
+    async (target) => {
+      const start = Date.now();
+      const from = activeRef.current?.id ?? null;
+      const refreshToken = storage.getRefreshToken();
+      const token = storage.getCustomerToken();
+      if (!refreshToken || !token) {
+        setActive(target);
+        storage.setActiveLegalEntityId(target?.id ?? null);
+      } else {
+        const next = await client.customers.refresh({
+          refreshToken,
+          ...target ? { legalEntityId: target.id } : {}
+        });
+        storage.setCustomerToken(next.customerToken);
+        if (next.refreshToken) storage.setRefreshToken(next.refreshToken);
+        storage.setCartId(null);
+        storage.setActiveLegalEntityId(target?.id ?? null);
+        setActive(target);
+        qc.invalidateQueries({
+          predicate: (q) => Array.isArray(q.queryKey) && q.queryKey.some(
+            (k) => k === "cart" || k === "companies" || k === "customer" || k === from || target !== null && k === target.id
+          )
+        });
+      }
+      emit({
+        type: "company:switched",
+        from,
+        to: target?.id ?? null,
+        durationMs: Date.now() - start
+      });
+    },
+    [client, storage, qc, emit]
+  );
+  const load = react.useCallback(async () => {
+    const token = storage.getCustomerToken();
+    if (!token) {
+      setMyCompanies([]);
+      setActive(null);
+      setStatus("idle");
+      return;
+    }
+    setStatus("loading");
+    try {
+      const companies = await client.companies.listMine(emporixSdk.auth.customer(token));
+      setMyCompanies(companies);
+      const persisted = initialActiveLegalEntityId ?? storage.getActiveLegalEntityId();
+      const matched = persisted ? companies.find((c) => c.id === persisted) ?? null : null;
+      if (matched) {
+        setActive(matched);
+        if (storage.getActiveLegalEntityId() !== matched.id) {
+          storage.setActiveLegalEntityId(matched.id);
+        }
+      } else if (companies.length === 1) {
+        await switchTo(companies[0] ?? null);
+      } else {
+        setActive(null);
+        if (persisted && !matched) storage.setActiveLegalEntityId(null);
+      }
+      setStatus("idle");
+    } catch (e) {
+      setError(e);
+      setStatus("error");
+    }
+  }, [client, storage, initialActiveLegalEntityId, switchTo]);
+  react.useEffect(() => {
+    void load();
+  }, [load]);
+  react.useEffect(() => {
+    let prev = storage.getCustomerToken();
+    return storage.subscribe?.((next) => {
+      const becameAuth = !prev && next;
+      const becameUnauth = prev && !next;
+      prev = next;
+      if (becameAuth || becameUnauth) void load();
+    });
+  }, [storage, load]);
+  const setActiveCompany = react.useCallback(
+    async (legalEntityId) => {
+      setStatus("switching");
+      try {
+        if (legalEntityId === null) {
+          await switchTo(null);
+        } else {
+          const target = myCompanies.find((c) => c.id === legalEntityId) ?? null;
+          if (!target) throw new Error(`setActiveCompany: unknown legalEntityId ${legalEntityId}`);
+          await switchTo(target);
+        }
+        setStatus("idle");
+      } catch (e) {
+        setError(e);
+        setStatus("error");
+        throw e;
+      }
+    },
+    [myCompanies, switchTo]
+  );
+  const value = react.useMemo(() => {
+    const mode = activeCompany ? "b2b" : myCompanies.length > 1 ? "unresolved" : "b2c";
+    return {
+      activeCompany,
+      myCompanies,
+      mode,
+      status,
+      error,
+      setActiveCompany,
+      refetchMyCompanies: load
+    };
+  }, [activeCompany, myCompanies, status, error, setActiveCompany, load]);
+  return /* @__PURE__ */ jsxRuntime.jsx(EmporixCompanyContext.Provider, { value, children });
+}
+var EmporixContext = react.createContext(null);
+var EmporixSiteContext = react.createContext(null);
+var DEFAULT_QUERY_OPTIONS = {
+  staleTime: 3e4,
+  refetchOnWindowFocus: false,
+  retry: 1
+};
+function EmporixProvider({
+  client,
+  queryClient,
+  storage,
+  initialCustomerToken,
+  initialSiteCode,
+  initialActiveLegalEntityId,
+  onTelemetry,
+  children
+}) {
+  const value = react.useMemo(() => {
+    const s = storage ?? createMemoryStorage(
+      initialCustomerToken !== void 0 ? { initial: initialCustomerToken } : {}
+    );
+    if (initialCustomerToken && storage && storage.getCustomerToken() === null) {
+      storage.setCustomerToken(initialCustomerToken);
+    }
+    return { client, storage: s };
+  }, [client, storage, initialCustomerToken]);
+  const qc = react.useMemo(
+    () => queryClient ?? new reactQuery.QueryClient({ defaultOptions: { queries: DEFAULT_QUERY_OPTIONS } }),
+    [queryClient]
+  );
+  react.useState(() => {
+    client.tokenProvider.attachAnonymousStore?.({
+      read: () => value.storage.getAnonymousSession(),
+      write: (s) => value.storage.setAnonymousSession(s)
+    });
+    return null;
+  });
+  const safeEmit = react.useCallback(
+    (event) => {
+      if (!onTelemetry) return;
+      try {
+        onTelemetry(event);
+      } catch (err) {
+        console.error("[emporix] telemetry handler threw:", err);
+      }
+    },
+    [onTelemetry]
+  );
+  const telemetryValue = react.useMemo(() => ({ emit: safeEmit }), [safeEmit]);
+  react.useEffect(() => {
+    if (!onTelemetry) return;
+    const startedAt = /* @__PURE__ */ new Map();
+    const unsubQuery = qc.getQueryCache().subscribe((event) => {
+      const key = event.query.queryKey;
+      if (!Array.isArray(key) || key[0] !== "emporix") return;
+      if (event.type === "updated") {
+        const action = event.action;
+        if (action.type === "fetch") {
+          const isRefetch = event.query.state.dataUpdateCount > 0;
+          if (isRefetch) {
+            safeEmit({
+              type: "query.refetch",
+              queryKey: key,
+              tenant: client.tenant,
+              reason: "invalidate"
+            });
+          }
+          startedAt.set(event.query.queryHash, Date.now());
+        } else if (action.type === "success") {
+          const start = startedAt.get(event.query.queryHash);
+          startedAt.delete(event.query.queryHash);
+          safeEmit({
+            type: "cache.miss",
+            queryKey: key,
+            tenant: client.tenant,
+            durationMs: start ? Date.now() - start : 0
+          });
+        } else if (action.type === "error") {
+          startedAt.delete(event.query.queryHash);
+          safeEmit({
+            type: "query.error",
+            queryKey: key,
+            tenant: client.tenant,
+            error: event.query.state.error
+          });
+        }
+      } else if (event.type === "observerResultsUpdated") {
+        const s = event.query.state;
+        if (s.status === "success" && s.fetchStatus === "idle" && s.dataUpdateCount > 0) {
+          safeEmit({ type: "cache.hit", queryKey: key, tenant: client.tenant });
+        }
+      }
+    });
+    const unsubMut = qc.getMutationCache().subscribe((event) => {
+      if (event.type !== "updated") return;
+      const m = event.mutation;
+      const dur = Date.now() - (m.state.submittedAt ?? Date.now());
+      const mk = m.options.mutationKey;
+      if (m.state.status === "success") {
+        safeEmit({
+          type: "mutation.success",
+          ...mk ? { mutationKey: mk } : {},
+          tenant: client.tenant,
+          durationMs: dur
+        });
+      } else if (m.state.status === "error") {
+        safeEmit({
+          type: "mutation.error",
+          ...mk ? { mutationKey: mk } : {},
+          tenant: client.tenant,
+          error: m.state.error,
+          durationMs: dur
+        });
+      }
+    });
+    const unsubAuth = client.tokenProvider.onRefresh?.(
+      (evt) => safeEmit({ type: "auth.refresh", ...evt, tenant: client.tenant })
+    );
+    const unsubStorage = value.storage.subscribeAll?.(
+      (key) => safeEmit({ type: "storage.write", key })
+    );
+    return () => {
+      unsubQuery();
+      unsubMut();
+      unsubAuth?.();
+      unsubStorage?.();
+    };
+  }, [qc, onTelemetry, client, value.storage, safeEmit]);
+  return /* @__PURE__ */ jsxRuntime.jsx(EmporixContext.Provider, { value, children: /* @__PURE__ */ jsxRuntime.jsx(EmporixTelemetryContext.Provider, { value: telemetryValue, children: /* @__PURE__ */ jsxRuntime.jsx(reactQuery.QueryClientProvider, { client: qc, children: /* @__PURE__ */ jsxRuntime.jsx(
+    SiteContextProvider,
+    {
+      client,
+      storage: value.storage,
+      ...initialSiteCode !== void 0 ? { initialSiteCode } : {},
+      children: /* @__PURE__ */ jsxRuntime.jsx(
+        CompanyContextProvider,
+        {
+          client,
+          storage: value.storage,
+          ...initialActiveLegalEntityId !== void 0 ? { initialActiveLegalEntityId } : {},
+          children
+        }
+      )
+    }
+  ) }) }) });
+}
+function SiteContextProvider({
+  client,
+  storage,
+  initialSiteCode,
+  children
+}) {
+  const qc = reactQuery.useQueryClient();
+  const [siteCode, setSiteCodeState] = react.useState(() => {
+    if (initialSiteCode !== void 0) return initialSiteCode;
+    const fromStorage = storage.getSiteCode();
+    if (fromStorage !== null) return fromStorage;
+    return client.config?.credentials?.storefront?.context?.siteCode ?? null;
+  });
+  const [currency, setCurrency] = react.useState(null);
+  const [targetLocation, setTargetLocation] = react.useState(null);
+  const [isSwitching, setIsSwitching] = react.useState(false);
+  const [switchError, setSwitchError] = react.useState(null);
+  react.useEffect(() => {
+    if (!siteCode || currency !== null) return;
+    let cancelled = false;
+    const token = storage.getCustomerToken();
+    const authCtx = token ? emporixSdk.auth.customer(token) : emporixSdk.auth.anonymous();
+    qc.fetchQuery({
+      queryKey: [
+        "emporix",
+        "site-by-code",
+        siteCode,
+        { tenant: client.tenant, authKind: authCtx.kind }
+      ],
+      queryFn: () => client.sites.get(siteCode, authCtx),
+      staleTime: 5 * 6e4
+    }).then((site) => {
+      if (cancelled) return;
+      setCurrency(site.currency);
+      setTargetLocation(site.homeBase?.address?.country ?? null);
+    }).catch(() => {
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [siteCode]);
+  const setSite = react.useCallback(
+    async (code) => {
+      storage.setSiteCode(code);
+      storage.setCartId(null);
+      setSiteCodeState(code);
+      setSwitchError(null);
+      void qc.invalidateQueries({ queryKey: ["emporix"] });
+      if (code === null) {
+        setCurrency(null);
+        setTargetLocation(null);
+        return;
+      }
+      setIsSwitching(true);
+      try {
+        const token = storage.getCustomerToken();
+        const authCtx = token ? emporixSdk.auth.customer(token) : emporixSdk.auth.anonymous();
+        const site = await qc.fetchQuery({
+          queryKey: [
+            "emporix",
+            "site-by-code",
+            code,
+            { tenant: client.tenant, authKind: authCtx.kind }
+          ],
+          queryFn: () => client.sites.get(code, authCtx),
+          staleTime: 5 * 6e4
+        });
+        const nextCurrency = site.currency;
+        const nextTarget = site.homeBase?.address?.country ?? null;
+        setCurrency(nextCurrency);
+        setTargetLocation(nextTarget);
+        await client.sessionContext.patch(
+          {
+            siteCode: code,
+            ...nextCurrency ? { currency: nextCurrency } : {},
+            ...nextTarget ? { targetLocation: nextTarget } : {}
+          },
+          authCtx
+        );
+      } catch (e) {
+        setSwitchError(e instanceof Error ? e : new Error(String(e)));
+      } finally {
+        setIsSwitching(false);
+      }
+    },
+    [client, storage, qc]
+  );
+  const value = react.useMemo(
+    () => ({
+      siteCode,
+      currency,
+      targetLocation,
+      setSite,
+      isSwitching,
+      switchError
+    }),
+    [siteCode, currency, targetLocation, setSite, isSwitching, switchError]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(EmporixSiteContext.Provider, { value, children });
+}
+function useEmporix() {
+  const ctx = react.useContext(EmporixContext);
+  if (!ctx) throw new Error("useEmporix must be used within an EmporixProvider");
+  return ctx;
+}
+
+// src/hooks/internal/bootstrap-cart.ts
+async function bootstrapCart(opts) {
+  return opts.qc.fetchQuery({
+    queryKey: [
+      "emporix",
+      "cart-bootstrap",
+      {
+        tenant: opts.client.tenant,
+        // ctx.kind is the discriminator of AuthContext — same string as the
+        // legacy `authKind` param, derived directly so callers can't drift.
+        authKind: opts.ctx.kind,
+        siteCode: opts.siteCode,
+        ...opts.type !== void 0 ? { type: opts.type } : {},
+        ...opts.legalEntityId !== void 0 ? { legalEntityId: opts.legalEntityId } : {}
+      }
+    ],
+    queryFn: () => opts.client.carts.getCurrent(opts.ctx, {
+      siteCode: opts.siteCode,
+      ...opts.type !== void 0 ? { type: opts.type } : {},
+      ...opts.legalEntityId !== void 0 ? { legalEntityId: opts.legalEntityId } : {},
+      create: true
+    }),
+    staleTime: Infinity
+  });
+}
+
+// src/hooks/use-customer-session.ts
+var EMPTY_SESSION = {
+  token: null,
+  refreshToken: null,
+  saasToken: null
+};
+function useCustomerSession() {
+  const { client, storage } = useEmporix();
+  const qc = reactQuery.useQueryClient();
+  const siteCtx = react.useContext(EmporixSiteContext);
+  const [session, setSession] = react.useState(() => ({
+    token: storage.getCustomerToken(),
+    refreshToken: null,
+    saasToken: null
+  }));
+  react.useEffect(() => {
+    return storage.subscribe?.((t) => setSession((s) => ({ ...s, token: t })));
+  }, [storage]);
+  const meQuery = reactQuery.useQuery({
+    queryKey: ["emporix", "customer", "me", { tenant: client.tenant, hasToken: session.token !== null }],
+    enabled: session.token !== null,
+    queryFn: () => client.customers.me(emporixSdk.auth.customer(session.token)),
+    // 30s — matches Balanced default. Lets honourPreferredSite's fetchQuery
+    // (with staleTime: Infinity) reuse the cache instead of refetching.
+    staleTime: 3e4
+  });
+  const login = react.useCallback(
+    async (input) => {
+      const result = await client.customers.login(input);
+      storage.setCustomerToken(result.customerToken);
+      storage.setRefreshToken(result.refreshToken || null);
+      setSession({
+        token: result.customerToken,
+        refreshToken: result.refreshToken || null,
+        saasToken: result.saasToken || null
+      });
+      await onboardCustomerCart({
+        qc,
+        client,
+        storage,
+        customerToken: result.customerToken
+      });
+      await honourPreferredSite({
+        qc,
+        client,
+        customerToken: result.customerToken,
+        siteCtx
+      });
+      await qc.invalidateQueries({ queryKey: ["emporix", "customer"], refetchType: "none" });
+      await qc.invalidateQueries({ queryKey: ["emporix", "cart"], refetchType: "none" });
+    },
+    [client, storage, qc, siteCtx]
+  );
+  const signup = react.useCallback(
+    async (input) => {
+      await client.customers.signup(input);
+    },
+    [client]
+  );
+  const applySession = react.useCallback(
+    async (incoming) => {
+      storage.setCustomerToken(incoming.customerToken);
+      storage.setRefreshToken(incoming.refreshToken || null);
+      setSession({
+        token: incoming.customerToken,
+        refreshToken: incoming.refreshToken || null,
+        saasToken: incoming.saasToken || null
+      });
+      await onboardCustomerCart({
+        qc,
+        client,
+        storage,
+        customerToken: incoming.customerToken
+      });
+      await honourPreferredSite({
+        qc,
+        client,
+        customerToken: incoming.customerToken,
+        siteCtx
+      });
+      await qc.invalidateQueries({ queryKey: ["emporix", "customer"], refetchType: "none" });
+      await qc.invalidateQueries({ queryKey: ["emporix", "cart"], refetchType: "none" });
+    },
+    [client, storage, qc, siteCtx]
+  );
+  const socialLogin = react.useCallback(
+    async (input) => {
+      await applySession(await client.customers.socialLogin(input));
+    },
+    [client, applySession]
+  );
+  const exchangeToken = react.useCallback(
+    async (input) => {
+      await applySession(await client.customers.exchangeToken(input));
+    },
+    [client, applySession]
+  );
+  const logout = react.useCallback(async () => {
+    if (session.token) {
+      try {
+        await client.customers.logout(emporixSdk.auth.customer(session.token));
+      } catch {
+      }
+    }
+    storage.setCustomerToken(null);
+    storage.setRefreshToken(null);
+    storage.setActiveLegalEntityId(null);
+    setSession(EMPTY_SESSION);
+    qc.removeQueries({ queryKey: ["emporix", "customer"] });
+    qc.removeQueries({ queryKey: ["emporix", "cart"] });
+  }, [client, session.token, storage, qc]);
+  const refresh = react.useCallback(async () => {
+    await meQuery.refetch();
+  }, [meQuery]);
+  const refreshSession = react.useCallback(async () => {
+    if (!session.refreshToken) return;
+    const refreshed = await client.customers.refresh({
+      refreshToken: session.refreshToken,
+      ...session.saasToken ? { saasToken: session.saasToken } : {}
+    });
+    storage.setCustomerToken(refreshed.customerToken);
+    if (refreshed.refreshToken) storage.setRefreshToken(refreshed.refreshToken);
+    setSession((s) => ({
+      token: refreshed.customerToken,
+      refreshToken: refreshed.refreshToken || s.refreshToken,
+      saasToken: refreshed.saasToken || s.saasToken
+    }));
+    await qc.invalidateQueries({ queryKey: ["emporix", "customer"] });
+    await qc.invalidateQueries({ queryKey: ["emporix", "cart"] });
+  }, [client, storage, qc, session.refreshToken, session.saasToken]);
+  return {
+    customerToken: session.token,
+    refreshToken: session.refreshToken,
+    customer: meQuery.data ?? null,
+    isAuthenticated: session.token !== null,
+    isLoading: meQuery.isLoading && session.token !== null,
+    login,
+    signup,
+    socialLogin,
+    exchangeToken,
+    logout,
+    refresh,
+    refreshSession
+  };
+}
+async function honourPreferredSite(opts) {
+  const { qc, client, customerToken, siteCtx } = opts;
+  if (!siteCtx) return;
+  try {
+    const me = await qc.fetchQuery({
+      queryKey: [
+        "emporix",
+        "customer",
+        "me",
+        { tenant: client.tenant, hasToken: true }
+      ],
+      queryFn: () => client.customers.me(emporixSdk.auth.customer(customerToken)),
+      // Reuse whatever meQuery already wrote (login flow runs meQuery in
+      // parallel). Without this, fetchQuery refetches if meQuery's data is
+      // already stale (default staleTime: 0 on meQuery).
+      staleTime: Infinity
+    });
+    const preferred = me.preferredSite;
+    if (preferred && siteCtx.siteCode !== preferred) {
+      await siteCtx.setSite(preferred);
+    }
+  } catch {
+  }
+}
+async function onboardCustomerCart(opts) {
+  const { qc, client, storage, customerToken } = opts;
+  const siteCode = client.config?.credentials?.storefront?.context?.siteCode;
+  if (!siteCode) return;
+  const ctx = emporixSdk.auth.customer(customerToken);
+  try {
+    const customerCart = await bootstrapCart({
+      qc,
+      client,
+      ctx,
+      siteCode
+    });
+    const customerCartId = customerCart?.id;
+    if (!customerCartId) return;
+    const anonCartId = storage.getCartId();
+    if (anonCartId && anonCartId !== customerCartId) {
+      await client.carts.merge(customerCartId, [anonCartId], ctx);
+    }
+    storage.setCartId(customerCartId);
+  } catch {
+  }
+}
+function useReadAuth(override) {
+  const { storage } = useEmporix();
+  if (override) return { ctx: override };
+  const token = storage.getCustomerToken();
+  return token ? { ctx: emporixSdk.auth.customer(token) } : { ctx: emporixSdk.auth.anonymous() };
+}
+function useCustomerOnlyCtx() {
+  const { storage } = useEmporix();
+  const token = storage.getCustomerToken();
+  if (!token) {
+    throw new Error("Requires a logged-in customer (no token in storage)");
+  }
+  return emporixSdk.auth.customer(token);
+}
+function useReadSite() {
+  const ctx = react.useContext(EmporixSiteContext);
+  return { siteCode: ctx?.siteCode ?? null };
+}
+
+// src/hooks/internal/query-keys.ts
+function emporixKey(resource, args, context) {
+  const meta = {
+    tenant: context.tenant,
+    authKind: context.authKind
+  };
+  if (context.siteCode !== void 0) {
+    meta.siteCode = context.siteCode;
+  }
+  return ["emporix", resource, ...args, meta];
+}
+function useEmporixInfinite(opts) {
+  return reactQuery.useInfiniteQuery({
+    queryKey: opts.queryKey,
+    initialPageParam: 1,
+    queryFn: ({ pageParam }) => opts.fetchPage(pageParam),
+    getNextPageParam: (last) => last.hasNextPage ? last.pageNumber + 1 : void 0,
+    ...opts.enabled !== void 0 ? { enabled: opts.enabled } : {},
+    ...opts.staleTime !== void 0 ? { staleTime: opts.staleTime } : {}
+  });
+}
+
+// src/hooks/use-products.ts
+var PRODUCTS_STALE_TIME = 6e4;
+function useProduct(productId, options = {}) {
+  const { client } = useEmporix();
+  const { ctx } = useReadAuth(options.auth);
+  const { siteCode } = useReadSite();
+  return reactQuery.useQuery({
+    queryKey: emporixKey("product", [productId], { tenant: client.tenant, authKind: ctx.kind, siteCode }),
+    queryFn: () => client.products.get(productId, void 0, ctx),
+    staleTime: PRODUCTS_STALE_TIME
+  });
+}
+function useProducts(params = {}, options = {}) {
+  const { client } = useEmporix();
+  const { ctx } = useReadAuth(options.auth);
+  const { siteCode } = useReadSite();
+  return reactQuery.useQuery({
+    queryKey: emporixKey("products", [params], { tenant: client.tenant, authKind: ctx.kind, siteCode }),
+    queryFn: () => client.products.list(params, ctx),
+    staleTime: PRODUCTS_STALE_TIME
+  });
+}
+function useProductsInfinite(params = {}, options = {}) {
+  const { client } = useEmporix();
+  const { ctx } = useReadAuth(options.auth);
+  const { siteCode } = useReadSite();
+  return useEmporixInfinite({
+    queryKey: emporixKey("products-infinite", [params], { tenant: client.tenant, authKind: ctx.kind, siteCode }),
+    fetchPage: (pageNumber) => client.products.list(
+      params.pageSize !== void 0 ? { pageNumber, pageSize: params.pageSize } : { pageNumber },
+      ctx
+    ),
+    staleTime: PRODUCTS_STALE_TIME
+  });
+}
+function useProductByCode(code, options = {}) {
+  const { client } = useEmporix();
+  const { ctx } = useReadAuth(options.auth);
+  const { siteCode } = useReadSite();
+  return reactQuery.useQuery({
+    queryKey: emporixKey("product-by-code", [code], { tenant: client.tenant, authKind: ctx.kind, siteCode }),
+    enabled: typeof code === "string" && code !== "",
+    queryFn: () => client.products.getByCode(code, ctx),
+    staleTime: PRODUCTS_STALE_TIME
+  });
+}
+function useProductSearch(query, params = {}, options = {}) {
+  const { client } = useEmporix();
+  const { ctx } = useReadAuth(options.auth);
+  const { siteCode } = useReadSite();
+  return reactQuery.useQuery({
+    queryKey: emporixKey("product-search", [query, params], { tenant: client.tenant, authKind: ctx.kind, siteCode }),
+    enabled: typeof query === "string" && query.trim() !== "",
+    queryFn: () => client.products.search(query, params, ctx),
+    staleTime: PRODUCTS_STALE_TIME
+  });
+}
+var CATEGORIES_STALE_TIME = 5 * 6e4;
+function useCategory(categoryId, options = {}) {
+  const { client } = useEmporix();
+  const { ctx } = useReadAuth(options.auth);
+  const { siteCode } = useReadSite();
+  return reactQuery.useQuery({
+    queryKey: emporixKey("category", [categoryId], { tenant: client.tenant, authKind: ctx.kind, siteCode }),
+    queryFn: () => client.categories.get(categoryId, ctx),
+    staleTime: CATEGORIES_STALE_TIME
+  });
+}
+function useCategories(params = {}, options = {}) {
+  const { client } = useEmporix();
+  const { ctx } = useReadAuth(options.auth);
+  const { siteCode } = useReadSite();
+  return reactQuery.useQuery({
+    queryKey: emporixKey("categories", [params], { tenant: client.tenant, authKind: ctx.kind, siteCode }),
+    queryFn: () => client.categories.list(params, ctx),
+    staleTime: CATEGORIES_STALE_TIME
+  });
+}
+function useCategoriesInfinite(params = {}, options = {}) {
+  const { client } = useEmporix();
+  const { ctx } = useReadAuth(options.auth);
+  const { siteCode } = useReadSite();
+  return useEmporixInfinite({
+    queryKey: emporixKey("categories-infinite", [params], { tenant: client.tenant, authKind: ctx.kind, siteCode }),
+    fetchPage: (pageNumber) => client.categories.list(
+      params.pageSize !== void 0 ? { pageNumber, pageSize: params.pageSize } : { pageNumber },
+      ctx
+    ),
+    staleTime: CATEGORIES_STALE_TIME
+  });
+}
+function useCategoryTree(rootId, options = {}) {
+  const { client } = useEmporix();
+  const { ctx } = useReadAuth(options.auth);
+  const { siteCode } = useReadSite();
+  return reactQuery.useQuery({
+    queryKey: emporixKey("category-tree", [rootId ?? null], { tenant: client.tenant, authKind: ctx.kind, siteCode }),
+    queryFn: () => client.categories.tree(rootId, ctx),
+    staleTime: CATEGORIES_STALE_TIME
+  });
+}
+function useProductsInCategory(categoryId, params = {}, options = {}) {
+  const { client } = useEmporix();
+  const { ctx } = useReadAuth(options.auth);
+  const { siteCode } = useReadSite();
+  return reactQuery.useQuery({
+    queryKey: emporixKey("products-in-category", [categoryId, params], { tenant: client.tenant, authKind: ctx.kind, siteCode }),
+    enabled: typeof categoryId === "string" && categoryId !== "",
+    queryFn: () => client.categories.productsIn(categoryId, params, ctx),
+    staleTime: CATEGORIES_STALE_TIME
+  });
+}
+function useProductsInCategoryInfinite(categoryId, params = {}, options = {}) {
+  const { client } = useEmporix();
+  const { ctx } = useReadAuth(options.auth);
+  const { siteCode } = useReadSite();
+  return useEmporixInfinite({
+    queryKey: emporixKey("products-in-category-infinite", [categoryId, params], { tenant: client.tenant, authKind: ctx.kind, siteCode }),
+    enabled: typeof categoryId === "string" && categoryId !== "",
+    fetchPage: (pageNumber) => client.categories.productsIn(
+      categoryId,
+      params.pageSize !== void 0 ? { pageNumber, pageSize: params.pageSize } : { pageNumber },
+      ctx
+    ),
+    staleTime: CATEGORIES_STALE_TIME
+  });
+}
+function useCart(cartId, options = {}) {
+  const { client, storage } = useEmporix();
+  const { ctx } = useReadAuth(options.auth);
+  const { siteCode } = useReadSite();
+  const { activeCompany } = useActiveCompany();
+  const resolvedId = cartId ?? storage.getCartId() ?? void 0;
+  return reactQuery.useQuery({
+    queryKey: emporixKey(
+      "cart",
+      [resolvedId ?? null, activeCompany?.id ?? null],
+      { tenant: client.tenant, authKind: ctx.kind, siteCode }
+    ),
+    enabled: resolvedId !== void 0,
+    queryFn: () => client.carts.get(resolvedId, ctx)
+  });
+}
+function useCartMutations(cartId) {
+  const { client, storage } = useEmporix();
+  const qc = reactQuery.useQueryClient();
+  const { ctx } = useReadAuth();
+  const { siteCode } = useReadSite();
+  const { activeCompany } = useActiveCompany();
+  const resolveId = () => {
+    const id = cartId ?? storage.getCartId();
+    if (!id) {
+      throw new emporixSdk.EmporixError(
+        "useCartMutations: no cartId available \u2014 pass one explicitly or call useActiveCart({ create: true }) first"
+      );
+    }
+    return id;
+  };
+  const keyFor = (id) => emporixKey(
+    "cart",
+    [id, activeCompany?.id ?? null],
+    { tenant: client.tenant, authKind: ctx.kind, siteCode }
+  );
+  function make(run, optimistic) {
+    return reactQuery.useMutation({
+      mutationFn: async (vars) => run(resolveId(), vars),
+      onMutate: async (vars) => {
+        const id = resolveId();
+        const key = keyFor(id);
+        await qc.cancelQueries({ queryKey: key });
+        const previous = qc.getQueryData(key);
+        if (optimistic) qc.setQueryData(key, optimistic(previous, vars));
+        return { previous, key };
+      },
+      onError: (_e, _v, c) => {
+        if (c) qc.setQueryData(c.key, c.previous);
+      },
+      onSuccess: (cart, _v, c) => {
+        if (c) qc.setQueryData(c.key, cart);
+      }
+    });
+  }
+  return {
+    addItem: make(
+      (id, v) => client.carts.addItem(id, v, ctx),
+      (prev, v) => prev ? {
+        ...prev,
+        // Optimistic placeholder; replaced by the real item on success.
+        items: [
+          ...prev.items ?? [],
+          {
+            id: `optimistic-${v.product?.id ?? "item"}`,
+            ...v
+          }
+        ]
+      } : prev
+    ),
+    updateItem: make((id, v) => client.carts.updateItem(id, v.itemId, v.patch, ctx)),
+    removeItem: make(
+      (id, v) => client.carts.removeItem(id, v.itemId, ctx),
+      (prev, v) => prev ? { ...prev, items: (prev.items ?? []).filter((i) => i.id !== v.itemId) } : prev
+    ),
+    clear: make(
+      (id) => client.carts.clear(id, ctx),
+      (prev) => prev ? { ...prev, items: [] } : prev
+    ),
+    applyCoupon: make((id, v) => client.carts.applyCoupon(id, v.code, ctx)),
+    removeCoupon: make((id, v) => client.carts.removeCoupon(id, v.code, ctx)),
+    setShippingAddress: make((id, v) => client.carts.setShippingAddress(id, v, ctx)),
+    setBillingAddress: make((id, v) => client.carts.setBillingAddress(id, v, ctx))
+  };
+}
+function useCreateCart() {
+  const { client, storage } = useEmporix();
+  const qc = reactQuery.useQueryClient();
+  const { ctx } = useReadAuth();
+  return reactQuery.useMutation({
+    mutationFn: (input) => client.carts.create(input, ctx),
+    onSuccess: async (cart) => {
+      if (cart.cartId) storage.setCartId(cart.cartId);
+      await qc.invalidateQueries({ queryKey: ["emporix", "cart"] });
+    }
+  });
+}
+function useActiveCart(opts) {
+  const { client, storage } = useEmporix();
+  const qc = reactQuery.useQueryClient();
+  const { ctx } = useReadAuth(opts?.auth);
+  const { siteCode: activeSite } = useReadSite();
+  const { activeCompany } = useActiveCompany();
+  const [cartId, setCartId] = react.useState(() => storage.getCartId());
+  const effectiveLegalEntityId = opts?.legalEntityId ?? activeCompany?.id;
+  react.useEffect(() => {
+    if (cartId !== null) return;
+    if (!opts?.create) return;
+    const siteCode = activeSite ?? client.config?.credentials?.storefront?.context?.siteCode;
+    if (!siteCode) return;
+    let cancelled = false;
+    bootstrapCart({
+      qc,
+      client,
+      ctx,
+      siteCode,
+      ...opts.type !== void 0 ? { type: opts.type } : {},
+      ...effectiveLegalEntityId !== void 0 ? { legalEntityId: effectiveLegalEntityId } : {}
+    }).then((cart) => {
+      if (cancelled) return;
+      if (cart?.id) {
+        storage.setCartId(cart.id);
+        setCartId(cart.id);
+      }
+    }).catch(() => {
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [cartId, opts?.create, opts?.type, effectiveLegalEntityId, ctx.kind, activeSite]);
+  const inner = useCart(cartId ?? void 0, opts?.auth ? { auth: opts.auth } : {});
+  const data = cartId === null ? null : inner.data;
+  return { ...inner, data };
+}
+var PAYMENT_MODES_STALE_TIME = 10 * 6e4;
+function customerOnlyCtx(token) {
+  if (!token) throw new Error("usePaymentModes requires a logged-in customer token");
+  return emporixSdk.auth.customer(token);
+}
+function useCheckout() {
+  const { client } = useEmporix();
+  const { ctx } = useReadAuth();
+  const { activeCompany } = useActiveCompany();
+  const withLE = (input) => {
+    if (!activeCompany?.id) return input;
+    if ("legalEntityId" in input) return input;
+    return { ...input, legalEntityId: activeCompany.id };
+  };
+  const placeOrder = reactQuery.useMutation({
+    mutationFn: (v) => client.checkout.placeOrder(withLE(v.input), ctx, {
+      ...v.saasToken !== void 0 ? { saasToken: v.saasToken } : {},
+      ...v.siteCode !== void 0 ? { siteCode: v.siteCode } : {}
+    })
+  });
+  const placeOrderFromQuote = reactQuery.useMutation({
+    mutationFn: (v) => client.checkout.placeOrderFromQuote(withLE(v.input), ctx, {
+      ...v.saasToken !== void 0 ? { saasToken: v.saasToken } : {},
+      ...v.siteCode !== void 0 ? { siteCode: v.siteCode } : {}
+    })
+  });
+  return { placeOrder, placeOrderFromQuote };
+}
+function usePaymentModes(options = {}) {
+  const { client, storage } = useEmporix();
+  const token = storage.getCustomerToken();
+  const { siteCode } = useReadSite();
+  const { activeCompany } = useActiveCompany();
+  return reactQuery.useQuery({
+    queryKey: emporixKey(
+      "payment-modes",
+      [activeCompany?.id ?? null],
+      { tenant: client.tenant, authKind: "customer", siteCode }
+    ),
+    enabled: (options.enabled ?? true) && token !== null,
+    queryFn: () => client.payments.listPaymentModes(customerOnlyCtx(token)),
+    staleTime: PAYMENT_MODES_STALE_TIME
+  });
+}
+var PRICES_STALE_TIME = 6e4;
+function useMatchPrices(input, options = {}) {
+  const { client } = useEmporix();
+  const { siteCode } = useReadSite();
+  const ctx = options.customerToken ? emporixSdk.auth.customer(options.customerToken) : emporixSdk.auth.anonymous();
+  return reactQuery.useQuery({
+    queryKey: [
+      "emporix",
+      "match-prices",
+      { tenant: client.tenant, input, anon: !options.customerToken, siteCode }
+    ],
+    enabled: (options.enabled ?? true) && (input.items?.length ?? 0) > 0,
+    queryFn: () => client.prices.matchByContext(input, ctx),
+    staleTime: PRICES_STALE_TIME
+  });
+}
+
+// src/hooks/use-product-media.ts
+function useProductMedia(productId) {
+  const q = useProduct(productId);
+  const data = q.data?.productMedia;
+  return { data, isLoading: q.isLoading, error: q.error };
+}
+var SEGMENTS_STALE_TIME = 5 * 6e4;
+function customerCtx(token) {
+  if (!token) throw new Error("requires a customer token in storage");
+  return emporixSdk.auth.customer(token);
+}
+function useMySegments(query = {}) {
+  const { client, storage } = useEmporix();
+  const token = storage.getCustomerToken();
+  const { siteCode } = useReadSite();
+  return reactQuery.useQuery({
+    queryKey: ["emporix", "segment", "list", { tenant: client.tenant, query, siteCode }],
+    enabled: token !== null,
+    queryFn: () => client.segments.list(query, customerCtx(token)),
+    staleTime: SEGMENTS_STALE_TIME
+  });
+}
+function useMySegmentItems(query = {}) {
+  const { client, storage } = useEmporix();
+  const token = storage.getCustomerToken();
+  const { siteCode } = useReadSite();
+  return reactQuery.useQuery({
+    queryKey: ["emporix", "segment", "items", { tenant: client.tenant, query, siteCode }],
+    enabled: token !== null,
+    queryFn: () => client.segments.listItems(query, customerCtx(token)),
+    staleTime: SEGMENTS_STALE_TIME
+  });
+}
+function useMySegmentCategoryTree(query = {}) {
+  const { client, storage } = useEmporix();
+  const token = storage.getCustomerToken();
+  const { siteCode } = useReadSite();
+  return reactQuery.useQuery({
+    queryKey: ["emporix", "segment", "categoryTree", { tenant: client.tenant, query, siteCode }],
+    enabled: token !== null,
+    queryFn: () => client.segments.getCategoryTree(query, customerCtx(token)),
+    staleTime: SEGMENTS_STALE_TIME
+  });
+}
+function useMySegmentProducts(query = {}) {
+  const { client, storage } = useEmporix();
+  const token = storage.getCustomerToken();
+  const { siteCode } = useReadSite();
+  return reactQuery.useQuery({
+    queryKey: ["emporix", "segment", "myProducts", { tenant: client.tenant, query, siteCode }],
+    enabled: token !== null,
+    queryFn: () => client.segments.listMyProducts(query, customerCtx(token)),
+    staleTime: SEGMENTS_STALE_TIME
+  });
+}
+function useMySegmentProductsInfinite(query = {}) {
+  const { client, storage } = useEmporix();
+  const token = storage.getCustomerToken();
+  const { siteCode } = useReadSite();
+  return useEmporixInfinite({
+    queryKey: [
+      "emporix",
+      "segment",
+      "myProductsInfinite",
+      { tenant: client.tenant, query, siteCode }
+    ],
+    enabled: token !== null,
+    fetchPage: (pageNumber) => client.segments.listMyProducts(
+      { ...query, pageNumber, pageSize: query.pageSize ?? 20 },
+      customerCtx(token)
+    ),
+    staleTime: SEGMENTS_STALE_TIME
+  });
+}
+function useMySegmentCategories(query = {}) {
+  const { client, storage } = useEmporix();
+  const token = storage.getCustomerToken();
+  const { siteCode } = useReadSite();
+  return reactQuery.useQuery({
+    queryKey: ["emporix", "segment", "myCategories", { tenant: client.tenant, query, siteCode }],
+    enabled: token !== null,
+    queryFn: () => client.segments.listMyCategories(query, customerCtx(token)),
+    staleTime: SEGMENTS_STALE_TIME
+  });
+}
+function useMySegmentCategoriesInfinite(query = {}) {
+  const { client, storage } = useEmporix();
+  const token = storage.getCustomerToken();
+  const { siteCode } = useReadSite();
+  return useEmporixInfinite({
+    queryKey: [
+      "emporix",
+      "segment",
+      "myCategoriesInfinite",
+      { tenant: client.tenant, query, siteCode }
+    ],
+    enabled: token !== null,
+    fetchPage: (pageNumber) => client.segments.listMyCategories(
+      { ...query, pageNumber, pageSize: query.pageSize ?? 20 },
+      customerCtx(token)
+    ),
+    staleTime: SEGMENTS_STALE_TIME
+  });
+}
+function useUpdateCustomer() {
+  const { client } = useEmporix();
+  const ctx = useCustomerOnlyCtx();
+  const qc = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: (patch) => client.customers.update(patch, ctx),
+    onSuccess: () => {
+      void qc.invalidateQueries({ queryKey: ["emporix", "customer", "me"] });
+    }
+  });
+}
+function useChangePassword() {
+  const { client } = useEmporix();
+  const ctx = useCustomerOnlyCtx();
+  return reactQuery.useMutation({
+    mutationFn: (input) => client.customers.changePassword(input, ctx)
+  });
+}
+var ADDRESSES_KEY = ["emporix", "customer", "addresses"];
+function useCustomerAddresses(options = {}) {
+  const { client, storage } = useEmporix();
+  const token = storage.getCustomerToken();
+  const { activeCompany } = useActiveCompany();
+  const ctx = options.auth ?? (token ? emporixSdk.auth.customer(token) : null);
+  return reactQuery.useQuery({
+    queryKey: [
+      ...ADDRESSES_KEY,
+      { tenant: client.tenant, hasToken: token !== null, legalEntityId: activeCompany?.id ?? null }
+    ],
+    enabled: ctx !== null,
+    queryFn: () => client.customers.addresses.list(ctx)
+  });
+}
+function useAddressMutations() {
+  const { client } = useEmporix();
+  const ctx = useCustomerOnlyCtx();
+  const qc = reactQuery.useQueryClient();
+  const invalidate = () => {
+    void qc.invalidateQueries({ queryKey: ADDRESSES_KEY });
+  };
+  return {
+    add: reactQuery.useMutation({
+      mutationFn: (input) => client.customers.addresses.add(input, ctx),
+      onSuccess: invalidate
+    }),
+    update: reactQuery.useMutation({
+      mutationFn: ({ id, patch }) => client.customers.addresses.update(id, patch, ctx),
+      onSuccess: invalidate
+    }),
+    remove: reactQuery.useMutation({
+      mutationFn: ({ id }) => client.customers.addresses.remove(id, ctx),
+      onSuccess: invalidate
+    })
+  };
+}
+function usePasswordReset() {
+  const { client } = useEmporix();
+  const anonCtx = emporixSdk.auth.anonymous();
+  return {
+    request: reactQuery.useMutation({
+      mutationFn: (input) => client.customers.requestPasswordReset(input, anonCtx)
+    }),
+    confirm: reactQuery.useMutation({
+      mutationFn: (input) => client.customers.confirmPasswordReset(input, anonCtx)
+    })
+  };
+}
+var SITES_STALE_TIME = 10 * 6e4;
+function useSites(options = {}) {
+  const { client } = useEmporix();
+  const { ctx } = useReadAuth(options.auth);
+  return reactQuery.useQuery({
+    queryKey: emporixKey("sites", [], { tenant: client.tenant, authKind: ctx.kind }),
+    queryFn: () => client.sites.list(ctx),
+    staleTime: SITES_STALE_TIME
+  });
+}
+function useDefaultSite(options = {}) {
+  const { client } = useEmporix();
+  const { ctx } = useReadAuth(options.auth);
+  return reactQuery.useQuery({
+    queryKey: emporixKey("site-default", [], { tenant: client.tenant, authKind: ctx.kind }),
+    queryFn: () => client.sites.current(ctx),
+    staleTime: SITES_STALE_TIME
+  });
+}
+function useSiteContext() {
+  const ctx = react.useContext(EmporixSiteContext);
+  if (!ctx) {
+    throw new Error("useSiteContext must be used within an EmporixProvider");
+  }
+  return ctx;
+}
+function useMyCompanies() {
+  const { client, storage } = useEmporix();
+  const token = storage.getCustomerToken();
+  return reactQuery.useQuery({
+    queryKey: emporixKey("companies", ["mine"], {
+      tenant: client.tenant,
+      authKind: token ? "customer" : "anonymous"
+    }),
+    enabled: token !== null,
+    queryFn: () => client.companies.listMine(emporixSdk.auth.customer(token))
+  });
+}
+function useCompany(legalEntityId) {
+  const { client, storage } = useEmporix();
+  const token = storage.getCustomerToken();
+  return reactQuery.useQuery({
+    queryKey: emporixKey("companies", [legalEntityId ?? null], {
+      tenant: client.tenant,
+      authKind: token ? "customer" : "anonymous"
+    }),
+    enabled: token !== null && legalEntityId !== void 0,
+    queryFn: () => client.companies.get(legalEntityId, emporixSdk.auth.customer(token))
+  });
+}
+function useCompanyContacts(legalEntityId) {
+  const { client, storage } = useEmporix();
+  const token = storage.getCustomerToken();
+  return reactQuery.useQuery({
+    queryKey: emporixKey("companies", ["contacts", legalEntityId ?? null], {
+      tenant: client.tenant,
+      authKind: token ? "customer" : "anonymous"
+    }),
+    enabled: token !== null && legalEntityId !== void 0,
+    queryFn: () => client.contacts.listForCompany(legalEntityId, emporixSdk.auth.customer(token))
+  });
+}
+function useCompanyLocations(legalEntityId) {
+  const { client, storage } = useEmporix();
+  const token = storage.getCustomerToken();
+  return reactQuery.useQuery({
+    queryKey: emporixKey("companies", ["locations", legalEntityId ?? null], {
+      tenant: client.tenant,
+      authKind: token ? "customer" : "anonymous"
+    }),
+    enabled: token !== null && legalEntityId !== void 0,
+    queryFn: () => client.locations.listForCompany(legalEntityId, emporixSdk.auth.customer(token))
+  });
+}
+function useCompanyGroups(legalEntityId) {
+  const { client, storage } = useEmporix();
+  const token = storage.getCustomerToken();
+  return reactQuery.useQuery({
+    queryKey: emporixKey("companies", ["groups", legalEntityId ?? null], {
+      tenant: client.tenant,
+      authKind: token ? "customer" : "anonymous"
+    }),
+    enabled: token !== null && legalEntityId !== void 0,
+    queryFn: () => client.customerGroups.listForCompany(legalEntityId, emporixSdk.auth.customer(token))
+  });
+}
+function useCustomerAuthResolver() {
+  const { storage } = useEmporix();
+  return () => {
+    const token = storage.getCustomerToken();
+    if (!token) throw new Error("Mutation requires a logged-in customer token");
+    return emporixSdk.auth.customer(token);
+  };
+}
+function useCreateCompany() {
+  const { client } = useEmporix();
+  const resolveAuth = useCustomerAuthResolver();
+  const qc = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: (input) => client.companies.create(input, resolveAuth()),
+    onSuccess: () => qc.invalidateQueries({ queryKey: ["emporix", "companies", "mine"] })
+  });
+}
+function useUpdateCompany() {
+  const { client } = useEmporix();
+  const resolveAuth = useCustomerAuthResolver();
+  const qc = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: ({ id, patch }) => client.companies.update(id, patch, resolveAuth()),
+    onSuccess: () => qc.invalidateQueries({ queryKey: ["emporix", "companies"] })
+  });
+}
+function useDeleteCompany() {
+  const { client } = useEmporix();
+  const resolveAuth = useCustomerAuthResolver();
+  const qc = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: (id) => client.companies.delete(id, resolveAuth()),
+    onSuccess: () => qc.invalidateQueries({ queryKey: ["emporix", "companies"] })
+  });
+}
+function useAssignContact() {
+  const { client } = useEmporix();
+  const resolveAuth = useCustomerAuthResolver();
+  const qc = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: (input) => client.contacts.assign(input, resolveAuth()),
+    onSuccess: () => qc.invalidateQueries({ predicate: (q) => q.queryKey.includes("contacts") })
+  });
+}
+function useUpdateContactAssignment() {
+  const { client } = useEmporix();
+  const resolveAuth = useCustomerAuthResolver();
+  const qc = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: ({ id, patch }) => client.contacts.update(id, patch, resolveAuth()),
+    onSuccess: () => qc.invalidateQueries({ predicate: (q) => q.queryKey.includes("contacts") })
+  });
+}
+function useUnassignContact() {
+  const { client } = useEmporix();
+  const resolveAuth = useCustomerAuthResolver();
+  const qc = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: (id) => client.contacts.unassign(id, resolveAuth()),
+    onSuccess: () => qc.invalidateQueries({ predicate: (q) => q.queryKey.includes("contacts") })
+  });
+}
+function useCreateLocation() {
+  const { client } = useEmporix();
+  const resolveAuth = useCustomerAuthResolver();
+  const qc = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: (input) => client.locations.create(input, resolveAuth()),
+    onSuccess: () => qc.invalidateQueries({ predicate: (q) => q.queryKey.includes("locations") })
+  });
+}
+function useUpdateLocation() {
+  const { client } = useEmporix();
+  const resolveAuth = useCustomerAuthResolver();
+  const qc = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: ({ id, patch }) => client.locations.update(id, patch, resolveAuth()),
+    onSuccess: () => qc.invalidateQueries({ predicate: (q) => q.queryKey.includes("locations") })
+  });
+}
+function useDeleteLocation() {
+  const { client } = useEmporix();
+  const resolveAuth = useCustomerAuthResolver();
+  const qc = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: (id) => client.locations.delete(id, resolveAuth()),
+    onSuccess: () => qc.invalidateQueries({ predicate: (q) => q.queryKey.includes("locations") })
+  });
+}
+function useCompanySwitcher() {
+  const ctx = useActiveCompany();
+  const switchFn = react.useCallback(
+    (legalEntityId) => ctx.setActiveCompany(legalEntityId),
+    [ctx]
+  );
+  const clearFn = react.useCallback(() => ctx.setActiveCompany(null), [ctx]);
+  return {
+    companies: ctx.myCompanies,
+    active: ctx.activeCompany,
+    status: ctx.status,
+    switch: switchFn,
+    clear: clearFn
+  };
+}
+function useMyOrders(options = {}) {
+  const { client, storage } = useEmporix();
+  const { activeCompany } = useActiveCompany();
+  const { siteCode } = useReadSite();
+  const token = storage.getCustomerToken();
+  const effectiveLE = options.legalEntityId === null ? void 0 : options.legalEntityId ?? activeCompany?.id;
+  return reactQuery.useQuery({
+    queryKey: emporixKey(
+      "orders",
+      ["mine", effectiveLE ?? null, options.status ?? null, options.pageNumber ?? 1, options.pageSize ?? null],
+      { tenant: client.tenant, authKind: token ? "customer" : "anonymous", siteCode }
+    ),
+    enabled: token !== null,
+    queryFn: () => client.orders.listMine(emporixSdk.auth.customer(token), {
+      ...options.pageNumber !== void 0 ? { pageNumber: options.pageNumber } : {},
+      ...options.pageSize !== void 0 ? { pageSize: options.pageSize } : {},
+      ...options.status !== void 0 ? { status: options.status } : {},
+      ...effectiveLE !== void 0 ? { legalEntityId: effectiveLE } : {},
+      ...siteCode ? { siteCode } : {},
+      ...options.saasToken !== void 0 ? { saasToken: options.saasToken } : {}
+    })
+  });
+}
+function useMyOrdersInfinite(options = {}) {
+  const { client, storage } = useEmporix();
+  const { activeCompany } = useActiveCompany();
+  const { siteCode } = useReadSite();
+  const token = storage.getCustomerToken();
+  const effectiveLE = options.legalEntityId === null ? void 0 : options.legalEntityId ?? activeCompany?.id;
+  return useEmporixInfinite({
+    queryKey: emporixKey(
+      "orders",
+      ["mine-infinite", effectiveLE ?? null, options.status ?? null, options.pageSize ?? null],
+      { tenant: client.tenant, authKind: token ? "customer" : "anonymous", siteCode }
+    ),
+    enabled: token !== null,
+    fetchPage: (pageNumber) => client.orders.listMine(emporixSdk.auth.customer(token), {
+      pageNumber,
+      ...options.pageSize !== void 0 ? { pageSize: options.pageSize } : {},
+      ...options.status !== void 0 ? { status: options.status } : {},
+      ...effectiveLE !== void 0 ? { legalEntityId: effectiveLE } : {},
+      ...siteCode ? { siteCode } : {},
+      ...options.saasToken !== void 0 ? { saasToken: options.saasToken } : {}
+    })
+  });
+}
+function useOrder(orderId, options = {}) {
+  const { client, storage } = useEmporix();
+  const token = storage.getCustomerToken();
+  return reactQuery.useQuery({
+    queryKey: emporixKey("orders", [orderId ?? null], {
+      tenant: client.tenant,
+      authKind: token ? "customer" : "anonymous"
+    }),
+    enabled: token !== null && orderId !== void 0,
+    queryFn: () => client.orders.get(
+      orderId,
+      emporixSdk.auth.customer(token),
+      options.saasToken ? { saasToken: options.saasToken } : {}
+    )
+  });
+}
+function useCancelOrder() {
+  const { client, storage } = useEmporix();
+  const qc = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationKey: ["emporix", "orders", "cancel"],
+    mutationFn: async (input) => {
+      const token = storage.getCustomerToken();
+      if (!token) throw new Error("useCancelOrder: requires a logged-in customer");
+      const { orderId, saasToken } = typeof input === "string" ? { orderId: input, saasToken: void 0 } : input;
+      await client.orders.cancel(
+        orderId,
+        emporixSdk.auth.customer(token),
+        saasToken ? { saasToken } : {}
+      );
+    },
+    onSuccess: () => qc.invalidateQueries({
+      predicate: (q) => Array.isArray(q.queryKey) && q.queryKey[1] === "orders"
+    })
+  });
+}
+function useOrderTransition() {
+  const { client, storage } = useEmporix();
+  const qc = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationKey: ["emporix", "orders", "transition"],
+    mutationFn: async ({ orderId, status, comment, saasToken }) => {
+      const token = storage.getCustomerToken();
+      if (!token) throw new Error("useOrderTransition: requires a logged-in customer");
+      await client.orders.transition(
+        orderId,
+        status,
+        emporixSdk.auth.customer(token),
+        {
+          ...comment !== void 0 ? { comment } : {},
+          ...saasToken !== void 0 ? { saasToken } : {}
+        }
+      );
+    },
+    onSuccess: () => qc.invalidateQueries({
+      predicate: (q) => Array.isArray(q.queryKey) && q.queryKey[1] === "orders"
+    })
+  });
+}
+function useReorder() {
+  const { client, storage } = useEmporix();
+  const qc = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationKey: ["emporix", "orders", "reorder"],
+    mutationFn: async ({ orderId, saasToken }) => {
+      const token = storage.getCustomerToken();
+      if (!token) throw new Error("useReorder: requires a logged-in customer");
+      const ctx = emporixSdk.auth.customer(token);
+      const order = await qc.fetchQuery({
+        queryKey: emporixKey("orders", [orderId], { tenant: client.tenant, authKind: ctx.kind }),
+        queryFn: () => client.orders.get(orderId, ctx, saasToken ? { saasToken } : {})
+      });
+      const cartId = storage.getCartId();
+      if (!cartId) throw new Error("useReorder: no active cart id in storage");
+      if (order.items.length === 0) return { added: 0, errors: [] };
+      const batchBody = order.items.map((item) => ({
+        product: { id: item.productId },
+        quantity: item.quantity
+      }));
+      const res = await client.carts.addItemsBatch(cartId, batchBody, ctx);
+      let added = 0;
+      const errors = [];
+      for (const entry of res) {
+        if (entry.status >= 200 && entry.status < 300) {
+          added += 1;
+        } else {
+          errors.push(
+            new Error(
+              `addItemsBatch entry ${entry.index ?? "?"}: status=${entry.status}${entry.errorMessage ? " " + entry.errorMessage : ""}`
+            )
+          );
+        }
+      }
+      return { added, errors };
+    },
+    onSuccess: () => {
+      qc.invalidateQueries({ predicate: (q) => Array.isArray(q.queryKey) && q.queryKey[1] === "cart" });
+    }
+  });
+}
+function useSalesOrder(orderId, authCtx) {
+  const { client } = useEmporix();
+  return reactQuery.useQuery({
+    queryKey: emporixKey("salesorders", [orderId ?? null], {
+      tenant: client.tenant,
+      authKind: authCtx?.kind ?? "anonymous"
+    }),
+    enabled: orderId !== void 0 && authCtx !== void 0,
+    queryFn: () => client.salesOrders.get(orderId, authCtx)
+  });
+}
+function useUpdateSalesOrder() {
+  const { client } = useEmporix();
+  const qc = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationKey: ["emporix", "salesorders", "update"],
+    mutationFn: async ({ orderId, patch, auth: auth23, recalculate }) => {
+      if (!auth23) throw new Error("useUpdateSalesOrder: requires an auth context");
+      return client.salesOrders.update(
+        orderId,
+        patch,
+        auth23,
+        recalculate !== void 0 ? { recalculate } : {}
+      );
+    },
+    onSuccess: (_data, vars) => {
+      qc.invalidateQueries({
+        predicate: (q) => Array.isArray(q.queryKey) && (q.queryKey[1] === "salesorders" || q.queryKey[1] === "orders" && q.queryKey[2] === vars.orderId)
+      });
+    }
+  });
+}
+var EmporixErrorBoundary = class extends react.Component {
+  state = { error: null };
+  static getDerivedStateFromError(error) {
+    return { error };
+  }
+  componentDidCatch(error, info) {
+    this.props.onError?.(error, info);
+  }
+  render() {
+    if (this.state.error) return this.props.fallback;
+    return this.props.children;
+  }
+};
+function useEmporixErrorHandler(handlers) {
+  return (error) => {
+    if (error instanceof emporixSdk.EmporixAuthError) handlers.onAuthError?.(error);
+    else if (error instanceof emporixSdk.EmporixError) handlers.onError?.(error);
+  };
+}
+async function prefetchProduct(qc, client, productId, authCtx = emporixSdk.auth.anonymous()) {
+  await qc.prefetchQuery({
+    queryKey: ["emporix", "product", productId, { tenant: client.tenant, authKind: authCtx.kind }],
+    queryFn: () => client.products.get(productId, void 0, authCtx)
+  });
+}
+async function prefetchCart(qc, client, cartId, authCtx) {
+  await qc.prefetchQuery({
+    queryKey: ["emporix", "cart", cartId, { tenant: client.tenant, authKind: authCtx.kind }],
+    queryFn: () => client.carts.get(cartId, authCtx)
+  });
+}
+async function prefetchOrder(qc, client, orderId, authCtx, opts = {}) {
+  await qc.prefetchQuery({
+    queryKey: ["emporix", "orders", orderId, { tenant: client.tenant, authKind: authCtx.kind }],
+    queryFn: () => client.orders.get(orderId, authCtx, opts.saasToken ? { saasToken: opts.saasToken } : {})
+  });
+}
+
+exports.CompanyContextProvider = CompanyContextProvider;
+exports.EmporixCompanyContext = EmporixCompanyContext;
+exports.EmporixErrorBoundary = EmporixErrorBoundary;
+exports.EmporixProvider = EmporixProvider;
+exports.createCookieStorage = createCookieStorage;
+exports.createLocalStorageStorage = createLocalStorageStorage;
+exports.createMemoryStorage = createMemoryStorage;
+exports.prefetchCart = prefetchCart;
+exports.prefetchOrder = prefetchOrder;
+exports.prefetchProduct = prefetchProduct;
+exports.useActiveCart = useActiveCart;
+exports.useActiveCompany = useActiveCompany;
+exports.useAddressMutations = useAddressMutations;
+exports.useAssignContact = useAssignContact;
+exports.useCancelOrder = useCancelOrder;
+exports.useCart = useCart;
+exports.useCartMutations = useCartMutations;
+exports.useCategories = useCategories;
+exports.useCategoriesInfinite = useCategoriesInfinite;
+exports.useCategory = useCategory;
+exports.useCategoryTree = useCategoryTree;
+exports.useChangePassword = useChangePassword;
+exports.useCheckout = useCheckout;
+exports.useCompany = useCompany;
+exports.useCompanyContacts = useCompanyContacts;
+exports.useCompanyGroups = useCompanyGroups;
+exports.useCompanyLocations = useCompanyLocations;
+exports.useCompanySwitcher = useCompanySwitcher;
+exports.useCreateCart = useCreateCart;
+exports.useCreateCompany = useCreateCompany;
+exports.useCreateLocation = useCreateLocation;
+exports.useCustomerAddresses = useCustomerAddresses;
+exports.useCustomerSession = useCustomerSession;
+exports.useDefaultSite = useDefaultSite;
+exports.useDeleteCompany = useDeleteCompany;
+exports.useDeleteLocation = useDeleteLocation;
+exports.useEmporix = useEmporix;
+exports.useEmporixErrorHandler = useEmporixErrorHandler;
+exports.useEmporixTelemetry = useEmporixTelemetry;
+exports.useMatchPrices = useMatchPrices;
+exports.useMyCompanies = useMyCompanies;
+exports.useMyOrders = useMyOrders;
+exports.useMyOrdersInfinite = useMyOrdersInfinite;
+exports.useMySegmentCategories = useMySegmentCategories;
+exports.useMySegmentCategoriesInfinite = useMySegmentCategoriesInfinite;
+exports.useMySegmentCategoryTree = useMySegmentCategoryTree;
+exports.useMySegmentItems = useMySegmentItems;
+exports.useMySegmentProducts = useMySegmentProducts;
+exports.useMySegmentProductsInfinite = useMySegmentProductsInfinite;
+exports.useMySegments = useMySegments;
+exports.useOrder = useOrder;
+exports.useOrderTransition = useOrderTransition;
+exports.usePasswordReset = usePasswordReset;
+exports.usePaymentModes = usePaymentModes;
+exports.useProduct = useProduct;
+exports.useProductByCode = useProductByCode;
+exports.useProductMedia = useProductMedia;
+exports.useProductSearch = useProductSearch;
+exports.useProducts = useProducts;
+exports.useProductsInCategory = useProductsInCategory;
+exports.useProductsInCategoryInfinite = useProductsInCategoryInfinite;
+exports.useProductsInfinite = useProductsInfinite;
+exports.useReorder = useReorder;
+exports.useSalesOrder = useSalesOrder;
+exports.useSiteContext = useSiteContext;
+exports.useSites = useSites;
+exports.useUnassignContact = useUnassignContact;
+exports.useUpdateCompany = useUpdateCompany;
+exports.useUpdateContactAssignment = useUpdateContactAssignment;
+exports.useUpdateCustomer = useUpdateCustomer;
+exports.useUpdateLocation = useUpdateLocation;
+exports.useUpdateSalesOrder = useUpdateSalesOrder;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map