@vlian/framework 1.2.54 → 1.2.55

package/dist/analytics.umd.js

@@ -1,5 +1,5 @@
 /*!
- * @vlian/framework v1.2.53
+ * @vlian/framework v1.2.54
  * Secra Framework - 一个现代化的低代码框架
  * (c) 2026 Secra Framework Contributors
  * Licensed under Apache-2.0

package/dist/index.umd.js

@@ -1,5 +1,5 @@
 /*!
- * @vlian/framework v1.2.53
+ * @vlian/framework v1.2.54
  * Secra Framework - 一个现代化的低代码框架
  * (c) 2026 Secra Framework Contributors
  * Licensed under Apache-2.0
@@ -12437,6 +12437,182 @@
         }
     }
 
+    function canUseDom() {
+        return typeof document !== 'undefined';
+    }
+    function resolveThemeMode(theme) {
+        if (theme.mode !== 'system') {
+            return theme.mode;
+        }
+        if (typeof window !== 'undefined' && window.matchMedia('(prefers-color-scheme: dark)').matches) {
+            return 'dark';
+        }
+        return 'light';
+    }
+    function applyThemeToDocument(nextTheme, prevTheme) {
+        if (!canUseDom()) {
+            return;
+        }
+        const root = document.documentElement;
+        const nextMode = resolveThemeMode(nextTheme);
+        const prevMode = prevTheme ? resolveThemeMode(prevTheme) : undefined;
+        if (!prevMode || prevMode !== nextMode) {
+            root.classList.remove('light', 'dark');
+            root.classList.add(nextMode);
+        }
+        if (!prevTheme || prevTheme.primaryColor !== nextTheme.primaryColor) {
+            if (nextTheme.primaryColor) {
+                root.style.setProperty('--app-primary-color', nextTheme.primaryColor);
+            } else {
+                root.style.removeProperty('--app-primary-color');
+            }
+        }
+        const prevTokens = prevTheme?.tokens || {};
+        const nextTokens = nextTheme.tokens || {};
+        for (const token of Object.keys(prevTokens)){
+            if (!(token in nextTokens)) {
+                root.style.removeProperty(`--${token}`);
+            }
+        }
+        for (const [token, value] of Object.entries(nextTokens)){
+            if (!prevTheme || prevTokens[token] !== value) {
+                root.style.setProperty(`--${token}`, String(value));
+            }
+        }
+    }
+
+    const VALID_THEME_MODES = new Set([
+        'light',
+        'dark',
+        'system'
+    ]);
+    const TOKEN_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_-]*$/;
+    function isPlainObject(value) {
+        return Object.prototype.toString.call(value) === '[object Object]';
+    }
+    function hasOwnProperty(value, key) {
+        return Object.prototype.hasOwnProperty.call(value, key);
+    }
+    function cloneTheme(theme) {
+        return {
+            ...theme,
+            ...theme.tokens ? {
+                tokens: {
+                    ...theme.tokens
+                }
+            } : {}
+        };
+    }
+    function sanitizeTokens(tokens) {
+        if (!isPlainObject(tokens)) {
+            return undefined;
+        }
+        const sanitizedTokens = {};
+        for (const [token, tokenValue] of Object.entries(tokens)){
+            if (!TOKEN_NAME_PATTERN.test(token)) {
+                continue;
+            }
+            if (typeof tokenValue === 'string' || typeof tokenValue === 'number') {
+                sanitizedTokens[token] = tokenValue;
+            }
+        }
+        return Object.keys(sanitizedTokens).length > 0 ? sanitizedTokens : undefined;
+    }
+    function normalizeTheme(value, fallback) {
+        const source = isPlainObject(value) ? value : {};
+        const mode = VALID_THEME_MODES.has(source.mode) ? source.mode : fallback.mode;
+        const primaryColor = typeof source.primaryColor === 'string' && source.primaryColor.trim() ? source.primaryColor : fallback.primaryColor;
+        const fallbackTokens = sanitizeTokens(fallback.tokens);
+        const incomingTokens = sanitizeTokens(source.tokens);
+        return {
+            mode,
+            ...primaryColor ? {
+                primaryColor
+            } : {},
+            ...incomingTokens || fallbackTokens ? {
+                tokens: {
+                    ...fallbackTokens || {},
+                    ...incomingTokens || {}
+                }
+            } : {}
+        };
+    }
+    function mergeTheme(current, next) {
+        const mergedTheme = {
+            mode: hasOwnProperty(next, 'mode') && VALID_THEME_MODES.has(next.mode) ? next.mode : current.mode,
+            ...hasOwnProperty(next, 'primaryColor') ? typeof next.primaryColor === 'string' && next.primaryColor.trim() ? {
+                primaryColor: next.primaryColor
+            } : {} : current.primaryColor ? {
+                primaryColor: current.primaryColor
+            } : {},
+            ...hasOwnProperty(next, 'tokens') ? sanitizeTokens(next.tokens) ? {
+                tokens: sanitizeTokens(next.tokens)
+            } : {} : current.tokens ? {
+                tokens: {
+                    ...current.tokens
+                }
+            } : {}
+        };
+        return normalizeTheme(mergedTheme, DEFAULT_EMPTY_THEME);
+    }
+    const DEFAULT_EMPTY_THEME = {
+        mode: 'light'
+    };
+    function isThemeEqual(left, right) {
+        if (left.mode !== right.mode || left.primaryColor !== right.primaryColor) {
+            return false;
+        }
+        const leftTokens = left.tokens || {};
+        const rightTokens = right.tokens || {};
+        const leftKeys = Object.keys(leftTokens);
+        const rightKeys = Object.keys(rightTokens);
+        if (leftKeys.length !== rightKeys.length) {
+            return false;
+        }
+        for (const key of leftKeys){
+            if (leftTokens[key] !== rightTokens[key]) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    const DEFAULT_THEME_CACHE_KEY = 'vlian:kernel:theme';
+    function resolvePersistenceContext(persistence) {
+        if (persistence?.enabled !== true) {
+            return null;
+        }
+        return {
+            key: persistence.key || DEFAULT_THEME_CACHE_KEY
+        };
+    }
+    async function loadThemeFromCache(cacheManager, persistence, fallback) {
+        const persistenceContext = resolvePersistenceContext(persistence);
+        const safeFallback = cloneTheme(fallback);
+        if (!persistenceContext) {
+            return safeFallback;
+        }
+        try {
+            const cached = await cacheManager.get(persistenceContext.key, {
+                defaultValue: safeFallback
+            });
+            return normalizeTheme(cached, safeFallback);
+        } catch  {
+            return safeFallback;
+        }
+    }
+    async function saveThemeToCache(cacheManager, persistence, theme) {
+        const persistenceContext = resolvePersistenceContext(persistence);
+        if (!persistenceContext) {
+            return;
+        }
+        try {
+            await cacheManager.set(persistenceContext.key, cloneTheme(theme));
+        } catch  {
+        // Ignore persistence failures and keep theme updates in memory.
+        }
+    }
+
     function _define_property$2(obj, key, value) {
         if (key in obj) {
             Object.defineProperty(obj, key, {
@@ -12450,49 +12626,20 @@
         }
         return obj;
     }
-    function applyThemeToDocument(theme) {
-        if (typeof document === 'undefined') {
-            return;
-        }
-        const root = document.documentElement;
-        root.classList.remove('light', 'dark');
-        const resolvedMode = theme.mode === 'system' ? typeof window !== 'undefined' && window.matchMedia('(prefers-color-scheme: dark)').matches ? 'dark' : 'light' : theme.mode;
-        root.classList.add(resolvedMode);
-        if (theme.primaryColor) {
-            root.style.setProperty('--app-primary-color', theme.primaryColor);
-        }
-        if (theme.tokens) {
-            Object.entries(theme.tokens).forEach(([token, tokenValue])=>{
-                root.style.setProperty(`--${token}`, String(tokenValue));
-            });
-        }
-    }
     class ThemeManager {
         async initialize(context) {
             this.config = context.config.theme;
-            this.theme = {
-                ...DEFAULT_THEME,
-                ...this.config.initial || {}
-            };
-            this.cache = context.cacheManager;
-            const { key = "vlian:kernel:theme" } = this.config.persistence || {};
-            const persisted = await this.cache.get(key, {
-                defaultValue: this.theme
-            });
-            if (persisted !== null) {
-                this.theme = {
-                    ...this.theme,
-                    ...persisted
-                };
-            } else {
-                await this.cache.set(key, persisted);
-            }
+            this.cacheManager = context.cacheManager;
+            const initialTheme = normalizeTheme(this.config.initial || {}, DEFAULT_THEME);
+            this.theme = await loadThemeFromCache(this.cacheManager, this.config.persistence, initialTheme);
             applyThemeToDocument(this.theme);
+            this.initialized = true;
         }
         getTheme() {
-            return {
-                ...this.theme
-            };
+            return cloneTheme(this.theme);
+        }
+        getSnapshot() {
+            return this.getTheme();
         }
         subscribe(listener) {
             this.listeners.add(listener);
@@ -12500,34 +12647,40 @@
                 this.listeners.delete(listener);
             };
         }
-        emit(next, prev) {
-            this.listeners.forEach((listener)=>{
-                listener({
-                    ...next
-                }, {
-                    ...prev
-                });
-            });
-        }
         async setTheme(nextTheme) {
-            const prev = this.theme;
-            this.theme = {
-                ...this.theme,
-                ...nextTheme
-            };
-            applyThemeToDocument(this.theme);
-            const { key = "vlian:kernel:theme" } = this.config.persistence || {};
-            await this.cache?.set(key, this.theme);
-            this.emit(this.theme, prev);
+            this.ensureInitialized();
+            const prevTheme = this.theme;
+            const mergedTheme = mergeTheme(prevTheme, nextTheme);
+            if (isThemeEqual(prevTheme, mergedTheme)) {
+                return;
+            }
+            this.theme = mergedTheme;
+            applyThemeToDocument(this.theme, prevTheme);
+            if (this.cacheManager) {
+                await saveThemeToCache(this.cacheManager, this.config.persistence, this.theme);
+            }
+            this.emit(this.theme, prevTheme);
         }
-        getSnapshot() {
-            return this.getTheme();
+        ensureInitialized() {
+            if (!this.initialized) {
+                throw new Error('ThemeManager must be initialized before use.');
+            }
+        }
+        emit(next, prev) {
+            for (const listener of this.listeners){
+                try {
+                    listener(cloneTheme(next), cloneTheme(prev));
+                } catch  {
+                // Keep notifying remaining listeners even if one fails.
+                }
+            }
         }
         constructor(){
-            _define_property$2(this, "theme", DEFAULT_THEME);
+            _define_property$2(this, "theme", cloneTheme(DEFAULT_THEME));
             _define_property$2(this, "config", DEFAULT_CONFIG.theme);
             _define_property$2(this, "listeners", new Set());
-            _define_property$2(this, "cache", undefined);
+            _define_property$2(this, "cacheManager", null);
+            _define_property$2(this, "initialized", false);
         }
     }