@vlian/framework 1.2.51 → 1.2.55

package/dist/analytics.umd.js

@@ -1,5 +1,5 @@
 /*!
- * @vlian/framework v1.2.50
+ * @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.50
+ * @vlian/framework v1.2.54
  * Secra Framework - 一个现代化的低代码框架
  * (c) 2026 Secra Framework Contributors
  * Licensed under Apache-2.0
@@ -12418,20 +12418,198 @@
     class CacheManager {
         initialize(context) {
             this.snapshot = context.config.cache;
-            storage.initialize({
+            this.cacheIn = vlianUtils.createStorage({
+                type: this.snapshot.storageOptions?.type || 'local',
                 prefix: this.snapshot.storageOptions?.prefix || 'vlian',
                 defaultExpire: this.snapshot.storageOptions?.defaultExpire || 24 * 60 * 60 * 1000,
-                tableName: this.snapshot.storageOptions?.tableName,
-                cache: {
-                    enabled: this.snapshot.enabled
-                }
+                dbName: this.snapshot.storageOptions?.tableName
             });
         }
+        get cache() {
+            return this.cacheIn;
+        }
         getSnapshot() {
             return this.snapshot;
         }
         constructor(){
             _define_property$3(this, "snapshot", DEFAULT_CONFIG.cache);
+            _define_property$3(this, "cacheIn", void 0);
+        }
+    }
+
+    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.
         }
     }
 
@@ -12448,50 +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 || {}
-            };
-            const persisted = await readPersistedValue(this.config.persistence);
-            if (persisted !== null) {
-                try {
-                    const parsed = JSON.parse(persisted);
-                    this.theme = {
-                        ...this.theme,
-                        ...parsed
-                    };
-                } catch  {
-                // ignore parse errors
-                }
-            } else {
-                await writePersistedValue(this.config.persistence, JSON.stringify(this.theme));
-            }
+            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);
@@ -12499,32 +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);
-            await writePersistedValue(this.config.persistence, JSON.stringify(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, "cacheManager", null);
+            _define_property$2(this, "initialized", false);
         }
     }
 
@@ -12798,7 +12954,8 @@
             }
             const context = {
                 instanceId: this.instanceId,
-                config: this.config
+                config: this.config,
+                cacheManager: this.cacheManager.cache
             };
             const initPromise = (async ()=>{
                 await manager.initialize(context);