storefront-layouts-staging 1.0.0-staging.0

package/dist/lib/api.js

@@ -0,0 +1,167 @@
+import axios from 'axios';
+// Customer storefront APIs (checkout, shipping, cart) live on the app backend (4002).
+// Merchant dashboard APIs use NEXT_PUBLIC_API_URL (admin backend, 4004).
+const API_URL = process.env.NEXT_PUBLIC_APP_BACKEND_URL ||
+    process.env.NEXT_PUBLIC_API_URL ||
+    'http://localhost:4002';
+// In-memory access token — storefront-app stores tokens here (not localStorage).
+// Legacy flows may still use localStorage 'token'.
+let _accessToken = null;
+export function setAccessToken(token) {
+    _accessToken = token;
+}
+export function getAccessToken() {
+    return _accessToken;
+}
+function resolveAuthToken() {
+    if (typeof window === 'undefined')
+        return _accessToken;
+    return _accessToken || localStorage.getItem('token');
+}
+export class ApiError extends Error {
+    constructor(message, status, data, code) {
+        super(message);
+        this.message = message;
+        this.status = status;
+        this.data = data;
+        this.name = 'ApiError';
+        this.code = code;
+    }
+}
+export const api = axios.create({
+    baseURL: `${API_URL}/api`,
+    headers: {
+        'Content-Type': 'application/json',
+        // Add test mode header if in test environment
+        ...(typeof window !== 'undefined' && window.__TEST_MODE__ ? { 'x-test-mode': 'true' } : {}),
+    },
+    timeout: 30000, // 30 seconds
+});
+// Request interceptor for auth token and session ID
+api.interceptors.request.use((config) => {
+    if (typeof window !== 'undefined') {
+        const token = resolveAuthToken();
+        if (token) {
+            config.headers.Authorization = `Bearer ${token}`;
+        }
+        // Guest cart only: pass session via `_sid` query param. Do NOT send a
+        // custom x-session-id header — custom headers force a CORS preflight that
+        // proxies in front of the backend (e.g. nginx with a hardcoded
+        // Access-Control-Allow-Headers list) reject, breaking checkout.
+        let sessionId = sessionStorage.getItem('sessionId');
+        if (!sessionId) {
+            sessionId = `session-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+            sessionStorage.setItem('sessionId', sessionId);
+        }
+        const urlPath = (config.url || '').split('?')[0];
+        const isCartApi = urlPath === '/cart' ||
+            urlPath.startsWith('/cart/') ||
+            urlPath === 'cart' ||
+            urlPath.startsWith('cart/');
+        if (isCartApi) {
+            config.params = { _sid: sessionId, ...config.params };
+        }
+        // Add test mode header if in test environment
+        if (window.__TEST_MODE__) {
+            config.headers['x-test-mode'] = 'true';
+        }
+        // For FormData requests, remove Content-Type header to let axios set it with boundary
+        if (config.data instanceof FormData) {
+            delete config.headers['Content-Type'];
+        }
+    }
+    return config;
+}, (error) => {
+    return Promise.reject(error);
+});
+// Response interceptor for error handling and token refresh
+api.interceptors.response.use((response) => {
+    return response;
+}, async (error) => {
+    const originalRequest = error.config;
+    // Handle 429 Too Many Requests - retry with exponential backoff
+    if (error.response?.status === 429 && originalRequest) {
+        const retryCount = originalRequest._retryCount || 0;
+        const maxRetries = 3;
+        const baseDelay = 1000; // 1 second
+        if (retryCount < maxRetries) {
+            originalRequest._retryCount = retryCount + 1;
+            originalRequest._retryDelay = baseDelay * Math.pow(2, retryCount); // Exponential backoff: 1s, 2s, 4s
+            // Wait before retrying
+            await new Promise(resolve => setTimeout(resolve, originalRequest._retryDelay));
+            console.log(`[API] Retrying request after rate limit (attempt ${retryCount + 1}/${maxRetries}, delay: ${originalRequest._retryDelay}ms)`);
+            return api(originalRequest);
+        }
+        else {
+            console.warn('[API] Max retries reached for rate-limited request');
+        }
+    }
+    // Handle 401 Unauthorized - try to refresh token
+    if (error.response?.status === 401 && !originalRequest._retry) {
+        // Check if we're in preview mode - skip ALL auth operations to prevent session invalidation
+        const isPreview = typeof window !== 'undefined' && window.__IS_PREVIEW__;
+        if (isPreview) {
+            // In preview mode, never attempt token refresh, clear tokens, or redirect
+            // This prevents interfering with the parent window's session (storefront-admin)
+            console.warn('[API] 401 Unauthorized in preview mode - skipping all auth operations (refresh, clear, redirect)');
+            return Promise.reject(error);
+        }
+        originalRequest._retry = true;
+        try {
+            let newToken = null;
+            // Prefer storefront-app BFF refresh (HttpOnly cookie) when no legacy refresh token.
+            const refreshToken = localStorage.getItem('refreshToken');
+            if (!refreshToken && typeof window !== 'undefined') {
+                const refreshRes = await fetch('/api/auth/refresh', {
+                    method: 'POST',
+                    credentials: 'same-origin',
+                });
+                if (refreshRes.ok) {
+                    const refreshData = await refreshRes.json();
+                    newToken = refreshData.data?.token ?? null;
+                }
+            }
+            else if (refreshToken) {
+                const response = await axios.post(`${API_URL}/api/auth/refresh`, { refreshToken });
+                if (response.data.status === 'success' && response.data.data) {
+                    newToken = response.data.data.token;
+                    const newRefreshToken = response.data.data.refreshToken;
+                    localStorage.setItem('token', newToken);
+                    if (newRefreshToken) {
+                        localStorage.setItem('refreshToken', newRefreshToken);
+                    }
+                }
+            }
+            if (newToken) {
+                setAccessToken(newToken);
+                localStorage.setItem('token', newToken);
+                if (originalRequest.headers) {
+                    originalRequest.headers.Authorization = `Bearer ${newToken}`;
+                }
+                return api(originalRequest);
+            }
+        }
+        catch (refreshError) {
+            // Refresh failed, clear tokens and redirect to login
+            // But only if NOT in preview mode (double check for safety)
+            const isPreviewCheck = typeof window !== 'undefined' && window.__IS_PREVIEW__;
+            if (!isPreviewCheck) {
+                setAccessToken(null);
+                localStorage.removeItem('token');
+                localStorage.removeItem('refreshToken');
+                localStorage.removeItem('storefront_user');
+                if (typeof window !== 'undefined') {
+                    window.location.href = '/auth/login';
+                }
+            }
+            return Promise.reject(refreshError);
+        }
+    }
+    // Handle other errors
+    const errorMessage = error.response?.data?.message ||
+        error.message ||
+        'An error occurred';
+    // Create custom ApiError with status and data
+    const apiError = new ApiError(errorMessage, error.response?.status, error.response?.data?.data || error.response?.data, error.code);
+    return Promise.reject(apiError);
+});

package/dist/lib/auth-context.d.ts

@@ -0,0 +1,49 @@
+import React from 'react';
+export interface User {
+    id: string;
+    firstName: string;
+    lastName: string;
+    email: string;
+    phone?: string;
+    address?: string;
+    city?: string;
+    state?: string;
+    zipCode?: string;
+    country?: string;
+    avatar?: string;
+    createdAt?: string | Date;
+}
+export interface OpenLoginOptions {
+    callbackUrl?: string;
+    onSuccess?: () => void;
+}
+interface AuthContextType {
+    user: User | null;
+    isAuthenticated: boolean;
+    isLoading: boolean;
+    /**
+     * Indicates that there was a recent connectivity issue while trying to
+     * talk to the auth API. This allows UIs to show a non-fatal banner
+     * without treating the user as logged out.
+     */
+    hasConnectionIssue?: boolean;
+    isLoginOpen: boolean;
+    loginCallbackUrl: string;
+    /** Invokes the optional success handler passed to openLogin */
+    loginOnSuccess?: () => void;
+    openLogin: (options?: OpenLoginOptions) => void;
+    closeLogin: () => void;
+    login: (email: string, password?: string) => Promise<void>;
+    logout: (redirectUrl?: string) => void;
+    updateProfile: (data: Partial<User>) => Promise<void>;
+    updateUserState: (user: User) => void;
+    /** Optional: storefront-app provides post-verification token login */
+    loginWithToken?: (token: string, refreshToken: string, user: User) => Promise<void>;
+}
+export declare const AuthContext: React.Context<AuthContextType>;
+export declare function AuthProvider({ children }: {
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare const useAuth: () => AuthContextType;
+export {};
+//# sourceMappingURL=auth-context.d.ts.map

package/dist/lib/auth-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth-context.d.ts","sourceRoot":"","sources":["../../src/lib/auth-context.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAuF,MAAM,OAAO,CAAC;AAK5G,MAAM,WAAW,IAAI;IACnB,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3B;AAED,MAAM,WAAW,gBAAgB;IAC/B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,IAAI,CAAC;CACxB;AAED,UAAU,eAAe;IACvB,IAAI,EAAE,IAAI,GAAG,IAAI,CAAC;IAClB,eAAe,EAAE,OAAO,CAAC;IACzB,SAAS,EAAE,OAAO,CAAC;IACnB;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,WAAW,EAAE,OAAO,CAAC;IACrB,gBAAgB,EAAE,MAAM,CAAC;IACzB,+DAA+D;IAC/D,cAAc,CAAC,EAAE,MAAM,IAAI,CAAC;IAC5B,SAAS,EAAE,CAAC,OAAO,CAAC,EAAE,gBAAgB,KAAK,IAAI,CAAC;IAChD,UAAU,EAAE,MAAM,IAAI,CAAC;IACvB,KAAK,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3D,MAAM,EAAE,CAAC,WAAW,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IACvC,aAAa,EAAE,CAAC,IAAI,EAAE,OAAO,CAAC,IAAI,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACtD,eAAe,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,IAAI,CAAC;IACtC,sEAAsE;IACtE,cAAc,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACrF;AAED,eAAO,MAAM,WAAW,gCActB,CAAC;AAGH,wBAAgB,YAAY,CAAC,EAAE,QAAQ,EAAE,EAAE;IAAE,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAA;CAAE,2CA4SvE;AAED,eAAO,MAAM,OAAO,uBAAgC,CAAC"}

package/dist/lib/auth-context.js

@@ -0,0 +1,296 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useState, useEffect, useCallback, useMemo, useRef } from 'react';
+import { useRouter } from 'next/navigation';
+import { authService } from './services/auth.service.js';
+import { customerService } from './services/customer.service.js';
+export const AuthContext = createContext({
+    user: null,
+    isAuthenticated: false,
+    isLoading: true,
+    hasConnectionIssue: false,
+    isLoginOpen: false,
+    loginCallbackUrl: '/',
+    loginOnSuccess: undefined,
+    openLogin: () => { },
+    closeLogin: () => { },
+    login: async () => { },
+    logout: () => { },
+    updateProfile: async () => { },
+    updateUserState: () => { },
+});
+export function AuthProvider({ children }) {
+    const [user, setUser] = useState(null);
+    const [isLoading, setIsLoading] = useState(true);
+    const [hasConnectionIssue, setHasConnectionIssue] = useState(false);
+    const [isLoginOpen, setIsLoginOpen] = useState(false);
+    const [loginCallbackUrl, setLoginCallbackUrl] = useState('/');
+    const loginOnSuccessRef = useRef(undefined);
+    const router = useRouter();
+    const openLogin = useCallback((options) => {
+        const isPreview = typeof window !== 'undefined' && window.__IS_PREVIEW__;
+        if (isPreview) {
+            return;
+        }
+        const fallback = typeof window !== 'undefined'
+            ? window.location.pathname + window.location.search
+            : '/';
+        setLoginCallbackUrl(options?.callbackUrl ?? fallback);
+        loginOnSuccessRef.current = options?.onSuccess;
+        setIsLoginOpen(true);
+    }, []);
+    const closeLogin = useCallback(() => {
+        setIsLoginOpen(false);
+        loginOnSuccessRef.current = undefined;
+    }, []);
+    const loginOnSuccess = useCallback(() => {
+        loginOnSuccessRef.current?.();
+    }, []);
+    useEffect(() => {
+        const loadUser = async () => {
+            try {
+                setIsLoading(true);
+                // Check if we're in preview mode - skip all API calls to prevent session invalidation
+                const isPreview = typeof window !== 'undefined' && window.__IS_PREVIEW__;
+                if (isPreview) {
+                    // In preview mode, don't make any API calls or clear tokens
+                    // Just return empty auth state to prevent interfering with parent window session
+                    console.log('[AuthProvider] Preview mode detected - skipping auth API calls');
+                    setUser(null);
+                    setIsLoading(false);
+                    return;
+                }
+                const token = localStorage.getItem('token');
+                if (token) {
+                    // Try to get current user from API
+                    try {
+                        const response = await authService.getCurrentUser();
+                        // Backend returns user object directly from auth service
+                        // Parse address if it exists (address may not be in API response)
+                        const addressData = response.address || {};
+                        const addressObj = typeof addressData === 'string' ? (addressData ? JSON.parse(addressData) : {}) : addressData;
+                        const user = {
+                            id: response.id,
+                            firstName: response.firstName,
+                            lastName: response.lastName,
+                            email: response.email,
+                            phone: response.phone,
+                            avatar: response.avatar,
+                            address: addressObj.address1 || addressObj.address || addressObj.street || '',
+                            city: addressObj.city || '',
+                            state: addressObj.state || '',
+                            zipCode: addressObj.zipCode || '',
+                            country: addressObj.country || '',
+                            createdAt: response.createdAt,
+                        };
+                        setUser(user);
+                        localStorage.setItem('storefront_user', JSON.stringify(user));
+                        setHasConnectionIssue(false);
+                    }
+                    catch (error) {
+                        console.error('Failed to load user from API:', error);
+                        // Do not eagerly clear tokens on connectivity/server issues here.
+                        // Auth token lifecycle is centrally handled in the shared API client.
+                        const status = error?.status;
+                        const message = (typeof error?.message === 'string' ? error.message : '').toLowerCase();
+                        const isNetworkOrConnectivityError = !status &&
+                            (message.includes('unable to connect to the server') ||
+                                message.includes('network error') ||
+                                message.includes('timeout'));
+                        if (status === 401 || status === 403) {
+                            // True auth/session failure; central API client will handle token clearing.
+                            setUser(null);
+                            setHasConnectionIssue(false);
+                        }
+                        else if (isNetworkOrConnectivityError || (status && status >= 500)) {
+                            // Transient connectivity or server issues – keep tokens and cached user if present.
+                            setHasConnectionIssue(true);
+                            if (!user) {
+                                try {
+                                    const cachedUser = localStorage.getItem('storefront_user');
+                                    if (cachedUser) {
+                                        const parsedUser = JSON.parse(cachedUser);
+                                        setUser(parsedUser);
+                                    }
+                                }
+                                catch (storageError) {
+                                    console.error('[AuthProvider] Failed to restore cached user after network error:', storageError);
+                                }
+                            }
+                        }
+                        else {
+                            // Unexpected error shape – reset in-memory user but do not manipulate tokens.
+                            setUser(null);
+                            setHasConnectionIssue(false);
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                console.error('Failed to load user:', error);
+                setUser(null);
+            }
+            finally {
+                setIsLoading(false);
+            }
+        };
+        loadUser();
+    }, []);
+    const login = useCallback(async (email, password) => {
+        setIsLoading(true);
+        try {
+            // Password is required for real API login
+            if (!password) {
+                throw new Error('Password is required');
+            }
+            // Real API login
+            const response = await authService.login(email, password);
+            // Parse address if it exists (address may not be in API response)
+            const addressData = response.user.address || {};
+            const addressObj = typeof addressData === 'string' ? (addressData ? JSON.parse(addressData) : {}) : addressData;
+            const user = {
+                id: response.user.id,
+                firstName: response.user.firstName,
+                lastName: response.user.lastName,
+                email: response.user.email,
+                phone: response.user.phone,
+                avatar: response.user.avatar,
+                address: addressObj.address1 || addressObj.address || addressObj.street || '',
+                city: addressObj.city || '',
+                state: addressObj.state || '',
+                zipCode: addressObj.zipCode || '',
+                country: addressObj.country || '',
+                createdAt: response.user.createdAt,
+            };
+            // Store tokens
+            localStorage.setItem('token', response.token);
+            if (response.refreshToken) {
+                localStorage.setItem('refreshToken', response.refreshToken);
+            }
+            localStorage.setItem('storefront_user', JSON.stringify(user));
+            // Clear guest user info since user is now authenticated
+            if (typeof window !== 'undefined') {
+                try {
+                    const { clearGuestUserInfo } = await import('./guest-user');
+                    clearGuestUserInfo();
+                }
+                catch (error) {
+                    console.error('Failed to clear guest user info:', error);
+                }
+            }
+            setUser(user);
+            // Trigger cart refresh after login - the backend will automatically merge session cart with user cart
+            // when the next cart operation happens, but we can trigger a refresh here to ensure cart is loaded
+            if (typeof window !== 'undefined') {
+                // Dispatch a custom event that store context can listen to for cart refresh
+                window.dispatchEvent(new CustomEvent('userLoggedIn'));
+            }
+        }
+        catch (error) {
+            console.error('Login failed:', error);
+            throw error;
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, []);
+    const logout = useCallback((redirectUrl) => {
+        setUser(null);
+        localStorage.removeItem('storefront_user');
+        localStorage.removeItem('token');
+        localStorage.removeItem('refreshToken');
+        router.push(redirectUrl ?? '/');
+    }, [router]);
+    const updateProfile = useCallback(async (data) => {
+        setIsLoading(true);
+        try {
+            const token = localStorage.getItem('token');
+            if (!token) {
+                throw new Error('You must be logged in to update your profile');
+            }
+            // Use customer service API for profile updates
+            const updatedUser = await customerService.updateProfile(data);
+            // Parse address if it exists
+            const addressData = updatedUser.address || {};
+            const addressObj = typeof addressData === 'string' ? (addressData ? JSON.parse(addressData) : {}) : addressData;
+            const user = {
+                id: updatedUser.id,
+                firstName: updatedUser.firstName,
+                lastName: updatedUser.lastName,
+                email: updatedUser.email,
+                phone: updatedUser.phone,
+                avatar: updatedUser.avatar,
+                address: addressObj.address1 || addressObj.address || addressObj.street || '',
+                city: addressObj.city || '',
+                state: addressObj.state || '',
+                zipCode: addressObj.zipCode || '',
+                country: addressObj.country || '',
+            };
+            setUser(user);
+            localStorage.setItem('storefront_user', JSON.stringify(user));
+        }
+        catch (error) {
+            console.error('Failed to update profile:', error);
+            throw error;
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, []);
+    /**
+     * Update user state without triggering isLoading
+     * This is used for updating user state after profile save without showing full-page loading
+     */
+    const updateUserState = useCallback((user) => {
+        try {
+            // Validate required fields before updating
+            if (!user || !user.id || !user.firstName || !user.lastName || !user.email) {
+                console.error('Invalid user data provided to updateUserState:', user);
+                throw new Error('Invalid user data: missing required fields');
+            }
+            setUser(user);
+            // Safely update localStorage
+            try {
+                localStorage.setItem('storefront_user', JSON.stringify(user));
+            }
+            catch (storageError) {
+                console.error('Error updating localStorage:', storageError);
+                // Continue even if localStorage update fails
+            }
+        }
+        catch (error) {
+            console.error('Error in updateUserState:', error);
+            throw error;
+        }
+    }, []);
+    const value = useMemo(() => ({
+        user,
+        isAuthenticated: !!user,
+        isLoading,
+        hasConnectionIssue,
+        isLoginOpen,
+        loginCallbackUrl,
+        loginOnSuccess,
+        openLogin,
+        closeLogin,
+        login,
+        logout,
+        updateProfile,
+        updateUserState
+    }), [
+        user,
+        isLoading,
+        hasConnectionIssue,
+        isLoginOpen,
+        loginCallbackUrl,
+        loginOnSuccess,
+        openLogin,
+        closeLogin,
+        login,
+        logout,
+        updateProfile,
+        updateUserState,
+    ]);
+    return (_jsx(AuthContext.Provider, { value: value, children: children }));
+}
+export const useAuth = () => useContext(AuthContext);

package/dist/lib/checkout-availability.d.ts

@@ -0,0 +1,10 @@
+export declare const CHECKOUT_UNAVAILABLE_MESSAGE = "Checkout is currently unavailable on this store. Please check back later.";
+export declare function isCheckoutDisabled(storeConfig: {
+    checkoutEnabled?: boolean;
+}): boolean;
+/** Store API responses always include checkoutEnabled; legacy payloads without it stay open. */
+export declare function resolveCheckoutEnabledFromApi(value: boolean | undefined | null): boolean;
+export declare function guardCheckoutAvailable(storeConfig: {
+    checkoutEnabled?: boolean;
+}, notify: (message: string, type: 'error') => void): boolean;
+//# sourceMappingURL=checkout-availability.d.ts.map

package/dist/lib/checkout-availability.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkout-availability.d.ts","sourceRoot":"","sources":["../../src/lib/checkout-availability.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,4BAA4B,8EACoC,CAAC;AAE9E,wBAAgB,kBAAkB,CAAC,WAAW,EAAE;IAAE,eAAe,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,OAAO,CAEtF;AAED,gGAAgG;AAChG,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,OAAO,GAAG,SAAS,GAAG,IAAI,GAAG,OAAO,CAGxF;AAED,wBAAgB,sBAAsB,CACpC,WAAW,EAAE;IAAE,eAAe,CAAC,EAAE,OAAO,CAAA;CAAE,EAC1C,MAAM,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,KAAK,IAAI,GAC/C,OAAO,CAIT"}

package/dist/lib/checkout-availability.js

@@ -0,0 +1,16 @@
+export const CHECKOUT_UNAVAILABLE_MESSAGE = 'Checkout is currently unavailable on this store. Please check back later.';
+export function isCheckoutDisabled(storeConfig) {
+    return storeConfig.checkoutEnabled === false;
+}
+/** Store API responses always include checkoutEnabled; legacy payloads without it stay open. */
+export function resolveCheckoutEnabledFromApi(value) {
+    if (typeof value === 'boolean')
+        return value;
+    return true;
+}
+export function guardCheckoutAvailable(storeConfig, notify) {
+    if (!isCheckoutDisabled(storeConfig))
+        return true;
+    notify(CHECKOUT_UNAVAILABLE_MESSAGE, 'error');
+    return false;
+}

package/dist/lib/compact-array-items.d.ts

@@ -0,0 +1,7 @@
+/** Drop null/undefined holes from editor-managed arrays before render. */
+export declare function compactArrayItems<T>(items: ReadonlyArray<T | null | undefined> | null | undefined): T[];
+/** Lucide icon id from a layout item; editor stores icon as a string. */
+export declare function readItemIconName(item: {
+    icon?: unknown;
+} | null | undefined, fallback?: string): string;
+//# sourceMappingURL=compact-array-items.d.ts.map

package/dist/lib/compact-array-items.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compact-array-items.d.ts","sourceRoot":"","sources":["../../src/lib/compact-array-items.ts"],"names":[],"mappings":"AAAA,0EAA0E;AAC1E,wBAAgB,iBAAiB,CAAC,CAAC,EACjC,KAAK,EAAE,aAAa,CAAC,CAAC,GAAG,IAAI,GAAG,SAAS,CAAC,GAAG,IAAI,GAAG,SAAS,GAC5D,CAAC,EAAE,CAGL;AAED,yEAAyE;AACzE,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE;IAAE,IAAI,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,IAAI,GAAG,SAAS,EAC3C,QAAQ,SAAS,GAChB,MAAM,CAIR"}

package/dist/lib/compact-array-items.js

@@ -0,0 +1,13 @@
+/** Drop null/undefined holes from editor-managed arrays before render. */
+export function compactArrayItems(items) {
+    if (!Array.isArray(items) || items.length === 0)
+        return [];
+    return items.filter((item) => item != null && typeof item === 'object');
+}
+/** Lucide icon id from a layout item; editor stores icon as a string. */
+export function readItemIconName(item, fallback = 'Star') {
+    const raw = item?.icon;
+    if (typeof raw === 'string' && raw.trim())
+        return raw.trim();
+    return fallback;
+}

package/dist/lib/content-selectors.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Content selectors for different route types
+ * Used to detect when page content is ready for display
+ */
+export type RouteType = 'product-detail' | 'products' | 'categories' | 'category-detail' | 'generic';
+export interface ContentSelectorConfig {
+    selectors: string[];
+    minElements?: number;
+    minPercentage?: number;
+    requiredSelectors?: string[];
+}
+export declare const CONTENT_SELECTORS: Record<RouteType, ContentSelectorConfig>;
+/**
+ * Get content selectors for a given route type
+ */
+export declare function getContentSelectors(routeType: RouteType): ContentSelectorConfig;
+/**
+ * Detect route type from pathname
+ */
+export declare function detectRouteType(pathname: string): RouteType;
+//# sourceMappingURL=content-selectors.d.ts.map

package/dist/lib/content-selectors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"content-selectors.d.ts","sourceRoot":"","sources":["../../src/lib/content-selectors.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,MAAM,SAAS,GAAG,gBAAgB,GAAG,UAAU,GAAG,YAAY,GAAG,iBAAiB,GAAG,SAAS,CAAC;AAErG,MAAM,WAAW,qBAAqB;IACpC,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAC;CAC9B;AAED,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,SAAS,EAAE,qBAAqB,CAyCtE,CAAC;AAEF;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,SAAS,GAAG,qBAAqB,CAE/E;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,CAyB3D"}