@nymbalhq/sdk 0.0.0-stage → 0.2.0

package/dist/index.js

@@ -0,0 +1,906 @@
+// 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 CSRF_HEADER = "x-csrf-token";
+var UNSAFE_METHODS = /* @__PURE__ */ new Set(["POST", "PUT", "PATCH", "DELETE"]);
+var FetchClient = class {
+  baseUrl;
+  credentials;
+  getAccessToken;
+  getCartToken;
+  onUnauthorized;
+  handlingUnauthorized = false;
+  /** 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) {
+    return (await this.requestWithMeta(method, path, body)).data;
+  }
+  /** Like `request`, keeping the envelope's `meta` (pagination cursors live there). */
+  async requestWithMeta(method, path, body) {
+    let response = await this.doFetch(method, path, body);
+    if (await this.isCsrfRejection(response)) {
+      this.csrfToken = null;
+      response = await this.doFetch(method, path, body);
+    }
+    if (response.status === 401 && this.onUnauthorized && !this.handlingUnauthorized) {
+      this.handlingUnauthorized = true;
+      try {
+        await this.onUnauthorized();
+      } finally {
+        this.handlingUnauthorized = false;
+      }
+      const retry = await this.doFetch(method, path, body);
+      return this.parseResponse(retry);
+    }
+    return this.parseResponse(response);
+  }
+  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) {
+    const 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("; ");
+    }
+    return globalThis.fetch(`${this.baseUrl}${path}`, {
+      method,
+      headers,
+      credentials: this.credentials,
+      ...body !== void 0 && { body: JSON.stringify(body) }
+    });
+  }
+  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
+function createNymbalApiAdapter(fetchClient) {
+  return {
+    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);
+        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"
+        );
+      },
+      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) {
+        return fetchClient.request("GET", `/api/orders/${encodeURIComponent(orderNumber)}`);
+      }
+    },
+    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);
+      }
+    }
+  };
+}
+
+// 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 });
+    }
+    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: "",
+  results: [],
+  total: 0,
+  loading: false
+};
+function createSearchStore(adapter) {
+  const store = createStore(INITIAL_STATE4);
+  async function search(query) {
+    if (!query.trim()) {
+      store.setState({ query: "", results: [], total: 0, loading: false });
+      return;
+    }
+    store.setState({ query, loading: true });
+    try {
+      const result = await adapter.products.search(query);
+      store.setState({
+        results: result.items,
+        total: result.items.length,
+        loading: false
+      });
+    } catch (err) {
+      console.error("[SearchStore] search failed", err);
+      store.setState({ loading: false });
+    }
+  }
+  function clearSearch() {
+    store.setState({ query: "", results: [], total: 0, loading: false });
+  }
+  return {
+    getState: store.getState,
+    subscribe: store.subscribe,
+    search,
+    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
+};
+function namedOrder(err) {
+  if (!(err instanceof NymbalApiError)) return null;
+  const orderNumber = err.context?.["orderNumber"];
+  return typeof orderNumber === "string" ? orderNumber : 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 });
+    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 placedOrderNumber = namedOrder(err);
+      store.setState({
+        paymentStatus: "failed",
+        error: err instanceof Error ? err.message : String(err),
+        placedOrderNumber
+      });
+      if (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) => adapter.customers.getOrder(orderNumber)
+    }
+  };
+  tokenManager.scheduleRefresh(() => adapter.customers.refresh());
+  function destroy() {
+    cart.destroy();
+    product.destroy();
+    productList.destroy();
+    search.destroy();
+    checkout.destroy();
+    auth.destroy();
+    tokenManager.destroy();
+  }
+  return { cart, product, productList, search, checkout, auth, customer, adapter, destroy };
+}
+export {
+  FetchClient,
+  NymbalApiError,
+  createAuthStore,
+  createCartStore,
+  createCheckoutStore,
+  createNymbalApiAdapter,
+  createNymbalClient,
+  createProductListStore,
+  createProductStore,
+  createSearchStore,
+  createStore,
+  createTokenManager
+};
+//# sourceMappingURL=index.js.map