@admin-layout/client 11.0.2-alpha.0 → 12.0.16-alpha.0

package/lib/utils/assignDefaults.js

@@ -0,0 +1,166 @@
+/**
+ * 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

@@ -0,0 +1 @@
+{"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

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

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

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"generateMenuLink.d.ts","sourceRoot":"","sources":["../../src/utils/generateMenuLink.ts"],"names":[],"mappings":"AAwEA,eAAO,MAAM,gBAAgB,oCAa5B,CAAC"}
+{"version":3,"file":"generateMenuLink.d.ts","sourceRoot":"","sources":["../../src/utils/generateMenuLink.ts"],"names":[],"mappings":"AAwEA,eAAO,MAAM,gBAAgB,GAAI,SAAI,EAAE,WAAM,WA2B5C,CAAC"}

package/lib/utils/generateMenuLink.js

@@ -67,12 +67,24 @@ function generatePath(originalPath, params) {
     return prefix + segments.join('/');
 }
 const generateMenuPath = (path, params) => {
+    // Check if all required parameters exist before attempting to generate the path
+    const requiredParams = [];
+    path.split('/').forEach((segment) => {
+        if (segment.startsWith(':') && !segment.endsWith('?')) {
+            const paramName = segment.substring(1);
+            requiredParams.push(paramName);
+        }
+    });
+    // If any required parameter is missing, return null immediately
+    const missingParams = requiredParams.filter((param) => params[param] === undefined);
+    if (missingParams.length > 0) {
+        return null;
+    }
     try {
         const generatedPath = generatePath(path, params);
         return generatedPath;
     }
     catch (err) {
-        console.error('Error generating path:', err);
         console.log('Path:', path);
         console.log('Params:', params);
         console.warn(`menu path ${path} is errored due to missing params. If it is not required, please use hidemenu option`);

package/lib/utils/generateMenuLink.js.map

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

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

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

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

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

package/lib/utils/index.d.ts

@@ -3,6 +3,6 @@ export * from './componentSize';
 export * from './parentRoute';
 export * from './menuUtils';
 export * from './matchMenuKeys';
-export * from './getAntdLocale';
 export * from './generateMenuLink';
+export * from './settingsDifference';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,iBAAiB,CAAC;AAChC,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC;AAC5B,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,oBAAoB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,iBAAiB,CAAC;AAChC,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC;AAC5B,cAAc,iBAAiB,CAAC;AAChC,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"matchMenuKeys.d.ts","sourceRoot":"","sources":["../../src/utils/matchMenuKeys.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAE7C;;;;;;;GAOG;AAEH,eAAO,MAAM,gBAAgB,cAAe,YAAY,EAAE,eAAe,MAAM,KAAG,MAAM,EA2CvF,CAAC"}
+{"version":3,"file":"matchMenuKeys.d.ts","sourceRoot":"","sources":["../../src/utils/matchMenuKeys.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAE7C;;;;;;;GAOG;AAEH,eAAO,MAAM,gBAAgB,GAAI,WAAW,YAAY,EAAE,EAAE,aAAa,MAAM,KAAG,MAAM,EA2CvF,CAAC"}

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,IAAO,MAAA,SAAA,GAAsB,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,SAAa,GAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/lib/utils/menuUtils.d.ts

@@ -1,4 +1,4 @@
-import { IMenuDataItem } from '@common-stack/client-react/lib/interfaces/menu';
+import { type IMenuData } from '@common-stack/client-react/lib/interfaces/menu';
 /**
  * Custom menuDataRender function which will be called on component render
  * to filter out menus from props.menuData on the basis of authorities.
@@ -9,7 +9,7 @@ import { IMenuDataItem } from '@common-stack/client-react/lib/interfaces/menu';
  * @param menuList
  * @param authorities
  */
-export declare const menuDataRender: (menuList: IMenuDataItem[], authorities: any) => IMenuDataItem[];
+export declare const menuDataRender: (menuList: IMenuData[], authorities: any) => IMenuData[];
 export declare function transformData(data: any): any;
 export declare function setLocale(obj: any, parentName?: string): void;
 export declare const addProLayoutParentKeys: (menuData?: any[], parentKeys?: string[]) => any[];

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

@@ -1 +1 @@
-{"version":3,"file":"menuUtils.d.ts","sourceRoot":"","sources":["../../src/utils/menuUtils.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,aAAa,EAAE,MAAM,gDAAgD,CAAC;AAC/E;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc,aAAc,aAAa,EAAE,uBAAgB,aAAa,EAqBpF,CAAC;AAMF,wBAAgB,aAAa,CAAC,IAAI,KAAA,OAcjC;AACD,wBAAgB,SAAS,CAAC,GAAG,KAAA,EAAE,UAAU,SAAK,QAO7C;AAED,eAAO,MAAM,sBAAsB,cAAe,GAAG,EAAE,eAAc,MAAM,EAAE,UAS5E,CAAC;AAEF,eAAO,MAAM,sBAAsB,sBAalC,CAAC;AAEF;;;GAGG;AACH,wBAAgB,2BAA2B,CAAC,GAAG,KAAA,QAY9C"}
+{"version":3,"file":"menuUtils.d.ts","sourceRoot":"","sources":["../../src/utils/menuUtils.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,gDAAgD,CAAC;AAChF;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc,GAAI,UAAU,SAAS,EAAE,EAAE,gBAAW,KAAG,SAAS,EAqB5E,CAAC;AAMF,wBAAgB,aAAa,CAAC,IAAI,KAAA,OAcjC;AACD,wBAAgB,SAAS,CAAC,GAAG,KAAA,EAAE,UAAU,SAAK,QAO7C;AAED,eAAO,MAAM,sBAAsB,GAAI,WAAW,GAAG,EAAE,EAAE,aAAY,MAAM,EAAO,UASjF,CAAC;AAEF,eAAO,MAAM,sBAAsB,GAAI,WAAM,QAa5C,CAAC;AAEF;;;GAGG;AACH,wBAAgB,2BAA2B,CAAC,GAAG,KAAA,QAY9C"}

package/lib/utils/menuUtils.js

@@ -1,4 +1,4 @@
-import {get,sortBy,cloneDeep}from'lodash-es';import {PermissionType}from'common';import {logger}from'@cdm-logger/client';/**
+import {get,cloneDeep,sortBy}from'lodash-es';import {PermissionType}from'common';import {logger}from'@cdm-logger/client';/**
  * Custom menuDataRender function which will be called on component render
  * to filter out menus from props.menuData on the basis of authorities.
  *

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,IAAO,MAAA,cAA4B,GAAA,mBAAA,CAAA,QAAA,CAAA;AAenC,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,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"parentRoute.d.ts","sourceRoot":"","sources":["../../src/utils/parentRoute.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,gBAAgB,4CAwB5B,CAAC"}
+{"version":3,"file":"parentRoute.d.ts","sourceRoot":"","sources":["../../src/utils/parentRoute.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,gBAAgB,GAAa,cAAS,EAAE,iBAAY,QAwBhE,CAAC"}

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

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

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

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

package/lib/utils/settingsDifference.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Compares settings objects and saves only the differences
+ */
+export declare const compareAndSaveSettingsDifferences: (currentSettings: any, defaultSettings: any) => any;
+//# sourceMappingURL=settingsDifference.d.ts.map

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

@@ -0,0 +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"}

package/lib/utils/settingsDifference.js

@@ -0,0 +1,207 @@
+import {cloneDeep,get,isObject,isEqual,transform}from'lodash-es';/**
+ * Gets the deep differences between two objects
+ * Returns only the values that differ from obj2
+ */
+const getDifference = (obj1, obj2) => {
+    // Create copies to avoid modifying the original objects
+    const source = cloneDeep(obj1);
+    const target = cloneDeep(obj2);
+    // If obj1 is undefined or null, return undefined to avoid adding to result
+    if (source === undefined || source === null) {
+        // Only include null/undefined if they differ from obj2
+        return source !== target ? source : undefined;
+    }
+    // If we're comparing different types, or if obj2 is null/undefined, return obj1
+    if (typeof source !== typeof target || target === undefined || target === null) {
+        return source;
+    }
+    // Handle non-object comparisons (primitives, functions, etc.)
+    if (!isObject(source) || !isObject(target)) {
+        // Case-insensitive string comparison
+        if (typeof source === 'string' && typeof target === 'string') {
+            return source.toLowerCase() !== target.toLowerCase() ? source : undefined;
+        }
+        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;
+    }
+    // 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
+        if (key in target && isEqual(value, target[key])) {
+            return;
+        }
+        // If the key doesn't exist in target, add it to the result
+        if (!(key in target)) {
+            result[key] = value;
+            return;
+        }
+        // For nested objects, recursively get differences
+        if (isObject(value) && isObject(target[key])) {
+            const nestedDiff = getDifference(value, target[key]);
+            if (nestedDiff !== undefined && (Array.isArray(nestedDiff) || Object.keys(nestedDiff).length > 0)) {
+                result[key] = nestedDiff;
+            }
+            return;
+        }
+        // For non-objects (primitives, etc.), only add if different
+        if (!isEqual(value, target[key])) {
+            result[key] = value;
+        }
+    });
+    // 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
+ */
+const compareAndSaveSettingsDifferences = (currentSettings, defaultSettings) => {
+    try {
+        if (!currentSettings || !defaultSettings) {
+            console.warn('Missing settings objects for comparison');
+            return null;
+        }
+        // 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 {};
+        }
+        // Remove empty objects from the diff
+        // This helps prevent unnecessary properties in the payload
+        const cleanDiffSettings = removeEmptyObjects(diffSettings);
+        return cleanDiffSettings;
+    }
+    catch (error) {
+        console.error('Error comparing settings differences:', error);
+        return null;
+    }
+};
+/**
+ * Recursively removes empty objects from an object
+ * This helps clean up the diff payload
+ */
+function removeEmptyObjects(obj) {
+    if (!isObject(obj) || Array.isArray(obj)) {
+        return obj;
+    }
+    const result = {};
+    let hasKeys = false;
+    Object.keys(obj).forEach((key) => {
+        const value = obj[key];
+        if (isObject(value) && !Array.isArray(value)) {
+            const cleanValue = removeEmptyObjects(value);
+            if (Object.keys(cleanValue).length > 0) {
+                result[key] = cleanValue;
+                hasKeys = true;
+            }
+        }
+        else if (value !== undefined) {
+            result[key] = value;
+            hasKeys = true;
+        }
+    });
+    return hasKeys ? result : {};
+}export{compareAndSaveSettingsDifferences};//# sourceMappingURL=settingsDifference.js.map

package/lib/utils/settingsDifference.js.map

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

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

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

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@admin-layout/client",
-    "version": "11.0.2-alpha.0",
+    "version": "12.0.16-alpha.0",
     "description": "Sample client for higher packages to depend on",
     "license": "ISC",
     "author": "CDMBase LLC",
@@ -19,11 +19,12 @@
         "test": "cross-env ENV_FILE=../../config/test/test.env jest",
         "test:debug": "npm test -- --runInBand",
         "test:watch": "npm test -- --watch",
+        "vitest": "cross-env ENV_FILE=../../config/test/test.env vitest",
         "watch": "yarn build:lib:watch"
     },
     "dependencies": {
-        "@common-stack/client-core": "7.0.2-alpha.1",
-        "common": "11.0.2-alpha.0",
+        "@common-stack/client-core": "7.1.1-alpha.32",
+        "common": "10.1.1-alpha.28",
         "serialize-error": "^8.0.0"
     },
     "peerDependencies": {
@@ -39,5 +40,5 @@
     "typescript": {
         "definition": "lib/index.d.ts"
     },
-    "gitHead": "f00268ad48da5c2f63088282a3061e00e3a807d1"
+    "gitHead": "13b6399435ba738671b6feea9adf84a12c256d69"
 }