@doswiftly/storefront-sdk 4.4.0 → 4.5.0

package/src/react/stores/currency.store.ts

@@ -1,93 +0,0 @@
-/**
- * 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';
-import type { ShopConfig } from '../types/shop-config';
-import { CURRENCY_COOKIE_NAME, CURRENCY_COOKIE_MAX_AGE } from '../../core/currency/cookie-config';
-import { getCookie, setCookie } from '../cookies';
-
-/**
- * @deprecated Use ShopConfig instead. Kept for backward compatibility of type exports.
- */
-export type ShopCurrencyData = ShopConfig;
-
-export interface CurrencyStore {
-  // State
-  baseCurrency: string | null;
-  supportedCurrencies: string[];
-  currency: string | null;
-  isLoaded: boolean;
-
-  // Actions
-  initialize: (shopData: ShopConfig) => void;
-  setCurrency: (currency: string) => void;
-}
-
-export const createCurrencyStore = () =>
-  createStore<CurrencyStore>()((set, get) => ({
-    baseCurrency: null,
-    supportedCurrencies: [],
-    currency: null,
-    isLoaded: false,
-
-    initialize: (shopData: ShopConfig) => {
-      // 1. Try saved currency from cookie (SSR-safe)
-      const saved = getCookie(CURRENCY_COOKIE_NAME);
-
-      // 2. Try to detect from browser locale
-      let detected: string | undefined;
-      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) {
-        setCookie(CURRENCY_COOKIE_NAME, finalCurrency, { maxAge: CURRENCY_COOKIE_MAX_AGE });
-      }
-    },
-
-    setCurrency: (currency: string) => {
-      const { supportedCurrencies } = get();
-
-      if (!supportedCurrencies.includes(currency)) {
-        console.warn(`[CurrencyStore] Currency ${currency} not supported`);
-        return;
-      }
-
-      set({ currency });
-      setCookie(CURRENCY_COOKIE_NAME, currency, { maxAge: CURRENCY_COOKIE_MAX_AGE });
-    },
-  }));
-
-// ---------------------------------------------------------------------------
-// Selectors (for use with useCurrencyStore(selector))
-// ---------------------------------------------------------------------------
-
-export const selectCurrency = (state: CurrencyStore) => state.currency;
-export const selectBaseCurrency = (state: CurrencyStore) => state.baseCurrency;
-export const selectSupportedCurrencies = (state: CurrencyStore) => state.supportedCurrencies;
-export const selectIsLoaded = (state: CurrencyStore) => state.isLoaded;

package/src/react/stores/index.ts

@@ -1,17 +0,0 @@
-/**
- * Zustand stores — factory functions + context hooks.
- */
-
-// Factory functions
-export { createAuthStore, type AuthStore, type CustomerInfo } from './auth.store';
-export { createCurrencyStore, type CurrencyStore, type ShopCurrencyData } 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/src/react/stores/language.store.ts

@@ -1,90 +0,0 @@
-/**
- * Language store factory — tracks active language for SDK middleware.
- *
- * 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.
- *
- * KEY PRINCIPLE: URL is the single source of truth for language.
- * - next-intl middleware uses `preferred-language` cookie (custom name via localeCookie.name)
- * - This store tracks the active language for SDK X-Lang header
- * - setLanguage() persists to `preferred-language` cookie
- * - initialize() sets defaultLanguage and supportedLanguages from Shop query
- * - setLanguage() is called by LanguageSyncProvider when URL locale changes
- *
- * Single `preferred-language` cookie serves both:
- * - next-intl middleware (locale detection/routing, via localeCookie.name override)
- * - SDK language store (X-Lang header, framework-agnostic)
- */
-
-import { createStore } from 'zustand/vanilla';
-import type { ShopConfig } from '../types/shop-config';
-import { LANGUAGE_COOKIE_NAME, LANGUAGE_COOKIE_MAX_AGE } from '../../core/language/cookie-config';
-import { getCookie, setCookie } from '../cookies';
-
-export interface LanguageStore {
-  // State
-  defaultLanguage: string | null;
-  supportedLanguages: string[];
-  language: string | null;
-  isLoaded: boolean;
-
-  // Actions
-  initialize: (shopData: ShopConfig) => void;
-  setLanguage: (language: string) => void;
-}
-
-export const createLanguageStore = (initialLanguage?: string | null) =>
-  createStore<LanguageStore>()((set, get) => ({
-    defaultLanguage: null,
-    supportedLanguages: [],
-    language: initialLanguage ?? null,
-    isLoaded: false,
-
-    initialize: (shopData: ShopConfig) => {
-      const supported = shopData.supportedLanguages ?? [];
-      const current = get().language;
-      const saved = getCookie(LANGUAGE_COOKIE_NAME);
-
-      // Priority: current (from initialLanguage/URL) > cookie (validated) > default
-      const finalLanguage =
-        current && (supported.length === 0 || supported.includes(current))
-          ? current
-          : saved && (supported.length === 0 || supported.includes(saved))
-            ? saved
-            : shopData.defaultLanguage ?? null;
-
-      set({
-        defaultLanguage: shopData.defaultLanguage ?? null,
-        supportedLanguages: supported,
-        language: finalLanguage,
-        isLoaded: true,
-      });
-
-      // Persist cookie if determined from fallback (not already saved)
-      if (finalLanguage && finalLanguage !== saved) {
-        setCookie(LANGUAGE_COOKIE_NAME, finalLanguage, { maxAge: LANGUAGE_COOKIE_MAX_AGE });
-      }
-    },
-
-    setLanguage: (language: string) => {
-      const { supportedLanguages } = get();
-      // Validate vs supported (bypass if empty — LanguageSyncProvider may call before initialize)
-      if (supportedLanguages.length > 0 && !supportedLanguages.includes(language)) {
-        console.warn(`[LanguageStore] Language ${language} not supported`);
-        return;
-      }
-      if (get().language === language) return;
-      setCookie(LANGUAGE_COOKIE_NAME, language, { maxAge: LANGUAGE_COOKIE_MAX_AGE });
-      set({ language });
-    },
-  }));
-
-// ---------------------------------------------------------------------------
-// Selectors (for use with useLanguageStore(selector))
-// ---------------------------------------------------------------------------
-
-export const selectLanguage = (state: LanguageStore) => state.language;
-export const selectDefaultLanguage = (state: LanguageStore) => state.defaultLanguage;
-export const selectSupportedLanguages = (state: LanguageStore) => state.supportedLanguages;
-export const selectLanguageIsLoaded = (state: LanguageStore) => state.isLoaded;

package/src/react/stores/store-context.tsx

@@ -1,103 +0,0 @@
-/**
- * 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, type StoreApi } from 'zustand';
-import type { AuthStore } from './auth.store';
-import type { CurrencyStore } from './currency.store';
-import type { LanguageStore } from './language.store';
-
-// ---------------------------------------------------------------------------
-// Contexts
-// ---------------------------------------------------------------------------
-
-export const AuthStoreContext = createContext<StoreApi<AuthStore> | null>(null);
-export const CurrencyStoreContext = createContext<StoreApi<CurrencyStore> | null>(null);
-export const LanguageStoreContext = createContext<StoreApi<LanguageStore> | null>(null);
-
-// ---------------------------------------------------------------------------
-// Auth hooks
-// ---------------------------------------------------------------------------
-
-export function useAuthStore(): AuthStore;
-export function useAuthStore<T>(selector: (s: AuthStore) => T): T;
-export function useAuthStore<T>(selector?: (s: AuthStore) => T) {
-  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(): StoreApi<AuthStore> {
-  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(): boolean {
-  const store = useAuthStoreApi();
-  const [hydrated, setHydrated] = useState(false);
-
-  useEffect(() => {
-    const persistApi = (store as any).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;
-}
-
-// ---------------------------------------------------------------------------
-// Currency hooks
-// ---------------------------------------------------------------------------
-
-export function useCurrencyStore(): CurrencyStore;
-export function useCurrencyStore<T>(selector: (s: CurrencyStore) => T): T;
-export function useCurrencyStore<T>(selector?: (s: CurrencyStore) => T) {
-  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(): StoreApi<CurrencyStore> {
-  const store = useContext(CurrencyStoreContext);
-  if (!store) throw new Error('useCurrencyStoreApi must be used within StorefrontProvider');
-  return store;
-}
-
-// ---------------------------------------------------------------------------
-// Language hooks
-// ---------------------------------------------------------------------------
-
-export function useLanguageStore(): LanguageStore;
-export function useLanguageStore<T>(selector: (s: LanguageStore) => T): T;
-export function useLanguageStore<T>(selector?: (s: LanguageStore) => T) {
-  const store = useContext(LanguageStoreContext);
-  if (!store) throw new Error('useLanguageStore must be used within StorefrontProvider');
-  // eslint-disable-next-line react-hooks/rules-of-hooks
-  return selector ? useStore(store, selector) : useStore(store);
-}
-
-export function useLanguageStoreApi(): StoreApi<LanguageStore> {
-  const store = useContext(LanguageStoreContext);
-  if (!store) throw new Error('useLanguageStoreApi must be used within StorefrontProvider');
-  return store;
-}

package/src/react/types/shop-config.ts

@@ -1,22 +0,0 @@
-/**
- * ShopConfig — full shop configuration from backend shop query.
- *
- * Flat interface — new features added here directly.
- * Each concern is consumed by its own provider internally.
- */
-
-import type { BotProtectionConfig } from '../../core/middleware/bot-protection';
-
-export interface ShopConfig {
-  // Currency
-  currencyCode: string;
-  supportedCurrencies: string[];
-  localeToCurrencyMap?: Array<{ locale: string; currency: string }>;
-
-  // Language
-  defaultLanguage?: string | null;
-  supportedLanguages?: string[] | null;
-
-  // Bot protection (platform-level, optional)
-  botProtection?: BotProtectionConfig | null;
-}

package/tsconfig.json

@@ -1,20 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "ESNext",
-    "lib": ["ES2022", "DOM"],
-    "declaration": true,
-    "declarationMap": true,
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "moduleResolution": "bundler",
-    "resolveJsonModule": true,
-    "jsx": "react-jsx"
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist", "**/*.spec.ts", "**/*.test.ts"]
-}

package/vitest.config.ts

@@ -1,14 +0,0 @@
-import { defineConfig } from "vitest/config";
-
-export default defineConfig({
-  // Suppress CJS deprecation warning
-  define: {
-    "import.meta.vitest": "undefined",
-  },
-  test: {
-    environment: "node",
-    globals: true, // Enable global test functions like describe, it, expect
-    // Use pool threads for better compatibility
-    pool: "threads",
-  },
-});