@admin-layout/client 12.0.16-alpha.7 → 12.0.16-alpha.70

package/lib/utils/generateMenuLink.js.map

@@ -1 +1 @@
-{"version":3,"file":"generateMenuLink.js","sources":["../../src/utils/generateMenuLink.ts"],"sourcesContent":[null],"names":[],"mappings":"AAwEA,SAAA,eAA6B,EAAA,OAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"generateMenuLink.js","sources":["../../src/utils/generateMenuLink.ts"],"sourcesContent":[null],"names":[],"mappings":"AAwEA,SAAA,eAAa,EAAA,OAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/lib/utils/matchMenuKeys.js.map

@@ -1 +1 @@
-{"version":3,"file":"matchMenuKeys.js","sources":["../../src/utils/matchMenuKeys.ts"],"sourcesContent":[null],"names":[],"mappings":"AAAA;AAEA;;;;;;;AAOG,MAAA,gBAAA,GAAA,CAAA,SAAA,EAAA,WAAA,KAAA;AAEH,IAAA,MAAA,SAAa,GAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"matchMenuKeys.js","sources":["../../src/utils/matchMenuKeys.ts"],"sourcesContent":[null],"names":[],"mappings":"AAAA;AAEA;;;;;;;AAOG,MAAA,gBAAA,GAAA,CAAA,SAAA,EAAA,WAAA,KAAA;AAEH,IAAA,MAAA,SAAO,GAAM,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/lib/utils/menuUtils.js.map

@@ -1 +1 @@
-{"version":3,"file":"menuUtils.js","sources":["../../src/utils/menuUtils.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;;AAaG;AACH;AA2BA;AAeA,MAAA,uCAA+B;AAS/B,IAAO,MAAA,CAAA,KAAA,CAAA,kCAA2C,CAAA;AAWlD,IAAA,MAAA,cAAa,GAAA,mBAA0B,CAAA,QAAA,CAAA;AAevC,IAAA,QAAA;;;AAGG,QAAA,MAAA,EAAA,SAAA,EAAA,GAAA,IAAA;AACH,QAAA,IAAA,KAAA,CAAA,OAA2C,CAAA,SAAA,CAAA,IAAA,SAAA,EAAA,MAAI,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"menuUtils.js","sources":["../../src/utils/menuUtils.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;;AAaG;AACH;AA2BA;AAeA,MAAA,uCAA+B;AAS/B,IAAA,MAAA,CAAA,KAAO,CAAA,kCAAgC,CAAA;AAWvC,IAAA,MAAA,cAAa,GAAA,mBAA0B,CAAA,QAAA,CAAA;AAevC,IAAA,QAAA;;;AAGG,QAAA,MAAA,EAAA,SAAA,EAAA,GAAA,IAAA;AACH,QAAA,IAAA,KAAA,CAAA,OAAgB,CAAA,SAAA,CAAA,IAAA,SAAA,EAA2B,MAAI,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/lib/utils/parseEnvUiLayoutSettings.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Parse LAYOUT_SETTINGS from config (which may be a JSON string from env variable)
+ * This is the single place where we handle the parsing logic
+ */
+export declare function parseEnvLayoutSettings(): Record<string, any>;
+//# sourceMappingURL=parseEnvUiLayoutSettings.d.ts.map

package/lib/utils/parseEnvUiLayoutSettings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseEnvUiLayoutSettings.d.ts","sourceRoot":"","sources":["../../src/utils/parseEnvUiLayoutSettings.ts"],"names":[],"mappings":"AACA;;;GAGG;AACH,wBAAgB,sBAAsB,IAAI,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAwB5D"}

package/lib/utils/parseEnvUiLayoutSettings.js

@@ -0,0 +1,27 @@
+import {config}from'../config/env-config.js';import'../config/defaultSettings.js';/**
+ * Parse LAYOUT_SETTINGS from config (which may be a JSON string from env variable)
+ * This is the single place where we handle the parsing logic
+ */
+function parseEnvLayoutSettings() {
+    try {
+        if (!config.LAYOUT_SETTINGS) {
+            return {};
+        }
+        // If it's already an object (parsed by envalid json validator), return it
+        if (typeof config.LAYOUT_SETTINGS === 'object' && !Array.isArray(config.LAYOUT_SETTINGS)) {
+            return config.LAYOUT_SETTINGS;
+        }
+        // If it's a string, parse it (this happens when envalid uses str validator)
+        if (typeof config.LAYOUT_SETTINGS === 'string') {
+            const parsed = JSON.parse(config.LAYOUT_SETTINGS);
+            return parsed || {};
+        }
+        console.warn('⚠️ config.LAYOUT_SETTINGS is unexpected type:', typeof config.LAYOUT_SETTINGS);
+        return {};
+    }
+    catch (error) {
+        console.error('❌ Error parsing LAYOUT_SETTINGS:', error);
+        console.error('❌ Value was:', config.LAYOUT_SETTINGS);
+        return {};
+    }
+}export{parseEnvLayoutSettings};//# sourceMappingURL=parseEnvUiLayoutSettings.js.map

package/lib/utils/parseEnvUiLayoutSettings.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseEnvUiLayoutSettings.js","sources":["../../src/utils/parseEnvUiLayoutSettings.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAIG;AACH;;;;;;;;;;;;;;;;;;;;;;;"}

package/lib/utils/parseEnvUiLayoutSettings.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=parseEnvUiLayoutSettings.test.d.ts.map

package/lib/utils/parseEnvUiLayoutSettings.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseEnvUiLayoutSettings.test.d.ts","sourceRoot":"","sources":["../../src/utils/parseEnvUiLayoutSettings.test.ts"],"names":[],"mappings":""}

package/lib/utils/seperatedMenus.js.map

@@ -1 +1 @@
-{"version":3,"file":"seperatedMenus.js","sources":["../../src/utils/seperatedMenus.ts"],"sourcesContent":[null],"names":[],"mappings":"AAAA;AAGY,uBAAkB,GAAG,CAAA,KAAA,KAAA;AAC7B,IAAA,IAAA,CAAA,KAAU,CAAC,OAAc,CAAA,KAAA,CAAA,EAAE;AAC3B,QAAA,OAAW,CAAC,GAAc,CAAA,kBAAG,EAAA,KAAA,CAAA;AAC7B;AACA;IACF,MAAA,UAAA,GAAA,KAAA,EAAA,MAAA,CAAA,CAAA,IAAA,KAAA,IAAA,CAAA,QAAA,KAAA,OAAA,CAAA,IAAA,EAAA;AAGF,IAAO,MAAA,WAAM,GAAiB,KAAA,EAAA,MAAA,CAAA,CAAA,IAAG,KAAO,IAAY,CAAA,QAAA,KAAO,QAAA;;;;;;;;;;;"}
+{"version":3,"file":"seperatedMenus.js","sources":["../../src/utils/seperatedMenus.ts"],"sourcesContent":[null],"names":[],"mappings":"AAAA;AAGY,uBAAkB,GAAG,CAAA,KAAA,KAAA;AAC7B,IAAA,IAAA,CAAA,KAAU,CAAC,OAAE,CAAA,KAAA,CAAY,EAAE;AAC3B,QAAA,OAAW,CAAC,GAAE,CAAA,kBAAe,EAAA,KAAA,CAAA;AAC7B,IAAA;AACA;IACF,MAAA,UAAA,GAAA,KAAA,EAAA,MAAA,CAAA,CAAA,IAAA,KAAA,IAAA,CAAA,QAAA,KAAA,OAAA,CAAA,IAAA,EAAA;AAGF,IAAA,MAAA,WAAa,GAAA,KAAA,EAAA,MAAA,CAAiB,CAAA,IAAG,KAAO,IAAA,CAAA,QAAY,KAAE,QAAK;;;;;;;;;;;"}

package/lib/utils/settingsDifference.d.ts

@@ -1,5 +1,6 @@
 /**
  * Compares settings objects and saves only the differences
+ * @returns An object containing only the differences, or an empty object on error
  */
 export declare const compareAndSaveSettingsDifferences: (currentSettings: any, defaultSettings: any) => any;
 //# sourceMappingURL=settingsDifference.d.ts.map

package/lib/utils/settingsDifference.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"settingsDifference.d.ts","sourceRoot":"","sources":["../../src/utils/settingsDifference.ts"],"names":[],"mappings":"AAuKA;;GAEG;AACH,eAAO,MAAM,iCAAiC,GAAI,iBAAiB,GAAG,EAAE,iBAAiB,GAAG,QAoD3F,CAAC"}
+{"version":3,"file":"settingsDifference.d.ts","sourceRoot":"","sources":["../../src/utils/settingsDifference.ts"],"names":[],"mappings":"AAkLA;;;GAGG;AACH,eAAO,MAAM,iCAAiC,GAAI,iBAAiB,GAAG,EAAE,iBAAiB,GAAG,QA8D3F,CAAC"}

package/lib/utils/settingsDifference.js

@@ -1,4 +1,4 @@
-import {cloneDeep,get,isObject,isEqual,transform}from'lodash-es';/**
+import {cloneDeep,isObject,isEqual,transform}from'lodash-es';/**
  * Gets the deep differences between two objects
  * Returns only the values that differ from obj2
  */
@@ -16,17 +16,26 @@ const getDifference = (obj1, obj2) => {
         return source;
     }
     // Handle non-object comparisons (primitives, functions, etc.)
-    if (!isObject(source) || !isObject(target)) {
-        // Case-insensitive string comparison
+    // IMPORTANT: Check for string BEFORE isObject check, because strings are technically objects
+    if (typeof source === 'string' || typeof target === 'string') {
         if (typeof source === 'string' && typeof target === 'string') {
+            // Case-insensitive string comparison
             return source.toLowerCase() !== target.toLowerCase() ? source : undefined;
         }
+        // If types differ, return the source value
+        return source;
+    }
+    if (!isObject(source) || !isObject(target)) {
         return !isEqual(source, target) ? source : undefined;
     }
     // For arrays, do a simple equality check and return the full array if different
     if (Array.isArray(source) && Array.isArray(target)) {
         return !isEqual(source, target) ? source : undefined;
     }
+    // Prevent string from being treated as an object with numeric keys
+    if (Array.isArray(source) !== Array.isArray(target)) {
+        return source;
+    }
     // For objects, do deep comparison
     const result = transform(source, (result, value, key) => {
         // Skip keys that are in source but have the exact same value in target
@@ -54,129 +63,61 @@ const getDifference = (obj1, obj2) => {
     // Return undefined if the resulting object is empty
     return Object.keys(result).length > 0 ? result : undefined;
 };
-/**
- * Special handler for route settings differences with improved nested comparison
- */
-const getRouteSettingsDifferences = (currentRouteSettings, defaultRouteSettings) => {
-    const differences = {};
-    // Get the default route template (typically from '/')
-    const defaultRouteTemplate = defaultRouteSettings['/'] || Object.values(defaultRouteSettings)[0];
-    if (!defaultRouteTemplate) {
-        console.warn('No default route template found for comparison');
-        return currentRouteSettings;
-    }
-    // Compare each route's settings
-    Object.keys(currentRouteSettings).forEach((route) => {
-        const currentRouteConfig = currentRouteSettings[route];
-        // Use the specific route config if it exists, otherwise use the default template
-        const defaultRouteConfig = defaultRouteSettings[route] || defaultRouteTemplate;
-        // Compare each section separately (layout, regions, etc)
-        const routeDiff = {};
-        Object.keys(currentRouteConfig).forEach((section) => {
-            if (section === 'layout' || section === 'regions') {
-                const sectionDiff = {};
-                // Compare desktop and mobile separately
-                ['desktop', 'mobile'].forEach((device) => {
-                    if (!currentRouteConfig[section][device]) {
-                        return;
-                    }
-                    // For regions section with header/footer/background
-                    if (section === 'regions') {
-                        const regionsDiff = {};
-                        ['header', 'footer', 'background'].forEach((region) => {
-                            if (!currentRouteConfig[section][device][region]) {
-                                return;
-                            }
-                            // Get default path for comparison
-                            const defaultRegionPath = `${section}.${device}.${region}`;
-                            const defaultRegion = get(defaultRouteConfig, defaultRegionPath);
-                            if (defaultRegion) {
-                                const regionDiff = getDifference(currentRouteConfig[section][device][region], defaultRegion);
-                                if (regionDiff !== undefined &&
-                                    (Array.isArray(regionDiff) || Object.keys(regionDiff).length > 0)) {
-                                    regionsDiff[region] = regionDiff;
-                                }
-                            }
-                        });
-                        if (Object.keys(regionsDiff).length > 0) {
-                            sectionDiff[device] = regionsDiff;
-                        }
-                    }
-                    else {
-                        // For other sections (like layout)
-                        const defaultDevicePath = `${section}.${device}`;
-                        const defaultDevice = get(defaultRouteConfig, defaultDevicePath);
-                        if (defaultDevice) {
-                            const deviceDiff = getDifference(currentRouteConfig[section][device], defaultDevice);
-                            if (deviceDiff !== undefined && Object.keys(deviceDiff).length > 0) {
-                                sectionDiff[device] = deviceDiff;
-                            }
-                        }
-                    }
-                });
-                if (Object.keys(sectionDiff).length > 0) {
-                    routeDiff[section] = sectionDiff;
-                }
-            }
-            else {
-                const sectionDiff = getDifference(currentRouteConfig[section], defaultRouteConfig[section]);
-                if (sectionDiff !== undefined && Object.keys(sectionDiff).length > 0) {
-                    routeDiff[section] = sectionDiff;
-                }
-            }
-        });
-        // Only include the route if there are actual differences
-        if (Object.keys(routeDiff).length > 0) {
-            differences[route] = routeDiff;
-        }
-    });
-    return Object.keys(differences).length > 0 ? differences : undefined;
-};
 /**
  * Compares settings objects and saves only the differences
+ * @returns An object containing only the differences, or an empty object on error
  */
 const compareAndSaveSettingsDifferences = (currentSettings, defaultSettings) => {
     try {
         if (!currentSettings || !defaultSettings) {
             console.warn('Missing settings objects for comparison');
-            return null;
+            return {};
         }
         // Make deep clones to avoid modifying the original objects
         const current = cloneDeep(currentSettings);
         const defaults = cloneDeep(defaultSettings);
-        // Handle route settings separately
-        const routeSettingsDiff = current.routeSettings
-            ? getRouteSettingsDifferences(current.routeSettings, defaults?.routeSettings || {})
-            : undefined;
-        // Make a copy of settings without routeSettings to compare separately
-        const currentWithoutRoutes = { ...current };
-        const defaultWithoutRoutes = { ...defaults };
-        delete currentWithoutRoutes.routeSettings;
-        delete defaultWithoutRoutes.routeSettings;
-        // Get differences for all other settings
-        const otherSettingsDiff = getDifference(currentWithoutRoutes, defaultWithoutRoutes);
-        // Combine the differences
-        const diffSettings = {};
-        // Add other settings differences if any exist and are not empty objects
-        if (otherSettingsDiff && Object.keys(otherSettingsDiff).length > 0) {
-            Object.assign(diffSettings, otherSettingsDiff);
-        }
-        // Add route settings differences if any exist
-        if (routeSettingsDiff && Object.keys(routeSettingsDiff).length > 0) {
-            diffSettings.routeSettings = routeSettingsDiff;
-        }
-        // If there are no differences at all, return early
-        if (Object.keys(diffSettings).length === 0) {
-            return {};
-        }
+        // Extract overrides (bracket keys) from current settings
+        const overrides = {};
+        Object.keys(current).forEach((key) => {
+            if (key.startsWith('[') && key.endsWith(']')) {
+                overrides[key] = current[key];
+            }
+        });
+        // Get differences for non-override settings (base settings)
+        const currentBase = { ...current };
+        const defaultBase = { ...defaults };
+        // Remove all bracket keys from both objects
+        Object.keys(currentBase).forEach((key) => {
+            if (key.startsWith('[') && key.endsWith(']')) {
+                delete currentBase[key];
+            }
+        });
+        Object.keys(defaultBase).forEach((key) => {
+            if (key.startsWith('[') && key.endsWith(']')) {
+                delete defaultBase[key];
+            }
+        });
+        const baseSettingsDiff = getDifference(currentBase, defaultBase);
+        // Combine base settings differences with overrides
+        // const diffSettings: any = {};
+        // // Add base settings differences if any exist
+        // if (baseSettingsDiff && Object.keys(baseSettingsDiff).length > 0) {
+        //     Object.assign(diffSettings, baseSettingsDiff);
+        // }
+        // console.log('diffSettings :', diffSettings);
+        // // Add all overrides (they are always different from defaults)
+        // Object.assign(diffSettings, overrides);
+        // // If there are no differences at all, return early
+        // if (Object.keys(diffSettings).length === 0) {
+        //     return {};
+        // }
         // Remove empty objects from the diff
-        // This helps prevent unnecessary properties in the payload
-        const cleanDiffSettings = removeEmptyObjects(diffSettings);
+        const cleanDiffSettings = removeEmptyObjects(baseSettingsDiff);
         return cleanDiffSettings;
     }
     catch (error) {
         console.error('Error comparing settings differences:', error);
-        return null;
+        return {};
     }
 };
 /**

package/lib/utils/settingsDifference.js.map

@@ -1 +1 @@
-{"version":3,"file":"settingsDifference.js","sources":["../../src/utils/settingsDifference.ts"],"sourcesContent":[null],"names":[],"mappings":";AAyKG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"settingsDifference.js","sources":["../../src/utils/settingsDifference.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAqLG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@admin-layout/client",
-    "version": "12.0.16-alpha.7",
+    "version": "12.0.16-alpha.70",
     "description": "Sample client for higher packages to depend on",
     "license": "ISC",
     "author": "CDMBase LLC",
@@ -23,11 +23,15 @@
         "watch": "yarn build:lib:watch"
     },
     "dependencies": {
-        "@common-stack/client-core": "7.1.1-alpha.32",
-        "common": "12.0.16-alpha.7",
         "serialize-error": "^8.0.0"
     },
+    "devDependencies": {
+        "common": "12.0.16-alpha.70",
+        "rc-menu": "^9.16.1"
+    },
     "peerDependencies": {
+        "@adminide-stack/core": ">=12.0.4-alpha.247",
+        "@common-stack/client-core": ">=7.1.1-alpha.63",
         "envalid": "*",
         "history": "*",
         "lodash-es": "^4.17.21",
@@ -40,5 +44,5 @@
     "typescript": {
         "definition": "lib/index.d.ts"
     },
-    "gitHead": "dc4d290fb02b1a5c8512168953772c8aeeec585b"
+    "gitHead": "a086ab5ea5213416f3c5e929bd68a74f2e89979e"
 }

package/lib/components/UpdateSettings/SettingsConfigurationModel.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SettingsConfigurationModel.test.d.ts","sourceRoot":"","sources":["../../../src/components/UpdateSettings/SettingsConfigurationModel.test.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC"}

package/lib/components/__tests__/ApplicationErrorHandlerCommon.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ApplicationErrorHandlerCommon.test.d.ts","sourceRoot":"","sources":["../../../src/components/__tests__/ApplicationErrorHandlerCommon.test.tsx"],"names":[],"mappings":""}

package/lib/utils/assignDefaults.js

@@ -1,166 +0,0 @@
-/**
- * Recursively assigns default values only for non-existent keys in target object,
- * based on source object structure. Does not modify any existing values in target.
- * @param target - The target object to assign defaults to
- * @param source - The source object containing the structure and default values
- */
-function assignDefaults(target, source) {
-    // Special handling for routeSettings to ensure all routes have complete structure
-    if (source?.routeSettings && target.routeSettings) {
-        const rootRoute = source.routeSettings['/'];
-        if (rootRoute) {
-            Object.keys(target.routeSettings).forEach((route) => {
-                const currentRoute = target.routeSettings[route];
-                // Handle layout
-                if (!currentRoute.layout) {
-                    currentRoute.layout = {
-                        desktop: { ...rootRoute.layout.desktop },
-                        mobile: { ...rootRoute.layout.mobile },
-                    };
-                }
-                else {
-                    if (!currentRoute.layout.desktop) {
-                        currentRoute.layout.desktop = { ...rootRoute.layout.desktop };
-                    }
-                    else {
-                        Object.keys(rootRoute.layout.desktop).forEach((key) => {
-                            if (!(key in currentRoute.layout.desktop)) {
-                                currentRoute.layout.desktop[key] = rootRoute.layout.desktop[key];
-                            }
-                        });
-                    }
-                    if (!currentRoute.layout.mobile) {
-                        currentRoute.layout.mobile = { ...rootRoute.layout.mobile };
-                    }
-                    else {
-                        Object.keys(rootRoute.layout.mobile).forEach((key) => {
-                            if (!(key in currentRoute.layout.mobile)) {
-                                currentRoute.layout.mobile[key] = rootRoute.layout.mobile[key];
-                            }
-                        });
-                    }
-                }
-                // Handle regions
-                if (!currentRoute.regions) {
-                    currentRoute.regions = {
-                        desktop: {
-                            header: { ...rootRoute.regions.desktop.header },
-                            background: { ...rootRoute.regions.desktop.background },
-                            footer: { ...rootRoute.regions.desktop.footer },
-                        },
-                        mobile: {
-                            header: { ...rootRoute.regions.mobile.header },
-                            background: { ...rootRoute.regions.mobile.background },
-                            footer: { ...rootRoute.regions.mobile.footer },
-                        },
-                    };
-                }
-                else {
-                    // Handle desktop regions
-                    if (!currentRoute.regions.desktop) {
-                        currentRoute.regions.desktop = {
-                            header: { ...rootRoute.regions.desktop.header },
-                            background: { ...rootRoute.regions.desktop.background },
-                            footer: { ...rootRoute.regions.desktop.footer },
-                        };
-                    }
-                    else {
-                        // Handle desktop header
-                        if (!currentRoute.regions.desktop.header) {
-                            currentRoute.regions.desktop.header = { ...rootRoute.regions.desktop.header };
-                        }
-                        else {
-                            Object.keys(rootRoute.regions.desktop.header).forEach((key) => {
-                                if (!(key in currentRoute.regions.desktop.header)) {
-                                    currentRoute.regions.desktop.header[key] = rootRoute.regions.desktop.header[key];
-                                }
-                            });
-                        }
-                        // Handle desktop background
-                        if (!currentRoute.regions.desktop.background) {
-                            currentRoute.regions.desktop.background = { ...rootRoute.regions.desktop.background };
-                        }
-                        else {
-                            Object.keys(rootRoute.regions.desktop.background).forEach((key) => {
-                                if (!(key in currentRoute.regions.desktop.background)) {
-                                    currentRoute.regions.desktop.background[key] =
-                                        rootRoute.regions.desktop.background[key];
-                                }
-                            });
-                        }
-                        // Handle desktop footer
-                        if (!currentRoute.regions.desktop.footer) {
-                            currentRoute.regions.desktop.footer = { ...rootRoute.regions.desktop.footer };
-                        }
-                        else {
-                            Object.keys(rootRoute.regions.desktop.footer).forEach((key) => {
-                                if (!(key in currentRoute.regions.desktop.footer)) {
-                                    currentRoute.regions.desktop.footer[key] = rootRoute.regions.desktop.footer[key];
-                                }
-                            });
-                        }
-                    }
-                    // Handle mobile regions
-                    if (!currentRoute.regions.mobile) {
-                        currentRoute.regions.mobile = {
-                            header: { ...rootRoute.regions.mobile.header },
-                            background: { ...rootRoute.regions.mobile.background },
-                            footer: { ...rootRoute.regions.mobile.footer },
-                        };
-                    }
-                    else {
-                        // Handle mobile header
-                        if (!currentRoute.regions.mobile.header) {
-                            currentRoute.regions.mobile.header = { ...rootRoute.regions.mobile.header };
-                        }
-                        else {
-                            Object.keys(rootRoute.regions.mobile.header).forEach((key) => {
-                                if (!(key in currentRoute.regions.mobile.header)) {
-                                    currentRoute.regions.mobile.header[key] = rootRoute.regions.mobile.header[key];
-                                }
-                            });
-                        }
-                        // Handle mobile background
-                        if (!currentRoute.regions.mobile.background) {
-                            currentRoute.regions.mobile.background = { ...rootRoute.regions.mobile.background };
-                        }
-                        else {
-                            Object.keys(rootRoute.regions.mobile.background).forEach((key) => {
-                                if (!(key in currentRoute.regions.mobile.background)) {
-                                    currentRoute.regions.mobile.background[key] =
-                                        rootRoute.regions.mobile.background[key];
-                                }
-                            });
-                        }
-                        // Handle mobile footer
-                        if (!currentRoute.regions.mobile.footer) {
-                            currentRoute.regions.mobile.footer = { ...rootRoute.regions.mobile.footer };
-                        }
-                        else {
-                            Object.keys(rootRoute.regions.mobile.footer).forEach((key) => {
-                                if (!(key in currentRoute.regions.mobile.footer)) {
-                                    currentRoute.regions.mobile.footer[key] = rootRoute.regions.mobile.footer[key];
-                                }
-                            });
-                        }
-                    }
-                }
-            });
-        }
-    }
-    Object.keys(source).forEach((key) => {
-        if (!(key in target)) {
-            // Only assign default if the key doesn't exist
-            target[key] = source[key];
-        }
-        else if (typeof source[key] === 'object' &&
-            source[key] !== null &&
-            !Array.isArray(source[key]) &&
-            typeof target[key] === 'object' &&
-            target[key] !== null &&
-            !Array.isArray(target[key])) {
-            // Recursively assign for nested objects
-            assignDefaults(target[key], source[key]);
-        }
-    });
-}export{assignDefaults};//# sourceMappingURL=assignDefaults.js.map

package/lib/utils/assignDefaults.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"assignDefaults.js","sources":["../../src/utils/assignDefaults.ts"],"sourcesContent":[null],"names":[],"mappings":"AAAA;AACI;AACH;AAED;;;;;AAKG,IAAA,IAAA,MAAA,EAAA,aAAA,IAAA,MAAA,CAAA,aAAA,EAAA;AACH,QAAgB,MAAA,SAAA,GAAA,MAAA,CAAA,aAAuB,CAAA,GAAA,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}