@nymbalhq/sdk 1.4.0 → 1.6.0

package/dist/index.js

@@ -1,1055 +1,40 @@
-// src/adapter/fetch-client.ts
-var NymbalApiError = class extends Error {
-  constructor(code, message, status, context) {
-    super(message);
-    this.code = code;
-    this.status = status;
-    this.context = context;
-    this.name = "NymbalApiError";
-  }
-  code;
-  status;
-  context;
-};
-var REFRESH_WAIT_MS = 1e4;
-var CSRF_HEADER = "x-csrf-token";
-var UNSAFE_METHODS = /* @__PURE__ */ new Set(["POST", "PUT", "PATCH", "DELETE"]);
-var FetchClient = class {
-  baseUrl;
-  credentials;
-  getAccessToken;
-  getCartToken;
-  onUnauthorized;
-  /** The refresh a refused request started, which every request refused meanwhile waits on rather than its own. */
-  refreshing = null;
-  /** The token `GET /api/csrf` answered: the API's `nymbal.csrf` cookie, which this origin may not be able to read. */
-  csrfToken = null;
-  constructor(options) {
-    this.baseUrl = options.baseUrl.replace(/\/+$/, "");
-    this.credentials = options.credentials ?? "include";
-    this.getAccessToken = options.getAccessToken ?? (() => null);
-    this.getCartToken = options.getCartToken;
-    this.onUnauthorized = options.onUnauthorized;
-  }
-  async request(method, path, body, options = {}) {
-    return (await this.requestWithMeta(method, path, body, options)).data;
-  }
-  /** Like `request`, keeping the envelope's `meta` (pagination cursors live there). */
-  async requestWithMeta(method, path, body, options = {}) {
-    const sentDuring = this.refreshing;
-    let { response, bearer } = await this.doFetch(method, path, body, options);
-    if (await this.isCsrfRejection(response)) {
-      this.csrfToken = null;
-      ({ response, bearer } = await this.doFetch(method, path, body, options));
-    }
-    if (response.status === 401 && this.onUnauthorized && options.authRefresh !== true) {
-      const pending = this.refreshing;
-      const retry = async () => this.parseResponse((await this.doFetch(method, path, body, options)).response);
-      if (pending === null && this.getAccessToken() !== bearer) {
-        return retry();
-      }
-      if (pending !== null && pending === sentDuring) {
-        if (await this.waitFor(pending) && this.getAccessToken() !== bearer) return retry();
-      } else if (await this.waitFor(pending ?? this.refresh(this.onUnauthorized))) {
-        return retry();
-      }
-    }
-    return this.parseResponse(response);
-  }
-  /** Whether the refresh ended within `REFRESH_WAIT_MS`; a refresh that fails throws here, as it always has. */
-  async waitFor(refresh) {
-    let timer;
-    const bound = new Promise((resolve) => {
-      timer = setTimeout(() => resolve(false), REFRESH_WAIT_MS);
-    });
-    try {
-      return await Promise.race([refresh.then(() => true), bound]);
-    } finally {
-      clearTimeout(timer);
-    }
-  }
-  refresh(onUnauthorized) {
-    const refresh = Promise.resolve().then(onUnauthorized).finally(() => {
-      this.refreshing = null;
-    });
-    this.refreshing = refresh;
-    return refresh;
-  }
-  csrf() {
-    this.csrfToken ??= this.fetchCsrfToken().catch((err) => {
-      this.csrfToken = null;
-      throw err;
-    });
-    return this.csrfToken;
-  }
-  async fetchCsrfToken() {
-    const response = await globalThis.fetch(`${this.baseUrl}/api/csrf`, {
-      method: "GET",
-      credentials: this.credentials
-    });
-    const { data } = await this.parseResponse(response);
-    return data.token;
-  }
-  async isCsrfRejection(response) {
-    if (response.status !== 403) return false;
-    const text = await response.clone().text();
-    try {
-      return JSON.parse(text).error?.code === "csrf.invalid";
-    } catch {
-      return false;
-    }
-  }
-  async doFetch(method, path, body, options) {
-    const headers = { ...options.headers };
-    const cookies = [];
-    if (UNSAFE_METHODS.has(method.toUpperCase())) {
-      const csrf = await this.csrf();
-      headers[CSRF_HEADER] = csrf;
-      cookies.push(`nymbal.csrf=${csrf}`);
-    }
-    if (body !== void 0) {
-      headers["Content-Type"] = "application/json";
-    }
-    const token = this.getAccessToken();
-    if (token) {
-      headers["Authorization"] = `Bearer ${token}`;
-    }
-    const cartToken = this.getCartToken?.();
-    if (cartToken) {
-      cookies.unshift(`nymbal.cart=${cartToken}`);
-    }
-    if (cookies.length > 0) {
-      headers["Cookie"] = cookies.join("; ");
-    }
-    const response = await globalThis.fetch(`${this.baseUrl}${path}`, {
-      method,
-      headers,
-      credentials: this.credentials,
-      ...body !== void 0 && { body: JSON.stringify(body) }
-    });
-    return { response, bearer: token };
-  }
-  async parseResponse(response) {
-    const text = await response.text();
-    if (!text) {
-      return { data: void 0, meta: {} };
-    }
-    const envelope = JSON.parse(text);
-    if (envelope.error) {
-      throw new NymbalApiError(
-        envelope.error.code,
-        envelope.error.message,
-        response.status,
-        envelope.error.context
-      );
-    }
-    return { data: envelope.data, meta: envelope.meta ?? {} };
-  }
-};
-
-// src/adapter/nymbal-api-adapter.ts
 import {
-  ORDER_KEY_HEADER
-} from "@nymbalhq/types";
-function createNymbalApiAdapter(fetchClient) {
-  return {
-    capabilities: {
-      get() {
-        return fetchClient.request("GET", "/api/capabilities");
-      }
-    },
-    cart: {
-      get() {
-        return fetchClient.request("GET", "/api/cart");
-      },
-      addItem(variantId, qty) {
-        return fetchClient.request("POST", "/api/cart/items", { variantId, qty });
-      },
-      removeItem(variantId) {
-        return fetchClient.request(
-          "DELETE",
-          `/api/cart/items/${encodeURIComponent(variantId)}`
-        );
-      },
-      updateQuantity(variantId, qty) {
-        return fetchClient.request(
-          "PATCH",
-          `/api/cart/items/${encodeURIComponent(variantId)}`,
-          { qty }
-        );
-      },
-      clear() {
-        return fetchClient.request("DELETE", "/api/cart");
-      }
-    },
-    products: {
-      getBySlug(slug) {
-        return fetchClient.request(
-          "GET",
-          `/api/products/${encodeURIComponent(slug)}`
-        );
-      },
-      list(params) {
-        const search = new URLSearchParams();
-        if (params?.limit !== void 0) search.set("limit", String(params.limit));
-        if (params?.cursor !== void 0) search.set("cursor", params.cursor);
-        if (params?.category !== void 0) search.set("category", params.category);
-        if (params?.sort !== void 0) search.set("sort", params.sort);
-        const qs = search.toString();
-        return fetchClient.request("GET", `/api/products${qs ? `?${qs}` : ""}`);
-      },
-      search(query, params) {
-        const search = new URLSearchParams();
-        search.set("q", query);
-        if (params?.limit !== void 0) search.set("limit", String(params.limit));
-        if (params?.cursor !== void 0) search.set("cursor", params.cursor);
-        if (params?.category !== void 0) search.set("category", params.category);
-        return fetchClient.request(
-          "GET",
-          `/api/products/search?${search.toString()}`
-        );
-      }
-    },
-    checkout: {
-      create(details) {
-        return fetchClient.request("POST", "/api/checkout", details);
-      }
-    },
-    customers: {
-      register(params) {
-        return fetchClient.request("POST", "/api/auth/register", params);
-      },
-      login(email, password) {
-        return fetchClient.request("POST", "/api/auth/login", { email, password });
-      },
-      async logout() {
-        await fetchClient.request("POST", "/api/auth/logout");
-      },
-      refresh() {
-        return fetchClient.request(
-          "POST",
-          "/api/auth/refresh",
-          void 0,
-          { authRefresh: true }
-        );
-      },
-      getProfile() {
-        return fetchClient.request("GET", "/api/customers/me");
-      },
-      updateProfile(updates) {
-        return fetchClient.request("PATCH", "/api/customers/me", updates);
-      },
-      listAddresses() {
-        return fetchClient.request("GET", "/api/customers/me/addresses");
-      },
-      addAddress(address) {
-        return fetchClient.request("POST", "/api/customers/me/addresses", address);
-      },
-      async removeAddress(id) {
-        await fetchClient.request(
-          "DELETE",
-          `/api/customers/me/addresses/${encodeURIComponent(id)}`
-        );
-      },
-      async listOrders(params) {
-        const qs = params?.cursor !== void 0 ? `?cursor=${encodeURIComponent(params.cursor)}` : "";
-        const { data, meta } = await fetchClient.requestWithMeta("GET", `/api/orders${qs}`);
-        const nextCursor = typeof meta.nextCursor === "string" ? meta.nextCursor : null;
-        return { items: data ?? [], nextCursor };
-      },
-      getOrder(orderNumber, options = {}) {
-        const { key } = options;
-        return fetchClient.request(
-          "GET",
-          `/api/orders/${encodeURIComponent(orderNumber)}`,
-          void 0,
-          key === void 0 ? {} : { headers: { [ORDER_KEY_HEADER]: key } }
-        );
-      }
-    },
-    recentlyViewed: {
-      async record(productId) {
-        await fetchClient.request("POST", "/api/recently-viewed", { productId });
-      },
-      list() {
-        return fetchClient.request("GET", "/api/recently-viewed");
-      }
-    },
-    reviews: {
-      getForProduct(productId, params) {
-        const search = new URLSearchParams();
-        if (params?.limit !== void 0) search.set("limit", String(params.limit));
-        if (params?.cursor !== void 0) search.set("cursor", params.cursor);
-        const qs = search.toString();
-        return fetchClient.request(
-          "GET",
-          `/api/products/${encodeURIComponent(productId)}/reviews${qs ? `?${qs}` : ""}`
-        );
-      },
-      submit(review) {
-        return fetchClient.request("POST", "/api/reviews", review);
-      }
-    },
-    alerts: {
-      subscribe(request) {
-        return fetchClient.request("POST", "/api/alerts/subscribe", request);
-      }
-    }
-  };
-}
-
-// src/auth/token-manager.ts
-var DEFAULT_STORAGE_KEY = "nymbal.auth.accessToken";
-function createTokenManager(options) {
-  const storageMode = options?.storage ?? "memory";
-  const storageKey = options?.storageKey ?? DEFAULT_STORAGE_KEY;
-  let memoryToken = null;
-  let refreshTimer = null;
-  let refreshFn = null;
-  function getAccessToken() {
-    if (storageMode === "localStorage" && typeof globalThis.localStorage !== "undefined") {
-      return globalThis.localStorage.getItem(storageKey);
-    }
-    return memoryToken;
-  }
-  function setAccessToken(token) {
-    memoryToken = token;
-    if (storageMode === "localStorage" && typeof globalThis.localStorage !== "undefined") {
-      if (token) {
-        globalThis.localStorage.setItem(storageKey, token);
-      } else {
-        globalThis.localStorage.removeItem(storageKey);
-      }
-    }
-  }
-  function setTokens(accessToken, expiresIn) {
-    setAccessToken(accessToken);
-    scheduleAutoRefresh(expiresIn);
-  }
-  function clear() {
-    setAccessToken(null);
-    if (refreshTimer !== null) {
-      clearTimeout(refreshTimer);
-      refreshTimer = null;
-    }
-  }
-  function scheduleAutoRefresh(expiresIn) {
-    if (refreshTimer !== null) {
-      clearTimeout(refreshTimer);
-    }
-    const delayMs = Math.max(1e3, expiresIn * 0.8 * 1e3);
-    refreshTimer = setTimeout(async () => {
-      if (!refreshFn) return;
-      try {
-        const result = await refreshFn();
-        setTokens(result.accessToken, result.expiresIn);
-      } catch (err) {
-        console.error("[TokenManager] auto-refresh failed, clearing session", err);
-        clear();
-      }
-    }, delayMs);
-  }
-  function scheduleRefresh(fn) {
-    refreshFn = fn;
-  }
-  function destroy() {
-    clear();
-    refreshFn = null;
-  }
-  return { getAccessToken, setTokens, clear, scheduleRefresh, destroy };
-}
-
-// src/store/create-store.ts
-function createStore(initialState) {
-  let state = initialState;
-  const listeners = /* @__PURE__ */ new Set();
-  function getState() {
-    return state;
-  }
-  function setState(partial) {
-    const next = typeof partial === "function" ? partial(state) : partial;
-    state = { ...state, ...next };
-    for (const listener of listeners) {
-      listener();
-    }
-  }
-  function subscribe(listener) {
-    listeners.add(listener);
-    return () => {
-      listeners.delete(listener);
-    };
-  }
-  function destroy() {
-    listeners.clear();
-  }
-  return { getState, setState, subscribe, destroy };
-}
-
-// src/store/cart-store.ts
-function deriveItemCount(items) {
-  let count = 0;
-  for (const item of items) {
-    count += item.qty;
-  }
-  return count;
-}
-var INITIAL_STATE = {
-  items: [],
-  subtotalMinor: 0,
-  currency: "USD",
-  itemCount: 0,
-  loading: false,
-  error: null
-};
-function createCartStore(adapter) {
-  const store = createStore(INITIAL_STATE);
-  async function load() {
-    store.setState({ loading: true, error: null });
-    try {
-      const cart = await adapter.cart.get();
-      store.setState({
-        items: cart.items,
-        subtotalMinor: cart.subtotalMinor,
-        currency: cart.currency,
-        itemCount: deriveItemCount(cart.items),
-        loading: false
-      });
-    } catch (err) {
-      store.setState({
-        loading: false,
-        error: err instanceof Error ? err.message : String(err)
-      });
-    }
-  }
-  async function addItem(variantId, qty = 1) {
-    store.setState({ loading: true, error: null });
-    try {
-      const cart = await adapter.cart.addItem(variantId, qty);
-      store.setState({
-        items: cart.items,
-        subtotalMinor: cart.subtotalMinor,
-        currency: cart.currency,
-        itemCount: deriveItemCount(cart.items),
-        loading: false
-      });
-    } catch (err) {
-      store.setState({
-        loading: false,
-        error: err instanceof Error ? err.message : String(err)
-      });
-    }
-  }
-  async function removeItem(variantId) {
-    store.setState({ loading: true, error: null });
-    try {
-      const cart = await adapter.cart.removeItem(variantId);
-      store.setState({
-        items: cart.items,
-        subtotalMinor: cart.subtotalMinor,
-        currency: cart.currency,
-        itemCount: deriveItemCount(cart.items),
-        loading: false
-      });
-    } catch (err) {
-      store.setState({
-        loading: false,
-        error: err instanceof Error ? err.message : String(err)
-      });
-    }
-  }
-  async function updateQuantity(variantId, qty) {
-    store.setState({ loading: true, error: null });
-    try {
-      const cart = await adapter.cart.updateQuantity(variantId, qty);
-      store.setState({
-        items: cart.items,
-        subtotalMinor: cart.subtotalMinor,
-        currency: cart.currency,
-        itemCount: deriveItemCount(cart.items),
-        loading: false
-      });
-    } catch (err) {
-      store.setState({
-        loading: false,
-        error: err instanceof Error ? err.message : String(err)
-      });
-    }
-  }
-  async function clear() {
-    store.setState({ loading: true, error: null });
-    try {
-      await adapter.cart.clear();
-      store.setState({
-        items: [],
-        subtotalMinor: 0,
-        itemCount: 0,
-        loading: false
-      });
-    } catch (err) {
-      store.setState({
-        loading: false,
-        error: err instanceof Error ? err.message : String(err)
-      });
-    }
-  }
-  return {
-    getState: store.getState,
-    subscribe: store.subscribe,
-    addItem,
-    removeItem,
-    updateQuantity,
-    clear,
-    load,
-    destroy: store.destroy
-  };
-}
-
-// src/store/product-store.ts
-var INITIAL_STATE2 = {
-  product: null,
-  selectedVariant: null,
-  loading: false,
-  error: null
-};
-function createProductStore(adapter) {
-  const store = createStore(INITIAL_STATE2);
-  async function loadBySlug(slug) {
-    store.setState({ loading: true, error: null });
-    try {
-      const product = await adapter.products.getBySlug(slug);
-      const firstVariant = product.variants[0] ?? null;
-      store.setState({
-        product,
-        selectedVariant: firstVariant,
-        loading: false
-      });
-    } catch (err) {
-      store.setState({
-        loading: false,
-        error: err instanceof Error ? err.message : String(err)
-      });
-    }
-  }
-  function selectVariant(variant) {
-    store.setState({ selectedVariant: variant });
-  }
-  return {
-    getState: store.getState,
-    subscribe: store.subscribe,
-    loadBySlug,
-    selectVariant,
-    destroy: store.destroy
-  };
-}
-
-// src/store/product-list-store.ts
-import { DEFAULT_PRODUCT_SORT } from "@nymbalhq/types";
-var INITIAL_STATE3 = {
-  products: [],
-  facets: [],
-  filters: {},
-  sort: DEFAULT_PRODUCT_SORT,
-  pagination: { cursor: null, hasMore: false },
-  loading: false,
-  error: null
-};
-function createProductListStore(adapter) {
-  const store = createStore(INITIAL_STATE3);
-  let lastLimit;
-  let generation = 0;
-  function buildParams() {
-    const state = store.getState();
-    const params = { sort: state.sort };
-    if (lastLimit !== void 0) params.limit = lastLimit;
-    const category = state.filters["category"];
-    if (typeof category === "string") {
-      params.category = category;
-    }
-    return params;
-  }
-  async function load(params) {
-    if (params !== void 0) {
-      if (params.limit !== void 0) lastLimit = params.limit;
-      const filters = { ...store.getState().filters };
-      if (params.category !== void 0) filters["category"] = params.category;
-      else delete filters["category"];
-      store.setState({ filters, sort: params.sort ?? DEFAULT_PRODUCT_SORT, loading: true });
-    }
-    const request = buildParams();
-    if (params?.cursor !== void 0) request.cursor = params.cursor;
-    const current = ++generation;
-    store.setState({ loading: true });
-    try {
-      const result = await adapter.products.list(request);
-      if (current !== generation) return;
-      store.setState({
-        products: result.items,
-        facets: result.facets ?? store.getState().facets,
-        pagination: { cursor: result.nextCursor, hasMore: result.nextCursor !== null },
-        loading: false,
-        error: null
-      });
-    } catch (err) {
-      if (current !== generation) return;
-      console.error("[ProductListStore] load failed", err);
-      store.setState({ loading: false, error: err instanceof Error ? err.message : String(err) });
-    }
-  }
-  async function loadMore() {
-    const state = store.getState();
-    if (!state.pagination.hasMore || state.loading) return;
-    const current = ++generation;
-    store.setState({ loading: true });
-    try {
-      const params = buildParams();
-      if (state.pagination.cursor !== null) {
-        params.cursor = state.pagination.cursor;
-      }
-      const result = await adapter.products.list(params);
-      if (current !== generation) return;
-      store.setState({
-        products: [...state.products, ...result.items],
-        pagination: { cursor: result.nextCursor, hasMore: result.nextCursor !== null },
-        loading: false,
-        error: null
-      });
-    } catch (err) {
-      if (current !== generation) return;
-      console.error("[ProductListStore] loadMore failed", err);
-      store.setState({ loading: false, error: err instanceof Error ? err.message : String(err) });
-    }
-  }
-  async function applyFilter(name, value) {
-    const filters = { ...store.getState().filters, [name]: value };
-    store.setState({ filters });
-    await load();
-  }
-  async function removeFilter(name) {
-    const filters = { ...store.getState().filters };
-    delete filters[name];
-    store.setState({ filters });
-    await load();
-  }
-  async function setSort(sort) {
-    store.setState({ sort });
-    await load();
-  }
-  return {
-    getState: store.getState,
-    subscribe: store.subscribe,
-    load,
-    loadMore,
-    applyFilter,
-    removeFilter,
-    setSort,
-    destroy: store.destroy
-  };
-}
-
-// src/store/search-store.ts
-var INITIAL_STATE4 = {
-  query: "",
-  category: null,
-  results: [],
-  total: 0,
-  nextCursor: null,
-  facets: [],
-  loading: false
-};
-function createSearchStore(adapter) {
-  const store = createStore(INITIAL_STATE4);
-  let generation = 0;
-  async function search(query, options) {
-    const run = ++generation;
-    if (!query.trim()) {
-      store.setState({ ...INITIAL_STATE4 });
-      return;
-    }
-    const category = options?.category ?? null;
-    store.setState({ query, category, loading: true });
-    try {
-      const result = await (category === null ? adapter.products.search(query) : adapter.products.search(query, { category }));
-      if (run !== generation) return;
-      store.setState({
-        results: result.items,
-        total: result.total,
-        nextCursor: result.nextCursor,
-        facets: result.facets ?? [],
-        loading: false
-      });
-    } catch (err) {
-      if (run !== generation) return;
-      console.error("[SearchStore] search failed", err);
-      store.setState({ loading: false });
-    }
-  }
-  async function loadMore() {
-    const { query, category, nextCursor, loading } = store.getState();
-    if (nextCursor === null || loading) return;
-    const run = generation;
-    store.setState({ loading: true });
-    try {
-      const result = await adapter.products.search(query, {
-        cursor: nextCursor,
-        ...category !== null && { category }
-      });
-      if (run !== generation) return;
-      store.setState({
-        results: [...store.getState().results, ...result.items],
-        total: result.total,
-        nextCursor: result.nextCursor,
-        loading: false
-      });
-    } catch (err) {
-      if (run !== generation) return;
-      console.error("[SearchStore] load more failed", err);
-      store.setState({ loading: false });
-    }
-  }
-  function setCategory(category) {
-    return search(store.getState().query, { category });
-  }
-  function clearSearch() {
-    generation++;
-    store.setState({ ...INITIAL_STATE4 });
-  }
-  return {
-    getState: store.getState,
-    subscribe: store.subscribe,
-    search,
-    loadMore,
-    setCategory,
-    clearSearch,
-    destroy: store.destroy
-  };
-}
-
-// src/store/checkout-store.ts
-var INITIAL_STATE5 = {
-  step: "contact",
-  email: "",
-  shippingAddress: null,
-  billingAddress: null,
-  shippingMethod: null,
-  paymentStatus: "idle",
-  error: null,
-  order: null,
-  placedOrderNumber: null,
-  placedOrderKey: null
-};
-function namedOrder(err) {
-  const context = err instanceof NymbalApiError ? err.context : void 0;
-  const orderNumber = context?.["orderNumber"];
-  const orderKey = context?.["orderKey"];
-  return typeof orderNumber === "string" ? {
-    placedOrderNumber: orderNumber,
-    placedOrderKey: typeof orderKey === "string" ? orderKey : null
-  } : { placedOrderNumber: null, placedOrderKey: null };
-}
-function createCheckoutStore(adapter, cart) {
-  const store = createStore(INITIAL_STATE5);
-  function setEmail(email) {
-    store.setState({ email, step: "shipping" });
-  }
-  function setShippingAddress(address) {
-    store.setState({ shippingAddress: address });
-  }
-  function setBillingAddress(address) {
-    store.setState({ billingAddress: address });
-  }
-  function setShippingMethod(method) {
-    store.setState({ shippingMethod: method, step: "payment" });
-  }
-  async function submitPayment() {
-    const state = store.getState();
-    if (!state.shippingAddress || !state.billingAddress) {
-      store.setState({ error: "Shipping and billing addresses are required" });
-      return null;
-    }
-    store.setState({
-      paymentStatus: "processing",
-      error: null,
-      placedOrderNumber: null,
-      placedOrderKey: null
-    });
-    try {
-      const result = await adapter.checkout.create({
-        email: state.email,
-        billingAddress: state.billingAddress,
-        shippingAddress: state.shippingAddress
-      });
-      const { status, reason } = result.payment;
-      store.setState({
-        paymentStatus: status,
-        order: {
-          orderId: result.orderId,
-          orderNumber: result.orderNumber,
-          paymentIntent: result.paymentIntent
-        },
-        error: status === "failed" ? `Your payment did not go through${reason ? ` (${reason})` : ""}. Please try again.` : null,
-        ...status === "succeeded" && { step: "confirmation" }
-      });
-      await cart?.load();
-      return result;
-    } catch (err) {
-      const placed = namedOrder(err);
-      store.setState({
-        paymentStatus: "failed",
-        error: err instanceof Error ? err.message : String(err),
-        ...placed
-      });
-      if (placed.placedOrderNumber !== null) await cart?.load();
-      return null;
-    }
-  }
-  function markConfirmed() {
-    store.setState({ paymentStatus: "succeeded", step: "confirmation" });
-  }
-  function reset() {
-    store.setState(INITIAL_STATE5);
-  }
-  return {
-    getState: store.getState,
-    subscribe: store.subscribe,
-    setEmail,
-    setShippingAddress,
-    setBillingAddress,
-    setShippingMethod,
-    submitPayment,
-    markConfirmed,
-    reset,
-    destroy: store.destroy
-  };
-}
-
-// src/store/auth-store.ts
-var INITIAL_STATE6 = {
-  customer: null,
-  isAuthenticated: false,
-  loading: false,
-  error: null
-};
-function createAuthStore(adapter, tokenManager) {
-  const store = createStore(INITIAL_STATE6);
-  async function login(email, password) {
-    store.setState({ loading: true, error: null });
-    try {
-      const result = await adapter.customers.login(email, password);
-      tokenManager.setTokens(result.accessToken, result.expiresIn);
-      store.setState({
-        customer: result.customer,
-        isAuthenticated: true,
-        loading: false
-      });
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      store.setState({ loading: false, error: message });
-      throw err;
-    }
-  }
-  async function register(params) {
-    store.setState({ loading: true, error: null });
-    try {
-      const result = await adapter.customers.register(params);
-      tokenManager.setTokens(result.accessToken, result.expiresIn);
-      store.setState({
-        customer: result.customer,
-        isAuthenticated: true,
-        loading: false
-      });
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      store.setState({ loading: false, error: message });
-      throw err;
-    }
-  }
-  async function logout() {
-    store.setState({ loading: true, error: null });
-    try {
-      await adapter.customers.logout();
-      tokenManager.clear();
-      store.setState({
-        customer: null,
-        isAuthenticated: false,
-        loading: false
-      });
-    } catch (err) {
-      tokenManager.clear();
-      store.setState({
-        customer: null,
-        isAuthenticated: false,
-        loading: false,
-        error: err instanceof Error ? err.message : String(err)
-      });
-    }
-  }
-  async function refreshToken() {
-    try {
-      const result = await adapter.customers.refresh();
-      tokenManager.setTokens(result.accessToken, result.expiresIn);
-    } catch (err) {
-      console.error("[AuthStore] token refresh failed, logging out", err);
-      tokenManager.clear();
-      store.setState({
-        customer: null,
-        isAuthenticated: false
-      });
-    }
-  }
-  async function updateProfile(updates) {
-    store.setState({ loading: true, error: null });
-    try {
-      const customer = await adapter.customers.updateProfile(updates);
-      store.setState({ customer, loading: false });
-    } catch (err) {
-      store.setState({
-        loading: false,
-        error: err instanceof Error ? err.message : String(err)
-      });
-    }
-  }
-  async function loadProfile() {
-    if (!tokenManager.getAccessToken()) return;
-    store.setState({ loading: true, error: null });
-    try {
-      const customer = await adapter.customers.getProfile();
-      store.setState({
-        customer,
-        isAuthenticated: true,
-        loading: false
-      });
-    } catch (err) {
-      store.setState({
-        loading: false,
-        error: err instanceof Error ? err.message : String(err)
-      });
-    }
-  }
-  return {
-    getState: store.getState,
-    subscribe: store.subscribe,
-    login,
-    register,
-    logout,
-    refreshToken,
-    updateProfile,
-    loadProfile,
-    destroy: store.destroy
-  };
-}
-
-// src/client.ts
-function createNymbalClient(options) {
-  const tokenManager = createTokenManager({
-    ...options.tokenStorage !== void 0 && { storage: options.tokenStorage }
-  });
-  let adapter;
-  if (options.adapter) {
-    adapter = options.adapter;
-  } else {
-    const fetchClient = new FetchClient({
-      baseUrl: options.baseUrl,
-      ...options.credentials !== void 0 && { credentials: options.credentials },
-      getAccessToken: () => tokenManager.getAccessToken(),
-      ...options.getCartToken !== void 0 && { getCartToken: options.getCartToken },
-      onUnauthorized: async () => {
-        try {
-          const result = await adapter.customers.refresh();
-          tokenManager.setTokens(result.accessToken, result.expiresIn);
-        } catch (err) {
-          console.warn("[NymbalClient] token refresh on unauthorized failed", err);
-          tokenManager.clear();
-        }
-      }
-    });
-    adapter = createNymbalApiAdapter(fetchClient);
-  }
-  const cart = createCartStore(adapter);
-  const product = createProductStore(adapter);
-  const productList = createProductListStore(adapter);
-  const search = createSearchStore(adapter);
-  const checkout = createCheckoutStore(adapter, cart);
-  const auth = createAuthStore(adapter, tokenManager);
-  const customer = {
-    addresses: {
-      list: () => adapter.customers.listAddresses(),
-      create: (address) => adapter.customers.addAddress(address),
-      remove: (id) => adapter.customers.removeAddress(id)
-    },
-    orders: {
-      list: (opts) => adapter.customers.listOrders(opts),
-      get: (orderNumber, options2) => adapter.customers.getOrder(orderNumber, options2)
-    }
-  };
-  let report = null;
-  const capabilities = {
-    get() {
-      if (report === null) {
-        const reader = adapter.capabilities;
-        report = reader === void 0 ? Promise.reject(new Error("This client\u2019s adapter cannot read the store capabilities.")) : reader.get();
-        report.catch(() => {
-          report = null;
-        });
-      }
-      return report;
-    }
-  };
-  const recentlyViewedOf = () => {
-    const reader = adapter.recentlyViewed;
-    if (reader === void 0) {
-      throw new Error("This client\u2019s adapter cannot record or list recently viewed products.");
-    }
-    return reader;
-  };
-  const recentlyViewed = {
-    async record(productId) {
-      await recentlyViewedOf().record(productId);
-    },
-    async list() {
-      return recentlyViewedOf().list();
-    }
-  };
-  tokenManager.scheduleRefresh(() => adapter.customers.refresh());
-  function destroy() {
-    cart.destroy();
-    product.destroy();
-    productList.destroy();
-    search.destroy();
-    checkout.destroy();
-    auth.destroy();
-    tokenManager.destroy();
-  }
-  return {
-    capabilities,
-    recentlyViewed,
-    cart,
-    product,
-    productList,
-    search,
-    checkout,
-    auth,
-    customer,
-    adapter,
-    destroy
-  };
-}
-
-// src/payment-drivers.ts
-var DRIVERS_KEY = /* @__PURE__ */ Symbol.for("nymbal.paymentDrivers");
-function drivers() {
-  const holder = globalThis;
-  holder[DRIVERS_KEY] ??= /* @__PURE__ */ new Map();
-  return holder[DRIVERS_KEY];
-}
-function registerPaymentDriver(name, driver) {
-  drivers().set(name, driver);
-}
-function getPaymentDriver(name) {
-  return drivers().get(name);
-}
+  getPaymentDriver,
+  registerPaymentDriver
+} from "./chunk-4GP43MKT.js";
+import {
+  createProductStore
+} from "./chunk-CJVA46FR.js";
+import {
+  createProductListStore
+} from "./chunk-XS7RNJSY.js";
+import {
+  createSearchStore
+} from "./chunk-YHXC7DS5.js";
+import {
+  createCheckoutStore
+} from "./chunk-VYX72KGY.js";
+import {
+  createCartStore
+} from "./chunk-7LQGOJIT.js";
+import {
+  createAuthStore
+} from "./chunk-PDZKR65O.js";
+import {
+  createStore
+} from "./chunk-U6QF2DRY.js";
+import {
+  FetchClient,
+  NymbalApiError,
+  SESSION_HINT_KEY,
+  createNymbalApiAdapter,
+  createNymbalClient,
+  createTokenManager
+} from "./chunk-2EEZZXZX.js";
 export {
   FetchClient,
   NymbalApiError,
+  SESSION_HINT_KEY,
   createAuthStore,
   createCartStore,
   createCheckoutStore,