@vlian/framework 1.2.63 → 2.0.1

package/dist/kernel/custom-manager/i18n/index.d.ts

@@ -0,0 +1,7 @@
+import type { Kernel } from '../../kernel';
+import { I18nManager } from '../../manager/i18n/I18nManager';
+import type { I18nManagerConfig } from './types';
+export { I18nManager } from '../../manager/i18n/I18nManager';
+export { DEFAULT_I18N, DEFAULT_I18N_MANAGER_CONFIG, I18N_MANAGER_NAME } from './constants';
+export type { I18nManagerConfig, I18nSnapshot } from './types';
+export declare function registerI18nManager(kernel: Kernel, config?: I18nManagerConfig): Promise<I18nManager>;

package/dist/kernel/custom-manager/i18n/index.js

@@ -0,0 +1 @@
+import{I18nManager}from"../../manager/i18n/I18nManager";import{DEFAULT_I18N_MANAGER_CONFIG,I18N_MANAGER_NAME}from"./constants";export{I18nManager}from"../../manager/i18n/I18nManager";export{DEFAULT_I18N,DEFAULT_I18N_MANAGER_CONFIG,I18N_MANAGER_NAME}from"./constants";export async function registerI18nManager(kernel,config=DEFAULT_I18N_MANAGER_CONFIG){const existing=kernel.getManager(I18N_MANAGER_NAME);if(existing instanceof I18nManager){kernel.setManagerConfig(I18N_MANAGER_NAME,config);await kernel.initializeManager(I18N_MANAGER_NAME);return existing}const manager=new I18nManager;kernel.setManagerConfig(I18N_MANAGER_NAME,config);kernel.registerManager(I18N_MANAGER_NAME,manager);await kernel.initializeManager(I18N_MANAGER_NAME);return manager}

package/dist/kernel/custom-manager/i18n/types.d.ts

@@ -0,0 +1,10 @@
+import type { Resource } from 'i18next';
+import type { PersistenceOptions } from '../../types';
+export interface I18nSnapshot {
+    locale: string;
+    resources?: Resource;
+}
+export interface I18nManagerConfig {
+    initial?: I18nSnapshot;
+    persistence?: PersistenceOptions;
+}

package/dist/kernel/custom-manager/index.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:true});function _export(target,all){for(var name in all)Object.defineProperty(target,name,{enumerable:true,get:Object.getOwnPropertyDescriptor(all,name).get})}_export(exports,{get DEFAULT_I18N(){return _i18n.DEFAULT_I18N},get DEFAULT_I18N_MANAGER_CONFIG(){return _i18n.DEFAULT_I18N_MANAGER_CONFIG},get DEFAULT_THEME(){return _theme.DEFAULT_THEME},get DEFAULT_THEME_MANAGER_CONFIG(){return _theme.DEFAULT_THEME_MANAGER_CONFIG},get I18N_MANAGER_NAME(){return _i18n.I18N_MANAGER_NAME},get I18nManager(){return _i18n.I18nManager},get THEME_MANAGER_NAME(){return _theme.THEME_MANAGER_NAME},get ThemeManager(){return _theme.ThemeManager},get registerI18nManager(){return _i18n.registerI18nManager},get registerThemeManager(){return _theme.registerThemeManager}});const _theme=require("./theme");const _i18n=require("./i18n");

package/dist/kernel/custom-manager/index.d.ts

@@ -0,0 +1,4 @@
+export { ThemeManager, DEFAULT_THEME, DEFAULT_THEME_MANAGER_CONFIG, THEME_MANAGER_NAME, registerThemeManager, } from './theme';
+export { I18nManager, DEFAULT_I18N, DEFAULT_I18N_MANAGER_CONFIG, I18N_MANAGER_NAME, registerI18nManager, } from './i18n';
+export type { ResolvedThemeMode, ResolvedThemeSnapshot, ThemeManagerConfig, ThemeSnapshot } from './theme';
+export type { I18nManagerConfig, I18nSnapshot } from './i18n';

package/dist/kernel/custom-manager/index.js

@@ -0,0 +1 @@
+export{ThemeManager,DEFAULT_THEME,DEFAULT_THEME_MANAGER_CONFIG,THEME_MANAGER_NAME,registerThemeManager}from"./theme";export{I18nManager,DEFAULT_I18N,DEFAULT_I18N_MANAGER_CONFIG,I18N_MANAGER_NAME,registerI18nManager}from"./i18n";

package/dist/kernel/custom-manager/theme/constants.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:true});function _export(target,all){for(var name in all)Object.defineProperty(target,name,{enumerable:true,get:Object.getOwnPropertyDescriptor(all,name).get})}_export(exports,{get DEFAULT_THEME(){return DEFAULT_THEME},get DEFAULT_THEME_MANAGER_CONFIG(){return DEFAULT_THEME_MANAGER_CONFIG},get THEME_MANAGER_NAME(){return THEME_MANAGER_NAME}});const THEME_MANAGER_NAME="theme";const DEFAULT_THEME={mode:"light"};const DEFAULT_THEME_MANAGER_CONFIG={initial:DEFAULT_THEME,persistence:{enabled:true,storage:"localStorage",key:"vlian:kernel:theme"}};

package/dist/kernel/custom-manager/theme/constants.d.ts

@@ -0,0 +1,4 @@
+import type { ThemeManagerConfig, ThemeSnapshot } from './types';
+export declare const THEME_MANAGER_NAME = "theme";
+export declare const DEFAULT_THEME: ThemeSnapshot;
+export declare const DEFAULT_THEME_MANAGER_CONFIG: ThemeManagerConfig;

package/dist/kernel/custom-manager/theme/constants.js

@@ -0,0 +1 @@
+export const THEME_MANAGER_NAME="theme";export const DEFAULT_THEME={mode:"light"};export const DEFAULT_THEME_MANAGER_CONFIG={initial:DEFAULT_THEME,persistence:{enabled:true,storage:"localStorage",key:"vlian:kernel:theme"}};

package/dist/kernel/custom-manager/theme/index.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:true});function _export(target,all){for(var name in all)Object.defineProperty(target,name,{enumerable:true,get:Object.getOwnPropertyDescriptor(all,name).get})}_export(exports,{get DEFAULT_THEME(){return _constants.DEFAULT_THEME},get DEFAULT_THEME_MANAGER_CONFIG(){return _constants.DEFAULT_THEME_MANAGER_CONFIG},get THEME_MANAGER_NAME(){return _constants.THEME_MANAGER_NAME},get ThemeManager(){return _ThemeManager.ThemeManager},get registerThemeManager(){return registerThemeManager}});const _ThemeManager=require("../../manager/theme/ThemeManager");const _constants=require("./constants");async function registerThemeManager(kernel,config=_constants.DEFAULT_THEME_MANAGER_CONFIG){const existing=kernel.getManager(_constants.THEME_MANAGER_NAME);if(existing instanceof _ThemeManager.ThemeManager){kernel.setManagerConfig(_constants.THEME_MANAGER_NAME,config);await kernel.initializeManager(_constants.THEME_MANAGER_NAME);return existing}const manager=new _ThemeManager.ThemeManager;kernel.setManagerConfig(_constants.THEME_MANAGER_NAME,config);kernel.registerManager(_constants.THEME_MANAGER_NAME,manager);await kernel.initializeManager(_constants.THEME_MANAGER_NAME);return manager}

package/dist/kernel/custom-manager/theme/index.d.ts

@@ -0,0 +1,7 @@
+import type { Kernel } from '../../kernel';
+import { ThemeManager } from '../../manager/theme/ThemeManager';
+import type { ThemeManagerConfig } from './types';
+export { ThemeManager } from '../../manager/theme/ThemeManager';
+export { DEFAULT_THEME, DEFAULT_THEME_MANAGER_CONFIG, THEME_MANAGER_NAME } from './constants';
+export type { ResolvedThemeMode, ResolvedThemeSnapshot, ThemeManagerConfig, ThemeSnapshot } from './types';
+export declare function registerThemeManager(kernel: Kernel, config?: ThemeManagerConfig): Promise<ThemeManager>;

package/dist/kernel/custom-manager/theme/index.js

@@ -0,0 +1 @@
+import{ThemeManager}from"../../manager/theme/ThemeManager";import{DEFAULT_THEME_MANAGER_CONFIG,THEME_MANAGER_NAME}from"./constants";export{ThemeManager}from"../../manager/theme/ThemeManager";export{DEFAULT_THEME,DEFAULT_THEME_MANAGER_CONFIG,THEME_MANAGER_NAME}from"./constants";export async function registerThemeManager(kernel,config=DEFAULT_THEME_MANAGER_CONFIG){const existing=kernel.getManager(THEME_MANAGER_NAME);if(existing instanceof ThemeManager){kernel.setManagerConfig(THEME_MANAGER_NAME,config);await kernel.initializeManager(THEME_MANAGER_NAME);return existing}const manager=new ThemeManager;kernel.setManagerConfig(THEME_MANAGER_NAME,config);kernel.registerManager(THEME_MANAGER_NAME,manager);await kernel.initializeManager(THEME_MANAGER_NAME);return manager}

package/dist/kernel/custom-manager/theme/types.d.ts

@@ -0,0 +1,14 @@
+import type { PersistenceOptions } from '../../types';
+export interface ThemeSnapshot {
+    mode: 'light' | 'dark' | 'system';
+    primaryColor?: string;
+    tokens?: Record<string, string | number>;
+}
+export type ResolvedThemeMode = Exclude<ThemeSnapshot['mode'], 'system'>;
+export interface ResolvedThemeSnapshot extends ThemeSnapshot {
+    resolvedMode: ResolvedThemeMode;
+}
+export interface ThemeManagerConfig {
+    initial?: ThemeSnapshot;
+    persistence?: PersistenceOptions;
+}

package/dist/kernel/index.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:true});function _export(target,all){for(var name in all)Object.defineProperty(target,name,{enumerable:true,get:Object.getOwnPropertyDescriptor(all,name).get})}_export(exports,{get CacheManager(){return _manager.CacheManager},get I18nManager(){return _manager.I18nManager},get Kernel(){return _kernel.Kernel},get LoggerManager(){return _manager.LoggerManager},get ThemeManager(){return _manager.ThemeManager},get getKernel(){return _kernel.getKernel},get kernelStartApp(){return _kernel.kernelStartApp},get startup(){return _kernel.startup}});const _kernel=require("./kernel");const _manager=require("./manager");
+"use strict";Object.defineProperty(exports,"__esModule",{value:true});function _export(target,all){for(var name in all)Object.defineProperty(target,name,{enumerable:true,get:Object.getOwnPropertyDescriptor(all,name).get})}_export(exports,{get CacheManager(){return _manager.CacheManager},get DEFAULT_I18N(){return _custommanager.DEFAULT_I18N},get DEFAULT_I18N_MANAGER_CONFIG(){return _custommanager.DEFAULT_I18N_MANAGER_CONFIG},get DEFAULT_THEME(){return _custommanager.DEFAULT_THEME},get DEFAULT_THEME_MANAGER_CONFIG(){return _custommanager.DEFAULT_THEME_MANAGER_CONFIG},get I18N_MANAGER_NAME(){return _custommanager.I18N_MANAGER_NAME},get I18nManager(){return _custommanager.I18nManager},get Kernel(){return _kernel.Kernel},get LoggerManager(){return _manager.LoggerManager},get THEME_MANAGER_NAME(){return _custommanager.THEME_MANAGER_NAME},get ThemeManager(){return _custommanager.ThemeManager},get getKernel(){return _kernel.getKernel},get kernelStartApp(){return _kernel.kernelStartApp},get registerI18nManager(){return _custommanager.registerI18nManager},get registerThemeManager(){return _custommanager.registerThemeManager},get startup(){return _kernel.startup}});const _kernel=require("./kernel");const _manager=require("./manager");const _custommanager=require("./custom-manager");

package/dist/kernel/index.d.ts

@@ -1,3 +1,5 @@
 export { Kernel, startup, getKernel, kernelStartApp } from './kernel';
-export { LoggerManager, CacheManager, ThemeManager, I18nManager } from './manager';
-export type { KernelInstanceId, KernelStorageDriver, ThemeSnapshot, I18nSnapshot, PersistenceOptions, LoggerManagerConfig, CacheManagerConfig, ThemeManagerConfig, I18nManagerConfig, KernelConfig, KernelTimingMetric, KernelManager, KernelManagerContext, KernelRenderContext, StartupHooks, StartOptions, KernelStartOptions, } from './types';
+export { LoggerManager, CacheManager } from './manager';
+export { ThemeManager, I18nManager, THEME_MANAGER_NAME, I18N_MANAGER_NAME, DEFAULT_THEME, DEFAULT_I18N, DEFAULT_THEME_MANAGER_CONFIG, DEFAULT_I18N_MANAGER_CONFIG, registerThemeManager, registerI18nManager, } from './custom-manager';
+export type { KernelInstanceId, KernelStorageDriver, StorageOptions, PersistenceOptions, LoggerManagerConfig, CacheManagerConfig, KernelConfig, KernelTimingMetric, KernelManager, KernelManagerContext, KernelRenderContext, StartupHooks, StartOptions, KernelStartOptions, } from './types';
+export type { ResolvedThemeMode, ResolvedThemeSnapshot, ThemeSnapshot, ThemeManagerConfig, I18nSnapshot, I18nManagerConfig, } from './custom-manager';

package/dist/kernel/index.js

@@ -1 +1 @@
-export{Kernel,startup,getKernel,kernelStartApp}from"./kernel";export{LoggerManager,CacheManager,ThemeManager,I18nManager}from"./manager";
+export{Kernel,startup,getKernel,kernelStartApp}from"./kernel";export{LoggerManager,CacheManager}from"./manager";export{ThemeManager,I18nManager,THEME_MANAGER_NAME,I18N_MANAGER_NAME,DEFAULT_THEME,DEFAULT_I18N,DEFAULT_THEME_MANAGER_CONFIG,DEFAULT_I18N_MANAGER_CONFIG,registerThemeManager,registerI18nManager}from"./custom-manager";

package/dist/kernel/kernel.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:true});function _export(target,all){for(var name in all)Object.defineProperty(target,name,{enumerable:true,get:Object.getOwnPropertyDescriptor(all,name).get})}_export(exports,{get Kernel(){return Kernel},get getKernel(){return getKernel},get kernelStartApp(){return kernelStartApp},get startup(){return startup}});const _constants=require("./constants");const _loggerManager=require("./manager/loggerManager");const _cacheManager=require("./manager/cacheManager");const _themeManager=require("./manager/themeManager");const _i18nManager=require("./manager/i18nManager");function _define_property(obj,key,value){if(key in obj){Object.defineProperty(obj,key,{value:value,enumerable:true,configurable:true,writable:true})}else{obj[key]=value}return obj}function now(){return typeof performance!=="undefined"?performance.now():Date.now()}function isRecord(value){return typeof value==="object"&&value!==null}let Kernel=class Kernel{static getInstance(instanceId=_constants.DEFAULT_INSTANCE_ID){const existing=Kernel.instances.get(instanceId);if(existing){return existing}const created=new Kernel(instanceId);Kernel.instances.set(instanceId,created);return created}getId(){return this.instanceId}getConfig(){return this.config}getMetrics(){return[...this.metrics]}getLoggerManager(){return this.loggerManager}getCacheManager(){return this.cacheManager}getThemeManager(){return this.themeManager}getI18nManager(){return this.i18nManager}getManager(name){return this.managers.get(name)}registerManager(name,manager){if(this.managers.has(name)){throw new Error(`Kernel manager "${name}" 已存在`)}this.managers.set(name,manager)}async startup(options={}){if(this.started){this.logDebug("kernel.startup.skip.already-started",{instanceId:this.instanceId});return this}if(this.startupPromise){return this.startupPromise}this.startupPromise=this.bootstrap(options).finally(()=>{this.startupPromise=null});return this.startupPromise}async bootstrap(options){await this.measurePhase("startup.begin",async()=>{this.logDebug("kernel.startup.begin",{instanceId:this.instanceId})});await this.measurePhase("config.load",async()=>{this.config=await this.resolveConfig(options)});await this.measurePhase("manager.register.custom",async()=>{if(options.customManagers){Object.entries(options.customManagers).forEach(([name,manager])=>{if(!this.managers.has(name)){this.managers.set(name,manager)}})}});await this.measurePhase("manager.initialize.default",async()=>{await this.initializeManager("cache");await Promise.all([this.initializeManager("logger"),this.initializeManager("theme"),this.initializeManager("i18n")])});await this.measurePhase("manager.initialize.custom",async()=>{const customManagerNames=[...this.managers.keys()].filter(name=>name!=="logger"&&name!=="cache"&&name!=="theme"&&name!=="i18n");for(const name of customManagerNames){await this.initializeManager(name)}});await this.measurePhase("hooks.initialize",async()=>{await options.hooks?.initialize?.();await options.lifecycle?.initialization?.()});await this.measurePhase("render.custom",async()=>{if(options.render){await options.render({instanceId:this.instanceId,config:this.config})}});this.started=true;this.logDebug("kernel.startup.end",{instanceId:this.instanceId,metrics:this.metrics});return this}async resolveConfig(options){let loaded={};if(options.configLoader){const loaderResult=await options.configLoader();loaded=loaderResult||{}}const loadedThemeInitial=loaded.theme?.initial||{};const loadedI18nInitial=loaded.i18n?.initial||{};const optionTheme=options.theme||{};const optionLocale=options.locale;return{logger:{..._constants.DEFAULT_CONFIG.logger,...loaded.logger,...options.config?.logger||{},level:options.loggerLevel??options.config?.logger?.level??loaded.logger?.level},cache:{..._constants.DEFAULT_CONFIG.cache,...loaded.cache,...options.config?.cache||{},storageOptions:{..._constants.DEFAULT_CONFIG.cache.storageOptions,...loaded.cache?.storageOptions||{},...options.config?.cache?.storageOptions||{},...options.storageOptions||{}}},theme:{..._constants.DEFAULT_CONFIG.theme,...loaded.theme,...options.config?.theme||{},initial:{..._constants.DEFAULT_THEME,...loadedThemeInitial,...options.config?.theme?.initial||{},...isRecord(optionTheme)?optionTheme:{}}},i18n:{..._constants.DEFAULT_CONFIG.i18n,...loaded.i18n,...options.config?.i18n||{},initial:{..._constants.DEFAULT_I18N,...loadedI18nInitial,...options.config?.i18n?.initial||{},resources:isRecord(optionLocale)?optionLocale:loadedI18nInitial.resources??options.config?.i18n?.initial?.resources}}}}async initializeManager(name){if(this.initializedManagers.has(name)){return}const existingPromise=this.managerInitPromises.get(name);if(existingPromise){await existingPromise;return}const manager=this.managers.get(name);if(!manager){throw new Error(`Kernel manager "${name}" 不存在`)}const context={instanceId:this.instanceId,config:this.config,cacheManager:this.cacheManager.cache};const initPromise=(async()=>{await manager.initialize(context);this.initializedManagers.add(name);this.logDebug("kernel.manager.initialized",{name,instanceId:this.instanceId})})();this.managerInitPromises.set(name,initPromise);try{await initPromise}finally{this.managerInitPromises.delete(name)}}async measurePhase(phase,task){const startTime=now();this.logDebug("kernel.phase.start",{phase,startTime,instanceId:this.instanceId});await task();const endTime=now();const metric={phase,startTime,endTime,duration:endTime-startTime};this.metrics.push(metric);this.logDebug("kernel.phase.end",metric)}logDebug(message,payload){this.loggerManager.debug(message,payload)}constructor(instanceId){_define_property(this,"instanceId",void 0);_define_property(this,"metrics",[]);_define_property(this,"managers",new Map);_define_property(this,"managerInitPromises",new Map);_define_property(this,"initializedManagers",new Set);_define_property(this,"loggerManager",new _loggerManager.LoggerManager);_define_property(this,"cacheManager",new _cacheManager.CacheManager);_define_property(this,"themeManager",new _themeManager.ThemeManager);_define_property(this,"i18nManager",new _i18nManager.I18nManager);_define_property(this,"config",_constants.DEFAULT_CONFIG);_define_property(this,"startupPromise",null);_define_property(this,"started",false);this.instanceId=instanceId;this.managers.set("logger",this.loggerManager);this.managers.set("cache",this.cacheManager);this.managers.set("theme",this.themeManager);this.managers.set("i18n",this.i18nManager)}};_define_property(Kernel,"instances",new Map);async function startup(options={},instanceId=_constants.DEFAULT_INSTANCE_ID){const kernel=Kernel.getInstance(instanceId);return kernel.startup(options)}function getKernel(instanceId=_constants.DEFAULT_INSTANCE_ID){return Kernel.getInstance(instanceId)}async function kernelStartApp(options={},instanceId=_constants.DEFAULT_INSTANCE_ID){return startup(options,instanceId)}
+"use strict";Object.defineProperty(exports,"__esModule",{value:true});function _export(target,all){for(var name in all)Object.defineProperty(target,name,{enumerable:true,get:Object.getOwnPropertyDescriptor(all,name).get})}_export(exports,{get Kernel(){return Kernel},get getKernel(){return getKernel},get kernelStartApp(){return kernelStartApp},get startup(){return startup}});const _constants=require("./constants");const _loggerManager=require("./manager/loggerManager");const _cacheManager=require("./manager/cacheManager");function _define_property(obj,key,value){if(key in obj){Object.defineProperty(obj,key,{value:value,enumerable:true,configurable:true,writable:true})}else{obj[key]=value}return obj}function now(){return typeof performance!=="undefined"?performance.now():Date.now()}let Kernel=class Kernel{static getInstance(instanceId=_constants.DEFAULT_INSTANCE_ID){const existing=Kernel.instances.get(instanceId);if(existing){return existing}const created=new Kernel(instanceId);Kernel.instances.set(instanceId,created);return created}getId(){return this.instanceId}getConfig(){return this.config}getMetrics(){return[...this.metrics]}getLoggerManager(){return this.loggerManager}getCacheManager(){return this.cacheManager}getManager(name){return this.managers.get(name)}registerManager(name,manager){if(this.managers.has(name)){throw new Error(`Kernel manager "${name}" 已存在`)}this.managers.set(name,manager)}getManagerConfig(name){return this.config.managerConfigs[name]}setManagerConfig(name,config){this.config={...this.config,managerConfigs:{...this.config.managerConfigs,[name]:config}}}async startup(options={}){if(this.started){this.logDebug("kernel.startup.skip.already-started",{instanceId:this.instanceId});return this}if(this.startupPromise){return this.startupPromise}this.startupPromise=this.bootstrap(options).finally(()=>{this.startupPromise=null});return this.startupPromise}async bootstrap(options){await this.measurePhase("startup.begin",async()=>{this.logDebug("kernel.startup.begin",{instanceId:this.instanceId})});await this.measurePhase("config.load",async()=>{this.config=await this.resolveConfig(options)});await this.measurePhase("manager.register.custom",async()=>{if(options.customManagers){Object.entries(options.customManagers).forEach(([name,manager])=>{if(!this.managers.has(name)){this.managers.set(name,manager)}})}});await this.measurePhase("manager.initialize.default",async()=>{await this.initializeManager("cache");await this.initializeManager("logger")});await this.measurePhase("manager.initialize.custom",async()=>{const customManagerNames=[...this.managers.keys()].filter(name=>name!=="logger"&&name!=="cache");for(const name of customManagerNames){await this.initializeManager(name)}});await this.measurePhase("hooks.initialize",async()=>{await options.hooks?.initialize?.();await options.lifecycle?.initialization?.()});await this.measurePhase("render.custom",async()=>{if(options.render){await options.render({instanceId:this.instanceId,config:this.config})}});this.started=true;this.logDebug("kernel.startup.end",{instanceId:this.instanceId,metrics:this.metrics});return this}async resolveConfig(options){let loaded={};if(options.configLoader){const loaderResult=await options.configLoader();loaded=loaderResult||{}}return{logger:{..._constants.DEFAULT_CONFIG.logger,...loaded.logger,...options.config?.logger||{},level:options.loggerLevel??options.config?.logger?.level??loaded.logger?.level},cache:{..._constants.DEFAULT_CONFIG.cache,...loaded.cache,...options.config?.cache||{},storageOptions:{..._constants.DEFAULT_CONFIG.cache.storageOptions,...loaded.cache?.storageOptions||{},...options.config?.cache?.storageOptions||{},...options.storageOptions||{}}},managerConfigs:{..._constants.DEFAULT_CONFIG.managerConfigs,...loaded.managerConfigs||{},...options.config?.managerConfigs||{},...options.managerConfigs||{}}}}async initializeManager(name){if(this.initializedManagers.has(name)){return}const existingPromise=this.managerInitPromises.get(name);if(existingPromise){await existingPromise;return}const manager=this.managers.get(name);if(!manager){throw new Error(`Kernel manager "${name}" 不存在`)}if(name!=="cache"&&!this.initializedManagers.has("cache")){await this.initializeManager("cache")}const context={instanceId:this.instanceId,config:this.config,cacheManager:this.cacheManager.cache,getManagerConfig:managerName=>this.config.managerConfigs[managerName]};const initPromise=(async()=>{await manager.initialize(context);this.initializedManagers.add(name);this.logDebug("kernel.manager.initialized",{name,instanceId:this.instanceId})})();this.managerInitPromises.set(name,initPromise);try{await initPromise}finally{this.managerInitPromises.delete(name)}}async measurePhase(phase,task){const startTime=now();this.logDebug("kernel.phase.start",{phase,startTime,instanceId:this.instanceId});await task();const endTime=now();const metric={phase,startTime,endTime,duration:endTime-startTime};this.metrics.push(metric);this.logDebug("kernel.phase.end",metric)}logDebug(message,payload){this.loggerManager.debug(message,payload)}constructor(instanceId){_define_property(this,"instanceId",void 0);_define_property(this,"metrics",[]);_define_property(this,"managers",new Map);_define_property(this,"managerInitPromises",new Map);_define_property(this,"initializedManagers",new Set);_define_property(this,"loggerManager",new _loggerManager.LoggerManager);_define_property(this,"cacheManager",new _cacheManager.CacheManager);_define_property(this,"config",_constants.DEFAULT_CONFIG);_define_property(this,"startupPromise",null);_define_property(this,"started",false);this.instanceId=instanceId;this.managers.set("logger",this.loggerManager);this.managers.set("cache",this.cacheManager)}};_define_property(Kernel,"instances",new Map);async function startup(options={},instanceId=_constants.DEFAULT_INSTANCE_ID){const kernel=Kernel.getInstance(instanceId);return kernel.startup(options)}function getKernel(instanceId=_constants.DEFAULT_INSTANCE_ID){return Kernel.getInstance(instanceId)}async function kernelStartApp(options={},instanceId=_constants.DEFAULT_INSTANCE_ID){return startup(options,instanceId)}

package/dist/kernel/kernel.d.ts

@@ -1,8 +1,6 @@
 import type { KernelConfig, KernelInstanceId, KernelManager, KernelTimingMetric, StartOptions } from './types';
 import { LoggerManager } from './manager/loggerManager';
 import { CacheManager } from './manager/cacheManager';
-import { ThemeManager } from './manager/themeManager';
-import { I18nManager } from './manager/i18nManager';
 export declare class Kernel {
     private static readonly instances;
     static getInstance(instanceId?: KernelInstanceId): Kernel;
@@ -13,8 +11,6 @@ export declare class Kernel {
     private readonly initializedManagers;
     private readonly loggerManager;
     private readonly cacheManager;
-    private readonly themeManager;
-    private readonly i18nManager;
     private config;
     private startupPromise;
     private started;
@@ -24,14 +20,14 @@ export declare class Kernel {
     getMetrics(): KernelTimingMetric[];
     getLoggerManager(): LoggerManager;
     getCacheManager(): CacheManager;
-    getThemeManager(): ThemeManager;
-    getI18nManager(): I18nManager;
     getManager(name: string): KernelManager | undefined;
     registerManager(name: string, manager: KernelManager): void;
+    getManagerConfig<TConfig = unknown>(name: string): TConfig | undefined;
+    setManagerConfig(name: string, config: unknown): void;
     startup(options?: StartOptions): Promise<Kernel>;
     private bootstrap;
     private resolveConfig;
-    private initializeManager;
+    initializeManager(name: string): Promise<void>;
     private measurePhase;
     private logDebug;
 }

package/dist/kernel/kernel.js

@@ -1 +1 @@
-function _define_property(obj,key,value){if(key in obj){Object.defineProperty(obj,key,{value:value,enumerable:true,configurable:true,writable:true})}else{obj[key]=value}return obj}import{DEFAULT_CONFIG,DEFAULT_I18N,DEFAULT_INSTANCE_ID,DEFAULT_THEME}from"./constants";import{LoggerManager}from"./manager/loggerManager";import{CacheManager}from"./manager/cacheManager";import{ThemeManager}from"./manager/themeManager";import{I18nManager}from"./manager/i18nManager";function now(){return typeof performance!=="undefined"?performance.now():Date.now()}function isRecord(value){return typeof value==="object"&&value!==null}export class Kernel{static getInstance(instanceId=DEFAULT_INSTANCE_ID){const existing=Kernel.instances.get(instanceId);if(existing){return existing}const created=new Kernel(instanceId);Kernel.instances.set(instanceId,created);return created}getId(){return this.instanceId}getConfig(){return this.config}getMetrics(){return[...this.metrics]}getLoggerManager(){return this.loggerManager}getCacheManager(){return this.cacheManager}getThemeManager(){return this.themeManager}getI18nManager(){return this.i18nManager}getManager(name){return this.managers.get(name)}registerManager(name,manager){if(this.managers.has(name)){throw new Error(`Kernel manager "${name}" 已存在`)}this.managers.set(name,manager)}async startup(options={}){if(this.started){this.logDebug("kernel.startup.skip.already-started",{instanceId:this.instanceId});return this}if(this.startupPromise){return this.startupPromise}this.startupPromise=this.bootstrap(options).finally(()=>{this.startupPromise=null});return this.startupPromise}async bootstrap(options){await this.measurePhase("startup.begin",async()=>{this.logDebug("kernel.startup.begin",{instanceId:this.instanceId})});await this.measurePhase("config.load",async()=>{this.config=await this.resolveConfig(options)});await this.measurePhase("manager.register.custom",async()=>{if(options.customManagers){Object.entries(options.customManagers).forEach(([name,manager])=>{if(!this.managers.has(name)){this.managers.set(name,manager)}})}});await this.measurePhase("manager.initialize.default",async()=>{await this.initializeManager("cache");await Promise.all([this.initializeManager("logger"),this.initializeManager("theme"),this.initializeManager("i18n")])});await this.measurePhase("manager.initialize.custom",async()=>{const customManagerNames=[...this.managers.keys()].filter(name=>name!=="logger"&&name!=="cache"&&name!=="theme"&&name!=="i18n");for(const name of customManagerNames){await this.initializeManager(name)}});await this.measurePhase("hooks.initialize",async()=>{await options.hooks?.initialize?.();await options.lifecycle?.initialization?.()});await this.measurePhase("render.custom",async()=>{if(options.render){await options.render({instanceId:this.instanceId,config:this.config})}});this.started=true;this.logDebug("kernel.startup.end",{instanceId:this.instanceId,metrics:this.metrics});return this}async resolveConfig(options){let loaded={};if(options.configLoader){const loaderResult=await options.configLoader();loaded=loaderResult||{}}const loadedThemeInitial=loaded.theme?.initial||{};const loadedI18nInitial=loaded.i18n?.initial||{};const optionTheme=options.theme||{};const optionLocale=options.locale;return{logger:{...DEFAULT_CONFIG.logger,...loaded.logger,...options.config?.logger||{},level:options.loggerLevel??options.config?.logger?.level??loaded.logger?.level},cache:{...DEFAULT_CONFIG.cache,...loaded.cache,...options.config?.cache||{},storageOptions:{...DEFAULT_CONFIG.cache.storageOptions,...loaded.cache?.storageOptions||{},...options.config?.cache?.storageOptions||{},...options.storageOptions||{}}},theme:{...DEFAULT_CONFIG.theme,...loaded.theme,...options.config?.theme||{},initial:{...DEFAULT_THEME,...loadedThemeInitial,...options.config?.theme?.initial||{},...isRecord(optionTheme)?optionTheme:{}}},i18n:{...DEFAULT_CONFIG.i18n,...loaded.i18n,...options.config?.i18n||{},initial:{...DEFAULT_I18N,...loadedI18nInitial,...options.config?.i18n?.initial||{},resources:isRecord(optionLocale)?optionLocale:loadedI18nInitial.resources??options.config?.i18n?.initial?.resources}}}}async initializeManager(name){if(this.initializedManagers.has(name)){return}const existingPromise=this.managerInitPromises.get(name);if(existingPromise){await existingPromise;return}const manager=this.managers.get(name);if(!manager){throw new Error(`Kernel manager "${name}" 不存在`)}const context={instanceId:this.instanceId,config:this.config,cacheManager:this.cacheManager.cache};const initPromise=(async()=>{await manager.initialize(context);this.initializedManagers.add(name);this.logDebug("kernel.manager.initialized",{name,instanceId:this.instanceId})})();this.managerInitPromises.set(name,initPromise);try{await initPromise}finally{this.managerInitPromises.delete(name)}}async measurePhase(phase,task){const startTime=now();this.logDebug("kernel.phase.start",{phase,startTime,instanceId:this.instanceId});await task();const endTime=now();const metric={phase,startTime,endTime,duration:endTime-startTime};this.metrics.push(metric);this.logDebug("kernel.phase.end",metric)}logDebug(message,payload){this.loggerManager.debug(message,payload)}constructor(instanceId){_define_property(this,"instanceId",void 0);_define_property(this,"metrics",[]);_define_property(this,"managers",new Map);_define_property(this,"managerInitPromises",new Map);_define_property(this,"initializedManagers",new Set);_define_property(this,"loggerManager",new LoggerManager);_define_property(this,"cacheManager",new CacheManager);_define_property(this,"themeManager",new ThemeManager);_define_property(this,"i18nManager",new I18nManager);_define_property(this,"config",DEFAULT_CONFIG);_define_property(this,"startupPromise",null);_define_property(this,"started",false);this.instanceId=instanceId;this.managers.set("logger",this.loggerManager);this.managers.set("cache",this.cacheManager);this.managers.set("theme",this.themeManager);this.managers.set("i18n",this.i18nManager)}}_define_property(Kernel,"instances",new Map);export async function startup(options={},instanceId=DEFAULT_INSTANCE_ID){const kernel=Kernel.getInstance(instanceId);return kernel.startup(options)}export function getKernel(instanceId=DEFAULT_INSTANCE_ID){return Kernel.getInstance(instanceId)}export async function kernelStartApp(options={},instanceId=DEFAULT_INSTANCE_ID){return startup(options,instanceId)}
+function _define_property(obj,key,value){if(key in obj){Object.defineProperty(obj,key,{value:value,enumerable:true,configurable:true,writable:true})}else{obj[key]=value}return obj}import{DEFAULT_CONFIG,DEFAULT_INSTANCE_ID}from"./constants";import{LoggerManager}from"./manager/loggerManager";import{CacheManager}from"./manager/cacheManager";function now(){return typeof performance!=="undefined"?performance.now():Date.now()}export class Kernel{static getInstance(instanceId=DEFAULT_INSTANCE_ID){const existing=Kernel.instances.get(instanceId);if(existing){return existing}const created=new Kernel(instanceId);Kernel.instances.set(instanceId,created);return created}getId(){return this.instanceId}getConfig(){return this.config}getMetrics(){return[...this.metrics]}getLoggerManager(){return this.loggerManager}getCacheManager(){return this.cacheManager}getManager(name){return this.managers.get(name)}registerManager(name,manager){if(this.managers.has(name)){throw new Error(`Kernel manager "${name}" 已存在`)}this.managers.set(name,manager)}getManagerConfig(name){return this.config.managerConfigs[name]}setManagerConfig(name,config){this.config={...this.config,managerConfigs:{...this.config.managerConfigs,[name]:config}}}async startup(options={}){if(this.started){this.logDebug("kernel.startup.skip.already-started",{instanceId:this.instanceId});return this}if(this.startupPromise){return this.startupPromise}this.startupPromise=this.bootstrap(options).finally(()=>{this.startupPromise=null});return this.startupPromise}async bootstrap(options){await this.measurePhase("startup.begin",async()=>{this.logDebug("kernel.startup.begin",{instanceId:this.instanceId})});await this.measurePhase("config.load",async()=>{this.config=await this.resolveConfig(options)});await this.measurePhase("manager.register.custom",async()=>{if(options.customManagers){Object.entries(options.customManagers).forEach(([name,manager])=>{if(!this.managers.has(name)){this.managers.set(name,manager)}})}});await this.measurePhase("manager.initialize.default",async()=>{await this.initializeManager("cache");await this.initializeManager("logger")});await this.measurePhase("manager.initialize.custom",async()=>{const customManagerNames=[...this.managers.keys()].filter(name=>name!=="logger"&&name!=="cache");for(const name of customManagerNames){await this.initializeManager(name)}});await this.measurePhase("hooks.initialize",async()=>{await options.hooks?.initialize?.();await options.lifecycle?.initialization?.()});await this.measurePhase("render.custom",async()=>{if(options.render){await options.render({instanceId:this.instanceId,config:this.config})}});this.started=true;this.logDebug("kernel.startup.end",{instanceId:this.instanceId,metrics:this.metrics});return this}async resolveConfig(options){let loaded={};if(options.configLoader){const loaderResult=await options.configLoader();loaded=loaderResult||{}}return{logger:{...DEFAULT_CONFIG.logger,...loaded.logger,...options.config?.logger||{},level:options.loggerLevel??options.config?.logger?.level??loaded.logger?.level},cache:{...DEFAULT_CONFIG.cache,...loaded.cache,...options.config?.cache||{},storageOptions:{...DEFAULT_CONFIG.cache.storageOptions,...loaded.cache?.storageOptions||{},...options.config?.cache?.storageOptions||{},...options.storageOptions||{}}},managerConfigs:{...DEFAULT_CONFIG.managerConfigs,...loaded.managerConfigs||{},...options.config?.managerConfigs||{},...options.managerConfigs||{}}}}async initializeManager(name){if(this.initializedManagers.has(name)){return}const existingPromise=this.managerInitPromises.get(name);if(existingPromise){await existingPromise;return}const manager=this.managers.get(name);if(!manager){throw new Error(`Kernel manager "${name}" 不存在`)}if(name!=="cache"&&!this.initializedManagers.has("cache")){await this.initializeManager("cache")}const context={instanceId:this.instanceId,config:this.config,cacheManager:this.cacheManager.cache,getManagerConfig:managerName=>this.config.managerConfigs[managerName]};const initPromise=(async()=>{await manager.initialize(context);this.initializedManagers.add(name);this.logDebug("kernel.manager.initialized",{name,instanceId:this.instanceId})})();this.managerInitPromises.set(name,initPromise);try{await initPromise}finally{this.managerInitPromises.delete(name)}}async measurePhase(phase,task){const startTime=now();this.logDebug("kernel.phase.start",{phase,startTime,instanceId:this.instanceId});await task();const endTime=now();const metric={phase,startTime,endTime,duration:endTime-startTime};this.metrics.push(metric);this.logDebug("kernel.phase.end",metric)}logDebug(message,payload){this.loggerManager.debug(message,payload)}constructor(instanceId){_define_property(this,"instanceId",void 0);_define_property(this,"metrics",[]);_define_property(this,"managers",new Map);_define_property(this,"managerInitPromises",new Map);_define_property(this,"initializedManagers",new Set);_define_property(this,"loggerManager",new LoggerManager);_define_property(this,"cacheManager",new CacheManager);_define_property(this,"config",DEFAULT_CONFIG);_define_property(this,"startupPromise",null);_define_property(this,"started",false);this.instanceId=instanceId;this.managers.set("logger",this.loggerManager);this.managers.set("cache",this.cacheManager)}}_define_property(Kernel,"instances",new Map);export async function startup(options={},instanceId=DEFAULT_INSTANCE_ID){const kernel=Kernel.getInstance(instanceId);return kernel.startup(options)}export function getKernel(instanceId=DEFAULT_INSTANCE_ID){return Kernel.getInstance(instanceId)}export async function kernelStartApp(options={},instanceId=DEFAULT_INSTANCE_ID){return startup(options,instanceId)}

package/dist/kernel/manager/i18n/I18nManager.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:true});Object.defineProperty(exports,"I18nManager",{enumerable:true,get:function(){return I18nManager}});const _library=require("../../../library");const _constants=require("../../constants");const _i18npersistence=require("./i18n.persistence");const _i18nschema=require("./i18n.schema");function _define_property(obj,key,value){if(key in obj){Object.defineProperty(obj,key,{value:value,enumerable:true,configurable:true,writable:true})}else{obj[key]=value}return obj}let I18nManager=class I18nManager{async initialize(context){this.config=context.config.i18n;this.cacheManager=context.cacheManager;const initialSnapshot=(0,_i18nschema.normalizeI18nSnapshot)(this.config.initial||{},_constants.DEFAULT_I18N);this.snapshot=await (0,_i18npersistence.loadI18nFromCache)(this.cacheManager,this.config.persistence,initialSnapshot);await (0,_library.setupI18n)({interpolation:{escapeValue:false},lng:this.snapshot.locale||"zh-CN",resources:this.snapshot.resources});await (0,_library.setLang)(this.snapshot.locale);this.initialized=true}getSnapshot(){return(0,_i18nschema.cloneI18nSnapshot)(this.snapshot)}subscribe(listener){this.listeners.add(listener);return()=>{this.listeners.delete(listener)}}async setLocale(locale){this.ensureInitialized();const prevSnapshot=this.snapshot;const nextSnapshot=(0,_i18nschema.mergeI18nSnapshot)(prevSnapshot,{locale});if((0,_i18nschema.isI18nEqual)(prevSnapshot,nextSnapshot)){return}this.snapshot=nextSnapshot;await (0,_library.setLang)(this.snapshot.locale);if(this.cacheManager){await (0,_i18npersistence.saveI18nToCache)(this.cacheManager,this.config.persistence,this.snapshot)}this.emit(this.snapshot,prevSnapshot)}ensureInitialized(){if(!this.initialized){throw new Error("I18nManager must be initialized before use.")}}emit(next,prev){for(const listener of this.listeners){try{listener((0,_i18nschema.cloneI18nSnapshot)(next),(0,_i18nschema.cloneI18nSnapshot)(prev))}catch{}}}constructor(){_define_property(this,"snapshot",(0,_i18nschema.cloneI18nSnapshot)(_constants.DEFAULT_I18N));_define_property(this,"config",_constants.DEFAULT_CONFIG.i18n);_define_property(this,"listeners",new Set);_define_property(this,"cacheManager",null);_define_property(this,"initialized",false)}};
+"use strict";Object.defineProperty(exports,"__esModule",{value:true});Object.defineProperty(exports,"I18nManager",{enumerable:true,get:function(){return I18nManager}});const _constants=require("../../custom-manager/i18n/constants");const _i18npersistence=require("./i18n.persistence");const _i18nruntime=require("./i18n.runtime");const _i18nschema=require("./i18n.schema");function _define_property(obj,key,value){if(key in obj){Object.defineProperty(obj,key,{value:value,enumerable:true,configurable:true,writable:true})}else{obj[key]=value}return obj}let I18nManager=class I18nManager{async initialize(context){this.config=context.getManagerConfig(_constants.I18N_MANAGER_NAME)||_constants.DEFAULT_I18N_MANAGER_CONFIG;this.cacheManager=context.cacheManager;const initialSnapshot=(0,_i18nschema.normalizeI18nSnapshot)(this.config.initial||{},_constants.DEFAULT_I18N);this.snapshot=await (0,_i18npersistence.loadI18nFromCache)(this.cacheManager,this.config.persistence,initialSnapshot);await (0,_i18nruntime.initializeI18nRuntime)({locale:this.snapshot.locale||"zh-CN",resources:this.snapshot.resources});this.initialized=true}getSnapshot(){return(0,_i18nschema.cloneI18nSnapshot)(this.snapshot)}subscribe(listener){this.listeners.add(listener);return()=>{this.listeners.delete(listener)}}async setLocale(locale){this.ensureInitialized();const prevSnapshot=this.snapshot;const nextSnapshot=(0,_i18nschema.mergeI18nSnapshot)(prevSnapshot,{locale});if((0,_i18nschema.isI18nEqual)(prevSnapshot,nextSnapshot)){return}this.snapshot=nextSnapshot;await (0,_i18nruntime.switchI18nLocale)(this.snapshot.locale);if(this.cacheManager){await (0,_i18npersistence.saveI18nToCache)(this.cacheManager,this.config.persistence,this.snapshot)}this.emit(this.snapshot,prevSnapshot)}ensureInitialized(){if(!this.initialized){throw new Error("I18nManager must be initialized before use.")}}emit(next,prev){for(const listener of this.listeners){try{listener((0,_i18nschema.cloneI18nSnapshot)(next),(0,_i18nschema.cloneI18nSnapshot)(prev))}catch{}}}constructor(){_define_property(this,"snapshot",(0,_i18nschema.cloneI18nSnapshot)(_constants.DEFAULT_I18N));_define_property(this,"config",_constants.DEFAULT_I18N_MANAGER_CONFIG);_define_property(this,"listeners",new Set);_define_property(this,"cacheManager",null);_define_property(this,"initialized",false)}};

package/dist/kernel/manager/i18n/I18nManager.d.ts

@@ -1,4 +1,5 @@
-import type { I18nSnapshot, KernelManager, KernelManagerContext } from '../../types';
+import type { KernelManager, KernelManagerContext } from '../../types';
+import type { I18nSnapshot } from '../../custom-manager/i18n/types';
 import { type I18nListener } from './i18n.schema';
 export declare class I18nManager implements KernelManager<I18nSnapshot> {
     private snapshot;

package/dist/kernel/manager/i18n/I18nManager.js

@@ -1 +1 @@
-function _define_property(obj,key,value){if(key in obj){Object.defineProperty(obj,key,{value:value,enumerable:true,configurable:true,writable:true})}else{obj[key]=value}return obj}import{setupI18n,setLang}from"../../../library";import{DEFAULT_CONFIG,DEFAULT_I18N}from"../../constants";import{loadI18nFromCache,saveI18nToCache}from"./i18n.persistence";import{cloneI18nSnapshot,isI18nEqual,mergeI18nSnapshot,normalizeI18nSnapshot}from"./i18n.schema";export class I18nManager{async initialize(context){this.config=context.config.i18n;this.cacheManager=context.cacheManager;const initialSnapshot=normalizeI18nSnapshot(this.config.initial||{},DEFAULT_I18N);this.snapshot=await loadI18nFromCache(this.cacheManager,this.config.persistence,initialSnapshot);await setupI18n({interpolation:{escapeValue:false},lng:this.snapshot.locale||"zh-CN",resources:this.snapshot.resources});await setLang(this.snapshot.locale);this.initialized=true}getSnapshot(){return cloneI18nSnapshot(this.snapshot)}subscribe(listener){this.listeners.add(listener);return()=>{this.listeners.delete(listener)}}async setLocale(locale){this.ensureInitialized();const prevSnapshot=this.snapshot;const nextSnapshot=mergeI18nSnapshot(prevSnapshot,{locale});if(isI18nEqual(prevSnapshot,nextSnapshot)){return}this.snapshot=nextSnapshot;await setLang(this.snapshot.locale);if(this.cacheManager){await saveI18nToCache(this.cacheManager,this.config.persistence,this.snapshot)}this.emit(this.snapshot,prevSnapshot)}ensureInitialized(){if(!this.initialized){throw new Error("I18nManager must be initialized before use.")}}emit(next,prev){for(const listener of this.listeners){try{listener(cloneI18nSnapshot(next),cloneI18nSnapshot(prev))}catch{}}}constructor(){_define_property(this,"snapshot",cloneI18nSnapshot(DEFAULT_I18N));_define_property(this,"config",DEFAULT_CONFIG.i18n);_define_property(this,"listeners",new Set);_define_property(this,"cacheManager",null);_define_property(this,"initialized",false)}}
+function _define_property(obj,key,value){if(key in obj){Object.defineProperty(obj,key,{value:value,enumerable:true,configurable:true,writable:true})}else{obj[key]=value}return obj}import{DEFAULT_I18N,DEFAULT_I18N_MANAGER_CONFIG,I18N_MANAGER_NAME}from"../../custom-manager/i18n/constants";import{loadI18nFromCache,saveI18nToCache}from"./i18n.persistence";import{initializeI18nRuntime,switchI18nLocale}from"./i18n.runtime";import{cloneI18nSnapshot,isI18nEqual,mergeI18nSnapshot,normalizeI18nSnapshot}from"./i18n.schema";export class I18nManager{async initialize(context){this.config=context.getManagerConfig(I18N_MANAGER_NAME)||DEFAULT_I18N_MANAGER_CONFIG;this.cacheManager=context.cacheManager;const initialSnapshot=normalizeI18nSnapshot(this.config.initial||{},DEFAULT_I18N);this.snapshot=await loadI18nFromCache(this.cacheManager,this.config.persistence,initialSnapshot);await initializeI18nRuntime({locale:this.snapshot.locale||"zh-CN",resources:this.snapshot.resources});this.initialized=true}getSnapshot(){return cloneI18nSnapshot(this.snapshot)}subscribe(listener){this.listeners.add(listener);return()=>{this.listeners.delete(listener)}}async setLocale(locale){this.ensureInitialized();const prevSnapshot=this.snapshot;const nextSnapshot=mergeI18nSnapshot(prevSnapshot,{locale});if(isI18nEqual(prevSnapshot,nextSnapshot)){return}this.snapshot=nextSnapshot;await switchI18nLocale(this.snapshot.locale);if(this.cacheManager){await saveI18nToCache(this.cacheManager,this.config.persistence,this.snapshot)}this.emit(this.snapshot,prevSnapshot)}ensureInitialized(){if(!this.initialized){throw new Error("I18nManager must be initialized before use.")}}emit(next,prev){for(const listener of this.listeners){try{listener(cloneI18nSnapshot(next),cloneI18nSnapshot(prev))}catch{}}}constructor(){_define_property(this,"snapshot",cloneI18nSnapshot(DEFAULT_I18N));_define_property(this,"config",DEFAULT_I18N_MANAGER_CONFIG);_define_property(this,"listeners",new Set);_define_property(this,"cacheManager",null);_define_property(this,"initialized",false)}}

package/dist/kernel/manager/i18n/i18n.persistence.d.ts

@@ -1,5 +1,6 @@
 import type { StorageInstance } from '@vlian/utils';
-import type { I18nSnapshot, PersistenceOptions } from '../../types';
+import type { PersistenceOptions } from '../../types';
+import type { I18nSnapshot } from '../../custom-manager/i18n/types';
 export declare const DEFAULT_I18N_CACHE_KEY = "vlian:kernel:i18n";
 export declare function loadI18nFromCache(cacheManager: StorageInstance, persistence: PersistenceOptions | undefined, fallback: I18nSnapshot): Promise<I18nSnapshot>;
 export declare function saveI18nToCache(cacheManager: StorageInstance, persistence: PersistenceOptions | undefined, snapshot: I18nSnapshot): Promise<void>;

package/dist/kernel/manager/i18n/i18n.runtime.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:true});function _export(target,all){for(var name in all)Object.defineProperty(target,name,{enumerable:true,get:Object.getOwnPropertyDescriptor(all,name).get})}_export(exports,{get initializeI18nRuntime(){return initializeI18nRuntime},get switchI18nLocale(){return switchI18nLocale}});const _i18next=/*#__PURE__*/_interop_require_default(require("i18next"));function _interop_require_default(obj){return obj&&obj.__esModule?obj:{default:obj}}let initPromise=null;async function initializeI18nRuntime(options){if(!initPromise){initPromise=(async()=>{await _i18next.default.init({interpolation:{escapeValue:false},lng:options.locale,resources:options.resources})})();await initPromise;return}await initPromise;if(options.resources){for(const[locale,resource]of Object.entries(options.resources)){_i18next.default.addResourceBundle(locale,"translation",resource.translation??resource,true,true)}}await _i18next.default.changeLanguage(options.locale)}async function switchI18nLocale(locale){await (initPromise??Promise.resolve());await _i18next.default.changeLanguage(locale)}

package/dist/kernel/manager/i18n/i18n.runtime.d.ts

@@ -0,0 +1,8 @@
+import { type Resource } from 'i18next';
+type I18nRuntimeOptions = {
+    locale: string;
+    resources?: Resource;
+};
+export declare function initializeI18nRuntime(options: I18nRuntimeOptions): Promise<void>;
+export declare function switchI18nLocale(locale: string): Promise<void>;
+export {};

package/dist/kernel/manager/i18n/i18n.runtime.js

@@ -0,0 +1 @@
+import i18n from"i18next";let initPromise=null;export async function initializeI18nRuntime(options){if(!initPromise){initPromise=(async()=>{await i18n.init({interpolation:{escapeValue:false},lng:options.locale,resources:options.resources})})();await initPromise;return}await initPromise;if(options.resources){for(const[locale,resource]of Object.entries(options.resources)){i18n.addResourceBundle(locale,"translation",resource.translation??resource,true,true)}}await i18n.changeLanguage(options.locale)}export async function switchI18nLocale(locale){await (initPromise??Promise.resolve());await i18n.changeLanguage(locale)}

package/dist/kernel/manager/i18n/i18n.schema.d.ts

@@ -1,4 +1,4 @@
-import type { I18nSnapshot } from '../../types';
+import type { I18nSnapshot } from '../../custom-manager/i18n/types';
 export type I18nListener = (next: I18nSnapshot, prev: I18nSnapshot) => void;
 export declare function cloneI18nSnapshot(snapshot: I18nSnapshot): I18nSnapshot;
 export declare function normalizeI18nSnapshot(value: unknown, fallback: I18nSnapshot): I18nSnapshot;

package/dist/kernel/manager/i18nManager.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:true});Object.defineProperty(exports,"I18nManager",{enumerable:true,get:function(){return _i18n.I18nManager}});const _i18n=require("./i18n");
+"use strict";Object.defineProperty(exports,"__esModule",{value:true});Object.defineProperty(exports,"I18nManager",{enumerable:true,get:function(){return _i18n.I18nManager}});const _i18n=require("../custom-manager/i18n");

package/dist/kernel/manager/i18nManager.d.ts

@@ -1 +1 @@
-export { I18nManager } from './i18n';
+export { I18nManager } from '../custom-manager/i18n';

package/dist/kernel/manager/i18nManager.js

@@ -1 +1 @@
-export{I18nManager}from"./i18n";
+export{I18nManager}from"../custom-manager/i18n";

package/dist/kernel/manager/index.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:true});function _export(target,all){for(var name in all)Object.defineProperty(target,name,{enumerable:true,get:Object.getOwnPropertyDescriptor(all,name).get})}_export(exports,{get CacheManager(){return _cacheManager.CacheManager},get I18nManager(){return _i18nManager.I18nManager},get LoggerManager(){return _loggerManager.LoggerManager},get ThemeManager(){return _themeManager.ThemeManager}});const _loggerManager=require("./loggerManager");const _cacheManager=require("./cacheManager");const _themeManager=require("./themeManager");const _i18nManager=require("./i18nManager");
+"use strict";Object.defineProperty(exports,"__esModule",{value:true});function _export(target,all){for(var name in all)Object.defineProperty(target,name,{enumerable:true,get:Object.getOwnPropertyDescriptor(all,name).get})}_export(exports,{get CacheManager(){return _cacheManager.CacheManager},get LoggerManager(){return _loggerManager.LoggerManager}});const _loggerManager=require("./loggerManager");const _cacheManager=require("./cacheManager");

package/dist/kernel/manager/index.d.ts

@@ -1,4 +1,2 @@
 export { LoggerManager } from './loggerManager';
 export { CacheManager } from './cacheManager';
-export { ThemeManager } from './themeManager';
-export { I18nManager } from './i18nManager';

package/dist/kernel/manager/index.js

@@ -1 +1 @@
-export{LoggerManager}from"./loggerManager";export{CacheManager}from"./cacheManager";export{ThemeManager}from"./themeManager";export{I18nManager}from"./i18nManager";
+export{LoggerManager}from"./loggerManager";export{CacheManager}from"./cacheManager";

package/dist/kernel/manager/theme/ThemeManager.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:true});Object.defineProperty(exports,"ThemeManager",{enumerable:true,get:function(){return ThemeManager}});const _constants=require("../../constants");const _themedom=require("./theme.dom");const _themepersistence=require("./theme.persistence");const _themeschema=require("./theme.schema");function _define_property(obj,key,value){if(key in obj){Object.defineProperty(obj,key,{value:value,enumerable:true,configurable:true,writable:true})}else{obj[key]=value}return obj}let ThemeManager=class ThemeManager{async initialize(context){this.config=context.config.theme;this.cacheManager=context.cacheManager;const initialTheme=(0,_themeschema.normalizeTheme)(this.config.initial||{},_constants.DEFAULT_THEME);this.theme=await (0,_themepersistence.loadThemeFromCache)(this.cacheManager,this.config.persistence,initialTheme);(0,_themedom.applyThemeToDocument)(this.theme);this.initialized=true}getTheme(){return(0,_themeschema.cloneTheme)(this.theme)}getSnapshot(){return this.getTheme()}subscribe(listener){this.listeners.add(listener);return()=>{this.listeners.delete(listener)}}async setTheme(nextTheme){this.ensureInitialized();const prevTheme=this.theme;const mergedTheme=(0,_themeschema.mergeTheme)(prevTheme,nextTheme);if((0,_themeschema.isThemeEqual)(prevTheme,mergedTheme)){return}this.theme=mergedTheme;(0,_themedom.applyThemeToDocument)(this.theme,prevTheme);if(this.cacheManager){await (0,_themepersistence.saveThemeToCache)(this.cacheManager,this.config.persistence,this.theme)}this.emit(this.theme,prevTheme)}ensureInitialized(){if(!this.initialized){throw new Error("ThemeManager must be initialized before use.")}}emit(next,prev){for(const listener of this.listeners){try{listener((0,_themeschema.cloneTheme)(next),(0,_themeschema.cloneTheme)(prev))}catch{}}}constructor(){_define_property(this,"theme",(0,_themeschema.cloneTheme)(_constants.DEFAULT_THEME));_define_property(this,"config",_constants.DEFAULT_CONFIG.theme);_define_property(this,"listeners",new Set);_define_property(this,"cacheManager",null);_define_property(this,"initialized",false)}};
+"use strict";Object.defineProperty(exports,"__esModule",{value:true});Object.defineProperty(exports,"ThemeManager",{enumerable:true,get:function(){return ThemeManager}});const _constants=require("../../custom-manager/theme/constants");const _themedom=require("./theme.dom");const _themepersistence=require("./theme.persistence");const _themeschema=require("./theme.schema");function _define_property(obj,key,value){if(key in obj){Object.defineProperty(obj,key,{value:value,enumerable:true,configurable:true,writable:true})}else{obj[key]=value}return obj}let ThemeManager=class ThemeManager{async initialize(context){this.config=context.getManagerConfig(_constants.THEME_MANAGER_NAME)||_constants.DEFAULT_THEME_MANAGER_CONFIG;this.cacheManager=context.cacheManager;const initialTheme=(0,_themeschema.normalizeTheme)(this.config.initial||{},_constants.DEFAULT_THEME);this.theme=await (0,_themepersistence.loadThemeFromCache)(this.cacheManager,this.config.persistence,initialTheme);this.resolvedMode=(0,_themedom.resolveThemeMode)(this.theme);(0,_themedom.applyThemeToDocument)(this.theme,{nextResolvedMode:this.resolvedMode});this.bindSystemThemeObserver();this.initialized=true}getTheme(){return(0,_themeschema.cloneTheme)(this.theme)}getSnapshot(){return this.getTheme()}getResolvedMode(){this.ensureInitialized();return this.resolvedMode}getResolvedTheme(){this.ensureInitialized();return(0,_themeschema.cloneResolvedTheme)({...this.getTheme(),resolvedMode:this.resolvedMode})}subscribe(listener){this.listeners.add(listener);return()=>{this.listeners.delete(listener)}}async setTheme(nextTheme){this.ensureInitialized();const prevTheme=this.theme;const prevResolvedMode=this.resolvedMode;const mergedTheme=(0,_themeschema.mergeTheme)(prevTheme,nextTheme);const nextResolvedMode=(0,_themedom.resolveThemeMode)(mergedTheme);if((0,_themeschema.isThemeEqual)(prevTheme,mergedTheme)&&(0,_themeschema.isResolvedThemeModeEqual)(prevResolvedMode,nextResolvedMode)){return}this.theme=mergedTheme;this.resolvedMode=nextResolvedMode;(0,_themedom.applyThemeToDocument)(this.theme,{prevTheme,prevResolvedMode,nextResolvedMode});if(this.cacheManager){await (0,_themepersistence.saveThemeToCache)(this.cacheManager,this.config.persistence,this.theme)}this.emit(this.theme,prevTheme)}ensureInitialized(){if(!this.initialized){throw new Error("ThemeManager must be initialized before use.")}}destroy(){this.stopSystemThemeObserver?.();this.stopSystemThemeObserver=null;this.listeners.clear();this.initialized=false}bindSystemThemeObserver(){this.stopSystemThemeObserver?.();this.stopSystemThemeObserver=(0,_themedom.observeSystemThemeChange)(nextResolvedMode=>{if(this.theme.mode!=="system"){return}const prevResolvedMode=this.resolvedMode;if((0,_themeschema.isResolvedThemeModeEqual)(prevResolvedMode,nextResolvedMode)){return}this.resolvedMode=nextResolvedMode;(0,_themedom.applyThemeToDocument)(this.theme,{prevTheme:this.theme,prevResolvedMode,nextResolvedMode});this.emit(this.theme,this.theme)})||null}emit(next,prev){for(const listener of this.listeners){try{listener((0,_themeschema.cloneTheme)(next),(0,_themeschema.cloneTheme)(prev))}catch{}}}constructor(){_define_property(this,"theme",(0,_themeschema.cloneTheme)(_constants.DEFAULT_THEME));_define_property(this,"resolvedMode",(0,_themedom.resolveThemeMode)(_constants.DEFAULT_THEME));_define_property(this,"config",_constants.DEFAULT_THEME_MANAGER_CONFIG);_define_property(this,"listeners",new Set);_define_property(this,"cacheManager",null);_define_property(this,"stopSystemThemeObserver",null);_define_property(this,"initialized",false)}};

package/dist/kernel/manager/theme/ThemeManager.d.ts

@@ -1,16 +1,23 @@
-import type { KernelManager, KernelManagerContext, ThemeSnapshot } from '../../types';
+import type { KernelManager, KernelManagerContext } from '../../types';
+import type { ResolvedThemeMode, ResolvedThemeSnapshot, ThemeSnapshot } from '../../custom-manager/theme/types';
 import { type ThemeListener } from './theme.schema';
 export declare class ThemeManager implements KernelManager<ThemeSnapshot> {
     private theme;
+    private resolvedMode;
     private config;
     private listeners;
     private cacheManager;
+    private stopSystemThemeObserver;
     private initialized;
     initialize(context: KernelManagerContext): Promise<void>;
     getTheme(): ThemeSnapshot;
     getSnapshot(): ThemeSnapshot;
+    getResolvedMode(): ResolvedThemeMode;
+    getResolvedTheme(): ResolvedThemeSnapshot;
     subscribe(listener: ThemeListener): () => void;
     setTheme(nextTheme: ThemeSnapshot): Promise<void>;
     private ensureInitialized;
+    destroy(): void;
+    private bindSystemThemeObserver;
     private emit;
 }

package/dist/kernel/manager/theme/ThemeManager.js

@@ -1 +1 @@
-function _define_property(obj,key,value){if(key in obj){Object.defineProperty(obj,key,{value:value,enumerable:true,configurable:true,writable:true})}else{obj[key]=value}return obj}import{DEFAULT_CONFIG,DEFAULT_THEME}from"../../constants";import{applyThemeToDocument}from"./theme.dom";import{loadThemeFromCache,saveThemeToCache}from"./theme.persistence";import{cloneTheme,isThemeEqual,mergeTheme,normalizeTheme}from"./theme.schema";export class ThemeManager{async initialize(context){this.config=context.config.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 cloneTheme(this.theme)}getSnapshot(){return this.getTheme()}subscribe(listener){this.listeners.add(listener);return()=>{this.listeners.delete(listener)}}async setTheme(nextTheme){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)}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{}}}constructor(){_define_property(this,"theme",cloneTheme(DEFAULT_THEME));_define_property(this,"config",DEFAULT_CONFIG.theme);_define_property(this,"listeners",new Set);_define_property(this,"cacheManager",null);_define_property(this,"initialized",false)}}
+function _define_property(obj,key,value){if(key in obj){Object.defineProperty(obj,key,{value:value,enumerable:true,configurable:true,writable:true})}else{obj[key]=value}return obj}import{DEFAULT_THEME,DEFAULT_THEME_MANAGER_CONFIG,THEME_MANAGER_NAME}from"../../custom-manager/theme/constants";import{applyThemeToDocument,observeSystemThemeChange,resolveThemeMode}from"./theme.dom";import{loadThemeFromCache,saveThemeToCache}from"./theme.persistence";import{cloneResolvedTheme,cloneTheme,isResolvedThemeModeEqual,isThemeEqual,mergeTheme,normalizeTheme}from"./theme.schema";export class ThemeManager{async initialize(context){this.config=context.getManagerConfig(THEME_MANAGER_NAME)||DEFAULT_THEME_MANAGER_CONFIG;this.cacheManager=context.cacheManager;const initialTheme=normalizeTheme(this.config.initial||{},DEFAULT_THEME);this.theme=await loadThemeFromCache(this.cacheManager,this.config.persistence,initialTheme);this.resolvedMode=resolveThemeMode(this.theme);applyThemeToDocument(this.theme,{nextResolvedMode:this.resolvedMode});this.bindSystemThemeObserver();this.initialized=true}getTheme(){return cloneTheme(this.theme)}getSnapshot(){return this.getTheme()}getResolvedMode(){this.ensureInitialized();return this.resolvedMode}getResolvedTheme(){this.ensureInitialized();return cloneResolvedTheme({...this.getTheme(),resolvedMode:this.resolvedMode})}subscribe(listener){this.listeners.add(listener);return()=>{this.listeners.delete(listener)}}async setTheme(nextTheme){this.ensureInitialized();const prevTheme=this.theme;const prevResolvedMode=this.resolvedMode;const mergedTheme=mergeTheme(prevTheme,nextTheme);const nextResolvedMode=resolveThemeMode(mergedTheme);if(isThemeEqual(prevTheme,mergedTheme)&&isResolvedThemeModeEqual(prevResolvedMode,nextResolvedMode)){return}this.theme=mergedTheme;this.resolvedMode=nextResolvedMode;applyThemeToDocument(this.theme,{prevTheme,prevResolvedMode,nextResolvedMode});if(this.cacheManager){await saveThemeToCache(this.cacheManager,this.config.persistence,this.theme)}this.emit(this.theme,prevTheme)}ensureInitialized(){if(!this.initialized){throw new Error("ThemeManager must be initialized before use.")}}destroy(){this.stopSystemThemeObserver?.();this.stopSystemThemeObserver=null;this.listeners.clear();this.initialized=false}bindSystemThemeObserver(){this.stopSystemThemeObserver?.();this.stopSystemThemeObserver=observeSystemThemeChange(nextResolvedMode=>{if(this.theme.mode!=="system"){return}const prevResolvedMode=this.resolvedMode;if(isResolvedThemeModeEqual(prevResolvedMode,nextResolvedMode)){return}this.resolvedMode=nextResolvedMode;applyThemeToDocument(this.theme,{prevTheme:this.theme,prevResolvedMode,nextResolvedMode});this.emit(this.theme,this.theme)})||null}emit(next,prev){for(const listener of this.listeners){try{listener(cloneTheme(next),cloneTheme(prev))}catch{}}}constructor(){_define_property(this,"theme",cloneTheme(DEFAULT_THEME));_define_property(this,"resolvedMode",resolveThemeMode(DEFAULT_THEME));_define_property(this,"config",DEFAULT_THEME_MANAGER_CONFIG);_define_property(this,"listeners",new Set);_define_property(this,"cacheManager",null);_define_property(this,"stopSystemThemeObserver",null);_define_property(this,"initialized",false)}}

package/dist/kernel/manager/theme/theme.dom.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:true});function _export(target,all){for(var name in all)Object.defineProperty(target,name,{enumerable:true,get:Object.getOwnPropertyDescriptor(all,name).get})}_export(exports,{get applyThemeToDocument(){return applyThemeToDocument},get resolveThemeMode(){return resolveThemeMode}});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))}}}
+"use strict";Object.defineProperty(exports,"__esModule",{value:true});function _export(target,all){for(var name in all)Object.defineProperty(target,name,{enumerable:true,get:Object.getOwnPropertyDescriptor(all,name).get})}_export(exports,{get applyThemeToDocument(){return applyThemeToDocument},get observeSystemThemeChange(){return observeSystemThemeChange},get resolveThemeMode(){return resolveThemeMode}});function canUseDom(){return typeof document!=="undefined"}function canUseMatchMedia(){return typeof window!=="undefined"&&typeof window.matchMedia==="function"}function resolveThemeMode(theme){if(theme.mode!=="system"){return theme.mode}if(canUseMatchMedia()&&window.matchMedia("(prefers-color-scheme: dark)").matches){return"dark"}return"light"}function applyThemeToDocument(nextTheme,options={}){if(!canUseDom()){return}const root=document.documentElement;const nextMode=options.nextResolvedMode??resolveThemeMode(nextTheme);const prevTheme=options.prevTheme;const prevMode=options.prevResolvedMode??(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))}}}function observeSystemThemeChange(listener){if(!canUseMatchMedia()){return null}const mediaQuery=window.matchMedia("(prefers-color-scheme: dark)");const handleChange=()=>{listener(mediaQuery.matches?"dark":"light")};if(typeof mediaQuery.addEventListener==="function"){mediaQuery.addEventListener("change",handleChange);return()=>{mediaQuery.removeEventListener("change",handleChange)}}mediaQuery.addListener(handleChange);return()=>{mediaQuery.removeListener(handleChange)}}

package/dist/kernel/manager/theme/theme.dom.d.ts

@@ -1,3 +1,10 @@
-import type { ThemeSnapshot } from '../../types';
-export declare function resolveThemeMode(theme: ThemeSnapshot): 'light' | 'dark';
-export declare function applyThemeToDocument(nextTheme: ThemeSnapshot, prevTheme?: ThemeSnapshot): void;
+import type { ResolvedThemeMode, ThemeSnapshot } from '../../custom-manager/theme/types';
+type ThemeDomApplyOptions = {
+    prevTheme?: ThemeSnapshot;
+    nextResolvedMode?: ResolvedThemeMode;
+    prevResolvedMode?: ResolvedThemeMode;
+};
+export declare function resolveThemeMode(theme: ThemeSnapshot): ResolvedThemeMode;
+export declare function applyThemeToDocument(nextTheme: ThemeSnapshot, options?: ThemeDomApplyOptions): void;
+export declare function observeSystemThemeChange(listener: (resolvedMode: ResolvedThemeMode) => void): (() => void) | null;
+export {};

package/dist/kernel/manager/theme/theme.dom.js

@@ -1 +1 @@
-function canUseDom(){return typeof document!=="undefined"}export 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"}export 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))}}}
+function canUseDom(){return typeof document!=="undefined"}function canUseMatchMedia(){return typeof window!=="undefined"&&typeof window.matchMedia==="function"}export function resolveThemeMode(theme){if(theme.mode!=="system"){return theme.mode}if(canUseMatchMedia()&&window.matchMedia("(prefers-color-scheme: dark)").matches){return"dark"}return"light"}export function applyThemeToDocument(nextTheme,options={}){if(!canUseDom()){return}const root=document.documentElement;const nextMode=options.nextResolvedMode??resolveThemeMode(nextTheme);const prevTheme=options.prevTheme;const prevMode=options.prevResolvedMode??(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))}}}export function observeSystemThemeChange(listener){if(!canUseMatchMedia()){return null}const mediaQuery=window.matchMedia("(prefers-color-scheme: dark)");const handleChange=()=>{listener(mediaQuery.matches?"dark":"light")};if(typeof mediaQuery.addEventListener==="function"){mediaQuery.addEventListener("change",handleChange);return()=>{mediaQuery.removeEventListener("change",handleChange)}}mediaQuery.addListener(handleChange);return()=>{mediaQuery.removeListener(handleChange)}}

package/dist/kernel/manager/theme/theme.persistence.d.ts

@@ -1,5 +1,6 @@
 import type { StorageInstance } from '@vlian/utils';
-import type { PersistenceOptions, ThemeSnapshot } from '../../types';
+import type { PersistenceOptions } from '../../types';
+import type { ThemeSnapshot } from '../../custom-manager/theme/types';
 export declare const DEFAULT_THEME_CACHE_KEY = "vlian:kernel:theme";
 export declare function loadThemeFromCache(cacheManager: StorageInstance, persistence: PersistenceOptions | undefined, fallback: ThemeSnapshot): Promise<ThemeSnapshot>;
 export declare function saveThemeToCache(cacheManager: StorageInstance, persistence: PersistenceOptions | undefined, theme: ThemeSnapshot): Promise<void>;

package/dist/kernel/manager/theme/theme.schema.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:true});function _export(target,all){for(var name in all)Object.defineProperty(target,name,{enumerable:true,get:Object.getOwnPropertyDescriptor(all,name).get})}_export(exports,{get cloneTheme(){return cloneTheme},get isThemeEqual(){return isThemeEqual},get mergeTheme(){return mergeTheme},get normalizeTheme(){return normalizeTheme},get sanitizeTokens(){return sanitizeTokens}});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}
+"use strict";Object.defineProperty(exports,"__esModule",{value:true});function _export(target,all){for(var name in all)Object.defineProperty(target,name,{enumerable:true,get:Object.getOwnPropertyDescriptor(all,name).get})}_export(exports,{get cloneResolvedTheme(){return cloneResolvedTheme},get cloneTheme(){return cloneTheme},get isResolvedThemeModeEqual(){return isResolvedThemeModeEqual},get isThemeEqual(){return isThemeEqual},get mergeTheme(){return mergeTheme},get normalizeTheme(){return normalizeTheme},get sanitizeTokens(){return sanitizeTokens}});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 cloneResolvedTheme(theme){return{...cloneTheme(theme),resolvedMode:theme.resolvedMode}}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}function isResolvedThemeModeEqual(left,right){return left===right}

package/dist/kernel/manager/theme/theme.schema.d.ts

@@ -1,7 +1,9 @@
-import type { ThemeSnapshot } from '../../types';
+import type { ResolvedThemeMode, ResolvedThemeSnapshot, ThemeSnapshot } from '../../custom-manager/theme/types';
 export type ThemeListener = (next: ThemeSnapshot, prev: ThemeSnapshot) => void;
 export declare function cloneTheme(theme: ThemeSnapshot): ThemeSnapshot;
+export declare function cloneResolvedTheme(theme: ResolvedThemeSnapshot): ResolvedThemeSnapshot;
 export declare function sanitizeTokens(tokens: unknown): ThemeSnapshot['tokens'];
 export declare function normalizeTheme(value: unknown, fallback: ThemeSnapshot): ThemeSnapshot;
 export declare function mergeTheme(current: ThemeSnapshot, next: Partial<ThemeSnapshot>): ThemeSnapshot;
 export declare function isThemeEqual(left: ThemeSnapshot, right: ThemeSnapshot): boolean;
+export declare function isResolvedThemeModeEqual(left: ResolvedThemeMode, right: ResolvedThemeMode): boolean;

package/dist/kernel/manager/theme/theme.schema.js

@@ -1 +1 @@
-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)}export function cloneTheme(theme){return{...theme,...theme.tokens?{tokens:{...theme.tokens}}:{}}}export 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}export 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||{}}}:{}}}export 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"};export 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 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)}export function cloneTheme(theme){return{...theme,...theme.tokens?{tokens:{...theme.tokens}}:{}}}export function cloneResolvedTheme(theme){return{...cloneTheme(theme),resolvedMode:theme.resolvedMode}}export 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}export 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||{}}}:{}}}export 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"};export 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}export function isResolvedThemeModeEqual(left,right){return left===right}

package/dist/kernel/manager/themeManager.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:true});Object.defineProperty(exports,"ThemeManager",{enumerable:true,get:function(){return _theme.ThemeManager}});const _theme=require("./theme");
+"use strict";Object.defineProperty(exports,"__esModule",{value:true});Object.defineProperty(exports,"ThemeManager",{enumerable:true,get:function(){return _theme.ThemeManager}});const _theme=require("../custom-manager/theme");

package/dist/kernel/manager/themeManager.d.ts

@@ -1 +1 @@
-export { ThemeManager } from './theme';
+export { ThemeManager } from '../custom-manager/theme';

package/dist/kernel/manager/themeManager.js

@@ -1 +1 @@
-export{ThemeManager}from"./theme";
+export{ThemeManager}from"../custom-manager/theme";

package/dist/kernel/types.d.ts

@@ -1,7 +1,12 @@
 import type { LogLevel } from '@vlian/logger';
-import type { StorageOptions } from '../types';
 import type { StorageInstance } from '@vlian/utils';
-import type { Resource } from 'i18next';
+import type { StorageType } from '@vlian/utils';
+export type StorageOptions = {
+    prefix: string;
+    defaultExpire: number;
+    tableName?: string;
+    type?: StorageType;
+};
 /**
  * 生命周期钩子函数类型
  */
@@ -23,40 +28,13 @@ export interface CoreStartOptions {
      * 生命周期钩子
      */
     lifecycle?: ManagerLifecycle;
-    /**
-     * 国际化
-     */
-    locale?: I18nSnapshot['resources'];
     /**
      * 存储配置
      */
     storageOptions?: StorageOptions;
-    /**
-     * 主题配置
-     *
-     * @example
-     * ```typescript
-     * start({
-     *   theme: {
-     *     mode: 'dark',
-     *     primaryColor: '#1890ff',
-     *   },
-     * });
-     * ```
-     */
-    theme?: Partial<ThemeSnapshot>;
 }
 export type KernelInstanceId = string;
 export type KernelStorageDriver = 'localStorage' | 'sessionStorage' | 'indexedDB' | 'none';
-export interface ThemeSnapshot {
-    mode: 'light' | 'dark' | 'system';
-    primaryColor?: string;
-    tokens?: Record<string, string | number>;
-}
-export interface I18nSnapshot {
-    locale: string;
-    resources?: Resource;
-}
 export interface PersistenceOptions {
     enabled?: boolean;
     storage?: KernelStorageDriver;
@@ -70,19 +48,10 @@ export interface CacheManagerConfig {
     enabled?: boolean;
     storageOptions?: Partial<StorageOptions>;
 }
-export interface ThemeManagerConfig {
-    initial?: ThemeSnapshot;
-    persistence?: PersistenceOptions;
-}
-export interface I18nManagerConfig {
-    initial?: I18nSnapshot;
-    persistence?: PersistenceOptions;
-}
 export interface KernelConfig {
     logger: LoggerManagerConfig;
     cache: CacheManagerConfig;
-    theme: ThemeManagerConfig;
-    i18n: I18nManagerConfig;
+    managerConfigs: Record<string, unknown>;
 }
 export interface KernelTimingMetric {
     phase: string;
@@ -94,6 +63,7 @@ export interface KernelManagerContext {
     instanceId: KernelInstanceId;
     config: KernelConfig;
     cacheManager: StorageInstance;
+    getManagerConfig: <TConfig = unknown>(name: string) => TConfig | undefined;
 }
 export interface KernelManager<TSnapshot = unknown> {
     initialize: (context: KernelManagerContext) => Promise<void> | void;
@@ -112,6 +82,7 @@ export interface StartOptions extends CoreStartOptions {
     configLoader?: () => Promise<Partial<KernelConfig> | void> | Partial<KernelConfig> | void;
     render?: (context: KernelRenderContext) => Promise<void> | void;
     customManagers?: Record<string, KernelManager>;
+    managerConfigs?: Record<string, unknown>;
     hooks?: StartupHooks;
 }
 export type KernelStartOptions = StartOptions;