@admin-layout/client 11.0.4-alpha.4 → 12.0.16-alpha.2

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.4-alpha.4",
+    "version": "12.0.16-alpha.2",
     "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": "8.0.2-alpha.0",
-        "common": "11.0.4-alpha.4",
+        "@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": "eff06b5e432bf05a97fdd61eb30af62ad219b617"
+    "gitHead": "f048296e4be0a0dc1c85237ac29b90089a933f0f"
 }

package/lib/antd-themes/ThemeProvider.d.ts

@@ -1,10 +0,0 @@
-import React from 'react';
-import { ISettings } from '../config/defaultSettings';
-interface ThemeProviderProps {
-    settings: ISettings;
-    children: React.ReactNode;
-}
-export declare const getTheme: any;
-export declare const ThemeProvider: React.FC<ThemeProviderProps>;
-export {};
-//# sourceMappingURL=ThemeProvider.d.ts.map

package/lib/antd-themes/ThemeProvider.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ThemeProvider.d.ts","sourceRoot":"","sources":["../../src/antd-themes/ThemeProvider.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAG1B,OAAO,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAEtD,UAAU,kBAAkB;IACxB,QAAQ,EAAE,SAAS,CAAC;IACpB,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;CAC7B;AAED,eAAO,MAAM,QAAQ,EAAE,GAQtB,CAAC;AAEF,eAAO,MAAM,aAAa,EAAE,KAAK,CAAC,EAAE,CAAC,kBAAkB,CAgCtD,CAAC"}

package/lib/antd-themes/ThemeProvider.js

@@ -1,34 +0,0 @@
-import {jsx}from'react/jsx-runtime';import {ConfigProvider}from'antd';import {themeRegistry}from'./themeRegistry.js';const getTheme = (themeType, themeName) => {
-    const key = `${themeName}${themeType === 'realDark' ? 'Dark' : 'Light'}Theme`;
-    if (key in themeRegistry) {
-        return themeRegistry[key];
-    }
-    else {
-        return themeRegistry?.defaultLightTheme;
-    }
-};
-const ThemeProvider = ({ settings, children }) => {
-    const { theme, themeType } = settings;
-    const selectedTheme = getTheme(themeType, theme);
-    const applyScopedStyles = (components) => {
-        selectedTheme?.scopes?.forEach((scope) => {
-            scope.scope.forEach((componentName) => {
-                if (!components[componentName]) {
-                    components[componentName] = {};
-                }
-                Object.assign(components[componentName], scope.settings);
-            });
-        });
-        return components;
-    };
-    return (jsx(ConfigProvider, { theme: {
-            algorithm: selectedTheme?.algorithm,
-            token: selectedTheme?.token,
-            components: {
-                ...applyScopedStyles(selectedTheme?.components || {}),
-                Layout: {
-                    siderBg: settings?.themeType == 'dark' ? `${settings?.siderBgColor} !important` : null,
-                },
-            },
-        }, children: children }));
-};export{ThemeProvider,getTheme};//# sourceMappingURL=ThemeProvider.js.map

package/lib/antd-themes/ThemeProvider.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ThemeProvider.js","sources":["../../src/antd-themes/ThemeProvider.tsx"],"sourcesContent":[null],"names":[],"mappings":"qHAMY,MAAA,WAAY,CAAA,SAAA,EAAA,SAAA,KAAA;AACpB,IAAA,MAAA,GAAU,GAAA,CAAA,EAAK,SAAC,CAAS,EAAC,SAAA,KAAA,UAAA,GAAA,MAAA,GAAA,OAAA,CAAA,KAAA,CAAA;AAC7B,IAAA,IAAA,GAAA,IAAA,aAAA,EAAA;AAED,QAAA,OAAO,aAAM,CAAQ,GAAE,CAAA;AAUvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/lib/antd-themes/airbnb-dark-theme.d.ts

@@ -1,2 +0,0 @@
-export declare const airbnbDarkTheme: any;
-//# sourceMappingURL=airbnb-dark-theme.d.ts.map

package/lib/antd-themes/airbnb-dark-theme.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"airbnb-dark-theme.d.ts","sourceRoot":"","sources":["../../src/antd-themes/airbnb-dark-theme.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,eAAe,EAAE,GAsK7B,CAAC"}

package/lib/antd-themes/airbnb-dark-theme.js

@@ -1,168 +0,0 @@
-import {theme}from'antd';const { defaultAlgorithm, darkAlgorithm } = theme;
-const airbnbDarkTheme = {
-    algorithm: darkAlgorithm,
-    token: {
-        colorPrimary: '#FF385C',
-        colorBgContainer: '#121212',
-        colorText: '#E0E0E0',
-        colorTextSecondary: '#A0A0A0',
-        fontFamily: 'Circular, -apple-system, BlinkMacSystemFont, Roboto, Helvetica Neue, sans-serif',
-        borderRadius: 8,
-        colorLink: '#00A699',
-        colorLinkHover: '#00C2B3',
-        colorLinkActive: '#00C2B3',
-    },
-    components: {
-        Button: {
-            // colorPrimary: '#FF385C',
-            algorithm: true,
-            borderRadius: 8,
-            controlHeight: 48,
-            controlHeightLG: 56,
-            controlHeightSM: 40,
-            paddingContentHorizontal: 24,
-        },
-        Menu: {
-            itemBg: 'transparent',
-            itemColor: '#E0E0E0',
-            itemHoverColor: '#FF385C',
-            itemSelectedColor: '#FF385C',
-            itemSelectedBg: '#2C2C2C',
-            itemHoverBg: '#2C2C2C',
-            activeBarWidth: 0,
-            activeBarHeight: 2,
-            activeBarBorderWidth: 0,
-            colorActiveBarColor: '#FF385C',
-        },
-        Typography: {
-            fontSizeHeading1: 44,
-            fontSizeHeading2: 32,
-            fontSizeHeading3: 24,
-            fontSizeHeading4: 20,
-            fontSizeHeading5: 16,
-        },
-        Form: {
-            labelColor: '#E0E0E0',
-            colorError: '#FF5A5F',
-            colorWarning: '#FFB400',
-            colorSuccess: '#00A699',
-        },
-        Input: {
-            controlHeight: 48,
-            controlHeightLG: 56,
-            controlHeightSM: 40,
-            paddingHorizontal: 16,
-            borderRadius: 8,
-        },
-    },
-    scopes: [
-        {
-            scope: ['Button'],
-            settings: {
-                default: {
-                    background: '#2C2C2C',
-                    foreground: '#E0E0E0',
-                    border: '#4A4A4A',
-                },
-                primary: {
-                    background: '#FF385C',
-                    foreground: '#FFFFFF',
-                    border: '#FF385C',
-                },
-                hover: {
-                    background: '#E31C5F',
-                    foreground: '#FFFFFF',
-                    border: '#E31C5F',
-                },
-                active: {
-                    background: '#D70466',
-                    foreground: '#FFFFFF',
-                    border: '#D70466',
-                },
-                disabled: {
-                    background: '#2C2C2C',
-                    foreground: '#6E6E6E',
-                    border: '#4A4A4A',
-                },
-            },
-        },
-        {
-            scope: ['Input'],
-            settings: {
-                default: {
-                    background: '#2C2C2C',
-                    foreground: '#E0E0E0',
-                    border: '#4A4A4A',
-                },
-                focus: {
-                    border: '#00A699',
-                    boxShadow: '0 0 0 1px #00A699',
-                },
-                hover: {
-                    border: '#A0A0A0',
-                },
-                disabled: {
-                    background: '#1E1E1E',
-                    foreground: '#6E6E6E',
-                    border: '#4A4A4A',
-                },
-            },
-        },
-        {
-            scope: ['Menu'],
-            settings: {
-                background: '#121212',
-                item: {
-                    default: {
-                        background: 'transparent',
-                        foreground: '#E0E0E0',
-                    },
-                    hover: {
-                        background: '#2C2C2C',
-                        foreground: '#E0E0E0',
-                    },
-                    active: {
-                        background: '#2C2C2C',
-                        foreground: '#FF385C',
-                    },
-                },
-            },
-        },
-        {
-            scope: ['Table'],
-            settings: {
-                header: {
-                    background: '#2C2C2C',
-                    foreground: '#E0E0E0',
-                },
-                row: {
-                    odd: {
-                        background: '#121212',
-                    },
-                    even: {
-                        background: '#1E1E1E',
-                    },
-                    hover: {
-                        background: '#2C2C2C',
-                    },
-                },
-            },
-        },
-        {
-            scope: ['Typography'],
-            settings: {
-                heading: {
-                    1: { fontSize: 32, fontWeight: 800 },
-                    2: { fontSize: 24, fontWeight: 600 },
-                    3: { fontSize: 20, fontWeight: 600 },
-                    4: { fontSize: 18, fontWeight: 600 },
-                    5: { fontSize: 16, fontWeight: 600 },
-                },
-                text: {
-                    default: { fontSize: 16, fontWeight: 400 },
-                    secondary: { fontSize: 14, fontWeight: 400, foreground: '#A0A0A0' },
-                },
-            },
-        },
-    ],
-};export{airbnbDarkTheme};//# sourceMappingURL=airbnb-dark-theme.js.map

package/lib/antd-themes/airbnb-dark-theme.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"airbnb-dark-theme.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}