storefront-layouts-staging 1.0.0-staging.0

package/dist/lib/layout-field-normalize.js

@@ -0,0 +1,190 @@
+/**
+ * Normalize layout field shapes for save/publish and denormalize block trees
+ * into flat section fields for storefront renderers that read legacy paths.
+ */
+function isPlainObject(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function richOrString(v) {
+    if (v == null)
+        return '';
+    if (typeof v === 'string')
+        return v;
+    if (typeof v === 'object' && 'sanitizedHtml' in v) {
+        return String(v.sanitizedHtml ?? '');
+    }
+    return String(v);
+}
+function blkAttr(block) {
+    const a = block.attributes;
+    if (a && typeof a === 'object' && !Array.isArray(a))
+        return a;
+    return {};
+}
+/** True when a clothing-minimal section has merchant-authored flat or block content. */
+export function hasClothingMinimalMerchantSectionSignal(sectionKey, section) {
+    if (!section || typeof section !== 'object')
+        return false;
+    if (Array.isArray(section.blocks) && section.blocks.length > 0) {
+        return true;
+    }
+    const textKeys = ['badge', 'title', 'subtitle', 'primaryCTA', 'description', 'text', 'viewAllLabel'];
+    for (const key of textKeys) {
+        const v = richOrString(section[key]);
+        if (v.trim())
+            return true;
+    }
+    if (typeof section.image === 'string' && section.image.trim())
+        return true;
+    if (typeof section.hero_main === 'string') {
+        if (section.hero_main.trim())
+            return true;
+    }
+    if (sectionKey === 'features' && Array.isArray(section.items) && section.items.length > 0) {
+        return true;
+    }
+    return false;
+}
+/** Extract flat hero fields from clothing-minimal block tree for legacy renderers. */
+export function denormalizeClothingMinimalHeroBlocks(section) {
+    const blocks = section.blocks;
+    if (!Array.isArray(blocks) || blocks.length === 0) {
+        return section;
+    }
+    const left = blocks.find((b) => b.name === 'payaza/group' && String(blkAttr(b).variant) === 'hero-left');
+    const right = blocks.find((b) => b.name === 'payaza/group' && String(blkAttr(b).variant) === 'hero-right');
+    const leftInner = left?.innerBlocks ?? [];
+    const badgeB = leftInner.find((x) => x.name === 'payaza/badge');
+    const headingB = leftInner.find((x) => x.name === 'payaza/heading');
+    const parB = leftInner.find((x) => x.name === 'payaza/paragraph');
+    const btnB = leftInner.find((x) => x.name === 'payaza/button');
+    const heroImg = right?.innerBlocks?.find((x) => x.name === 'payaza/image');
+    const next = { ...section };
+    if (badgeB)
+        next.badge = richOrString(blkAttr(badgeB).text) || next.badge;
+    if (headingB)
+        next.title = richOrString(blkAttr(headingB).content) || next.title;
+    if (parB)
+        next.subtitle = richOrString(blkAttr(parB).content) || next.subtitle;
+    if (btnB)
+        next.primaryCTA = richOrString(blkAttr(btnB).text) || next.primaryCTA;
+    if (heroImg) {
+        const rawUrl = blkAttr(heroImg).url;
+        const url = typeof rawUrl === 'string' ? rawUrl : '';
+        if (url.trim()) {
+            next.image = url.trim();
+            next.hero_main = url.trim();
+        }
+    }
+    return next;
+}
+/** Denormalize block-based clothing-minimal home sections into flat fields. */
+export function denormalizeClothingMinimalBlocksToSectionFields(layoutPayload) {
+    const sections = layoutPayload.sections;
+    if (!isPlainObject(sections))
+        return layoutPayload;
+    const nextSections = { ...sections };
+    const hero = nextSections.hero;
+    if (isPlainObject(hero) && Array.isArray(hero.blocks) && hero.blocks.length > 0) {
+        nextSections.hero = denormalizeClothingMinimalHeroBlocks(hero);
+    }
+    return { ...layoutPayload, sections: nextSections };
+}
+function normalizeHeroSliders(sliders) {
+    if (!Array.isArray(sliders))
+        return sliders;
+    return sliders.map((slide) => {
+        if (!isPlainObject(slide))
+            return slide;
+        const next = { ...slide };
+        if ((!next.image || (typeof next.image === 'string' && !next.image.trim())) &&
+            typeof next.backgroundImage === 'string' &&
+            next.backgroundImage.trim()) {
+            next.image = next.backgroundImage.trim();
+        }
+        return next;
+    });
+}
+function normalizeEditorialSection(editorial) {
+    const next = { ...editorial };
+    if (typeof next.primaryButtonText === 'string' &&
+        next.primaryButtonText.trim() &&
+        !isPlainObject(next.primaryButton)) {
+        next.primaryButton = {
+            text: next.primaryButtonText.trim(),
+            link: typeof next.primaryButtonLink === 'string' ? next.primaryButtonLink.trim() : '',
+        };
+    }
+    else if (isPlainObject(next.primaryButton)) {
+        const btn = { ...next.primaryButton };
+        if (typeof next.primaryButtonText === 'string' &&
+            next.primaryButtonText.trim() &&
+            !btn.text) {
+            btn.text = next.primaryButtonText.trim();
+        }
+        if (typeof next.primaryButtonLink === 'string' &&
+            next.primaryButtonLink.trim() &&
+            !btn.link) {
+            btn.link = next.primaryButtonLink.trim();
+        }
+        next.primaryButton = btn;
+    }
+    if (typeof next.label === 'string' && next.label.trim() && !next.badgeText) {
+        next.badgeText = next.label.trim();
+    }
+    return next;
+}
+function normalizeBookingHeroSection(hero) {
+    const next = { ...hero };
+    if (typeof next.headline === 'string' && next.headline.trim() && !next.title) {
+        next.title = next.headline.trim();
+    }
+    if (typeof next.tagline === 'string' && next.tagline.trim() && !next.subtitle) {
+        next.subtitle = next.tagline.trim();
+    }
+    return next;
+}
+/**
+ * Normalize field shapes on a layoutConfig payload before save/publish.
+ * Ensures storefront renderers and hydration read consistent paths.
+ */
+export function normalizeLayoutConfigFieldShapes(layoutPayload) {
+    if (!layoutPayload || !isPlainObject(layoutPayload))
+        return null;
+    const next = JSON.parse(JSON.stringify(layoutPayload));
+    const sections = next.sections;
+    if (!isPlainObject(sections))
+        return next;
+    const nextSections = { ...sections };
+    const hero = nextSections.hero;
+    if (isPlainObject(hero)) {
+        let h = { ...hero };
+        if (Array.isArray(h.sliders)) {
+            h = { ...h, sliders: normalizeHeroSliders(h.sliders) };
+        }
+        h = normalizeBookingHeroSection(h);
+        nextSections.hero = h;
+    }
+    const marketing = nextSections.marketing;
+    if (isPlainObject(marketing)) {
+        const m = { ...marketing };
+        if (isPlainObject(m.editorial)) {
+            m.editorial = normalizeEditorialSection(m.editorial);
+        }
+        nextSections.marketing = m;
+    }
+    const lookbook = nextSections.lookbook;
+    if (isPlainObject(lookbook)) {
+        nextSections.lookbook = normalizeEditorialSection(lookbook);
+    }
+    next.sections = nextSections;
+    return next;
+}
+/** Apply normalization + clothing-minimal denormalization for publish materialization. */
+export function prepareLayoutPayloadForPublish(layoutPayload) {
+    let payload = denormalizeClothingMinimalBlocksToSectionFields(layoutPayload);
+    const normalized = normalizeLayoutConfigFieldShapes(payload);
+    if (normalized)
+        payload = normalized;
+    return payload;
+}

package/dist/lib/layout-route-utils.d.ts

@@ -0,0 +1,30 @@
+import type { StoreConfig } from './store-types';
+/**
+ * Returns the store's home URL for both platform and custom domain routing.
+ * Platform domains (shopaza.africa, payaza.africa, localhost, vercel.app): returns /{storeSlug}
+ * Custom domains: returns /
+ */
+export declare function getStoreHomeUrl(storeSlug: string): string;
+/**
+ * Resolves a template page path to the correct URL for the current access mode.
+ *
+ * Accepts a path segment ("menu"), relative path ("/menu"), or multi-segment
+ * path ("categories/my-cat"). External URLs (http/https) are returned as-is.
+ *
+ * Platform domain → /{storeSlug}/{path}
+ * Custom domain   → /{path}
+ * SSR fallback    → platform domain form (hydration-safe; client corrects on mount)
+ */
+export declare function resolveStoreLink(path: string, storeSlug: string): string;
+/**
+ * Determines if the given pathname or route is the store root for a booking-agenda layout.
+ * When true, the caller should NOT wrap with BookingAgendaLayout (the page is self-contained
+ * with its own sidebar). Used by BaseStoreLayout (pathname) and PreviewRouter (route) so that
+ * preview, editor, template page, and launched store (slug + custom domain) all behave the same.
+ *
+ * @param pathnameOrRoute - Next.js pathname (e.g. /templates/agenda-book) or preview route (e.g. /)
+ * @param storeConfig - Store config with slug (e.g. demo/agenda-book or agenda-book)
+ * @returns true when this is the store root for booking-agenda (no wrapper)
+ */
+export declare function isBookingAgendaStoreRoot(pathnameOrRoute: string, storeConfig: StoreConfig): boolean;
+//# sourceMappingURL=layout-route-utils.d.ts.map

package/dist/lib/layout-route-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"layout-route-utils.d.ts","sourceRoot":"","sources":["../../src/lib/layout-route-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAUjD;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAGzD;AAED;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CA2BxE;AAED;;;;;;;;;GASG;AACH,wBAAgB,wBAAwB,CACtC,eAAe,EAAE,MAAM,EACvB,WAAW,EAAE,WAAW,GACvB,OAAO,CA0BT"}

package/dist/lib/layout-route-utils.js

@@ -0,0 +1,79 @@
+function isPlatformHostname(hostname) {
+    return (hostname === 'shopaza.africa' || hostname.endsWith('.shopaza.africa') ||
+        hostname === 'payaza.africa' || hostname.endsWith('.payaza.africa') ||
+        hostname.includes('localhost') || hostname.endsWith('.vercel.app'));
+}
+/**
+ * Returns the store's home URL for both platform and custom domain routing.
+ * Platform domains (shopaza.africa, payaza.africa, localhost, vercel.app): returns /{storeSlug}
+ * Custom domains: returns /
+ */
+export function getStoreHomeUrl(storeSlug) {
+    if (typeof window === 'undefined')
+        return `/${storeSlug}`;
+    return isPlatformHostname(window.location.hostname) ? `/${storeSlug}` : '/';
+}
+/**
+ * Resolves a template page path to the correct URL for the current access mode.
+ *
+ * Accepts a path segment ("menu"), relative path ("/menu"), or multi-segment
+ * path ("categories/my-cat"). External URLs (http/https) are returned as-is.
+ *
+ * Platform domain → /{storeSlug}/{path}
+ * Custom domain   → /{path}
+ * SSR fallback    → platform domain form (hydration-safe; client corrects on mount)
+ */
+export function resolveStoreLink(path, storeSlug) {
+    if (!path)
+        return getStoreHomeUrl(storeSlug);
+    // External URLs pass through unchanged
+    if (path.startsWith('http://') || path.startsWith('https://') || path.startsWith('//')) {
+        return path;
+    }
+    // Normalize: strip leading slashes
+    const clean = path.replace(/^\/+/, '');
+    if (!clean)
+        return getStoreHomeUrl(storeSlug);
+    // If the path already starts with the store slug, it's already fully qualified.
+    // Return it as-is to avoid doubling the slug (e.g. /watamaa-wears/products → /watamaa-wears/watamaa-wears/products).
+    if (clean === storeSlug || clean.startsWith(`${storeSlug}/`)) {
+        return `/${clean}`;
+    }
+    if (typeof window === 'undefined') {
+        // SSR: default to platform form; client-side render will correct for custom domains
+        return `/${storeSlug}/${clean}`;
+    }
+    return isPlatformHostname(window.location.hostname)
+        ? `/${storeSlug}/${clean}`
+        : `/${clean}`;
+}
+/**
+ * Determines if the given pathname or route is the store root for a booking-agenda layout.
+ * When true, the caller should NOT wrap with BookingAgendaLayout (the page is self-contained
+ * with its own sidebar). Used by BaseStoreLayout (pathname) and PreviewRouter (route) so that
+ * preview, editor, template page, and launched store (slug + custom domain) all behave the same.
+ *
+ * @param pathnameOrRoute - Next.js pathname (e.g. /templates/agenda-book) or preview route (e.g. /)
+ * @param storeConfig - Store config with slug (e.g. demo/agenda-book or agenda-book)
+ * @returns true when this is the store root for booking-agenda (no wrapper)
+ */
+export function isBookingAgendaStoreRoot(pathnameOrRoute, storeConfig) {
+    const raw = (pathnameOrRoute || '').trim().replace(/\/+$/, '') || '/';
+    const path = raw.startsWith('/') ? raw : `/${raw}`;
+    if (path === '/' || path === '') {
+        return true;
+    }
+    const segments = path.split('/').filter(Boolean);
+    const baseSlug = storeConfig.slug.split('/').pop() || storeConfig.slug;
+    if (path === `/${storeConfig.slug}` || path.endsWith(`/${storeConfig.slug}`)) {
+        return true;
+    }
+    const lastSegment = segments[segments.length - 1];
+    if (lastSegment !== baseSlug) {
+        return false;
+    }
+    const isStoreRootSegmentCount = segments.length === 1 ||
+        (segments.length === 2 &&
+            (segments[0] === 'templates' || segments[0] === 'demo'));
+    return isStoreRootSegmentCount;
+}

package/dist/lib/limited-time-offer.d.ts

@@ -0,0 +1,6 @@
+export declare function isActiveLimitedTimeOffer(product: {
+    isLimitedTimeOffer?: boolean;
+    limitedTimeOfferEndsAt?: string | Date | null;
+}): boolean;
+export declare function formatLimitedOfferEndsAt(endsAt: string | Date | null | undefined): string | null;
+//# sourceMappingURL=limited-time-offer.d.ts.map

package/dist/lib/limited-time-offer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"limited-time-offer.d.ts","sourceRoot":"","sources":["../../src/lib/limited-time-offer.ts"],"names":[],"mappings":"AAAA,wBAAgB,wBAAwB,CAAC,OAAO,EAAE;IAChD,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,sBAAsB,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAAC;CAC/C,GAAG,OAAO,CAKV;AAED,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,GAAG,SAAS,GACvC,MAAM,GAAG,IAAI,CAYf"}

package/dist/lib/limited-time-offer.js

@@ -0,0 +1,24 @@
+export function isActiveLimitedTimeOffer(product) {
+    if (!product.isLimitedTimeOffer)
+        return false;
+    if (!product.limitedTimeOfferEndsAt)
+        return true;
+    const ends = new Date(product.limitedTimeOfferEndsAt);
+    return !Number.isNaN(ends.getTime()) && ends.getTime() > Date.now();
+}
+export function formatLimitedOfferEndsAt(endsAt) {
+    if (!endsAt)
+        return null;
+    const date = new Date(endsAt);
+    if (Number.isNaN(date.getTime()))
+        return null;
+    try {
+        return date.toLocaleString(undefined, {
+            dateStyle: 'medium',
+            timeStyle: 'short',
+        });
+    }
+    catch {
+        return date.toISOString();
+    }
+}

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

@@ -0,0 +1,20 @@
+import 'nprogress/nprogress.css';
+interface LoadingContextType {
+    isLoading: boolean;
+    setLoading: (loading: boolean) => void;
+    loadingActions: Set<string>;
+    setActionLoading: (actionId: string, loading: boolean) => void;
+    isActionLoading: (actionId: string) => boolean;
+    startPageLoading: (targetPathname?: string) => void;
+    stopPageLoading: () => void;
+    isBackendLoading: boolean;
+    startBackendLoading: () => void;
+    stopBackendLoading: () => void;
+}
+export declare const LoadingContext: import("react").Context<LoadingContextType>;
+export declare function LoadingProvider({ children }: {
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function useLoading(): LoadingContextType;
+export {};
+//# sourceMappingURL=loading-context.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"loading-context.d.ts","sourceRoot":"","sources":["../../src/lib/loading-context.tsx"],"names":[],"mappings":"AAKA,OAAO,yBAAyB,CAAC;AAiBjC,UAAU,kBAAkB;IAC1B,SAAS,EAAE,OAAO,CAAC;IACnB,UAAU,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC;IACvC,cAAc,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC5B,gBAAgB,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC;IAC/D,eAAe,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC;IAC/C,gBAAgB,EAAE,CAAC,cAAc,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IACpD,eAAe,EAAE,MAAM,IAAI,CAAC;IAC5B,gBAAgB,EAAE,OAAO,CAAC;IAC1B,mBAAmB,EAAE,MAAM,IAAI,CAAC;IAChC,kBAAkB,EAAE,MAAM,IAAI,CAAC;CAChC;AAED,eAAO,MAAM,cAAc,6CAA2D,CAAC;AAEvF,wBAAgB,eAAe,CAAC,EAAE,QAAQ,EAAE,EAAE;IAAE,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAA;CAAE,2CAoN1E;AAED,wBAAgB,UAAU,uBAMzB"}

package/dist/lib/loading-context.js

@@ -0,0 +1,212 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { createContext, useContext, useState, useCallback, useEffect, useRef } from 'react';
+import { usePathname, useSearchParams } from 'next/navigation';
+import NProgress from 'nprogress';
+import 'nprogress/nprogress.css';
+import { PageLoader } from '../components/ui/page-loader.js';
+import { RouteSkeletonLoader } from '../components/ui/route-skeleton-loader.js';
+import { useContentReady } from '../hooks/use-content-ready.js';
+import { scrollToTop } from '../lib/utils/scroll-to-top.util.js';
+// Configure NProgress
+if (typeof window !== 'undefined') {
+    NProgress.configure({
+        showSpinner: true,
+        trickleSpeed: 200,
+        minimum: 0.08,
+        easing: 'ease',
+        speed: 500
+    });
+}
+export const LoadingContext = createContext(undefined);
+export function LoadingProvider({ children }) {
+    const [isLoading, setIsLoading] = useState(false);
+    const [loadingActions, setLoadingActions] = useState(new Set());
+    const [isPageTransitioning, setIsPageTransitioning] = useState(false);
+    const [targetPathname, setTargetPathname] = useState(null);
+    const [backendLoadingCount, setBackendLoadingCount] = useState(0);
+    const pathname = usePathname();
+    // Safely get searchParams - may not be available during static generation
+    let searchParams = null;
+    try {
+        searchParams = useSearchParams();
+    }
+    catch {
+        // useSearchParams not available (e.g., during static generation)
+        searchParams = null;
+    }
+    const loadingTimeoutRef = useRef(null);
+    const previousPathnameRef = useRef(null);
+    const skeletonTimeoutRef = useRef(null);
+    const nprogressTimeoutRef = useRef(null);
+    // Use content detection to determine when page content is ready
+    const { isContentReady } = useContentReady({
+        pathname: targetPathname || pathname,
+        enabled: isPageTransitioning,
+        minDisplayTime: 300,
+        maxWaitTime: 5000,
+        checkInterval: 100,
+    });
+    // Track route changes for page transitions with progress bar
+    useEffect(() => {
+        // Only trigger on actual pathname changes, not initial mount
+        if (previousPathnameRef.current === null) {
+            previousPathnameRef.current = pathname;
+            return;
+        }
+        if (previousPathnameRef.current !== pathname) {
+            // Route changed - start loading
+            scrollToTop();
+            setIsPageTransitioning(true);
+            setTargetPathname(pathname); // Set target pathname for skeleton
+            if (typeof window !== 'undefined') {
+                NProgress.start();
+            }
+            previousPathnameRef.current = pathname;
+            // Clear any existing timeouts
+            if (loadingTimeoutRef.current) {
+                clearTimeout(loadingTimeoutRef.current);
+            }
+            if (skeletonTimeoutRef.current) {
+                clearTimeout(skeletonTimeoutRef.current);
+            }
+            // Note: Content detection will handle hiding the skeleton
+            // This timeout is now a fallback only
+            skeletonTimeoutRef.current = setTimeout(() => {
+                // Fallback: hide after 3 seconds regardless (reduced from 5)
+                setIsPageTransitioning(false);
+                setIsLoading(false); // Also reset isLoading
+                setTargetPathname(null);
+                if (typeof window !== 'undefined') {
+                    NProgress.done();
+                }
+            }, 3000); // Fallback timeout - reduced to 3 seconds
+        }
+        return () => {
+            if (loadingTimeoutRef.current) {
+                clearTimeout(loadingTimeoutRef.current);
+            }
+            if (skeletonTimeoutRef.current) {
+                clearTimeout(skeletonTimeoutRef.current);
+            }
+            if (nprogressTimeoutRef.current) {
+                clearTimeout(nprogressTimeoutRef.current);
+            }
+        };
+    }, [pathname, searchParams?.toString()]);
+    const setLoading = useCallback((loading) => {
+        setIsLoading(loading);
+        if (typeof window !== 'undefined') {
+            if (loading) {
+                if (nprogressTimeoutRef.current) {
+                    clearTimeout(nprogressTimeoutRef.current);
+                    nprogressTimeoutRef.current = null;
+                }
+                NProgress.start();
+            }
+            else {
+                // Small delay to ensure smooth transition
+                if (nprogressTimeoutRef.current) {
+                    clearTimeout(nprogressTimeoutRef.current);
+                }
+                nprogressTimeoutRef.current = setTimeout(() => {
+                    NProgress.done();
+                    nprogressTimeoutRef.current = null;
+                }, 100);
+            }
+        }
+    }, []);
+    const startPageLoading = useCallback((targetPathnameParam) => {
+        setIsPageTransitioning(true);
+        setIsLoading(true);
+        // Use provided target pathname or current pathname
+        setTargetPathname(targetPathnameParam || pathname);
+        if (typeof window !== 'undefined') {
+            NProgress.start();
+        }
+    }, [pathname]);
+    const stopPageLoading = useCallback(() => {
+        // Clear any pending timeouts
+        if (skeletonTimeoutRef.current) {
+            clearTimeout(skeletonTimeoutRef.current);
+        }
+        setIsPageTransitioning(false);
+        setIsLoading(false);
+        setTargetPathname(null);
+        if (typeof window !== 'undefined') {
+            NProgress.done();
+        }
+    }, []);
+    const setActionLoading = useCallback((actionId, loading) => {
+        setLoadingActions(prev => {
+            const next = new Set(prev);
+            if (loading) {
+                next.add(actionId);
+            }
+            else {
+                next.delete(actionId);
+            }
+            return next;
+        });
+    }, []);
+    const isActionLoading = useCallback((actionId) => {
+        return loadingActions.has(actionId);
+    }, [loadingActions]);
+    const startBackendLoading = useCallback(() => {
+        setBackendLoadingCount(prev => prev + 1);
+    }, []);
+    const stopBackendLoading = useCallback(() => {
+        setBackendLoadingCount(prev => Math.max(0, prev - 1));
+    }, []);
+    const isBackendLoading = backendLoadingCount > 0;
+    // Hide skeleton when content is ready AND backend loading is complete
+    // This ensures spinner and blurred background close together
+    useEffect(() => {
+        if (isPageTransitioning && isContentReady && !isBackendLoading) {
+            scrollToTop();
+            // Content is ready AND backend loading is complete, hide skeleton and loader together
+            if (skeletonTimeoutRef.current) {
+                clearTimeout(skeletonTimeoutRef.current);
+            }
+            setIsPageTransitioning(false);
+            setIsLoading(false); // Also reset isLoading
+            setTargetPathname(null);
+            if (typeof window !== 'undefined') {
+                NProgress.done();
+            }
+        }
+    }, [isPageTransitioning, isContentReady, isBackendLoading]);
+    // Additional safety: Hide loader if page transition completes but content detection didn't trigger
+    useEffect(() => {
+        if (!isPageTransitioning && isLoading) {
+            // If we're not transitioning but still loading, check if we should hide
+            // This handles cases where content detection might have missed
+            const hideTimeout = setTimeout(() => {
+                setIsLoading(false);
+                if (typeof window !== 'undefined') {
+                    NProgress.done();
+                }
+            }, 1000); // Give it 1 second after transition ends
+            return () => clearTimeout(hideTimeout);
+        }
+    }, [isPageTransitioning, isLoading]);
+    return (_jsxs(LoadingContext.Provider, { value: {
+            isLoading,
+            setLoading,
+            loadingActions,
+            setActionLoading,
+            isActionLoading,
+            startPageLoading,
+            stopPageLoading,
+            isBackendLoading,
+            startBackendLoading,
+            stopBackendLoading,
+        }, children: [children, isPageTransitioning && targetPathname && (_jsx(RouteSkeletonLoader, { pathname: targetPathname })), isLoading && !isPageTransitioning && _jsx(PageLoader, { fullPage: true })] }));
+}
+export function useLoading() {
+    const context = useContext(LoadingContext);
+    if (context === undefined) {
+        throw new Error('useLoading must be used within a LoadingProvider');
+    }
+    return context;
+}

package/dist/lib/mock-stores.d.ts

@@ -0,0 +1,24 @@
+import { StoreConfig } from './store-types';
+/**
+ * Feature Flags System:
+ *
+ * Use `pageFeatures` to enable/disable specific pages based on business type:
+ *
+ * - `teamPage`: For businesses that showcase their team (wellness, spa, medical, etc.)
+ * - `portfolioPage`: For creative businesses (makeup, photography, design, etc.)
+ * - `servicesPage`: For booking/service-based stores
+ * - `aboutPage`: For "About Us" page
+ * - `helpCenterPage`: For customer support
+ * - `shippingReturnsPage`: For e-commerce stores
+ * - `trackOrderPage`: For order tracking
+ *
+ * Navigation items in `navigation.main` should match enabled pages.
+ * Routing will automatically respect these flags and return 404 for disabled pages.
+ */
+export declare const mockStores: StoreConfig[];
+export declare function getStoreConfig(slug: string): StoreConfig | null;
+export declare function getAllStores(): Array<Pick<StoreConfig, 'slug' | 'name' | 'description' | 'type' | 'branding'>>;
+/** Template layoutConfig for a layout type (demo defaults — not merchant DB data). */
+export declare function getTemplateLayoutConfigForLayoutType(layoutType: string): StoreConfig['layoutConfig'] | undefined;
+export declare function isValidStoreSlug(slug: string): boolean;
+//# sourceMappingURL=mock-stores.d.ts.map

package/dist/lib/mock-stores.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock-stores.d.ts","sourceRoot":"","sources":["../../src/lib/mock-stores.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5C;;;;;;;;;;;;;;;GAeG;AAEH,eAAO,MAAM,UAAU,EAAE,WAAW,EAyhEnC,CAAC;AAGF,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI,CAE/D;AAED,wBAAgB,YAAY,IAAI,KAAK,CAAC,IAAI,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,GAAG,aAAa,GAAG,MAAM,GAAG,UAAU,CAAC,CAAC,CAQ9G;AAED,sFAAsF;AACtF,wBAAgB,oCAAoC,CAClD,UAAU,EAAE,MAAM,GACjB,WAAW,CAAC,cAAc,CAAC,GAAG,SAAS,CAQzC;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEtD"}