storefront-layouts-staging 1.0.0-staging.0

package/dist/editor/payaza-form/data-merger.js

@@ -0,0 +1,878 @@
+import { deepClone } from '../../lib/utils/index.js';
+import { transformToStoreConfig } from './data-transformer.js';
+import { ensureClothingMinimalHomeBlocksInPageData } from '../blocks/migrate-clothing-minimal.js';
+import { BOOKING_DEFAULT_TESTIMONIALS, normalizeBookingTestimonialItems, } from '../../layouts/booking/components/booking-testimonial-defaults.js';
+import { BOOKING_DEFAULT_ABOUT_STATS, BOOKING_DEFAULT_ABOUT_VALUES, mergeBookingAboutItemsSection, } from '../../layouts/booking/components/booking-about-defaults.js';
+import { mergeBookingFooterSection } from '../../layouts/booking/components/booking-footer-defaults.js';
+function sliderHasUsableContent(slider) {
+    if (!slider)
+        return false;
+    const image = (typeof slider.image === 'string' && slider.image.trim()) ||
+        (typeof slider.backgroundImage === 'string' && slider.backgroundImage.trim()) ||
+        (slider.image && typeof slider.image === 'object' && typeof slider.image.url === 'string' && slider.image.url.trim()) ||
+        (slider.backgroundImage &&
+            typeof slider.backgroundImage === 'object' &&
+            typeof slider.backgroundImage.url === 'string' &&
+            slider.backgroundImage.url.trim());
+    return Boolean(image ||
+        (slider.title && String(slider.title).trim()) ||
+        (slider.description && String(slider.description).trim()));
+}
+function resolveHeroSlidersFromLegacy(legacyHero) {
+    if (Array.isArray(legacyHero.sliders) && legacyHero.sliders.length > 0) {
+        return [...legacyHero.sliders];
+    }
+    if (Array.isArray(legacyHero.slides) && legacyHero.slides.length > 0) {
+        return [...legacyHero.slides];
+    }
+    return [];
+}
+function imageUrlOrEmpty(value) {
+    if (value == null)
+        return '';
+    return String(value).trim();
+}
+function enrichLookbookFromAssignedAssets(editorial, layoutConfig) {
+    const assets = layoutConfig.assignedAssets ?? {};
+    const next = { ...editorial };
+    if (!imageUrlOrEmpty(next.image) && assets.lookbook_main) {
+        next.image = assets.lookbook_main;
+    }
+    if (!imageUrlOrEmpty(next.detailImage) && assets.lookbook_detail) {
+        next.detailImage = assets.lookbook_detail;
+    }
+    return next;
+}
+/** Backfill booking editor image fields from legacy assignedAssets when section fields are empty. */
+function enrichBookingSectionImages(sectionKey, sectionData, layoutConfig) {
+    const assets = layoutConfig.assignedAssets ?? {};
+    const next = { ...sectionData };
+    if (sectionKey === 'hero' && !imageUrlOrEmpty(next.hero_bg)) {
+        const legacy = assets.hero_bg || assets.hero_image || assets.heroImage;
+        if (imageUrlOrEmpty(legacy))
+            next.hero_bg = legacy;
+    }
+    if (sectionKey === 'team' && !imageUrlOrEmpty(next.specialist_image)) {
+        const legacy = assets.specialist_image || assets.team_image;
+        if (imageUrlOrEmpty(legacy))
+            next.specialist_image = legacy;
+    }
+    if (sectionKey === 'promoBanner' && !imageUrlOrEmpty(next.image)) {
+        const legacy = assets.promo_banner || assets.promoBanner;
+        if (imageUrlOrEmpty(legacy))
+            next.image = legacy;
+    }
+    return next;
+}
+function mergeLookbookImagesWithDefaults(actual, requirement) {
+    const merged = deepMerge(requirement, actual);
+    const actualImage = imageUrlOrEmpty(actual.image);
+    const actualDetailImage = imageUrlOrEmpty(actual.detailImage);
+    if (actualImage)
+        merged.image = actualImage;
+    if (actualDetailImage)
+        merged.detailImage = actualDetailImage;
+    return merged;
+}
+function mergeHeroSlidersWithDefaults(actualSliders, requirementSliders) {
+    if (!actualSliders.length) {
+        return requirementSliders?.length ? [...requirementSliders] : [];
+    }
+    const anyUsable = actualSliders.some(sliderHasUsableContent);
+    if (!anyUsable && requirementSliders?.length) {
+        return [...requirementSliders];
+    }
+    if (!requirementSliders?.length) {
+        return [...actualSliders];
+    }
+    return actualSliders.map((actual, index) => {
+        const fallback = requirementSliders[index] || requirementSliders[requirementSliders.length - 1];
+        const resolvedImage = (typeof actual.image === 'string' && actual.image.trim()) ||
+            (actual.image && typeof actual.image === 'object' && typeof actual.image.url === 'string' && actual.image.url.trim()) ||
+            (typeof actual.backgroundImage === 'string' && actual.backgroundImage.trim()) ||
+            (actual.backgroundImage &&
+                typeof actual.backgroundImage === 'object' &&
+                typeof actual.backgroundImage.url === 'string' &&
+                actual.backgroundImage.url.trim()) ||
+            fallback?.image;
+        return {
+            ...fallback,
+            ...actual,
+            image: resolvedImage || fallback?.image,
+        };
+    });
+}
+/**
+ * Deep merge two objects, with source taking precedence over target
+ * Special handling for arrays: merge by id/index when both sides have entries
+ */
+function isImageLikeFieldKey(key) {
+    return (key === 'image' ||
+        key === 'url' ||
+        key === 'detailImage' ||
+        key === 'hero_bg' ||
+        key === 'heroImage' ||
+        key === 'backgroundImage' ||
+        key.endsWith('Image'));
+}
+function recordHasMerchantTextEdits(actual) {
+    for (const [key, val] of Object.entries(actual)) {
+        if (isImageLikeFieldKey(key))
+            continue;
+        if (typeof val === 'string' && val.trim())
+            return true;
+        if (val && typeof val === 'object' && 'sanitizedHtml' in val) {
+            const html = String(val.sanitizedHtml ?? '').trim();
+            if (html)
+                return true;
+        }
+    }
+    return false;
+}
+function mergeRecordPreferFilledDefaults(defaults, actual) {
+    const merged = deepMerge(defaults, actual);
+    const merchantEdited = recordHasMerchantTextEdits(actual);
+    for (const key of Object.keys(defaults)) {
+        const actualVal = actual[key];
+        const defaultVal = defaults[key];
+        if ((actualVal === '' || actualVal == null) &&
+            defaultVal != null &&
+            typeof defaultVal === 'string' &&
+            defaultVal.trim()) {
+            // When the merchant edited any field in this record, do not backfill empty
+            // sibling text fields from template defaults — partial slider saves must not
+            // reset messaging/description that was intentionally cleared or omitted.
+            if (merchantEdited) {
+                continue;
+            }
+            merged[key] = defaultVal;
+        }
+    }
+    return merged;
+}
+function mergeTestimonialsSectionWithDefaults(actual, requirement) {
+    const merged = deepMerge(requirement, actual);
+    const defaultItems = Array.isArray(requirement.items) ? requirement.items : BOOKING_DEFAULT_TESTIMONIALS;
+    const actualItems = Array.isArray(actual.items) ? actual.items : [];
+    if (actualItems.length === 0) {
+        merged.items = [...defaultItems];
+        return merged;
+    }
+    const normalized = normalizeBookingTestimonialItems(actualItems, defaultItems);
+    merged.items = normalized.length > 0 ? normalized : [...defaultItems];
+    return merged;
+}
+function deepMerge(target, source) {
+    const result = { ...target };
+    for (const key in source) {
+        if (source.hasOwnProperty(key)) {
+            const sourceValue = source[key];
+            const targetValue = result[key];
+            // Handle arrays: merge by id/index when both sides have entries
+            if (Array.isArray(sourceValue)) {
+                if (sourceValue.length > 0 &&
+                    Array.isArray(targetValue) &&
+                    targetValue.length > 0) {
+                    result[key] = mergeArrays(targetValue, sourceValue);
+                }
+                else if (sourceValue.length > 0) {
+                    result[key] = sourceValue;
+                }
+                else if (Array.isArray(targetValue) && targetValue.length > 0) {
+                    result[key] = targetValue;
+                }
+                else {
+                    result[key] = sourceValue;
+                }
+            }
+            else if (sourceValue !== null &&
+                typeof sourceValue === 'object' &&
+                targetValue !== null &&
+                typeof targetValue === 'object' &&
+                !Array.isArray(targetValue)) {
+                // Recursively merge nested objects
+                result[key] = deepMerge(targetValue, sourceValue);
+            }
+            else {
+                // Use source value (takes precedence)
+                result[key] = sourceValue;
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Merge arrays by matching IDs or by index
+ * Source (actual data) always takes precedence
+ */
+function mergeArrays(targetArray, sourceArray) {
+    if (!sourceArray || sourceArray.length === 0) {
+        return targetArray || [];
+    }
+    if (!targetArray || targetArray.length === 0) {
+        return sourceArray;
+    }
+    const result = [];
+    const usedTargetIndices = new Set();
+    const maxLen = Math.max(targetArray.length, sourceArray.length);
+    for (let i = 0; i < maxLen; i++) {
+        const sourceItem = sourceArray[i];
+        const targetItem = targetArray[i];
+        if (sourceItem === undefined) {
+            if (targetItem !== undefined)
+                result.push(targetItem);
+            continue;
+        }
+        if (targetItem === undefined) {
+            result.push(sourceItem);
+            continue;
+        }
+        if (sourceItem && typeof sourceItem === 'object' && sourceItem.id) {
+            const targetIndex = targetArray.findIndex((item, idx) => item && item.id === sourceItem.id && !usedTargetIndices.has(idx));
+            if (targetIndex !== -1) {
+                result.push(mergeRecordPreferFilledDefaults(targetArray[targetIndex], sourceItem));
+                usedTargetIndices.add(targetIndex);
+            }
+            else {
+                result.push(mergeRecordPreferFilledDefaults(targetItem, sourceItem));
+                usedTargetIndices.add(i);
+            }
+        }
+        else if (!usedTargetIndices.has(i)) {
+            result.push(mergeRecordPreferFilledDefaults(targetItem, sourceItem));
+            usedTargetIndices.add(i);
+        }
+    }
+    return result;
+}
+/**
+ * Helper to resolve deep path from object
+ */
+function getValueByPath(obj, path) {
+    if (!path)
+        return undefined;
+    const parts = path.split('.');
+    let current = obj;
+    for (const part of parts) {
+        if (current === null || current === undefined)
+            return undefined;
+        current = current[part];
+    }
+    return current;
+}
+/**
+ * Extract page-specific data from StoreConfig layoutConfig structure
+ */
+export function extractActualPageData(storeConfig, pageId, requirement) {
+    const layoutConfig = storeConfig.layoutConfig;
+    if (!layoutConfig) {
+        return {};
+    }
+    const pageDataMap = {};
+    // If requirement is provided, use its schema to find data paths
+    // This is the PRIMARY method and should always be used when available
+    if (requirement) {
+        const requirementPage = requirement.pages.find(p => p.id === pageId);
+        if (requirementPage) {
+            const sections = requirementPage._schema;
+            const layoutSections = layoutConfig.sections || {};
+            for (const sectionKey in sections) {
+                const sectionSchema = sections[sectionKey];
+                if (sectionSchema._sourcePath) {
+                    // Explicit source path mapping - this is the authoritative source
+                    const value = getValueByPath(storeConfig, sectionSchema._sourcePath);
+                    // booking uses pages.services.servicesHeader; booking-agenda uses pages.services.hero
+                    if (pageId === 'services' && (sectionKey === 'servicesHeader' || sectionKey === 'hero')) {
+                        const servicesPage = ((layoutConfig.pages || {}).services || {});
+                        const alternateRaw = sectionKey === 'servicesHeader' ? servicesPage.hero : servicesPage.servicesHeader;
+                        const primary = value != null && typeof value === 'object' && !Array.isArray(value)
+                            ? deepClone(value)
+                            : {};
+                        const alternate = alternateRaw != null && typeof alternateRaw === 'object' && !Array.isArray(alternateRaw)
+                            ? deepClone(alternateRaw)
+                            : {};
+                        const merged = { ...alternate, ...primary };
+                        if (Object.keys(merged).length > 0) {
+                            pageDataMap[sectionKey] = merged;
+                            continue;
+                        }
+                    }
+                    if (value !== undefined && value !== null) {
+                        if (pageId === 'home' &&
+                            (sectionKey === 'lookbook' || sectionKey === 'editorial')) {
+                            pageDataMap[sectionKey] = enrichLookbookFromAssignedAssets(deepClone(value), layoutConfig);
+                        }
+                        else if (pageId === 'home' &&
+                            requirement.layoutId === 'booking' &&
+                            (sectionKey === 'hero' || sectionKey === 'team' || sectionKey === 'promoBanner')) {
+                            pageDataMap[sectionKey] = enrichBookingSectionImages(sectionKey, deepClone(value), layoutConfig);
+                        }
+                        else {
+                            pageDataMap[sectionKey] = deepClone(value);
+                        }
+                        continue;
+                    }
+                    // _sourcePath returned nothing – apply per-section legacy fallbacks so data
+                    // stored under the old top-level layoutConfig shape is not silently dropped.
+                    if (pageId === 'home') {
+                        // hero: try layoutConfig.hero (old top-level) then layoutConfig.sections.hero
+                        if (sectionKey === 'hero') {
+                            const legacyHero = layoutConfig.hero || layoutSections.hero;
+                            if (legacyHero) {
+                                pageDataMap[sectionKey] = deepClone({
+                                    ...legacyHero,
+                                    sliders: resolveHeroSlidersFromLegacy(legacyHero),
+                                });
+                                continue;
+                            }
+                        }
+                        // benefitsStrip: mapped from sections.features in clothing schema
+                        if (sectionKey === 'benefitsStrip' && layoutSections.features) {
+                            const features = deepClone(layoutSections.features);
+                            if (Array.isArray(features.items)) {
+                                features.items = features.items
+                                    .filter((item) => item != null && typeof item === 'object')
+                                    .map((item) => ({
+                                    ...item,
+                                    title: item.title ?? item.text,
+                                    description: item.description ?? item.subtext,
+                                }));
+                            }
+                            pageDataMap[sectionKey] = features;
+                            continue;
+                        }
+                        // newsletter / marketing
+                        if (sectionKey === 'newsletter') {
+                            const nlSource = layoutSections.marketing?.newsletter || layoutSections.subscription;
+                            if (nlSource) {
+                                pageDataMap[sectionKey] = deepClone(nlSource);
+                                continue;
+                            }
+                        }
+                        // lookbook / editorial
+                        if (sectionKey === 'lookbook' || sectionKey === 'editorial') {
+                            const lbSource = layoutSections.marketing?.editorial;
+                            if (lbSource) {
+                                pageDataMap[sectionKey] = enrichLookbookFromAssignedAssets(deepClone(lbSource), layoutConfig);
+                                continue;
+                            }
+                            const assets = layoutConfig.assignedAssets;
+                            if (assets?.lookbook_main || assets?.lookbook_detail) {
+                                pageDataMap[sectionKey] = enrichLookbookFromAssignedAssets({ show: true }, layoutConfig);
+                                continue;
+                            }
+                        }
+                        // promoBanner — booking/clothing-minimal use sections.promoBanner; Fashion Hub uses marketing.promoBanner
+                        if (sectionKey === 'promoBanner') {
+                            const promoSource = layoutSections.promoBanner || layoutSections.marketing?.promoBanner;
+                            if (promoSource) {
+                                pageDataMap[sectionKey] = deepClone(promoSource);
+                                continue;
+                            }
+                        }
+                        // Generic: try sections[sectionKey] as a last resort
+                        if (layoutSections[sectionKey]) {
+                            pageDataMap[sectionKey] = deepClone(layoutSections[sectionKey]);
+                        }
+                    }
+                    // clothing-minimal: categories page headers live in sections.* (isolated from
+                    // shared layoutConfig.pages.categories used by Fashion Hub / food templates).
+                    if (pageId === 'categories' && requirement.layoutId === 'clothing-minimal') {
+                        const categoriesPage = (layoutConfig.pages || {}).categories || {};
+                        if (sectionKey === 'categoriesHeader' && categoriesPage.categoriesHeader) {
+                            pageDataMap[sectionKey] = deepClone(categoriesPage.categoriesHeader);
+                            continue;
+                        }
+                        if (sectionKey === 'categoryGrid' &&
+                            (categoriesPage.categoryGrid || categoriesPage.categoriesGrid)) {
+                            pageDataMap[sectionKey] = deepClone(categoriesPage.categoryGrid || categoriesPage.categoriesGrid);
+                            continue;
+                        }
+                    }
+                }
+                else {
+                    // No _sourcePath – fall back to sections[sectionKey] for home page,
+                    // or pages[pageId][sectionKey] for non-home pages so saved data is preserved.
+                    if (pageId === 'home' && layoutSections[sectionKey]) {
+                        pageDataMap[sectionKey] = deepClone(layoutSections[sectionKey]);
+                    }
+                    else if (pageId !== 'home') {
+                        const pages = layoutConfig.pages || {};
+                        const savedValue = pages[pageId]?.[sectionKey] ??
+                            layoutSections[sectionKey];
+                        if (savedValue) {
+                            pageDataMap[sectionKey] = deepClone(savedValue);
+                        }
+                    }
+                }
+            }
+            return pageDataMap;
+        }
+    }
+    // Fallback to traditional mapping logic for common sections
+    // This ensures backward compatibility if _sourcePath is missing or requirement not provided
+    const layoutSections = layoutConfig.sections || {};
+    const pages = layoutConfig.pages || {};
+    // Home page sections
+    if (pageId === 'home') {
+        if (layoutConfig.hero || layoutSections.hero) {
+            const hero = layoutConfig.hero || layoutSections.hero;
+            pageDataMap.hero = deepClone({
+                ...hero,
+                sliders: hero.sliders ? [...hero.sliders] : [],
+            });
+        }
+        if (layoutSections.features)
+            pageDataMap.benefitsStrip = layoutSections.features;
+        if (layoutSections.categories)
+            pageDataMap.categories = layoutSections.categories;
+        if (layoutSections.featuredProducts)
+            pageDataMap.featuredProducts = layoutSections.featuredProducts;
+        if (layoutSections.marketing?.newsletter)
+            pageDataMap.newsletter = layoutSections.marketing.newsletter;
+        else if (layoutSections.subscription)
+            pageDataMap.newsletter = layoutSections.subscription;
+        if (layoutSections.marketing?.editorial) {
+            const enriched = enrichLookbookFromAssignedAssets(deepClone(layoutSections.marketing.editorial), layoutConfig);
+            pageDataMap.editorial = enriched;
+            pageDataMap.lookbook = enriched;
+        }
+        else {
+            const assets = layoutConfig.assignedAssets;
+            if (assets?.lookbook_main || assets?.lookbook_detail) {
+                const enriched = enrichLookbookFromAssignedAssets({ show: true }, layoutConfig);
+                pageDataMap.editorial = enriched;
+                pageDataMap.lookbook = enriched;
+            }
+        }
+        if (layoutSections.promoBanner)
+            pageDataMap.promoBanner = deepClone(layoutSections.promoBanner);
+        else if (layoutSections.marketing?.promoBanner)
+            pageDataMap.promoBanner = layoutSections.marketing.promoBanner;
+        if (layoutSections.featuredServices)
+            pageDataMap.featuredServices = deepClone(layoutSections.featuredServices);
+        if (layoutSections.team)
+            pageDataMap.team = deepClone(layoutSections.team);
+        if (layoutSections.testimonials)
+            pageDataMap.testimonials = deepClone(layoutSections.testimonials);
+        if (layoutSections.marketing && !pageDataMap.marketing) {
+            pageDataMap.marketing = deepClone(layoutSections.marketing);
+        }
+    }
+    // Products page
+    if (pageId === 'products') {
+        const productsPage = pages.products || {};
+        // Check pages.products first, then fallback to sections
+        if (productsPage.productsHeader || layoutSections.productsHeader) {
+            pageDataMap.productsHeader = {
+                show: true,
+                ...(productsPage.productsHeader || layoutSections.productsHeader || {}),
+            };
+        }
+        if (productsPage.productsGrid || layoutSections.productsGrid) {
+            pageDataMap.productsGrid = {
+                show: true,
+                ...(productsPage.productsGrid || layoutSections.productsGrid || {}),
+            };
+        }
+    }
+    // Product detail page
+    if (pageId === 'productDetail') {
+        if (layoutSections.productDetail) {
+            pageDataMap.productDetail = {
+                show: true,
+                ...layoutSections.productDetail,
+            };
+        }
+    }
+    // Categories page
+    if (pageId === 'categories') {
+        const categoriesPage = pages.categories || {};
+        // Check pages.categories first, then fallback to sections
+        if (categoriesPage.categoriesHeader || layoutSections.categoriesHeader) {
+            pageDataMap.categoriesHeader = {
+                show: true,
+                ...(layoutSections.categoriesHeader || {}),
+                ...(categoriesPage.categoriesHeader || {}),
+            };
+        }
+        const categoryGridSource = categoriesPage.categoryGrid ||
+            categoriesPage.categoriesGrid ||
+            layoutSections.categoriesPageGrid ||
+            layoutSections.categoryGrid ||
+            layoutSections.categoriesGrid;
+        if (categoryGridSource) {
+            pageDataMap.categoryGrid = { show: true, ...categoryGridSource };
+            pageDataMap.categoriesGrid = { show: true, ...categoryGridSource };
+        }
+    }
+    // Menu page (food, food-modern)
+    if (pageId === 'menu') {
+        const menuPage = pages.menu || {};
+        if (menuPage.menuHeader || layoutSections.menuHeader) {
+            pageDataMap.menuHeader = {
+                show: true,
+                ...(layoutSections.menuHeader || {}),
+                ...(menuPage.menuHeader || {}),
+            };
+        }
+        if (menuPage.menuGrid || layoutSections.menuGrid) {
+            pageDataMap.menuGrid = {
+                show: true,
+                ...(layoutSections.menuGrid || {}),
+                ...(menuPage.menuGrid || {}),
+            };
+        }
+    }
+    // Services page (booking, booking-agenda, motivational-speaker)
+    if (pageId === 'services') {
+        const servicesPage = pages.services || {};
+        const servicesHero = servicesPage.hero || servicesPage.servicesHeader || layoutSections.servicesHeader;
+        if (servicesHero) {
+            const mergedHero = { show: true, ...servicesHero };
+            pageDataMap.hero = mergedHero;
+            pageDataMap.servicesHeader = mergedHero;
+        }
+        const servicesList = servicesPage['services-list'] ||
+            servicesPage.servicesGrid ||
+            layoutSections.servicesGrid;
+        if (servicesList) {
+            pageDataMap['services-list'] = { show: true, ...servicesList };
+        }
+    }
+    // Book page (booking)
+    if (pageId === 'book') {
+        const bookPage = pages.book || {};
+        if (bookPage.bookingHeader || layoutSections.bookingHeader) {
+            pageDataMap.bookingHeader = {
+                show: true,
+                ...(layoutSections.bookingHeader || {}),
+                ...(bookPage.bookingHeader || {}),
+            };
+        }
+        if (bookPage.bookingForm || layoutSections.bookingForm) {
+            pageDataMap.bookingForm = {
+                show: true,
+                ...(layoutSections.bookingForm || {}),
+                ...(bookPage.bookingForm || {}),
+            };
+        }
+    }
+    // Service detail page (booking)
+    if (pageId === 'serviceDetail') {
+        const serviceDetailPage = pages.serviceDetail || {};
+        if (serviceDetailPage.serviceDetail || layoutSections.serviceDetail) {
+            pageDataMap.serviceDetail = {
+                show: true,
+                ...(layoutSections.serviceDetail || {}),
+                ...(serviceDetailPage.serviceDetail || {}),
+            };
+        }
+    }
+    // Category detail page
+    if (pageId === 'categoryDetail') {
+        if (layoutSections.categoryDetail) {
+            pageDataMap.categoryDetail = {
+                show: true,
+                ...layoutSections.categoryDetail,
+            };
+        }
+    }
+    // About page
+    if (pageId === 'about') {
+        const aboutPage = pages.about || {};
+        // Check pages.about first, then fallback to sections
+        // Hero section
+        if (aboutPage.hero || layoutSections.hero) {
+            pageDataMap.hero = {
+                show: true,
+                ...(aboutPage.hero || layoutSections.hero || {}),
+            };
+        }
+        // Story section
+        if (aboutPage.story || layoutSections.story) {
+            pageDataMap.story = {
+                show: true,
+                ...(aboutPage.story || layoutSections.story || {}),
+            };
+        }
+        // Stats section
+        if (aboutPage.stats || layoutSections.stats) {
+            pageDataMap.stats = {
+                show: true,
+                ...(aboutPage.stats || layoutSections.stats || {}),
+            };
+        }
+        // Contact-info section (note: key has hyphen, so use bracket notation)
+        if (aboutPage['contact-info'] || layoutSections['contact-info']) {
+            pageDataMap['contact-info'] = {
+                show: true,
+                ...(aboutPage['contact-info'] || layoutSections['contact-info'] || {}),
+            };
+        }
+        // Values section
+        if (aboutPage.values || layoutSections.values) {
+            pageDataMap.values = {
+                show: true,
+                ...(layoutSections.values || {}),
+                ...(aboutPage.values || {}),
+            };
+        }
+        // Food layout section keys
+        if (aboutPage.aboutHero) {
+            pageDataMap.aboutHero = { show: true, ...aboutPage.aboutHero };
+        }
+        if (aboutPage.ourStory) {
+            pageDataMap.ourStory = { show: true, ...aboutPage.ourStory };
+        }
+        if (aboutPage.statsSection) {
+            pageDataMap.statsSection = { show: true, ...aboutPage.statsSection };
+        }
+        if (aboutPage.contactInfoSection) {
+            pageDataMap.contactInfoSection = { show: true, ...aboutPage.contactInfoSection };
+        }
+        // Clothing-minimal section keys
+        if (aboutPage.aboutHeader || layoutSections.aboutHeader) {
+            pageDataMap.aboutHeader = {
+                show: true,
+                ...(layoutSections.aboutHeader || {}),
+                ...(aboutPage.aboutHeader || {}),
+            };
+        }
+        if (aboutPage.aboutContent || layoutSections.aboutContent) {
+            pageDataMap.aboutContent = {
+                show: true,
+                ...(layoutSections.aboutContent || {}),
+                ...(aboutPage.aboutContent || {}),
+            };
+        }
+        if (aboutPage.contactSection || layoutSections.contactSection) {
+            pageDataMap.contactSection = {
+                show: true,
+                ...(layoutSections.contactSection || {}),
+                ...(aboutPage.contactSection || {}),
+            };
+        }
+        // Legacy support for old structure
+        if (layoutSections.aboutHeader)
+            pageDataMap.aboutHeader = { show: true, ...layoutSections.aboutHeader };
+        if (layoutSections.aboutContent)
+            pageDataMap.aboutContent = { show: true, ...layoutSections.aboutContent };
+        if (layoutSections.about)
+            pageDataMap.aboutPage = { show: true, ...layoutSections.about };
+    }
+    // Contact page
+    if (pageId === 'contact') {
+        const contactPage = pages.contact || {};
+        // Check pages.contact first, then fallback to sections
+        if (contactPage.contactHeader || layoutSections.contactHeader) {
+            pageDataMap.contactHeader = {
+                show: true,
+                ...(contactPage.contactHeader || layoutSections.contactHeader || {}),
+            };
+        }
+        if (contactPage.contactForm || layoutSections.contactForm) {
+            pageDataMap.contactForm = {
+                show: true,
+                ...(layoutSections.contactForm || {}),
+                ...(contactPage.contactForm || {}),
+            };
+        }
+        if (contactPage.hero || layoutSections.contactHero) {
+            pageDataMap.hero = {
+                show: true,
+                ...(layoutSections.contactHero || {}),
+                ...(contactPage.hero || {}),
+            };
+        }
+        if (contactPage.form || layoutSections.contactFormLegacy) {
+            pageDataMap.form = {
+                show: true,
+                ...(layoutSections.contactFormLegacy || {}),
+                ...(contactPage.form || {}),
+            };
+        }
+        if (contactPage.reservationForm) {
+            pageDataMap.reservationForm = { show: true, ...contactPage.reservationForm };
+        }
+        // Legacy support for minimal layout
+        if (layoutSections.contact)
+            pageDataMap.contactPage = { show: true, ...layoutSections.contact };
+    }
+    return pageDataMap;
+}
+/**
+ * Merge requirement schema with actual layout data
+ * Actual data takes precedence, but requirement provides structure and defaults
+ */
+export function mergeRequirementWithActualData(requirement, storeConfig, pageId, options = { actualDataPrecedence: true }) {
+    // Find the page in requirement
+    const requirementPage = requirement.pages.find(p => p.id === pageId);
+    if (!requirementPage) {
+        // Page not in requirement, return requirement as-is
+        return requirement;
+    }
+    // Extract actual data for this page
+    const actualPageData = extractActualPageData(storeConfig, pageId, requirement);
+    const shouldMarkHydrated = Object.keys(actualPageData ?? {}).length > 0;
+    // Create merged page data - start with requirement defaults
+    const mergedPageData = { ...requirementPage.data };
+    // If we want actual data to take precedence (normal loading)
+    if (options.actualDataPrecedence) {
+        // First, merge all sections that exist in requirement
+        for (const sectionKey in requirementPage.data) {
+            const requirementSection = requirementPage.data[sectionKey];
+            const actualSection = actualPageData[sectionKey];
+            if (actualSection) {
+                // Special handling for hero section to ensure sliders are preserved
+                if (sectionKey === 'hero' &&
+                    typeof requirementSection === 'object' &&
+                    typeof actualSection === 'object' &&
+                    !Array.isArray(requirementSection) &&
+                    !Array.isArray(actualSection)) {
+                    // For hero section, start with actual data (it has the real values)
+                    // Then merge requirement defaults for any missing properties
+                    const mergedHero = {
+                        ...requirementSection, // Start with requirement defaults
+                        ...actualSection, // Override with actual data (takes precedence)
+                    };
+                    // Explicitly preserve sliders from actual data if they exist and have items
+                    // Otherwise, use requirement sliders if actual has none
+                    if (actualSection.sliders && Array.isArray(actualSection.sliders) && actualSection.sliders.length > 0) {
+                        mergedHero.sliders = mergeHeroSlidersWithDefaults(actualSection.sliders, Array.isArray(requirementSection.sliders) ? requirementSection.sliders : []);
+                    }
+                    else if (requirementSection.sliders && Array.isArray(requirementSection.sliders)) {
+                        // Use requirement sliders if actual has none
+                        mergedHero.sliders = [...requirementSection.sliders];
+                    }
+                    // Normalize show: if schema defaults the hero to visible (show: true) but the DB
+                    // has show: false from an engine default (not a deliberate user toggle), restore it.
+                    // Heuristic: if the hero has no custom slider content (only defaults or empty), the
+                    // show: false was never explicitly set by the user — it's stale initialization data.
+                    if (mergedHero.show === false && requirementSection.show === true) {
+                        const hasCustomSliderContent = Array.isArray(actualSection.sliders) &&
+                            actualSection.sliders.length > 0 &&
+                            actualSection.sliders.some((s) => (s.title && s.title.trim()) || (s.subtitle && s.subtitle.trim()) || s.backgroundImage || s.image);
+                        if (!hasCustomSliderContent) {
+                            mergedHero.show = true;
+                        }
+                    }
+                    mergedPageData[sectionKey] = mergedHero;
+                }
+                else if (sectionKey === 'testimonials' &&
+                    typeof requirementSection === 'object' &&
+                    typeof actualSection === 'object' &&
+                    !Array.isArray(requirementSection) &&
+                    !Array.isArray(actualSection)) {
+                    mergedPageData[sectionKey] = mergeTestimonialsSectionWithDefaults(actualSection, requirementSection);
+                }
+                else if (sectionKey === 'values' &&
+                    typeof requirementSection === 'object' &&
+                    typeof actualSection === 'object' &&
+                    !Array.isArray(requirementSection) &&
+                    !Array.isArray(actualSection)) {
+                    mergedPageData[sectionKey] = mergeBookingAboutItemsSection(actualSection, requirementSection, BOOKING_DEFAULT_ABOUT_VALUES);
+                }
+                else if (sectionKey === 'stats' &&
+                    typeof requirementSection === 'object' &&
+                    typeof actualSection === 'object' &&
+                    !Array.isArray(requirementSection) &&
+                    !Array.isArray(actualSection)) {
+                    mergedPageData[sectionKey] = mergeBookingAboutItemsSection(actualSection, requirementSection, BOOKING_DEFAULT_ABOUT_STATS);
+                }
+                else if (sectionKey === 'footer' &&
+                    typeof requirementSection === 'object' &&
+                    typeof actualSection === 'object' &&
+                    !Array.isArray(requirementSection) &&
+                    !Array.isArray(actualSection)) {
+                    mergedPageData[sectionKey] = mergeBookingFooterSection(actualSection, requirementSection);
+                }
+                else if (sectionKey === 'lookbook' &&
+                    typeof requirementSection === 'object' &&
+                    typeof actualSection === 'object' &&
+                    !Array.isArray(requirementSection) &&
+                    !Array.isArray(actualSection)) {
+                    mergedPageData[sectionKey] = mergeLookbookImagesWithDefaults(actualSection, requirementSection);
+                }
+                else if (Array.isArray(requirementSection) && Array.isArray(actualSection)) {
+                    // Merge arrays
+                    mergedPageData[sectionKey] = mergeArrays(requirementSection, actualSection);
+                }
+                else if (typeof requirementSection === 'object' &&
+                    requirementSection !== null &&
+                    !Array.isArray(requirementSection) &&
+                    typeof actualSection === 'object' &&
+                    actualSection !== null &&
+                    !Array.isArray(actualSection)) {
+                    // Deep merge objects
+                    mergedPageData[sectionKey] = deepMerge(requirementSection, actualSection);
+                }
+                else {
+                    // Use actual value
+                    mergedPageData[sectionKey] = actualSection;
+                }
+            }
+            // If no actual section, keep requirement default
+        }
+        // Also add any sections from actual data that don't exist in requirement
+        // This ensures we don't lose any sections that exist in the store but not in requirement
+        for (const sectionKey in actualPageData) {
+            if (!mergedPageData[sectionKey] && actualPageData[sectionKey]) {
+                // Section exists in actual data but not in requirement - add it
+                mergedPageData[sectionKey] = actualPageData[sectionKey];
+            }
+        }
+    }
+    else {
+        // AI Precedence mode: requirementPage.data (AI data) already contains the updates.
+        // We just want to make sure we don't lose sections that WEREN'T updated by AI
+        // but exist in actualPageData.
+        for (const sectionKey in actualPageData) {
+            if (mergedPageData[sectionKey] === undefined && actualPageData[sectionKey]) {
+                mergedPageData[sectionKey] = actualPageData[sectionKey];
+            }
+        }
+    }
+    const pageDataWithBlocks = ensureClothingMinimalHomeBlocksInPageData(requirement.layoutId, pageId, mergedPageData);
+    // Create merged page - preserve schema from requirement
+    const mergedPage = {
+        ...requirementPage,
+        data: pageDataWithBlocks,
+        // CRITICAL: Preserve the _schema from requirement - don't overwrite it!
+        _schema: requirementPage._schema,
+        // Mark persisted data as hydrated so block applications use `_sourcePath`
+        // and do not rely solely on slimmed `section:*` entries.
+        _hydrated: shouldMarkHydrated,
+    };
+    // Create merged layout JSON
+    const mergedLayout = {
+        ...requirement,
+        pages: requirement.pages.map(p => (p.id === pageId ? mergedPage : p)),
+    };
+    return mergedLayout;
+}
+/**
+ * Merge every page in a requirement with StoreConfig so the overlay reflects
+ * persisted content for all pages — not just the active editor page.
+ */
+export function mergeRequirementAllPagesWithActualData(requirement, storeConfig, options = { actualDataPrecedence: true }) {
+    let overlay = requirement;
+    for (const page of requirement.pages) {
+        overlay = mergeRequirementWithActualData(overlay, storeConfig, page.id, options);
+    }
+    return overlay;
+}
+/**
+ * Merge ALL pages in a requirement with actual data from StoreConfig
+ * This ensures the StoreConfig is fully populated with defaults for all pages
+ */
+export function mergeAllPagesWithActualData(requirement, storeConfig, options = { actualDataPrecedence: true }) {
+    let currentStoreConfig = { ...storeConfig };
+    // Iterate through all pages in the requirement and merge them one by one
+    // transformToStoreConfig handles the projection back to StoreConfig
+    requirement.pages.forEach(page => {
+        const mergedLayout = mergeRequirementWithActualData(requirement, currentStoreConfig, page.id, options);
+        currentStoreConfig = transformToStoreConfig(mergedLayout, page.id, currentStoreConfig);
+    });
+    return currentStoreConfig;
+}