@admin-layout/client 11.0.4-alpha.4 → 11.2.1-alpha.1

package/lib/utils/settingsDifference.js

@@ -0,0 +1,148 @@
+import {cloneDeep,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.)
+    // 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
+        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;
+};
+/**
+ * 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 {};
+        }
+        // Make deep clones to avoid modifying the original objects
+        const current = cloneDeep(currentSettings);
+        const defaults = cloneDeep(defaultSettings);
+        // 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
+        const cleanDiffSettings = removeEmptyObjects(baseSettingsDiff);
+        return cleanDiffSettings;
+    }
+    catch (error) {
+        console.error('Error comparing settings differences:', error);
+        return {};
+    }
+};
+/**
+ * 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":";;AAqLG;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": "11.2.1-alpha.1",
     "description": "Sample client for higher packages to depend on",
     "license": "ISC",
     "author": "CDMBase LLC",
@@ -19,14 +19,19 @@
         "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",
         "serialize-error": "^8.0.0"
     },
+    "devDependencies": {
+        "common": "11.2.1-alpha.1",
+        "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",
@@ -39,5 +44,5 @@
     "typescript": {
         "definition": "lib/index.d.ts"
     },
-    "gitHead": "eff06b5e432bf05a97fdd61eb30af62ad219b617"
+    "gitHead": "07c2534a0ba6f7955e1a718f54aa5e26b78cbacc"
 }

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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

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

@@ -1,230 +0,0 @@
-export declare const airbnbLightTheme: {
-    algorithm: typeof import("antd/es/theme/themes/default").default;
-    token: {
-        colorPrimary: string;
-        colorBgContainer: string;
-        colorText: string;
-        colorTextSecondary: string;
-        fontFamily: string;
-        borderRadius: number;
-        colorLink: string;
-        colorLinkHover: string;
-        colorLinkActive: string;
-    };
-    components: {
-        Button: {
-            algorithm: boolean;
-            borderRadius: number;
-            controlHeight: number;
-            controlHeightLG: number;
-            controlHeightSM: number;
-            paddingContentHorizontal: number;
-        };
-        Menu: {
-            itemBg: string;
-            itemColor: string;
-            itemHoverColor: string;
-            itemSelectedColor: string;
-            itemSelectedBg: string;
-            itemHoverBg: string;
-            activeBarWidth: number;
-            activeBarHeight: number;
-            activeBarBorderWidth: number;
-            colorActiveBarColor: string;
-        };
-        Typography: {
-            fontSizeHeading1: number;
-            fontSizeHeading2: number;
-            fontSizeHeading3: number;
-            fontSizeHeading4: number;
-            fontSizeHeading5: number;
-        };
-        Form: {
-            labelColor: string;
-            colorError: string;
-            colorWarning: string;
-            colorSuccess: string;
-        };
-        Input: {
-            controlHeight: number;
-            controlHeightLG: number;
-            controlHeightSM: number;
-            paddingHorizontal: number;
-            borderRadius: number;
-        };
-    };
-    scopes: ({
-        scope: string[];
-        settings: {
-            default: {
-                background: string;
-                foreground: string;
-                border: string;
-            };
-            primary: {
-                background: string;
-                foreground: string;
-                border: string;
-            };
-            hover: {
-                background: string;
-                foreground: string;
-                border: string;
-            };
-            active: {
-                background: string;
-                foreground: string;
-                border: string;
-            };
-            disabled: {
-                background: string;
-                foreground: string;
-                border: string;
-            };
-            focus?: undefined;
-            background?: undefined;
-            item?: undefined;
-            header?: undefined;
-            row?: undefined;
-            heading?: undefined;
-            text?: undefined;
-        };
-    } | {
-        scope: string[];
-        settings: {
-            default: {
-                background: string;
-                foreground: string;
-                border: string;
-            };
-            focus: {
-                border: string;
-                boxShadow: string;
-            };
-            hover: {
-                border: string;
-                background?: undefined;
-                foreground?: undefined;
-            };
-            disabled: {
-                background: string;
-                foreground: string;
-                border: string;
-            };
-            primary?: undefined;
-            active?: undefined;
-            background?: undefined;
-            item?: undefined;
-            header?: undefined;
-            row?: undefined;
-            heading?: undefined;
-            text?: undefined;
-        };
-    } | {
-        scope: string[];
-        settings: {
-            background: string;
-            item: {
-                default: {
-                    background: string;
-                    foreground: string;
-                };
-                hover: {
-                    background: string;
-                    foreground: string;
-                };
-                active: {
-                    background: string;
-                    foreground: string;
-                };
-            };
-            default?: undefined;
-            primary?: undefined;
-            hover?: undefined;
-            active?: undefined;
-            disabled?: undefined;
-            focus?: undefined;
-            header?: undefined;
-            row?: undefined;
-            heading?: undefined;
-            text?: undefined;
-        };
-    } | {
-        scope: string[];
-        settings: {
-            header: {
-                background: string;
-                foreground: string;
-            };
-            row: {
-                odd: {
-                    background: string;
-                };
-                even: {
-                    background: string;
-                };
-                hover: {
-                    background: string;
-                };
-            };
-            default?: undefined;
-            primary?: undefined;
-            hover?: undefined;
-            active?: undefined;
-            disabled?: undefined;
-            focus?: undefined;
-            background?: undefined;
-            item?: undefined;
-            heading?: undefined;
-            text?: undefined;
-        };
-    } | {
-        scope: string[];
-        settings: {
-            heading: {
-                1: {
-                    fontSize: number;
-                    fontWeight: number;
-                };
-                2: {
-                    fontSize: number;
-                    fontWeight: number;
-                };
-                3: {
-                    fontSize: number;
-                    fontWeight: number;
-                };
-                4: {
-                    fontSize: number;
-                    fontWeight: number;
-                };
-                5: {
-                    fontSize: number;
-                    fontWeight: number;
-                };
-            };
-            text: {
-                default: {
-                    fontSize: number;
-                    fontWeight: number;
-                };
-                secondary: {
-                    fontSize: number;
-                    fontWeight: number;
-                    foreground: string;
-                };
-            };
-            default?: undefined;
-            primary?: undefined;
-            hover?: undefined;
-            active?: undefined;
-            disabled?: undefined;
-            focus?: undefined;
-            background?: undefined;
-            item?: undefined;
-            header?: undefined;
-            row?: undefined;
-        };
-    })[];
-};
-//# sourceMappingURL=airbnb-light-theme.d.ts.map

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

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