storefront-layouts-staging 1.0.0-staging.0

package/dist/lib/store-config.d.ts

@@ -0,0 +1,4 @@
+import { getStoreConfig, getAllStores, isValidStoreSlug, getTemplateLayoutConfigForLayoutType } from './mock-stores';
+export { getStoreConfig, getAllStores, isValidStoreSlug, getTemplateLayoutConfigForLayoutType };
+export type { StoreConfig } from './store-types';
+//# sourceMappingURL=store-config.d.ts.map

package/dist/lib/store-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store-config.d.ts","sourceRoot":"","sources":["../../src/lib/store-config.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,gBAAgB,EAAE,oCAAoC,EAAE,MAAM,eAAe,CAAC;AACrH,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,gBAAgB,EAAE,oCAAoC,EAAE,CAAC;AAChG,YAAY,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC"}

package/dist/lib/store-config.js

@@ -0,0 +1,4 @@
+// Re-export functions from mock-stores for convenience
+// Import first, then export to ensure webpack can resolve properly
+import { getStoreConfig, getAllStores, isValidStoreSlug, getTemplateLayoutConfigForLayoutType } from './mock-stores.js';
+export { getStoreConfig, getAllStores, isValidStoreSlug, getTemplateLayoutConfigForLayoutType };

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

@@ -0,0 +1,69 @@
+import type { StoreConfig, StoreProduct } from './store-types';
+export interface CartItem {
+    id: string;
+    productId: string;
+    quantity: number;
+    variantId?: string;
+    variantName?: string;
+    price: number;
+    product: StoreProduct;
+    /** Currency for this line item (multi-currency grouping). */
+    currency?: string;
+}
+/**
+ * Options for addToCart beyond a plain variant id — consuming apps (e.g. for
+ * variant-specific pricing display) may pass this instead of a bare variantId.
+ */
+export type AddToCartOptions = {
+    variantId?: string;
+    variantName?: string;
+    unitPrice?: number;
+};
+interface StoreContextType {
+    store: StoreConfig | null;
+    isLoading: boolean;
+    error: string | null;
+    cart: CartItem[];
+    addToCart: (product: StoreProduct, quantity?: number, variantIdOrOptions?: string | AddToCartOptions) => Promise<void>;
+    removeFromCart: (cartItemId: string) => Promise<void>;
+    updateCartQuantity: (cartItemId: string, quantity: number) => Promise<void>;
+    removeOrderItemsFromCart?: (orderItems: {
+        productId: string;
+        variantId?: string;
+        quantity: number;
+    }[]) => Promise<void>;
+    finalizeCartAfterOrder?: (orderItems: {
+        productId: string;
+        variantId?: string;
+        quantity: number;
+    }[], options?: {
+        checkoutEntireCart?: boolean;
+    }) => Promise<void>;
+    cartTotal: number;
+    cartCount: number;
+    isCartOpen: boolean;
+    setIsCartOpen: (open: boolean) => void;
+    isCartLoading: boolean;
+    isCartHydrated: boolean;
+    isCartRefreshing?: boolean;
+    refreshCart: () => Promise<void>;
+    inventoryHoldUntil?: string | null;
+    setInventoryHoldUntil?: (value: string | null) => void;
+    handleInventoryHoldExpired?: () => void;
+    buyNowItem: CartItem | null;
+    setBuyNowItem: (item: CartItem | null) => void;
+    clearBuyNowItem: () => void;
+    wishlist: string[];
+    toggleWishlist: (productId: string) => Promise<void>;
+    isInWishlist: (productId: string) => boolean;
+    isWishlistLoading: boolean;
+}
+export declare const StoreContext: import("react").Context<StoreContextType>;
+export declare function StoreProvider({ children, storeSlug, initialConfig }: {
+    children: React.ReactNode;
+    storeSlug?: string;
+    initialConfig?: StoreConfig | null;
+}): import("react/jsx-runtime").JSX.Element;
+export declare const useStore: () => StoreContextType;
+export {};
+//# sourceMappingURL=store-context.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"store-context.d.ts","sourceRoot":"","sources":["../../src/lib/store-context.tsx"],"names":[],"mappings":"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"}

package/dist/lib/store-context.js

@@ -0,0 +1,456 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useEffect, useState, useMemo, useCallback, useRef } from 'react';
+import { getStoreConfig } from './store-config.js';
+import { shouldUseAPI, getBaseStoreSlug } from './utils/demo-detection.js';
+import { storeService } from './services/store.service.js';
+// Note: cartService and wishlistService removed - using localStorage only for cart/wishlist
+// These services are only needed for shared pages (cart, wishlist, account) which aren't editable in the editor
+import { categoryService } from './services/category.service.js';
+import { productService } from './services/product.service.js';
+import { serviceService } from './services/service.service.js';
+import { transformCategoryToStoreCategory, transformProductToStoreProduct, transformServiceToStoreService, transformStoreResponseToConfig } from './store-config-utils.js';
+import { useLoading } from './loading-context.js';
+import { normalizePrice, isDeepEqual } from './utils/index.js';
+import { richFieldPlainTextForDisplay } from './rich-html.js';
+import { useAuth } from './auth-context.js';
+import { analyticsService } from './services/analytics.service.js';
+import { getProductStockInfo, formatStockLimitMessage } from './inventory-utils.js';
+function normalizeAddToCartOptions(variantIdOrOptions) {
+    if (typeof variantIdOrOptions === 'string') {
+        return { variantId: variantIdOrOptions };
+    }
+    return variantIdOrOptions ?? {};
+}
+export const StoreContext = createContext({
+    store: null,
+    isLoading: true,
+    error: null,
+    cart: [],
+    addToCart: async () => { },
+    removeFromCart: async () => { },
+    updateCartQuantity: async () => { },
+    removeOrderItemsFromCart: async () => { },
+    finalizeCartAfterOrder: async () => { },
+    cartTotal: 0,
+    cartCount: 0,
+    isCartOpen: false,
+    setIsCartOpen: () => { },
+    isCartLoading: false,
+    isCartHydrated: true,
+    isCartRefreshing: false,
+    refreshCart: async () => { },
+    handleInventoryHoldExpired: () => { },
+    buyNowItem: null,
+    setBuyNowItem: () => { },
+    clearBuyNowItem: () => { },
+    wishlist: [],
+    toggleWishlist: async () => { },
+    isInWishlist: () => false,
+    isWishlistLoading: false,
+});
+export function StoreProvider({ children, storeSlug, initialConfig }) {
+    const [store, setStore] = useState(initialConfig || null);
+    const [isLoading, setIsLoading] = useState(!initialConfig);
+    const [error, setError] = useState(null);
+    // Get auth context for analytics
+    let authContext = null;
+    try {
+        authContext = useAuth();
+    }
+    catch {
+        // AuthProvider not available, continue without it
+    }
+    const isAuthenticated = authContext?.isAuthenticated || false;
+    const user = authContext?.user || null;
+    // Use loading context - it should be available since LoadingProvider wraps the app
+    // If not available, the hook will throw and we'll handle it gracefully
+    let loadingContext = null;
+    try {
+        loadingContext = useLoading();
+    }
+    catch {
+        // LoadingProvider not available in this context, continue without it
+    }
+    const setLoading = loadingContext?.setLoading;
+    const stopPageLoading = loadingContext?.stopPageLoading;
+    const startBackendLoading = loadingContext?.startBackendLoading;
+    const stopBackendLoading = loadingContext?.stopBackendLoading;
+    // Cart State
+    const [cart, setCart] = useState([]);
+    const [isCartOpen, setIsCartOpen] = useState(false);
+    const [isCartLoading, setIsCartLoading] = useState(false);
+    // Buy Now State (temporary single-item for direct checkout)
+    // Initialize from sessionStorage to persist across navigation
+    const [buyNowItem, setBuyNowItemState] = useState(() => {
+        if (typeof window === 'undefined')
+            return null;
+        try {
+            const stored = sessionStorage.getItem('buyNowItem');
+            return stored ? JSON.parse(stored) : null;
+        }
+        catch {
+            return null;
+        }
+    });
+    // Wrapper to persist to sessionStorage
+    const setBuyNowItem = useCallback((item) => {
+        setBuyNowItemState(item);
+        if (typeof window !== 'undefined') {
+            if (item) {
+                sessionStorage.setItem('buyNowItem', JSON.stringify(item));
+            }
+            else {
+                sessionStorage.removeItem('buyNowItem');
+            }
+        }
+    }, []);
+    const clearBuyNowItem = useCallback(() => {
+        setBuyNowItemState(null);
+        if (typeof window !== 'undefined') {
+            sessionStorage.removeItem('buyNowItem');
+        }
+    }, []);
+    // Wishlist State
+    const [wishlist, setWishlist] = useState([]);
+    const [isWishlistLoading, setIsWishlistLoading] = useState(false);
+    const lastSyncedInitialConfigRef = useRef(null);
+    useEffect(() => {
+        if (initialConfig) {
+            // Avoid setStore on every parent re-render when the editor passes a new object reference
+            // with identical data (reduces preview flicker / layout thrashing)
+            const prev = lastSyncedInitialConfigRef.current;
+            if (!prev || !isDeepEqual(prev, initialConfig)) {
+                setStore(initialConfig);
+                lastSyncedInitialConfigRef.current = initialConfig;
+            }
+            setIsLoading(false);
+            return;
+        }
+        lastSyncedInitialConfigRef.current = null;
+        if (!storeSlug) {
+            setIsLoading(false);
+            return;
+        }
+        const loadStore = async () => {
+            try {
+                setIsLoading(true);
+                setLoading?.(true);
+                setError(null);
+                if (shouldUseAPI(storeSlug)) {
+                    // Use API for non-demo stores - signal backend loading
+                    startBackendLoading?.();
+                    const baseSlug = getBaseStoreSlug(storeSlug);
+                    console.log('[StoreContext] Loading store from API (client-side):', baseSlug);
+                    const { store: apiStore } = await storeService.getStoreBySlug(baseSlug);
+                    const storeConfig = transformStoreResponseToConfig(apiStore);
+                    // Fetch categories, products, and services in parallel
+                    const [categoriesResult, productsResult, servicesResult] = await Promise.allSettled([
+                        categoryService.getCategories(apiStore.id).then((apiCategories) => apiCategories.map(transformCategoryToStoreCategory)),
+                        productService
+                            .getProducts({
+                            storeId: apiStore.id,
+                            limit: 1000,
+                        })
+                            .then((response) => response.data.map((product) => transformProductToStoreProduct(product))),
+                        serviceService
+                            .getServices(apiStore.id)
+                            .then((apiServices) => apiServices.map(transformServiceToStoreService)),
+                    ]);
+                    // Extract results with graceful degradation
+                    const categories = categoriesResult.status === 'fulfilled' ? categoriesResult.value : [];
+                    const products = productsResult.status === 'fulfilled' ? productsResult.value : [];
+                    const services = servicesResult.status === 'fulfilled' ? servicesResult.value : [];
+                    // Log errors if any occurred
+                    if (categoriesResult.status === 'rejected') {
+                        console.error('[StoreContext] Failed to fetch categories:', categoriesResult.reason);
+                    }
+                    else {
+                        console.log(`[StoreContext] Fetched ${categories.length} categories`);
+                    }
+                    if (productsResult.status === 'rejected') {
+                        console.error('[StoreContext] Failed to fetch products:', productsResult.reason);
+                    }
+                    else {
+                        console.log(`[StoreContext] Fetched ${products.length} products`);
+                    }
+                    if (servicesResult.status === 'rejected') {
+                        console.error('[StoreContext] Failed to fetch services:', servicesResult.reason);
+                    }
+                    else {
+                        console.log(`[StoreContext] Fetched ${services.length} services`);
+                    }
+                    // Populate dynamic catalog data on the hydrated store config
+                    storeConfig.categories = categories;
+                    storeConfig.products = products;
+                    storeConfig.services = services;
+                    if (storeConfig.layout.startsWith('food')) {
+                        storeConfig.menuItems = products.map((product) => ({
+                            id: product.id,
+                            name: product.name,
+                            description: richFieldPlainTextForDisplay(product.description),
+                            price: product.price,
+                            image: product.images[0],
+                            categoryId: product.categoryId,
+                            inStock: product.inStock,
+                            dietaryInfo: product.specifications?.dietaryInfo || [],
+                            customizable: !!product.variants?.length,
+                        }));
+                    }
+                    setStore(storeConfig);
+                }
+                else {
+                    // Use mock data for demo stores
+                    const baseSlug = getBaseStoreSlug(storeSlug);
+                    const storeConfig = getStoreConfig(baseSlug);
+                    if (storeConfig) {
+                        setStore(storeConfig);
+                    }
+                    else {
+                        setStore(null);
+                        setError('Store not found');
+                    }
+                }
+            }
+            catch (err) {
+                const errorMessage = err instanceof Error ? err.message : 'Failed to load store';
+                setError(errorMessage);
+                // Fallback to mock data on error
+                const baseSlug = getBaseStoreSlug(storeSlug);
+                const storeConfig = getStoreConfig(baseSlug);
+                if (storeConfig) {
+                    setStore(storeConfig);
+                    setError(null);
+                }
+            }
+            finally {
+                setIsLoading(false);
+                setLoading?.(false);
+                stopBackendLoading?.();
+                // Don't call stopPageLoading here - let content detection handle it
+                // Content detection will verify that page content is actually rendered
+                // before hiding the skeleton
+                // before hiding the skeleton
+            }
+        };
+        loadStore();
+    }, [storeSlug, initialConfig]);
+    // Load cart/wishlist from local storage only
+    // Note: cartService and wishlistService removed - using localStorage only
+    // These services are only needed for shared pages (cart, wishlist, account) which aren't editable in the editor
+    useEffect(() => {
+        if (typeof window === 'undefined' || !storeSlug || !store)
+            return;
+        // Load from local storage only
+        const savedCart = localStorage.getItem(`cart_${storeSlug}`);
+        const savedWishlist = localStorage.getItem(`wishlist_${storeSlug}`);
+        if (savedCart) {
+            try {
+                setCart(JSON.parse(savedCart));
+            }
+            catch (error) {
+                console.error('Failed to parse saved cart:', error);
+            }
+        }
+        if (savedWishlist) {
+            try {
+                setWishlist(JSON.parse(savedWishlist));
+            }
+            catch (error) {
+                console.error('Failed to parse saved wishlist:', error);
+            }
+        }
+    }, [storeSlug, store]);
+    // Note: Guest wishlist sync removed - using localStorage only
+    // cartService and wishlistService are not available
+    // Sync cart/wishlist to local storage only
+    // Note: cartService and wishlistService removed - using localStorage only
+    useEffect(() => {
+        if (typeof window === 'undefined' || !storeSlug || !store)
+            return;
+        // Save to local storage
+        localStorage.setItem(`cart_${storeSlug}`, JSON.stringify(cart));
+        localStorage.setItem(`wishlist_${storeSlug}`, JSON.stringify(wishlist));
+    }, [cart, wishlist, storeSlug, store]);
+    const addToCart = useCallback(async (product, quantity = 1, variantIdOrOptions) => {
+        const { variantId, variantName, unitPrice } = normalizeAddToCartOptions(variantIdOrOptions);
+        const matchingVariant = variantId ? product.variants?.find(v => v.id === variantId) : undefined;
+        const resolvedVariantName = variantName ?? matchingVariant?.name ?? matchingVariant?.value;
+        const resolvedUnitPrice = unitPrice ?? matchingVariant?.price ?? product.price;
+        const stock = getProductStockInfo(product);
+        if (!stock.canPurchase) {
+            console.warn('[StoreContext] Attempted to add out-of-stock product to cart:', product.id);
+            throw new Error(formatStockLimitMessage(product.name, stock.availableStock ?? 0));
+        }
+        if (product.trackInventory !== false && stock.availableStock != null) {
+            const cartItemId = variantId ? `${product.id}-${variantId}` : product.id;
+            const existingItem = cart.find((item) => item.id === cartItemId || (item.productId === product.id && item.variantId === variantId));
+            const requestedQty = (existingItem?.quantity || 0) + quantity;
+            if (requestedQty > stock.availableStock) {
+                throw new Error(formatStockLimitMessage(product.name, stock.availableStock, requestedQty));
+            }
+        }
+        setIsCartLoading(true);
+        try {
+            // Use local storage only (cartService removed)
+            setCart(prev => {
+                const cartItemId = variantId ? `${product.id}-${variantId}` : product.id;
+                const existingItem = prev.find(item => item.id === cartItemId);
+                if (existingItem) {
+                    return prev.map(item => item.id === cartItemId
+                        ? { ...item, quantity: item.quantity + quantity }
+                        : item);
+                }
+                return [...prev, {
+                        id: cartItemId,
+                        productId: product.id,
+                        quantity,
+                        variantId,
+                        variantName: resolvedVariantName,
+                        price: resolvedUnitPrice,
+                        product
+                    }];
+            });
+            setIsCartOpen(true);
+            if (store?.id) {
+                analyticsService.trackCommerceEvent({
+                    storeId: store.id,
+                    eventType: 'add_to_cart',
+                    userId: isAuthenticated ? (user?.id || null) : null,
+                    metadata: {
+                        productId: product.id,
+                        productName: product.name,
+                        categoryId: product.categoryId,
+                        quantity,
+                        price: resolvedUnitPrice,
+                        variantId,
+                    },
+                }, `add_to_cart:${product.id}:${variantId || 'default'}`);
+            }
+        }
+        finally {
+            setIsCartLoading(false);
+        }
+    }, [store?.id, isAuthenticated, user?.id]);
+    const removeFromCart = useCallback(async (cartItemId) => {
+        setIsCartLoading(true);
+        try {
+            // Get item details before removing for analytics
+            const removedItem = cart.find(item => item.id === cartItemId);
+            // Use local storage only (cartService removed)
+            setCart(prev => prev.filter(item => item.id !== cartItemId));
+            if (removedItem && store?.id) {
+                analyticsService.trackCommerceEvent({
+                    storeId: store.id,
+                    eventType: 'remove_from_cart',
+                    userId: isAuthenticated ? (user?.id || null) : null,
+                    metadata: {
+                        productId: removedItem.productId,
+                        productName: removedItem.product.name,
+                        quantity: removedItem.quantity,
+                        price: removedItem.price,
+                        variantId: removedItem.variantId,
+                    },
+                }, `remove_from_cart:${removedItem.productId}:${removedItem.variantId || 'default'}`);
+            }
+        }
+        finally {
+            setIsCartLoading(false);
+        }
+    }, [cart, store?.id, isAuthenticated, user?.id]);
+    const updateCartQuantity = useCallback(async (cartItemId, quantity) => {
+        if (quantity <= 0) {
+            await removeFromCart(cartItemId);
+            return;
+        }
+        setIsCartLoading(true);
+        try {
+            // Use local storage only (cartService removed)
+            setCart(prev => prev.map(item => item.id === cartItemId ? { ...item, quantity } : item));
+        }
+        finally {
+            setIsCartLoading(false);
+        }
+    }, [removeFromCart]);
+    const toggleWishlist = useCallback(async (productId) => {
+        setIsWishlistLoading(true);
+        try {
+            const product = store?.products?.find(p => p.id === productId);
+            const productName = product?.name || 'Product';
+            const wasInWishlist = wishlist.includes(productId);
+            // Use local storage only (wishlistService removed)
+            setWishlist(prev => {
+                const updated = prev.includes(productId)
+                    ? prev.filter(id => id !== productId)
+                    : [...prev, productId];
+                // Save to localStorage
+                if (storeSlug) {
+                    localStorage.setItem(`wishlist_${storeSlug}`, JSON.stringify(updated));
+                }
+                return updated;
+            });
+            if (store?.id) {
+                analyticsService.trackCommerceEvent({
+                    storeId: store.id,
+                    eventType: wasInWishlist ? 'wishlist_remove' : 'wishlist_add',
+                    userId: isAuthenticated ? (user?.id || null) : null,
+                    metadata: { productId, productName },
+                }, `wishlist:${productId}`);
+            }
+        }
+        catch (error) {
+            console.error('[StoreContext] Error in toggleWishlist:', error);
+            throw error;
+        }
+        finally {
+            setIsWishlistLoading(false);
+        }
+    }, [store?.id, store?.products, wishlist, storeSlug, isAuthenticated, user?.id]);
+    const isInWishlist = useCallback((productId) => wishlist.includes(productId), [wishlist]);
+    const cartTotal = cart.reduce((total, item) => total + (normalizePrice(item.price) * item.quantity), 0);
+    const cartCount = cart.reduce((count, item) => count + item.quantity, 0);
+    const contextValue = useMemo(() => ({
+        store,
+        isLoading,
+        error,
+        cart,
+        addToCart,
+        removeFromCart,
+        updateCartQuantity,
+        cartTotal,
+        cartCount,
+        isCartOpen,
+        setIsCartOpen,
+        isCartLoading,
+        isCartHydrated: true,
+        refreshCart: async () => { },
+        buyNowItem,
+        setBuyNowItem,
+        clearBuyNowItem,
+        wishlist,
+        toggleWishlist,
+        isInWishlist,
+        isWishlistLoading
+    }), [
+        store,
+        isLoading,
+        error,
+        cart,
+        addToCart,
+        removeFromCart,
+        updateCartQuantity,
+        cartTotal,
+        cartCount,
+        isCartOpen,
+        isCartLoading,
+        buyNowItem,
+        setBuyNowItem,
+        clearBuyNowItem,
+        wishlist,
+        toggleWishlist,
+        isInWishlist,
+        isWishlistLoading
+    ]);
+    return (_jsx(StoreContext.Provider, { value: contextValue, children: children }));
+}
+export const useStore = () => useContext(StoreContext);