@doswiftly/storefront-sdk 4.0.0

package/dist/react/server/get-storefront-client.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Server-side StorefrontClient factory — for Server Components, API routes, etc.
+ *
+ * Creates a StorefrontClient with default middleware pipeline,
+ * without requiring React context (no providers needed server-side).
+ *
+ * @example
+ * ```typescript
+ * // lib/graphql/server.ts
+ * import { getStorefrontClient } from '@doswiftly/storefront-sdk/react/server';
+ *
+ * const client = getStorefrontClient({
+ *   apiUrl: process.env.NEXT_PUBLIC_API_URL!,
+ *   shopSlug: process.env.NEXT_PUBLIC_SHOP_SLUG!,
+ * });
+ *
+ * export const fetchProduct = cache(async (handle: string) => {
+ *   return client.query(ProductDocument, { handle });
+ * });
+ * ```
+ */
+import type { StorefrontClient, StorefrontClientConfig, Middleware } from '../../core/client/types';
+export interface ServerClientOptions extends Omit<StorefrontClientConfig, 'middleware'> {
+    /**
+     * Function that returns request-scoped headers (e.g. currency from cookie).
+     * Called once per client creation.
+     */
+    getHeaders?: () => Record<string, string> | Promise<Record<string, string>>;
+    /**
+     * Additional middleware (prepended to default pipeline).
+     */
+    middleware?: Middleware[];
+}
+/**
+ * Create a StorefrontClient for server-side use.
+ *
+ * Includes default middleware: retry → timeout → errors.
+ * Does NOT include auth/currency middleware (server has no Zustand stores).
+ * Pass headers via config.defaultHeaders or getHeaders option.
+ */
+export declare function getStorefrontClient(options: ServerClientOptions): StorefrontClient;
+//# sourceMappingURL=get-storefront-client.d.ts.map

package/dist/react/server/get-storefront-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-storefront-client.d.ts","sourceRoot":"","sources":["../../../src/react/server/get-storefront-client.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAMH,OAAO,KAAK,EAAE,gBAAgB,EAAE,sBAAsB,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAEpG,MAAM,WAAW,mBAAoB,SAAQ,IAAI,CAAC,sBAAsB,EAAE,YAAY,CAAC;IACrF;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAC5E;;OAEG;IACH,UAAU,CAAC,EAAE,UAAU,EAAE,CAAC;CAC3B;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,mBAAmB,GAAG,gBAAgB,CAYlF"}

package/dist/react/server/get-storefront-client.js

@@ -0,0 +1,44 @@
+/**
+ * Server-side StorefrontClient factory — for Server Components, API routes, etc.
+ *
+ * Creates a StorefrontClient with default middleware pipeline,
+ * without requiring React context (no providers needed server-side).
+ *
+ * @example
+ * ```typescript
+ * // lib/graphql/server.ts
+ * import { getStorefrontClient } from '@doswiftly/storefront-sdk/react/server';
+ *
+ * const client = getStorefrontClient({
+ *   apiUrl: process.env.NEXT_PUBLIC_API_URL!,
+ *   shopSlug: process.env.NEXT_PUBLIC_SHOP_SLUG!,
+ * });
+ *
+ * export const fetchProduct = cache(async (handle: string) => {
+ *   return client.query(ProductDocument, { handle });
+ * });
+ * ```
+ */
+import { createStorefrontClient } from '../../core/client/create-client';
+import { retryMiddleware } from '../../core/middleware/retry';
+import { timeoutMiddleware } from '../../core/middleware/timeout';
+import { errorMiddleware } from '../../core/middleware/errors';
+/**
+ * Create a StorefrontClient for server-side use.
+ *
+ * Includes default middleware: retry → timeout → errors.
+ * Does NOT include auth/currency middleware (server has no Zustand stores).
+ * Pass headers via config.defaultHeaders or getHeaders option.
+ */
+export function getStorefrontClient(options) {
+    const { middleware: customMiddleware = [], ...config } = options;
+    return createStorefrontClient({
+        ...config,
+        middleware: [
+            ...customMiddleware,
+            retryMiddleware({ maxRetries: 2 }),
+            timeoutMiddleware({ timeout: 10000 }), // Server-side: 10s timeout
+            errorMiddleware(),
+        ],
+    });
+}

package/dist/react/server/index.d.ts

@@ -0,0 +1,2 @@
+export { getStorefrontClient, type ServerClientOptions } from './get-storefront-client';
+//# sourceMappingURL=index.d.ts.map

package/dist/react/server/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/react/server/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,KAAK,mBAAmB,EAAE,MAAM,yBAAyB,CAAC"}

package/dist/react/server/index.js

@@ -0,0 +1 @@
+export { getStorefrontClient } from './get-storefront-client';

package/dist/react/stores/auth.store.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Auth store factory — localStorage persistence via Zustand persist.
+ *
+ * Creates a vanilla Zustand store (not a React hook singleton).
+ * Instance is created in StorefrontProvider via useRef and provided
+ * through React Context — eliminates module duplication in Turbopack.
+ *
+ * httpOnly cookie is managed separately (for SSR/middleware).
+ */
+export interface CustomerInfo {
+    id: string;
+    email: string;
+    firstName?: string;
+    lastName?: string;
+    phone?: string;
+}
+export interface AuthStore {
+    customer: CustomerInfo | null;
+    accessToken: string | null;
+    isAuthenticated: boolean;
+    isLoading: boolean;
+    setAuth: (customer: CustomerInfo, accessToken: string) => void;
+    clearAuth: () => void;
+    updateCustomer: (updates: Partial<CustomerInfo>) => void;
+    setLoading: (isLoading: boolean) => void;
+}
+export declare const createAuthStore: (initialIsAuthenticated?: boolean) => Omit<import("zustand").StoreApi<AuthStore>, "setState" | "persist"> & {
+    setState(partial: AuthStore | Partial<AuthStore> | ((state: AuthStore) => AuthStore | Partial<AuthStore>), replace?: false | undefined): unknown;
+    setState(state: AuthStore | ((state: AuthStore) => AuthStore), replace: true): unknown;
+    persist: {
+        setOptions: (options: Partial<import("zustand/middleware").PersistOptions<AuthStore, {
+            customer: CustomerInfo | null;
+            accessToken: string | null;
+            isAuthenticated: boolean;
+        }, unknown>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: AuthStore) => void) => () => void;
+        onFinishHydration: (fn: (state: AuthStore) => void) => () => void;
+        getOptions: () => Partial<import("zustand/middleware").PersistOptions<AuthStore, {
+            customer: CustomerInfo | null;
+            accessToken: string | null;
+            isAuthenticated: boolean;
+        }, unknown>>;
+    };
+};
+//# sourceMappingURL=auth.store.d.ts.map

package/dist/react/stores/auth.store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.store.d.ts","sourceRoot":"","sources":["../../../src/react/stores/auth.store.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAKH,MAAM,WAAW,YAAY;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,SAAS;IAExB,QAAQ,EAAE,YAAY,GAAG,IAAI,CAAC;IAC9B,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,eAAe,EAAE,OAAO,CAAC;IACzB,SAAS,EAAE,OAAO,CAAC;IAGnB,OAAO,EAAE,CAAC,QAAQ,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,KAAK,IAAI,CAAC;IAC/D,SAAS,EAAE,MAAM,IAAI,CAAC;IACtB,cAAc,EAAE,CAAC,OAAO,EAAE,OAAO,CAAC,YAAY,CAAC,KAAK,IAAI,CAAC;IACzD,UAAU,EAAE,CAAC,SAAS,EAAE,OAAO,KAAK,IAAI,CAAC;CAC1C;AAED,eAAO,MAAM,eAAe,GAAI,gCAA8B;;;;;sBA+DtC,YAAY,GAAG,IAAI;yBAChB,MAAM,GAAG,IAAI;6BACT,OAAO;;;;;;;;sBAFd,YAAY,GAAG,IAAI;yBAChB,MAAM,GAAG,IAAI;6BACT,OAAO;;;CAWnC,CAAC"}

package/dist/react/stores/auth.store.js

@@ -0,0 +1,67 @@
+/**
+ * Auth store factory — localStorage persistence via Zustand persist.
+ *
+ * Creates a vanilla Zustand store (not a React hook singleton).
+ * Instance is created in StorefrontProvider via useRef and provided
+ * through React Context — eliminates module duplication in Turbopack.
+ *
+ * httpOnly cookie is managed separately (for SSR/middleware).
+ */
+import { createStore } from 'zustand/vanilla';
+import { persist } from 'zustand/middleware';
+export const createAuthStore = (initialIsAuthenticated = false) => createStore()(persist((set) => ({
+    customer: null,
+    accessToken: null,
+    isAuthenticated: initialIsAuthenticated,
+    isLoading: false,
+    setAuth: (customer, accessToken) => set({
+        customer,
+        accessToken,
+        isAuthenticated: true,
+    }),
+    clearAuth: () => set({
+        customer: null,
+        accessToken: null,
+        isAuthenticated: false,
+    }),
+    updateCustomer: (updates) => set((state) => ({
+        customer: state.customer
+            ? { ...state.customer, ...updates }
+            : null,
+    })),
+    setLoading: (isLoading) => set({ isLoading }),
+}), {
+    name: 'auth-storage',
+    version: 2, // Invalidate stale data from old module-level store era
+    partialize: (state) => ({
+        customer: state.customer,
+        accessToken: state.accessToken,
+        isAuthenticated: state.isAuthenticated,
+    }),
+    /**
+     * Custom merge — server cookie check (initialIsAuthenticated) is authoritative
+     * for isAuthenticated. localStorage provides supplementary data (customer, token).
+     *
+     * This prevents stale localStorage from overwriting the server-provided auth state.
+     */
+    merge: (persistedState, currentState) => {
+        const persisted = persistedState;
+        if (!persisted)
+            return currentState;
+        return {
+            ...currentState,
+            customer: persisted.customer ?? currentState.customer,
+            accessToken: persisted.accessToken ?? currentState.accessToken,
+            // Server cookie is the authority — never let stale localStorage override it
+            isAuthenticated: currentState.isAuthenticated,
+        };
+    },
+    migrate: (persistedState, version) => {
+        if (version < 2) {
+            // Data from old module-level store may be unreliable (Turbopack duplication)
+            // Clear it — user will re-authenticate via cookie or login
+            return { customer: null, accessToken: null, isAuthenticated: false };
+        }
+        return persistedState;
+    },
+}));

package/dist/react/stores/currency.store.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Currency store factory — cookie persistence (SSR-safe).
+ *
+ * Creates a vanilla Zustand store (not a React hook singleton).
+ * Instance is created in StorefrontProvider via useRef and provided
+ * through React Context — eliminates module duplication in Turbopack.
+ */
+export interface ShopCurrencyData {
+    currencyCode: string;
+    supportedCurrencies: string[];
+    localeToCurrencyMap?: Array<{
+        locale: string;
+        currency: string;
+    }>;
+}
+export interface CurrencyStore {
+    baseCurrency: string | null;
+    supportedCurrencies: string[];
+    currency: string | null;
+    isLoaded: boolean;
+    initialize: (shopData: ShopCurrencyData) => void;
+    setCurrency: (currency: string) => void;
+}
+export declare const createCurrencyStore: () => import("zustand").StoreApi<CurrencyStore>;
+export declare const selectCurrency: (state: CurrencyStore) => string | null;
+export declare const selectBaseCurrency: (state: CurrencyStore) => string | null;
+export declare const selectSupportedCurrencies: (state: CurrencyStore) => string[];
+export declare const selectIsLoaded: (state: CurrencyStore) => boolean;
+//# sourceMappingURL=currency.store.d.ts.map

package/dist/react/stores/currency.store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"currency.store.d.ts","sourceRoot":"","sources":["../../../src/react/stores/currency.store.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,MAAM,WAAW,gBAAgB;IAC/B,YAAY,EAAE,MAAM,CAAC;IACrB,mBAAmB,EAAE,MAAM,EAAE,CAAC;IAC9B,mBAAmB,CAAC,EAAE,KAAK,CAAC;QAC1B,MAAM,EAAE,MAAM,CAAC;QACf,QAAQ,EAAE,MAAM,CAAC;KAClB,CAAC,CAAC;CACJ;AAED,MAAM,WAAW,aAAa;IAE5B,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,mBAAmB,EAAE,MAAM,EAAE,CAAC;IAC9B,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,QAAQ,EAAE,OAAO,CAAC;IAGlB,UAAU,EAAE,CAAC,QAAQ,EAAE,gBAAgB,KAAK,IAAI,CAAC;IACjD,WAAW,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;CACzC;AAqBD,eAAO,MAAM,mBAAmB,iDAqD3B,CAAC;AAMN,eAAO,MAAM,cAAc,GAAI,OAAO,aAAa,kBAAmB,CAAC;AACvE,eAAO,MAAM,kBAAkB,GAAI,OAAO,aAAa,kBAAuB,CAAC;AAC/E,eAAO,MAAM,yBAAyB,GAAI,OAAO,aAAa,aAA8B,CAAC;AAC7F,eAAO,MAAM,cAAc,GAAI,OAAO,aAAa,YAAmB,CAAC"}

package/dist/react/stores/currency.store.js

@@ -0,0 +1,76 @@
+/**
+ * Currency store factory — cookie persistence (SSR-safe).
+ *
+ * Creates a vanilla Zustand store (not a React hook singleton).
+ * Instance is created in StorefrontProvider via useRef and provided
+ * through React Context — eliminates module duplication in Turbopack.
+ */
+import { createStore } from 'zustand/vanilla';
+/**
+ * Get currency from cookie (client-side).
+ */
+function getCurrencyFromCookie() {
+    if (typeof document === 'undefined')
+        return null;
+    const match = document.cookie.match(/(?:^|;\s*)preferred-currency=([^;]*)/);
+    return match ? decodeURIComponent(match[1]) : null;
+}
+/**
+ * Set currency in cookie (client-side).
+ */
+function setCurrencyCookie(currency) {
+    if (typeof document === 'undefined')
+        return;
+    const maxAge = 365 * 24 * 60 * 60; // 1 year
+    const secure = typeof location !== 'undefined' && location.protocol === 'https:' ? ';secure' : '';
+    document.cookie = `preferred-currency=${encodeURIComponent(currency)};max-age=${maxAge};path=/;samesite=lax${secure}`;
+}
+export const createCurrencyStore = () => createStore()((set, get) => ({
+    baseCurrency: null,
+    supportedCurrencies: [],
+    currency: null,
+    isLoaded: false,
+    initialize: (shopData) => {
+        // 1. Try saved currency from cookie (SSR-safe)
+        const saved = getCurrencyFromCookie();
+        // 2. Try to detect from browser locale
+        let detected;
+        if (shopData.localeToCurrencyMap && typeof navigator !== 'undefined') {
+            const browserLocale = navigator.language;
+            const match = shopData.localeToCurrencyMap.find((m) => m.locale === browserLocale);
+            detected = match?.currency;
+        }
+        // 3. Determine final currency (priority: saved > detected > base)
+        const finalCurrency = saved && shopData.supportedCurrencies.includes(saved)
+            ? saved
+            : detected && shopData.supportedCurrencies.includes(detected)
+                ? detected
+                : shopData.currencyCode;
+        set({
+            baseCurrency: shopData.currencyCode,
+            supportedCurrencies: shopData.supportedCurrencies,
+            currency: finalCurrency,
+            isLoaded: true,
+        });
+        // Ensure cookie is set if we determined a currency
+        if (finalCurrency && !saved) {
+            setCurrencyCookie(finalCurrency);
+        }
+    },
+    setCurrency: (currency) => {
+        const { supportedCurrencies } = get();
+        if (!supportedCurrencies.includes(currency)) {
+            console.warn(`[CurrencyStore] Currency ${currency} not supported`);
+            return;
+        }
+        set({ currency });
+        setCurrencyCookie(currency);
+    },
+}));
+// ---------------------------------------------------------------------------
+// Selectors (for use with useCurrencyStore(selector))
+// ---------------------------------------------------------------------------
+export const selectCurrency = (state) => state.currency;
+export const selectBaseCurrency = (state) => state.baseCurrency;
+export const selectSupportedCurrencies = (state) => state.supportedCurrencies;
+export const selectIsLoaded = (state) => state.isLoaded;

package/dist/react/stores/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Zustand stores — factory functions + context hooks.
+ */
+export { createAuthStore, type AuthStore, type CustomerInfo } from './auth.store';
+export { createCurrencyStore, type CurrencyStore, type ShopCurrencyData } from './currency.store';
+export { selectCurrency, selectBaseCurrency, selectSupportedCurrencies, selectIsLoaded } from './currency.store';
+export { useAuthStore, useAuthStoreApi, useAuthHydrated, useCurrencyStore, useCurrencyStoreApi, AuthStoreContext, CurrencyStoreContext, } from './store-context';
+//# sourceMappingURL=index.d.ts.map

package/dist/react/stores/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/react/stores/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,EAAE,eAAe,EAAE,KAAK,SAAS,EAAE,KAAK,YAAY,EAAE,MAAM,cAAc,CAAC;AAClF,OAAO,EAAE,mBAAmB,EAAE,KAAK,aAAa,EAAE,KAAK,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAGlG,OAAO,EAAE,cAAc,EAAE,kBAAkB,EAAE,yBAAyB,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAGjH,OAAO,EACL,YAAY,EAAE,eAAe,EAAE,eAAe,EAC9C,gBAAgB,EAAE,mBAAmB,EACrC,gBAAgB,EAAE,oBAAoB,GACvC,MAAM,iBAAiB,CAAC"}

package/dist/react/stores/index.js

@@ -0,0 +1,10 @@
+/**
+ * Zustand stores — factory functions + context hooks.
+ */
+// Factory functions
+export { createAuthStore } from './auth.store';
+export { createCurrencyStore } from './currency.store';
+// Selectors
+export { selectCurrency, selectBaseCurrency, selectSupportedCurrencies, selectIsLoaded } from './currency.store';
+// Context hooks
+export { useAuthStore, useAuthStoreApi, useAuthHydrated, useCurrencyStore, useCurrencyStoreApi, AuthStoreContext, CurrencyStoreContext, } from './store-context';

package/dist/react/stores/store-context.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Store Context — React Context + hooks for Zustand vanilla stores.
+ *
+ * This is the SINGLE source for useAuthStore and useCurrencyStore hooks.
+ * Stores are created in StorefrontProvider (useRef) and provided via Context.
+ * This eliminates module-level singletons and Turbopack duplication bugs.
+ *
+ * useAuthHydrated() replaces the old isHydrated store field — tracks
+ * Zustand persist rehydration via React lifecycle (not module-level code).
+ */
+import { type StoreApi } from 'zustand';
+import type { AuthStore } from './auth.store';
+import type { CurrencyStore } from './currency.store';
+export declare const AuthStoreContext: import("react").Context<StoreApi<AuthStore> | null>;
+export declare const CurrencyStoreContext: import("react").Context<StoreApi<CurrencyStore> | null>;
+export declare function useAuthStore(): AuthStore;
+export declare function useAuthStore<T>(selector: (s: AuthStore) => T): T;
+export declare function useAuthStoreApi(): StoreApi<AuthStore>;
+/**
+ * Tracks persist hydration state via React lifecycle (not module-level).
+ * Returns `true` once Zustand persist has finished rehydrating from localStorage.
+ */
+export declare function useAuthHydrated(): boolean;
+export declare function useCurrencyStore(): CurrencyStore;
+export declare function useCurrencyStore<T>(selector: (s: CurrencyStore) => T): T;
+export declare function useCurrencyStoreApi(): StoreApi<CurrencyStore>;
+//# sourceMappingURL=store-context.d.ts.map

package/dist/react/stores/store-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store-context.d.ts","sourceRoot":"","sources":["../../../src/react/stores/store-context.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAKH,OAAO,EAAY,KAAK,QAAQ,EAAE,MAAM,SAAS,CAAC;AAClD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAMtD,eAAO,MAAM,gBAAgB,qDAAkD,CAAC;AAChF,eAAO,MAAM,oBAAoB,yDAAsD,CAAC;AAMxF,wBAAgB,YAAY,IAAI,SAAS,CAAC;AAC1C,wBAAgB,YAAY,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,CAAC,EAAE,SAAS,KAAK,CAAC,GAAG,CAAC,CAAC;AAQlE,wBAAgB,eAAe,IAAI,QAAQ,CAAC,SAAS,CAAC,CAIrD;AAED;;;GAGG;AACH,wBAAgB,eAAe,IAAI,OAAO,CAczC;AAMD,wBAAgB,gBAAgB,IAAI,aAAa,CAAC;AAClD,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,CAAC,EAAE,aAAa,KAAK,CAAC,GAAG,CAAC,CAAC;AAQ1E,wBAAgB,mBAAmB,IAAI,QAAQ,CAAC,aAAa,CAAC,CAI7D"}

package/dist/react/stores/store-context.js

@@ -0,0 +1,62 @@
+/**
+ * Store Context — React Context + hooks for Zustand vanilla stores.
+ *
+ * This is the SINGLE source for useAuthStore and useCurrencyStore hooks.
+ * Stores are created in StorefrontProvider (useRef) and provided via Context.
+ * This eliminates module-level singletons and Turbopack duplication bugs.
+ *
+ * useAuthHydrated() replaces the old isHydrated store field — tracks
+ * Zustand persist rehydration via React lifecycle (not module-level code).
+ */
+'use client';
+import { createContext, useContext, useState, useEffect } from 'react';
+import { useStore } from 'zustand';
+// ---------------------------------------------------------------------------
+// Contexts
+// ---------------------------------------------------------------------------
+export const AuthStoreContext = createContext(null);
+export const CurrencyStoreContext = createContext(null);
+export function useAuthStore(selector) {
+    const store = useContext(AuthStoreContext);
+    if (!store)
+        throw new Error('useAuthStore must be used within StorefrontProvider');
+    // eslint-disable-next-line react-hooks/rules-of-hooks
+    return selector ? useStore(store, selector) : useStore(store);
+}
+export function useAuthStoreApi() {
+    const store = useContext(AuthStoreContext);
+    if (!store)
+        throw new Error('useAuthStoreApi must be used within StorefrontProvider');
+    return store;
+}
+/**
+ * Tracks persist hydration state via React lifecycle (not module-level).
+ * Returns `true` once Zustand persist has finished rehydrating from localStorage.
+ */
+export function useAuthHydrated() {
+    const store = useAuthStoreApi();
+    const [hydrated, setHydrated] = useState(false);
+    useEffect(() => {
+        const persistApi = store.persist;
+        // Subscribe to future hydration completions
+        const unsubFinish = persistApi.onFinishHydration(() => setHydrated(true));
+        // Check if hydration already completed before effect ran
+        if (persistApi.hasHydrated())
+            setHydrated(true);
+        return unsubFinish;
+    }, [store]);
+    return hydrated;
+}
+export function useCurrencyStore(selector) {
+    const store = useContext(CurrencyStoreContext);
+    if (!store)
+        throw new Error('useCurrencyStore must be used within StorefrontProvider');
+    // eslint-disable-next-line react-hooks/rules-of-hooks
+    return selector ? useStore(store, selector) : useStore(store);
+}
+export function useCurrencyStoreApi() {
+    const store = useContext(CurrencyStoreContext);
+    if (!store)
+        throw new Error('useCurrencyStoreApi must be used within StorefrontProvider');
+    return store;
+}

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "@doswiftly/storefront-sdk",
+  "version": "4.0.0",
+  "description": "Storefront runtime SDK for DoSwiftly Commerce — layered transport, middleware pipeline, React providers, Zustand stores, cache strategies. 0 runtime dependencies in core.",
+  "type": "module",
+  "types": "dist/core/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/core/index.d.ts",
+      "default": "./dist/core/index.js"
+    },
+    "./react": {
+      "types": "./dist/react/index.d.ts",
+      "default": "./dist/react/index.js"
+    },
+    "./react/server": {
+      "types": "./dist/react/server/index.d.ts",
+      "default": "./dist/react/server/index.js"
+    },
+    "./cache": {
+      "types": "./dist/core/cache.d.ts",
+      "default": "./dist/core/cache.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "build:only": "tsc",
+    "dev": "tsc --watch",
+    "clean": "rm -rf dist",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:unit": "vitest run src/__tests__/unit/",
+    "test:contract": "vitest run src/__tests__/contract/"
+  },
+  "keywords": [
+    "sdk",
+    "typescript",
+    "storefront",
+    "ecommerce",
+    "graphql",
+    "react",
+    "zustand",
+    "middleware",
+    "hydrogen"
+  ],
+  "author": "DoSwiftly Team",
+  "license": "MIT",
+  "dependencies": {},
+  "devDependencies": {
+    "@types/node": "^22.10.2",
+    "@types/react": "^18.3.0 || ^19.0.0",
+    "fast-check": "^3.23.2",
+    "next": "^15.0.0",
+    "typescript": "^5.7.2",
+    "vitest": "^2.1.8",
+    "zustand": "^5.0.2",
+    "react": "^19.0.0"
+  },
+  "peerDependencies": {
+    "react": "^18.0.0 || ^19.0.0",
+    "zustand": "^5.0.0"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    },
+    "zustand": {
+      "optional": true
+    }
+  }
+}