storefront-layouts-staging 1.0.0-staging.0

package/dist/lib/utils/asset-helpers.js

@@ -0,0 +1,462 @@
+import { shouldUseAPI } from './demo-detection.js';
+export { shouldUseAPI };
+function normalizeAssetUrl(url) {
+    if (typeof url !== 'string')
+        return null;
+    const trimmed = url.trim();
+    if (!trimmed)
+        return null;
+    // Basic sanity guard: avoid obvious non-urls like "undefined"/"null"
+    if (trimmed === 'undefined' || trimmed === 'null')
+        return null;
+    return trimmed;
+}
+/**
+ * Normalizes store image URLs to absolute URLs
+ * Handles both absolute URLs (R2/Cloudflare/etc.) and relative paths
+ * @param raw - The raw image URL (can be relative or absolute)
+ * @returns Normalized absolute URL or null if invalid
+ */
+export function normalizeStoreImageUrl(raw) {
+    // Handle null, undefined, or non-string values
+    if (raw === null || raw === undefined)
+        return null;
+    if (typeof raw !== 'string')
+        return null;
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return null;
+    if (trimmed === 'undefined' || trimmed === 'null' || trimmed === '')
+        return null;
+    // Absolute URLs (R2/Cloudflare/etc.) - return as-is
+    if (/^https?:\/\//i.test(trimmed)) {
+        return trimmed;
+    }
+    // Backend-served uploads (relative path)
+    // Try to get API base URL from environment or use default
+    const apiBase = typeof process !== 'undefined' && process.env?.NEXT_PUBLIC_API_URL
+        ? process.env.NEXT_PUBLIC_API_URL
+        : (typeof window !== 'undefined'
+            ? window.location.origin.replace(/:\d+$/, ':4002') // Try to infer from current origin
+            : 'http://localhost:4002');
+    // Handle paths starting with /uploads/
+    if (trimmed.startsWith('/uploads/')) {
+        return `${apiBase}${trimmed}`;
+    }
+    // Handle paths starting with uploads/ (no leading slash)
+    if (trimmed.startsWith('uploads/')) {
+        return `${apiBase}/${trimmed}`;
+    }
+    // Handle paths starting with / (other backend paths)
+    if (trimmed.startsWith('/')) {
+        return `${apiBase}${trimmed}`;
+    }
+    // As a last resort, return as-is (could already be a resolvable relative asset)
+    return trimmed;
+}
+function pickFirstAssetUrl(...candidates) {
+    for (const c of candidates) {
+        const normalized = normalizeAssetUrl(c);
+        if (normalized)
+            return normalized;
+    }
+    return null;
+}
+/**
+ * Gets text content from backend assignedText for real stores, or returns fallback for demo stores
+ * @param storeConfig - The store configuration
+ * @param textKey - Key to look up in layoutConfig.assignedText (e.g., 'hero_title', 'team_section_title')
+ * @param fallbackText - Fallback text to use for demo stores or when text is missing
+ * @returns Text content string
+ */
+export function getTextContent(storeConfig, textKey, fallbackText) {
+    if (!storeConfig) {
+        return fallbackText;
+    }
+    // 1. Try to get text from new text hierarchy first
+    if (storeConfig.layoutConfig?.text) {
+        const value = getLayoutText(storeConfig, textKey, '');
+        if (value)
+            return value;
+    }
+    // 2. Try to get text from assignedText (legacy)
+    const assignedText = storeConfig.layoutConfig?.assignedText;
+    if (assignedText && typeof assignedText === 'object') {
+        const textValue = assignedText[textKey];
+        if (textValue && typeof textValue === 'string' && textValue.trim()) {
+            return textValue.trim();
+        }
+    }
+    // 3. Fallback to default
+    return fallbackText;
+}
+/**
+ * Gets an array of features/benefits from backend
+ * Checks new structured text system first, then assignedText (legacy), or returns fallback array
+ * @param storeConfig - The store configuration
+ * @param textKeyPrefix - Prefix for feature keys (e.g., 'team_feature_' will look for 'team_feature_1', 'team_feature_2', etc.)
+ * @param fallbackFeatures - Fallback array of features for demo stores or when features are missing
+ * @returns Array of feature strings
+ */
+export function getFeaturesList(storeConfig, textKeyPrefix, fallbackFeatures) {
+    if (!storeConfig) {
+        return fallbackFeatures;
+    }
+    // 1. Try new structured text system first (e.g., sections.team.features)
+    const sectionMatch = textKeyPrefix.match(/^(\w+)_feature_/);
+    if (sectionMatch && storeConfig.layoutConfig?.text) {
+        const sectionName = sectionMatch[1];
+        const textConfig = storeConfig.layoutConfig.text;
+        if (textConfig.sections &&
+            typeof textConfig.sections === 'object' &&
+            sectionName in textConfig.sections) {
+            const section = textConfig.sections[sectionName];
+            if (section && typeof section === 'object' && 'features' in section) {
+                const features = section.features;
+                if (Array.isArray(features) && features.length > 0) {
+                    const validFeatures = features
+                        .filter((f) => typeof f === 'string' && f.trim())
+                        .map((f) => f.trim());
+                    if (validFeatures.length > 0) {
+                        return validFeatures;
+                    }
+                }
+            }
+        }
+    }
+    // 2. Fallback to legacy assignedText system
+    const assignedText = storeConfig.layoutConfig?.assignedText;
+    if (assignedText && typeof assignedText === 'object') {
+        const features = [];
+        let index = 1;
+        while (index <= 10) {
+            const featureKey = `${textKeyPrefix}${index}`;
+            const featureValue = assignedText[featureKey];
+            if (featureValue && typeof featureValue === 'string' && featureValue.trim()) {
+                features.push(featureValue.trim());
+                index++;
+            }
+            else {
+                break;
+            }
+        }
+        if (features.length > 0) {
+            return features;
+        }
+    }
+    // 3. Check for benefit strip style items if textKeyPrefix matches
+    const featuresSection = storeConfig.layoutConfig?.sections?.features;
+    if (textKeyPrefix === 'features_item_' && featuresSection?.items && Array.isArray(featuresSection.items)) {
+        return featuresSection.items.map((item) => item.title || item.text || '').filter(Boolean);
+    }
+    return fallbackFeatures;
+}
+/**
+ * Gets an asset URL from the backend for real stores, or returns fallback for demo stores
+ * @param storeConfig - The store configuration
+ * @param assetKey - Key to look up in layoutConfig.assignedAssets
+ * @param fallbackUrl - Fallback URL to use for demo stores or when asset is missing
+ * @returns Asset URL string
+ */
+export function getAssetUrl(storeConfig, assetKey, fallbackUrl) {
+    if (!storeConfig) {
+        return fallbackUrl;
+    }
+    // 1. Try to get asset from layoutConfig.assignedAssets
+    const assignedAsset = storeConfig.layoutConfig?.assignedAssets?.[assetKey];
+    if (assignedAsset && typeof assignedAsset === 'string' && assignedAsset.trim()) {
+        return assignedAsset.trim();
+    }
+    // 2. Try to get asset from nested sections (common pattern)
+    const sections = storeConfig.layoutConfig?.sections;
+    if (sections) {
+        // Try to find image in any section that might have it
+        for (const section of Object.values(sections)) {
+            if (section && typeof section === 'object' && section.image === assetKey) {
+                return section.image;
+            }
+        }
+    }
+    return fallbackUrl;
+}
+/**
+ * Gets a hero/promo banner image from backend
+ * Checks multiple sources: assignedAssets, banner, then fallback
+ * @param storeConfig - The store configuration
+ * @param assetKey - Key to look up in layoutConfig.assignedAssets (e.g., 'hero_bg', 'promo_banner')
+ * @param fallbackUrl - Fallback URL to use for demo stores or when asset is missing
+ * @returns Asset URL string
+ */
+export function getBannerImage(storeConfig, assetKey, fallbackUrl) {
+    if (!storeConfig) {
+        return fallbackUrl;
+    }
+    const heroSection = storeConfig.layoutConfig?.sections?.hero ||
+        storeConfig.layoutConfig?.hero;
+    // 1) Editor/schema fields on sections.hero (e.g. hero_bg) take precedence over legacy assignedAssets
+    if (heroSection) {
+        const directSectionUrl = pickFirstAssetUrl(heroSection[assetKey], assetKey === 'hero_bg' ? heroSection.backgroundImage : undefined, assetKey === 'hero_bg' ? heroSection.image : undefined);
+        if (directSectionUrl)
+            return directSectionUrl;
+        const sectionHeroUrl = pickFirstAssetUrl(heroSection.backgroundImage, heroSection.image, heroSection.bannerImage, heroSection.heroImage, heroSection.bg, heroSection.background, heroSection.media?.image, heroSection.media?.src, heroSection.slides?.[0]?.image, heroSection.slides?.[0]?.backgroundImage, heroSection.sliders?.[0]?.image, heroSection.sliders?.[0]?.backgroundImage);
+        if (sectionHeroUrl)
+            return sectionHeroUrl;
+    }
+    const assignedAssets = storeConfig.layoutConfig?.assignedAssets;
+    // 2) Explicit assignedAssets key (legacy)
+    const explicit = pickFirstAssetUrl(assignedAssets?.[assetKey]);
+    if (explicit)
+        return explicit;
+    // 3) Common alternate keys (defensive: backend/admin may use different naming)
+    const alternates = pickFirstAssetUrl(assignedAssets?.hero_bg, assignedAssets?.hero_background, assignedAssets?.heroBg, assignedAssets?.hero_banner, assignedAssets?.heroBanner, assignedAssets?.hero_image, assignedAssets?.heroImage, assignedAssets?.banner, assignedAssets?.banner_image, assignedAssets?.bannerImage);
+    if (alternates)
+        return alternates;
+    // 4) Store-level banner if present
+    const storeBanner = pickFirstAssetUrl(storeConfig?.banner);
+    if (storeBanner)
+        return storeBanner;
+    // 5) Fallback if nothing found
+    return fallbackUrl;
+}
+/**
+ * Gets a team member image from backend
+ * Checks team page members first, then assignedAssets
+ * @param storeConfig - The store configuration
+ * @param memberName - Optional name to match team member
+ * @param assetKey - Key to look up in layoutConfig.assignedAssets (e.g., 'specialist_image')
+ * @param fallbackUrl - Fallback URL to use for demo stores or when asset is missing
+ * @returns Asset URL string
+ */
+export function getTeamMemberImage(storeConfig, memberName, assetKey, fallbackUrl) {
+    if (!storeConfig) {
+        return fallbackUrl;
+    }
+    const teamSection = (storeConfig.layoutConfig?.sections?.team || {});
+    const sectionImage = pickFirstAssetUrl(teamSection[assetKey], assetKey === 'specialist_image' ? teamSection.specialist_image : undefined, assetKey === 'specialist_image' ? teamSection.image : undefined, assetKey === 'specialist_image' ? teamSection.photo : undefined);
+    if (sectionImage)
+        return sectionImage;
+    const isRealStore = shouldUseAPI(storeConfig.slug);
+    // For demo stores, always use fallback
+    if (!isRealStore) {
+        return fallbackUrl;
+    }
+    // For real stores, check team members first if name provided
+    if (memberName) {
+        const teamMember = storeConfig.layoutConfig?.pages?.team?.members?.find((member) => member.name.toLowerCase() === memberName.toLowerCase());
+        if (teamMember?.photo && teamMember.photo.trim()) {
+            return teamMember.photo.trim();
+        }
+    }
+    // Check assignedAssets
+    const assignedAsset = storeConfig.layoutConfig?.assignedAssets?.[assetKey];
+    if (assignedAsset && typeof assignedAsset === 'string' && assignedAsset.trim()) {
+        return assignedAsset.trim();
+    }
+    // Return fallback if nothing found
+    return fallbackUrl;
+}
+/**
+ * Gets a service image from backend, with fallback
+ * @param serviceImage - Image from service object (may be from backend)
+ * @param storeConfig - The store configuration
+ * @param fallbackUrl - Fallback URL to use for demo stores or when asset is missing
+ * @returns Asset URL string
+ */
+export function getServiceImage(serviceImage, storeConfig, fallbackUrl) {
+    if (!storeConfig) {
+        return fallbackUrl;
+    }
+    // If service has an image, use it
+    if (serviceImage && serviceImage.trim()) {
+        return serviceImage.trim();
+    }
+    const isRealStore = shouldUseAPI(storeConfig.slug);
+    // For real stores without service image, return empty string to trigger fallback placeholder
+    return isRealStore ? '' : fallbackUrl;
+}
+/**
+ * Gets text content from layoutConfig.text hierarchy using dot notation path
+ * Falls back to common text, then fallback parameter
+ * @param storeConfig - The store configuration
+ * @param path - Dot notation path (e.g., 'hero.title', 'sections.categories.viewAll', 'common.shopNow')
+ * @param fallbackText - Fallback text to use when text is missing
+ * @returns Text content string
+ */
+export function getLayoutText(storeConfig, path, fallbackText) {
+    if (!storeConfig || !storeConfig.layoutConfig) {
+        return fallbackText;
+    }
+    // 1. Try to get text from layoutConfig.text hierarchy using dot notation path
+    if (storeConfig.layoutConfig.text) {
+        const textConfig = storeConfig.layoutConfig.text;
+        const pathParts = path.split('.');
+        // Navigate through the path
+        let current = textConfig;
+        let found = true;
+        for (const part of pathParts) {
+            if (current && typeof current === 'object' && part in current) {
+                current = current[part];
+            }
+            else {
+                found = false;
+                break;
+            }
+        }
+        if (found && typeof current === 'string' && current.trim()) {
+            return current.trim();
+        }
+    }
+    // 2. Try to get text from sections hierarchy (common for many layouts)
+    // e.g. path 'sections.categories.title' -> layoutConfig.sections.categories.title
+    const pathParts = path.split('.');
+    if (pathParts.length > 0) {
+        let current = storeConfig.layoutConfig;
+        let found = true;
+        for (const part of pathParts) {
+            if (current && typeof current === 'object' && part in current) {
+                current = current[part];
+            }
+            else {
+                found = false;
+                break;
+            }
+        }
+        if (found && typeof current === 'string' && current.trim()) {
+            return current.trim();
+        }
+    }
+    // 3. Try to get from assignedText (legacy)
+    const assignedText = storeConfig.layoutConfig.assignedText;
+    if (assignedText && typeof assignedText === 'object') {
+        const textValue = assignedText[path];
+        if (textValue && typeof textValue === 'string' && textValue.trim()) {
+            return textValue.trim();
+        }
+    }
+    return fallbackText;
+}
+/**
+ * Gets text content with priority:
+ * 1. layoutConfig.text (new system) - using getLayoutText
+ * 2. layoutConfig.assignedText (legacy system)
+ * 3. fallback
+ * @param storeConfig - The store configuration
+ * @param textKey - Key to look up (can be dot notation path for new system or legacy key)
+ * @param fallbackText - Fallback text to use when text is missing
+ * @returns Text content string
+ */
+export function getTextContentV2(storeConfig, textKey, fallbackText) {
+    if (!storeConfig) {
+        return fallbackText;
+    }
+    const isRealStore = shouldUseAPI(storeConfig.slug);
+    // For demo stores, always use fallback
+    if (!isRealStore) {
+        return fallbackText;
+    }
+    // Try new system first (if path contains dots, it's likely new system)
+    if (textKey.includes('.')) {
+        const newSystemValue = getLayoutText(storeConfig, textKey, '');
+        if (newSystemValue) {
+            return newSystemValue;
+        }
+    }
+    // Try legacy assignedText system
+    const assignedText = storeConfig.layoutConfig?.assignedText;
+    if (assignedText && typeof assignedText === 'object') {
+        const textValue = assignedText[textKey];
+        if (textValue && typeof textValue === 'string' && textValue.trim()) {
+            return textValue.trim();
+        }
+    }
+    // Fallback
+    return fallbackText;
+}
+/**
+ * Gets logo URL from backend for real stores, or returns null for demo stores
+ * @param storeConfig - The store configuration
+ * @returns Logo URL string or null
+ */
+export function getLogoUrl(storeConfig) {
+    if (!storeConfig) {
+        return null;
+    }
+    const isRealStore = shouldUseAPI(storeConfig.slug);
+    // For demo stores, always return null (use default SVG)
+    if (!isRealStore) {
+        return null;
+    }
+    // For real stores, check branding.logo
+    const logoUrl = storeConfig.branding?.logo;
+    if (logoUrl && typeof logoUrl === 'string' && logoUrl.trim()) {
+        return logoUrl.trim();
+    }
+    // If logo not found, return null to use default SVG
+    return null;
+}
+/**
+ * Gets a theme color from layout configuration with fallback
+ * @param storeConfig - The store configuration
+ * @param category - Color category (background, text, border, gradient, accent, layoutSpecific)
+ * @param key - Color key within the category (e.g., 'primary', 'secondary', 'blob1')
+ * @param fallback - Fallback color value
+ * @returns Color string
+ */
+export function getThemeColor(storeConfig, category, key, fallback) {
+    if (!storeConfig) {
+        return fallback;
+    }
+    const isRealStore = shouldUseAPI(storeConfig.slug);
+    // For demo stores, always use fallback
+    if (!isRealStore) {
+        return fallback;
+    }
+    // Try to get color from layoutConfig.themeColors
+    const themeColors = storeConfig.layoutConfig?.themeColors;
+    if (themeColors) {
+        if (category === 'layoutSpecific') {
+            const layoutSpecific = themeColors.layoutSpecific;
+            if (layoutSpecific && typeof layoutSpecific === 'object') {
+                const color = layoutSpecific[key];
+                if (color && typeof color === 'string' && color.trim()) {
+                    return color.trim();
+                }
+            }
+        }
+        else {
+            const categoryColors = themeColors[category];
+            if (categoryColors && typeof categoryColors === 'object') {
+                const color = categoryColors[key];
+                if (color && typeof color === 'string' && color.trim()) {
+                    return color.trim();
+                }
+            }
+        }
+    }
+    // Fallback to branding colors for certain keys
+    if (category === 'accent' && key === 'hover') {
+        return storeConfig.branding?.primaryColor || fallback;
+    }
+    if (category === 'accent' && key === 'focus') {
+        const primaryColor = storeConfig.branding?.primaryColor;
+        if (primaryColor) {
+            // Convert hex to rgba for focus ring
+            return primaryColor.includes('rgba') ? primaryColor : `${primaryColor}80`;
+        }
+    }
+    // If color not found, return fallback
+    return fallback;
+}
+/**
+ * Gets multiple theme colors at once
+ * @param storeConfig - The store configuration
+ * @param colorMap - Map of color keys to fallback values
+ * @returns Object with color values
+ */
+export function getThemeColors(storeConfig, colorMap) {
+    const result = {};
+    for (const [outputKey, config] of Object.entries(colorMap)) {
+        result[outputKey] = getThemeColor(storeConfig, config.category, config.key, config.fallback);
+    }
+    return result;
+}

package/dist/lib/utils/catalog-price-bounds.d.ts

@@ -0,0 +1,13 @@
+export type PriceableItem = {
+    price?: number | null;
+};
+/** Round catalog max up to a sensible slider step for the price filter UI. */
+export declare function roundPriceCeiling(value: number): number;
+/**
+ * Derive min/max price bounds from catalog items so the default filter shows all products.
+ */
+export declare function getCatalogPriceBounds(items: PriceableItem[], fallbackMax?: number): {
+    min: number;
+    max: number;
+};
+//# sourceMappingURL=catalog-price-bounds.d.ts.map

package/dist/lib/utils/catalog-price-bounds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"catalog-price-bounds.d.ts","sourceRoot":"","sources":["../../../src/lib/utils/catalog-price-bounds.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,aAAa,GAAG;IAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAC;AAEtD,8EAA8E;AAC9E,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAKvD;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,aAAa,EAAE,EACtB,WAAW,SAAO,GACjB;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAY9B"}

package/dist/lib/utils/catalog-price-bounds.js

@@ -0,0 +1,24 @@
+/** Round catalog max up to a sensible slider step for the price filter UI. */
+export function roundPriceCeiling(value) {
+    if (value <= 0)
+        return 100;
+    if (value <= 100)
+        return 100;
+    if (value <= 1000)
+        return Math.ceil(value / 100) * 100;
+    return Math.ceil(value / 1000) * 1000;
+}
+/**
+ * Derive min/max price bounds from catalog items so the default filter shows all products.
+ */
+export function getCatalogPriceBounds(items, fallbackMax = 5000) {
+    const prices = items
+        .map((item) => item.price)
+        .filter((p) => typeof p === 'number' && Number.isFinite(p) && p >= 0);
+    if (prices.length === 0) {
+        return { min: 0, max: fallbackMax };
+    }
+    const min = Math.max(0, Math.floor(Math.min(...prices)));
+    const max = roundPriceCeiling(Math.max(...prices));
+    return { min, max: Math.max(max, min) };
+}

package/dist/lib/utils/category-tree.d.ts

@@ -0,0 +1,25 @@
+import { StoreCategory } from '../../lib/store-types';
+/**
+ * Builds a hierarchical category tree from a flat array of categories
+ * Filters to show only root categories (no parentId) and recursively attaches children
+ *
+ * @param categories - Flat array of categories with parentId references
+ * @returns Array of root categories with nested children
+ */
+export declare function buildCategoryTree(categories: StoreCategory[]): StoreCategory[];
+/**
+ * Flattens a category tree back to a flat array (useful for filtering)
+ *
+ * @param categoryTree - Hierarchical category tree
+ * @returns Flat array of all categories including children
+ */
+export declare function flattenCategoryTree(categoryTree: StoreCategory[]): StoreCategory[];
+/**
+ * Gets all category IDs from a category and its children (recursively)
+ * Useful for filtering products when a parent category is selected
+ *
+ * @param category - Category to get IDs from
+ * @returns Array of category IDs including the category itself and all descendants
+ */
+export declare function getAllCategoryIds(category: StoreCategory): string[];
+//# sourceMappingURL=category-tree.d.ts.map

package/dist/lib/utils/category-tree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"category-tree.d.ts","sourceRoot":"","sources":["../../../src/lib/utils/category-tree.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAElD;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,aAAa,EAAE,GAAG,aAAa,EAAE,CA+C9E;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,YAAY,EAAE,aAAa,EAAE,GAAG,aAAa,EAAE,CAclF;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,aAAa,GAAG,MAAM,EAAE,CAUnE"}

package/dist/lib/utils/category-tree.js

@@ -0,0 +1,85 @@
+/**
+ * Builds a hierarchical category tree from a flat array of categories
+ * Filters to show only root categories (no parentId) and recursively attaches children
+ *
+ * @param categories - Flat array of categories with parentId references
+ * @returns Array of root categories with nested children
+ */
+export function buildCategoryTree(categories) {
+    if (!categories || categories.length === 0) {
+        return [];
+    }
+    // Create a map for quick lookup
+    const categoryMap = new Map();
+    const rootCategories = [];
+    // First pass: create copies of all categories and add to map
+    categories.forEach(category => {
+        categoryMap.set(category.id, {
+            ...category,
+            children: [],
+        });
+    });
+    // Second pass: build the tree structure
+    categories.forEach(category => {
+        const categoryCopy = categoryMap.get(category.id);
+        if (category.parentId) {
+            // This is a child category
+            const parent = categoryMap.get(category.parentId);
+            if (parent) {
+                if (!parent.children) {
+                    parent.children = [];
+                }
+                parent.children.push(categoryCopy);
+            }
+        }
+        else {
+            // This is a root category
+            rootCategories.push(categoryCopy);
+        }
+    });
+    // Sort root categories and recursively sort children
+    const sortCategories = (cats) => {
+        return cats
+            .sort((a, b) => a.name.localeCompare(b.name))
+            .map(cat => ({
+            ...cat,
+            children: cat.children ? sortCategories(cat.children) : undefined,
+        }));
+    };
+    return sortCategories(rootCategories);
+}
+/**
+ * Flattens a category tree back to a flat array (useful for filtering)
+ *
+ * @param categoryTree - Hierarchical category tree
+ * @returns Flat array of all categories including children
+ */
+export function flattenCategoryTree(categoryTree) {
+    const result = [];
+    const traverse = (categories) => {
+        categories.forEach(category => {
+            result.push(category);
+            if (category.children && category.children.length > 0) {
+                traverse(category.children);
+            }
+        });
+    };
+    traverse(categoryTree);
+    return result;
+}
+/**
+ * Gets all category IDs from a category and its children (recursively)
+ * Useful for filtering products when a parent category is selected
+ *
+ * @param category - Category to get IDs from
+ * @returns Array of category IDs including the category itself and all descendants
+ */
+export function getAllCategoryIds(category) {
+    const ids = [category.id];
+    if (category.children && category.children.length > 0) {
+        category.children.forEach(child => {
+            ids.push(...getAllCategoryIds(child));
+        });
+    }
+    return ids;
+}

package/dist/lib/utils/demo-detection.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Demo Detection Utility
+ *
+ * Determines if a store is a demo store and whether to use API or mock data.
+ * Demo stores are identified by:
+ * - Routes starting with /demo/
+ * - Store slugs starting with "demo/"
+ */
+/**
+ * Check if a store slug represents a demo store
+ */
+export declare function isDemoStore(slug: string | undefined | null): boolean;
+/**
+ * Determine if API should be used for a given store slug
+ * Returns false for demo stores (use mock data), true for real stores (use API)
+ */
+export declare function shouldUseAPI(slug: string | undefined | null): boolean;
+/**
+ * Extract the base store slug from a demo slug
+ * e.g., "demo/savory-bites" -> "savory-bites"
+ */
+export declare function getBaseStoreSlug(slug: string): string;
+//# sourceMappingURL=demo-detection.d.ts.map

package/dist/lib/utils/demo-detection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"demo-detection.d.ts","sourceRoot":"","sources":["../../../src/lib/utils/demo-detection.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH;;GAEG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,GAAG,OAAO,CAGpE;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,GAAG,OAAO,CAErE;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAQrD"}

package/dist/lib/utils/demo-detection.js

@@ -0,0 +1,36 @@
+/**
+ * Demo Detection Utility
+ *
+ * Determines if a store is a demo store and whether to use API or mock data.
+ * Demo stores are identified by:
+ * - Routes starting with /demo/
+ * - Store slugs starting with "demo/"
+ */
+/**
+ * Check if a store slug represents a demo store
+ */
+export function isDemoStore(slug) {
+    if (!slug)
+        return false;
+    return slug.startsWith('demo/') || slug.startsWith('demo-');
+}
+/**
+ * Determine if API should be used for a given store slug
+ * Returns false for demo stores (use mock data), true for real stores (use API)
+ */
+export function shouldUseAPI(slug) {
+    return !isDemoStore(slug);
+}
+/**
+ * Extract the base store slug from a demo slug
+ * e.g., "demo/savory-bites" -> "savory-bites"
+ */
+export function getBaseStoreSlug(slug) {
+    if (slug.startsWith('demo/')) {
+        return slug.replace('demo/', '');
+    }
+    if (slug.startsWith('demo-')) {
+        return slug.replace('demo-', '');
+    }
+    return slug;
+}