@vlian/framework 2.0.2 → 2.0.3

package/dist/i18n.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 DEFAULT_I18N(){return _i18n.DEFAULT_I18N},get DEFAULT_I18N_MANAGER_CONFIG(){return _i18n.DEFAULT_I18N_MANAGER_CONFIG},get I18N_MANAGER_NAME(){return _i18n.I18N_MANAGER_NAME},get I18nManager(){return _i18n.I18nManager},get registerI18nManager(){return _i18n.registerI18nManager}});const _i18n=require("./kernel/custom-manager/i18n");
+"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 I18N_MANAGER_NAME(){return _i18n.I18N_MANAGER_NAME},get I18nManager(){return _i18n.I18nManager},get registerI18nManager(){return _i18n.registerI18nManager},get registerLazyI18nManager(){return _i18n.registerLazyI18nManager}});const _i18n=require("./kernel/custom-manager/i18n");

package/dist/i18n.d.ts

@@ -1,2 +1,2 @@
-export { I18nManager, DEFAULT_I18N, DEFAULT_I18N_MANAGER_CONFIG, I18N_MANAGER_NAME, registerI18nManager, } from './kernel/custom-manager/i18n';
+export { I18nManager, DEFAULT_I18N, DEFAULT_I18N_MANAGER_CONFIG, I18N_MANAGER_NAME, registerLazyI18nManager, registerI18nManager, } from './kernel/custom-manager/i18n';
 export type { I18nManagerConfig, I18nSnapshot } from './kernel/custom-manager/i18n';

package/dist/i18n.js

@@ -1 +1 @@
-export{I18nManager,DEFAULT_I18N,DEFAULT_I18N_MANAGER_CONFIG,I18N_MANAGER_NAME,registerI18nManager}from"./kernel/custom-manager/i18n";
+export{I18nManager,DEFAULT_I18N,DEFAULT_I18N_MANAGER_CONFIG,I18N_MANAGER_NAME,registerLazyI18nManager,registerI18nManager}from"./kernel/custom-manager/i18n";

package/dist/i18n.lazy.cjs

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

package/dist/i18n.lazy.d.ts

@@ -0,0 +1,2 @@
+export { registerLazyI18nManager } from './kernel/custom-manager/i18n/lazy';
+export type { I18nManagerConfig } from './kernel/custom-manager/i18n';

package/dist/i18n.lazy.js

@@ -0,0 +1 @@
+export{registerLazyI18nManager}from"./kernel/custom-manager/i18n/lazy";

package/dist/index.umd.js

@@ -1,5 +1,5 @@
 /*!
- * @vlian/framework v2.0.1
+ * @vlian/framework v2.0.2
  * Secra Framework - 一个现代化的低代码框架
  * (c) 2026 Secra Framework Contributors
  * Licensed under Apache-2.0
@@ -16,11 +16,13 @@
 
 	const DEFAULT_LOGGER_CACHE_KEY="vlian:kernel:logger-level";function resolvePersistenceContext(persistence){if(persistence?.enabled!==true){return null}return {key:persistence.key||DEFAULT_LOGGER_CACHE_KEY}}async function loadLoggerFromCache(cacheManager,persistence,fallback){const persistenceContext=resolvePersistenceContext(persistence);if(!persistenceContext){return {...fallback}}try{const cached=await cacheManager.get(persistenceContext.key,{defaultValue:fallback});return normalizeLoggerSnapshot(cached,fallback)}catch{return {...fallback}}}async function saveLoggerToCache(cacheManager,persistence,snapshot){const persistenceContext=resolvePersistenceContext(persistence);if(!persistenceContext){return}try{await cacheManager.set(persistenceContext.key,{...snapshot});}catch{}}
 
-	function _define_property$2(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}class LoggerManager{async initialize(context){this.config=context.config.logger;this.cacheManager=context.cacheManager;const initialSnapshot=normalizeLoggerSnapshot({level:this.config.level},{level:logger.LogLevel.INFO});this.snapshot=await loadLoggerFromCache(this.cacheManager,this.config.persistence,initialSnapshot);logger.logger.setLevel(this.snapshot.level);this.initialized=true;}subscribe(listener){this.listeners.add(listener);return ()=>{this.listeners.delete(listener);}}debug(...args){logger.logger.debug(...args);}info(...args){logger.logger.info(...args);}warn(...args){logger.logger.warn(...args);}error(...args){logger.logger.error(...args);}async setLevel(level){this.ensureInitialized();const prevSnapshot=this.snapshot;const nextSnapshot=normalizeLoggerSnapshot({level},prevSnapshot);if(isLoggerEqual(prevSnapshot,nextSnapshot)){return}this.snapshot=nextSnapshot;logger.logger.setLevel(this.snapshot.level);if(this.cacheManager){await saveLoggerToCache(this.cacheManager,this.config.persistence,this.snapshot);}this.emit(this.snapshot,prevSnapshot);}getSnapshot(){return {...this.snapshot}}ensureInitialized(){if(!this.initialized){throw new Error("LoggerManager must be initialized before use.")}}emit(next,prev){for(const listener of this.listeners){try{listener({...next},{...prev});}catch{}}}constructor(){_define_property$2(this,"snapshot",{level:logger.LogLevel.INFO});_define_property$2(this,"config",DEFAULT_CONFIG.logger);_define_property$2(this,"listeners",new Set);_define_property$2(this,"cacheManager",null);_define_property$2(this,"initialized",false);}}
+	class LoggerManager{snapshot={level:logger.LogLevel.INFO};config=DEFAULT_CONFIG.logger;listeners=new Set;cacheManager=null;initialized=false;async initialize(context){this.config=context.config.logger;this.cacheManager=context.cacheManager;const initialSnapshot=normalizeLoggerSnapshot({level:this.config.level},{level:logger.LogLevel.INFO});this.snapshot=await loadLoggerFromCache(this.cacheManager,this.config.persistence,initialSnapshot);logger.logger.setLevel(this.snapshot.level);this.initialized=true;}subscribe(listener){this.listeners.add(listener);return ()=>{this.listeners.delete(listener);}}debug(...args){logger.logger.debug(...args);}info(...args){logger.logger.info(...args);}warn(...args){logger.logger.warn(...args);}error(...args){logger.logger.error(...args);}async setLevel(level){this.ensureInitialized();const prevSnapshot=this.snapshot;const nextSnapshot=normalizeLoggerSnapshot({level},prevSnapshot);if(isLoggerEqual(prevSnapshot,nextSnapshot)){return}this.snapshot=nextSnapshot;logger.logger.setLevel(this.snapshot.level);if(this.cacheManager){await saveLoggerToCache(this.cacheManager,this.config.persistence,this.snapshot);}this.emit(this.snapshot,prevSnapshot);}getSnapshot(){return {...this.snapshot}}ensureInitialized(){if(!this.initialized){throw new Error("LoggerManager must be initialized before use.")}}emit(next,prev){for(const listener of this.listeners){try{listener({...next},{...prev});}catch{}}}}
 
-	function _define_property$1(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}class CacheManager{initialize(context){this.snapshot=context.config.cache;this.cacheIn=utils.createStorage({type:this.snapshot.storageOptions?.type||"local",prefix:this.snapshot.storageOptions?.prefix||"vlian",defaultExpire:this.snapshot.storageOptions?.defaultExpire||24*60*60*1e3,dbName:this.snapshot.storageOptions?.tableName});}get cache(){return this.cacheIn}getSnapshot(){return this.snapshot}constructor(){_define_property$1(this,"snapshot",DEFAULT_CONFIG.cache);_define_property$1(this,"cacheIn",void 0);}}
+	class CacheManager{snapshot=DEFAULT_CONFIG.cache;cacheIn;initialize(context){this.snapshot=context.config.cache;this.cacheIn=utils.createStorage({type:this.snapshot.storageOptions?.type||"local",prefix:this.snapshot.storageOptions?.prefix||"vlian",defaultExpire:this.snapshot.storageOptions?.defaultExpire||24*60*60*1e3,dbName:this.snapshot.storageOptions?.tableName});}get cache(){return this.cacheIn}getSnapshot(){return this.snapshot}}
 
-	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()}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);async function startup(options={},instanceId=DEFAULT_INSTANCE_ID){const kernel=Kernel.getInstance(instanceId);return kernel.startup(options)}function getKernel(instanceId=DEFAULT_INSTANCE_ID){return Kernel.getInstance(instanceId)}async function kernelStartApp(options={},instanceId=DEFAULT_INSTANCE_ID){return startup(options,instanceId)}
+	function isKernelManager(value){return typeof value==="object"&&value!==null&&typeof value.initialize==="function"}function isLazyKernelManagerRegistration(value){return typeof value==="object"&&value!==null&&"load"in value}function isEagerKernelManagerRegistration(value){return typeof value==="object"&&value!==null&&"manager"in value}function resolveKernelManagerModule(module){if(isKernelManager(module)){return module}if("manager"in module&&isKernelManager(module.manager)){return module.manager}if("default"in module&&isKernelManager(module.default)){return module.default}throw new Error("Invalid lazy kernel manager module")}
+
+	function now(){return typeof performance!=="undefined"?performance.now():Date.now()}class Kernel{static instances=new Map;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}instanceId;metrics=[];managers=new Map;managerLoaders=new Map;eagerManagers=new Set;managerInitPromises=new Map;initializedManagers=new Set;loggerManager=new LoggerManager;cacheManager=new CacheManager;config=DEFAULT_CONFIG;startupPromise=null;started=false;constructor(instanceId){this.instanceId=instanceId;this.managers.set("logger",this.loggerManager);this.managers.set("cache",this.cacheManager);}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)}hasManager(name){return this.managers.has(name)||this.managerLoaders.has(name)}registerManager(name,manager){if(this.hasManager(name)){throw new Error(`Kernel manager "${name}" 已存在`)}this.managers.set(name,manager);}registerLazyManager(name,load,options={}){if(this.hasManager(name)){throw new Error(`Kernel manager "${name}" 已存在`)}this.managerLoaders.set(name,load);if(options.eager){this.eagerManagers.add(name);}}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,registration])=>{if(!this.hasManager(name)){this.registerConfiguredManager(name,registration);}});}});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.eagerManagers].filter(name=>name!=="logger"&&name!=="cache");await Promise.all(customManagerNames.map(name=>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}let manager=this.managers.get(name);if(!manager){manager=await this.loadManager(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);}}registerConfiguredManager(name,registration){if(isKernelManager(registration)){this.registerManager(name,registration);this.eagerManagers.add(name);return}if(isLazyKernelManagerRegistration(registration)){if(registration.config!==undefined){this.setManagerConfig(name,registration.config);}this.registerLazyManager(name,registration.load,{eager:registration.eager});return}if(isEagerKernelManagerRegistration(registration)){if(registration.config!==undefined){this.setManagerConfig(name,registration.config);}this.registerManager(name,registration.manager);if(registration.eager!==false){this.eagerManagers.add(name);}}}async loadManager(name){const load=this.managerLoaders.get(name);if(!load){return undefined}const loaded=resolveKernelManagerModule(await load());this.managerLoaders.delete(name);this.managers.set(name,loaded);return loaded}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);}}async function startup(options={},instanceId=DEFAULT_INSTANCE_ID){const kernel=Kernel.getInstance(instanceId);return kernel.startup(options)}function getKernel(instanceId=DEFAULT_INSTANCE_ID){return Kernel.getInstance(instanceId)}async function kernelStartApp(options={},instanceId=DEFAULT_INSTANCE_ID){return startup(options,instanceId)}
 
 	exports.Kernel = Kernel;
 	exports.getKernel = getKernel;

package/dist/kernel/custom-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 _constants=require("./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)}};
+"use strict";Object.defineProperty(exports,"__esModule",{value:true});Object.defineProperty(exports,"I18nManager",{enumerable:true,get:function(){return I18nManager}});const _constants=require("./constants");const _i18npersistence=require("./i18n.persistence");const _i18nruntime=require("./i18n.runtime");const _i18nschema=require("./i18n.schema");let I18nManager=class I18nManager{snapshot=(0,_i18nschema.cloneI18nSnapshot)(_constants.DEFAULT_I18N);config=_constants.DEFAULT_I18N_MANAGER_CONFIG;listeners=new Set;cacheManager=null;initialized=false;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{}}}};

package/dist/kernel/custom-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{DEFAULT_I18N,DEFAULT_I18N_MANAGER_CONFIG,I18N_MANAGER_NAME}from"./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)}}
+import{DEFAULT_I18N,DEFAULT_I18N_MANAGER_CONFIG,I18N_MANAGER_NAME}from"./constants";import{loadI18nFromCache,saveI18nToCache}from"./i18n.persistence";import{initializeI18nRuntime,switchI18nLocale}from"./i18n.runtime";import{cloneI18nSnapshot,isI18nEqual,mergeI18nSnapshot,normalizeI18nSnapshot}from"./i18n.schema";export class I18nManager{snapshot=cloneI18nSnapshot(DEFAULT_I18N);config=DEFAULT_I18N_MANAGER_CONFIG;listeners=new Set;cacheManager=null;initialized=false;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{}}}}

package/dist/kernel/custom-manager/i18n/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 DEFAULT_I18N(){return _constants.DEFAULT_I18N},get DEFAULT_I18N_MANAGER_CONFIG(){return _constants.DEFAULT_I18N_MANAGER_CONFIG},get I18N_MANAGER_NAME(){return _constants.I18N_MANAGER_NAME},get I18nManager(){return _I18nManager.I18nManager},get registerI18nManager(){return registerI18nManager}});const _I18nManager=require("./I18nManager");const _constants=require("./constants");async function registerI18nManager(kernel,config=_constants.DEFAULT_I18N_MANAGER_CONFIG){const existing=kernel.getManager(_constants.I18N_MANAGER_NAME);if(existing instanceof _I18nManager.I18nManager){kernel.setManagerConfig(_constants.I18N_MANAGER_NAME,config);await kernel.initializeManager(_constants.I18N_MANAGER_NAME);return existing}const manager=new _I18nManager.I18nManager;kernel.setManagerConfig(_constants.I18N_MANAGER_NAME,config);kernel.registerManager(_constants.I18N_MANAGER_NAME,manager);await kernel.initializeManager(_constants.I18N_MANAGER_NAME);return 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 DEFAULT_I18N(){return _constants.DEFAULT_I18N},get DEFAULT_I18N_MANAGER_CONFIG(){return _constants.DEFAULT_I18N_MANAGER_CONFIG},get I18N_MANAGER_NAME(){return _constants.I18N_MANAGER_NAME},get I18nManager(){return _I18nManager.I18nManager},get registerI18nManager(){return registerI18nManager},get registerLazyI18nManager(){return _lazy.registerLazyI18nManager}});const _I18nManager=require("./I18nManager");const _constants=require("./constants");const _lazy=require("./lazy");async function registerI18nManager(kernel,config=_constants.DEFAULT_I18N_MANAGER_CONFIG){if(kernel.hasManager(_constants.I18N_MANAGER_NAME)){kernel.setManagerConfig(_constants.I18N_MANAGER_NAME,config);await kernel.initializeManager(_constants.I18N_MANAGER_NAME);const existing=kernel.getManager(_constants.I18N_MANAGER_NAME);if(existing instanceof _I18nManager.I18nManager){return existing}throw new Error(`Kernel manager "${_constants.I18N_MANAGER_NAME}" is not an I18nManager`)}const existing=kernel.getManager(_constants.I18N_MANAGER_NAME);if(existing instanceof _I18nManager.I18nManager){kernel.setManagerConfig(_constants.I18N_MANAGER_NAME,config);await kernel.initializeManager(_constants.I18N_MANAGER_NAME);return existing}const manager=new _I18nManager.I18nManager;kernel.setManagerConfig(_constants.I18N_MANAGER_NAME,config);kernel.registerManager(_constants.I18N_MANAGER_NAME,manager);await kernel.initializeManager(_constants.I18N_MANAGER_NAME);return manager}

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

@@ -3,5 +3,6 @@ import { I18nManager } from './I18nManager';
 import type { I18nManagerConfig } from './types';
 export { I18nManager } from './I18nManager';
 export { DEFAULT_I18N, DEFAULT_I18N_MANAGER_CONFIG, I18N_MANAGER_NAME } from './constants';
+export { registerLazyI18nManager } from './lazy';
 export type { I18nManagerConfig, I18nSnapshot } from './types';
 export declare function registerI18nManager(kernel: Kernel, config?: I18nManagerConfig): Promise<I18nManager>;

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

@@ -1 +1 @@
-import{I18nManager}from"./I18nManager";import{DEFAULT_I18N_MANAGER_CONFIG,I18N_MANAGER_NAME}from"./constants";export{I18nManager}from"./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}
+import{I18nManager}from"./I18nManager";import{DEFAULT_I18N_MANAGER_CONFIG,I18N_MANAGER_NAME}from"./constants";export{I18nManager}from"./I18nManager";export{DEFAULT_I18N,DEFAULT_I18N_MANAGER_CONFIG,I18N_MANAGER_NAME}from"./constants";export{registerLazyI18nManager}from"./lazy";export async function registerI18nManager(kernel,config=DEFAULT_I18N_MANAGER_CONFIG){if(kernel.hasManager(I18N_MANAGER_NAME)){kernel.setManagerConfig(I18N_MANAGER_NAME,config);await kernel.initializeManager(I18N_MANAGER_NAME);const existing=kernel.getManager(I18N_MANAGER_NAME);if(existing instanceof I18nManager){return existing}throw new Error(`Kernel manager "${I18N_MANAGER_NAME}" is not an I18nManager`)}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/lazy.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:true});Object.defineProperty(exports,"registerLazyI18nManager",{enumerable:true,get:function(){return registerLazyI18nManager}});const _constants=require("./constants");function _getRequireWildcardCache(nodeInterop){if(typeof WeakMap!=="function")return null;var cacheBabelInterop=new WeakMap;var cacheNodeInterop=new WeakMap;return(_getRequireWildcardCache=function(nodeInterop){return nodeInterop?cacheNodeInterop:cacheBabelInterop})(nodeInterop)}function _interop_require_wildcard(obj,nodeInterop){if(!nodeInterop&&obj&&obj.__esModule){return obj}if(obj===null||typeof obj!=="object"&&typeof obj!=="function"){return{default:obj}}var cache=_getRequireWildcardCache(nodeInterop);if(cache&&cache.has(obj)){return cache.get(obj)}var newObj={__proto__:null};var hasPropertyDescriptor=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var key in obj){if(key!=="default"&&Object.prototype.hasOwnProperty.call(obj,key)){var desc=hasPropertyDescriptor?Object.getOwnPropertyDescriptor(obj,key):null;if(desc&&(desc.get||desc.set)){Object.defineProperty(newObj,key,desc)}else{newObj[key]=obj[key]}}}newObj.default=obj;if(cache){cache.set(obj,newObj)}return newObj}function registerLazyI18nManager(kernel,config=_constants.DEFAULT_I18N_MANAGER_CONFIG){if(kernel.hasManager(_constants.I18N_MANAGER_NAME)){kernel.setManagerConfig(_constants.I18N_MANAGER_NAME,config);return}kernel.setManagerConfig(_constants.I18N_MANAGER_NAME,config);kernel.registerLazyManager(_constants.I18N_MANAGER_NAME,async()=>{const module=await Promise.resolve().then(()=>/*#__PURE__*/_interop_require_wildcard(require("./I18nManager")));return new module.I18nManager})}

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

@@ -0,0 +1,3 @@
+import type { Kernel } from '../../kernel';
+import type { I18nManagerConfig } from './types';
+export declare function registerLazyI18nManager(kernel: Kernel, config?: I18nManagerConfig): void;

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

@@ -0,0 +1 @@
+import{DEFAULT_I18N_MANAGER_CONFIG,I18N_MANAGER_NAME}from"./constants";export function registerLazyI18nManager(kernel,config=DEFAULT_I18N_MANAGER_CONFIG){if(kernel.hasManager(I18N_MANAGER_NAME)){kernel.setManagerConfig(I18N_MANAGER_NAME,config);return}kernel.setManagerConfig(I18N_MANAGER_NAME,config);kernel.registerLazyManager(I18N_MANAGER_NAME,async()=>{const module=await import("./I18nManager");return new module.I18nManager})}

package/dist/kernel/custom-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 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");
+"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 registerLazyI18nManager(){return _i18n.registerLazyI18nManager},get registerLazyThemeManager(){return _theme.registerLazyThemeManager},get registerThemeManager(){return _theme.registerThemeManager}});const _theme=require("./theme");const _i18n=require("./i18n");

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

@@ -1,4 +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 { ThemeManager, DEFAULT_THEME, DEFAULT_THEME_MANAGER_CONFIG, THEME_MANAGER_NAME, registerLazyThemeManager, registerThemeManager, } from './theme';
+export { I18nManager, DEFAULT_I18N, DEFAULT_I18N_MANAGER_CONFIG, I18N_MANAGER_NAME, registerLazyI18nManager, registerI18nManager, } from './i18n';
 export type { ResolvedThemeMode, ResolvedThemeSnapshot, ThemeManagerConfig, ThemeSnapshot } from './theme';
 export type { I18nManagerConfig, I18nSnapshot } from './i18n';

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

@@ -1 +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";
+export{ThemeManager,DEFAULT_THEME,DEFAULT_THEME_MANAGER_CONFIG,THEME_MANAGER_NAME,registerLazyThemeManager,registerThemeManager}from"./theme";export{I18nManager,DEFAULT_I18N,DEFAULT_I18N_MANAGER_CONFIG,I18N_MANAGER_NAME,registerLazyI18nManager,registerI18nManager}from"./i18n";

package/dist/kernel/custom-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.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)}};
+"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");let ThemeManager=class ThemeManager{theme=(0,_themeschema.cloneTheme)(_constants.DEFAULT_THEME);resolvedMode=(0,_themedom.resolveThemeMode)(_constants.DEFAULT_THEME);config=_constants.DEFAULT_THEME_MANAGER_CONFIG;listeners=new Set;cacheManager=null;stopSystemThemeObserver=null;initialized=false;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{}}}};

package/dist/kernel/custom-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_THEME,DEFAULT_THEME_MANAGER_CONFIG,THEME_MANAGER_NAME}from"./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)}}
+import{DEFAULT_THEME,DEFAULT_THEME_MANAGER_CONFIG,THEME_MANAGER_NAME}from"./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{theme=cloneTheme(DEFAULT_THEME);resolvedMode=resolveThemeMode(DEFAULT_THEME);config=DEFAULT_THEME_MANAGER_CONFIG;listeners=new Set;cacheManager=null;stopSystemThemeObserver=null;initialized=false;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{}}}}

package/dist/kernel/custom-manager/theme/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 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("./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}
+"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 registerLazyThemeManager(){return _lazy.registerLazyThemeManager},get registerThemeManager(){return registerThemeManager}});const _ThemeManager=require("./ThemeManager");const _constants=require("./constants");const _lazy=require("./lazy");async function registerThemeManager(kernel,config=_constants.DEFAULT_THEME_MANAGER_CONFIG){if(kernel.hasManager(_constants.THEME_MANAGER_NAME)){kernel.setManagerConfig(_constants.THEME_MANAGER_NAME,config);await kernel.initializeManager(_constants.THEME_MANAGER_NAME);const existing=kernel.getManager(_constants.THEME_MANAGER_NAME);if(existing instanceof _ThemeManager.ThemeManager){return existing}throw new Error(`Kernel manager "${_constants.THEME_MANAGER_NAME}" is not a ThemeManager`)}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

@@ -3,5 +3,6 @@ import { ThemeManager } from './ThemeManager';
 import type { ThemeManagerConfig } from './types';
 export { ThemeManager } from './ThemeManager';
 export { DEFAULT_THEME, DEFAULT_THEME_MANAGER_CONFIG, THEME_MANAGER_NAME } from './constants';
+export { registerLazyThemeManager } from './lazy';
 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

@@ -1 +1 @@
-import{ThemeManager}from"./ThemeManager";import{DEFAULT_THEME_MANAGER_CONFIG,THEME_MANAGER_NAME}from"./constants";export{ThemeManager}from"./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}
+import{ThemeManager}from"./ThemeManager";import{DEFAULT_THEME_MANAGER_CONFIG,THEME_MANAGER_NAME}from"./constants";export{ThemeManager}from"./ThemeManager";export{DEFAULT_THEME,DEFAULT_THEME_MANAGER_CONFIG,THEME_MANAGER_NAME}from"./constants";export{registerLazyThemeManager}from"./lazy";export async function registerThemeManager(kernel,config=DEFAULT_THEME_MANAGER_CONFIG){if(kernel.hasManager(THEME_MANAGER_NAME)){kernel.setManagerConfig(THEME_MANAGER_NAME,config);await kernel.initializeManager(THEME_MANAGER_NAME);const existing=kernel.getManager(THEME_MANAGER_NAME);if(existing instanceof ThemeManager){return existing}throw new Error(`Kernel manager "${THEME_MANAGER_NAME}" is not a ThemeManager`)}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/lazy.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:true});Object.defineProperty(exports,"registerLazyThemeManager",{enumerable:true,get:function(){return registerLazyThemeManager}});const _constants=require("./constants");function _getRequireWildcardCache(nodeInterop){if(typeof WeakMap!=="function")return null;var cacheBabelInterop=new WeakMap;var cacheNodeInterop=new WeakMap;return(_getRequireWildcardCache=function(nodeInterop){return nodeInterop?cacheNodeInterop:cacheBabelInterop})(nodeInterop)}function _interop_require_wildcard(obj,nodeInterop){if(!nodeInterop&&obj&&obj.__esModule){return obj}if(obj===null||typeof obj!=="object"&&typeof obj!=="function"){return{default:obj}}var cache=_getRequireWildcardCache(nodeInterop);if(cache&&cache.has(obj)){return cache.get(obj)}var newObj={__proto__:null};var hasPropertyDescriptor=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var key in obj){if(key!=="default"&&Object.prototype.hasOwnProperty.call(obj,key)){var desc=hasPropertyDescriptor?Object.getOwnPropertyDescriptor(obj,key):null;if(desc&&(desc.get||desc.set)){Object.defineProperty(newObj,key,desc)}else{newObj[key]=obj[key]}}}newObj.default=obj;if(cache){cache.set(obj,newObj)}return newObj}function registerLazyThemeManager(kernel,config=_constants.DEFAULT_THEME_MANAGER_CONFIG){if(kernel.hasManager(_constants.THEME_MANAGER_NAME)){kernel.setManagerConfig(_constants.THEME_MANAGER_NAME,config);return}kernel.setManagerConfig(_constants.THEME_MANAGER_NAME,config);kernel.registerLazyManager(_constants.THEME_MANAGER_NAME,async()=>{const module=await Promise.resolve().then(()=>/*#__PURE__*/_interop_require_wildcard(require("./ThemeManager")));return new module.ThemeManager})}

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

@@ -0,0 +1,3 @@
+import type { Kernel } from '../../kernel';
+import type { ThemeManagerConfig } from './types';
+export declare function registerLazyThemeManager(kernel: Kernel, config?: ThemeManagerConfig): void;

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

@@ -0,0 +1 @@
+import{DEFAULT_THEME_MANAGER_CONFIG,THEME_MANAGER_NAME}from"./constants";export function registerLazyThemeManager(kernel,config=DEFAULT_THEME_MANAGER_CONFIG){if(kernel.hasManager(THEME_MANAGER_NAME)){kernel.setManagerConfig(THEME_MANAGER_NAME,config);return}kernel.setManagerConfig(THEME_MANAGER_NAME,config);kernel.registerLazyManager(THEME_MANAGER_NAME,async()=>{const module=await import("./ThemeManager");return new module.ThemeManager})}

package/dist/kernel/index.d.ts

@@ -1,3 +1,4 @@
 export { Kernel, startup, getKernel, kernelStartApp } from './kernel';
 export { LoggerManager, CacheManager } from './manager';
+export type { EagerKernelManagerRegistration, KernelLazyManagerOptions, KernelManagerLoader, KernelManagerModule, KernelManagerRegistration, LazyKernelManagerRegistration, } from './manager-registration';
 export type { KernelInstanceId, KernelStorageDriver, StorageOptions, PersistenceOptions, LoggerManagerConfig, CacheManagerConfig, KernelConfig, KernelTimingMetric, KernelManager, KernelManagerContext, KernelRenderContext, StartupHooks, StartOptions, KernelStartOptions, } from './types';

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");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)}
+"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 _managerregistration=require("./manager-registration");function now(){return typeof performance!=="undefined"?performance.now():Date.now()}let Kernel=class Kernel{static instances=new Map;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}instanceId;metrics=[];managers=new Map;managerLoaders=new Map;eagerManagers=new Set;managerInitPromises=new Map;initializedManagers=new Set;loggerManager=new _loggerManager.LoggerManager;cacheManager=new _cacheManager.CacheManager;config=_constants.DEFAULT_CONFIG;startupPromise=null;started=false;constructor(instanceId){this.instanceId=instanceId;this.managers.set("logger",this.loggerManager);this.managers.set("cache",this.cacheManager)}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)}hasManager(name){return this.managers.has(name)||this.managerLoaders.has(name)}registerManager(name,manager){if(this.hasManager(name)){throw new Error(`Kernel manager "${name}" 已存在`)}this.managers.set(name,manager)}registerLazyManager(name,load,options={}){if(this.hasManager(name)){throw new Error(`Kernel manager "${name}" 已存在`)}this.managerLoaders.set(name,load);if(options.eager){this.eagerManagers.add(name)}}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,registration])=>{if(!this.hasManager(name)){this.registerConfiguredManager(name,registration)}})}});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.eagerManagers].filter(name=>name!=="logger"&&name!=="cache");await Promise.all(customManagerNames.map(name=>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}let manager=this.managers.get(name);if(!manager){manager=await this.loadManager(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)}}registerConfiguredManager(name,registration){if((0,_managerregistration.isKernelManager)(registration)){this.registerManager(name,registration);this.eagerManagers.add(name);return}if((0,_managerregistration.isLazyKernelManagerRegistration)(registration)){if(registration.config!==undefined){this.setManagerConfig(name,registration.config)}this.registerLazyManager(name,registration.load,{eager:registration.eager});return}if((0,_managerregistration.isEagerKernelManagerRegistration)(registration)){if(registration.config!==undefined){this.setManagerConfig(name,registration.config)}this.registerManager(name,registration.manager);if(registration.eager!==false){this.eagerManagers.add(name)}}}async loadManager(name){const load=this.managerLoaders.get(name);if(!load){return undefined}const loaded=(0,_managerregistration.resolveKernelManagerModule)(await load());this.managerLoaders.delete(name);this.managers.set(name,loaded);return loaded}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)}};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,12 +1,15 @@
 import type { KernelConfig, KernelInstanceId, KernelManager, KernelTimingMetric, StartOptions } from './types';
 import { LoggerManager } from './manager/loggerManager';
 import { CacheManager } from './manager/cacheManager';
+import type { KernelLazyManagerOptions, KernelManagerLoader } from './manager-registration';
 export declare class Kernel {
     private static readonly instances;
     static getInstance(instanceId?: KernelInstanceId): Kernel;
     private readonly instanceId;
     private readonly metrics;
     private readonly managers;
+    private readonly managerLoaders;
+    private readonly eagerManagers;
     private readonly managerInitPromises;
     private readonly initializedManagers;
     private readonly loggerManager;
@@ -21,13 +24,17 @@ export declare class Kernel {
     getLoggerManager(): LoggerManager;
     getCacheManager(): CacheManager;
     getManager(name: string): KernelManager | undefined;
+    hasManager(name: string): boolean;
     registerManager(name: string, manager: KernelManager): void;
+    registerLazyManager(name: string, load: KernelManagerLoader, options?: KernelLazyManagerOptions): void;
     getManagerConfig<TConfig = unknown>(name: string): TConfig | undefined;
     setManagerConfig(name: string, config: unknown): void;
     startup(options?: StartOptions): Promise<Kernel>;
     private bootstrap;
     private resolveConfig;
     initializeManager(name: string): Promise<void>;
+    private registerConfiguredManager;
+    private loadManager;
     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_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)}
+import{DEFAULT_CONFIG,DEFAULT_INSTANCE_ID}from"./constants";import{LoggerManager}from"./manager/loggerManager";import{CacheManager}from"./manager/cacheManager";import{isEagerKernelManagerRegistration,isKernelManager,isLazyKernelManagerRegistration,resolveKernelManagerModule}from"./manager-registration";function now(){return typeof performance!=="undefined"?performance.now():Date.now()}export class Kernel{static instances=new Map;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}instanceId;metrics=[];managers=new Map;managerLoaders=new Map;eagerManagers=new Set;managerInitPromises=new Map;initializedManagers=new Set;loggerManager=new LoggerManager;cacheManager=new CacheManager;config=DEFAULT_CONFIG;startupPromise=null;started=false;constructor(instanceId){this.instanceId=instanceId;this.managers.set("logger",this.loggerManager);this.managers.set("cache",this.cacheManager)}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)}hasManager(name){return this.managers.has(name)||this.managerLoaders.has(name)}registerManager(name,manager){if(this.hasManager(name)){throw new Error(`Kernel manager "${name}" 已存在`)}this.managers.set(name,manager)}registerLazyManager(name,load,options={}){if(this.hasManager(name)){throw new Error(`Kernel manager "${name}" 已存在`)}this.managerLoaders.set(name,load);if(options.eager){this.eagerManagers.add(name)}}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,registration])=>{if(!this.hasManager(name)){this.registerConfiguredManager(name,registration)}})}});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.eagerManagers].filter(name=>name!=="logger"&&name!=="cache");await Promise.all(customManagerNames.map(name=>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}let manager=this.managers.get(name);if(!manager){manager=await this.loadManager(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)}}registerConfiguredManager(name,registration){if(isKernelManager(registration)){this.registerManager(name,registration);this.eagerManagers.add(name);return}if(isLazyKernelManagerRegistration(registration)){if(registration.config!==undefined){this.setManagerConfig(name,registration.config)}this.registerLazyManager(name,registration.load,{eager:registration.eager});return}if(isEagerKernelManagerRegistration(registration)){if(registration.config!==undefined){this.setManagerConfig(name,registration.config)}this.registerManager(name,registration.manager);if(registration.eager!==false){this.eagerManagers.add(name)}}}async loadManager(name){const load=this.managerLoaders.get(name);if(!load){return undefined}const loaded=resolveKernelManagerModule(await load());this.managerLoaders.delete(name);this.managers.set(name,loaded);return loaded}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)}}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/cacheManager.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:true});Object.defineProperty(exports,"CacheManager",{enumerable:true,get:function(){return CacheManager}});const _constants=require("../constants");const _utils=require("@vlian/utils");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 CacheManager=class CacheManager{initialize(context){this.snapshot=context.config.cache;this.cacheIn=(0,_utils.createStorage)({type:this.snapshot.storageOptions?.type||"local",prefix:this.snapshot.storageOptions?.prefix||"vlian",defaultExpire:this.snapshot.storageOptions?.defaultExpire||24*60*60*1e3,dbName:this.snapshot.storageOptions?.tableName})}get cache(){return this.cacheIn}getSnapshot(){return this.snapshot}constructor(){_define_property(this,"snapshot",_constants.DEFAULT_CONFIG.cache);_define_property(this,"cacheIn",void 0)}};
+"use strict";Object.defineProperty(exports,"__esModule",{value:true});Object.defineProperty(exports,"CacheManager",{enumerable:true,get:function(){return CacheManager}});const _constants=require("../constants");const _utils=require("@vlian/utils");let CacheManager=class CacheManager{snapshot=_constants.DEFAULT_CONFIG.cache;cacheIn;initialize(context){this.snapshot=context.config.cache;this.cacheIn=(0,_utils.createStorage)({type:this.snapshot.storageOptions?.type||"local",prefix:this.snapshot.storageOptions?.prefix||"vlian",defaultExpire:this.snapshot.storageOptions?.defaultExpire||24*60*60*1e3,dbName:this.snapshot.storageOptions?.tableName})}get cache(){return this.cacheIn}getSnapshot(){return this.snapshot}};

package/dist/kernel/manager/cacheManager.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}from"../constants";import{createStorage}from"@vlian/utils";export class CacheManager{initialize(context){this.snapshot=context.config.cache;this.cacheIn=createStorage({type:this.snapshot.storageOptions?.type||"local",prefix:this.snapshot.storageOptions?.prefix||"vlian",defaultExpire:this.snapshot.storageOptions?.defaultExpire||24*60*60*1e3,dbName:this.snapshot.storageOptions?.tableName})}get cache(){return this.cacheIn}getSnapshot(){return this.snapshot}constructor(){_define_property(this,"snapshot",DEFAULT_CONFIG.cache);_define_property(this,"cacheIn",void 0)}}
+import{DEFAULT_CONFIG}from"../constants";import{createStorage}from"@vlian/utils";export class CacheManager{snapshot=DEFAULT_CONFIG.cache;cacheIn;initialize(context){this.snapshot=context.config.cache;this.cacheIn=createStorage({type:this.snapshot.storageOptions?.type||"local",prefix:this.snapshot.storageOptions?.prefix||"vlian",defaultExpire:this.snapshot.storageOptions?.defaultExpire||24*60*60*1e3,dbName:this.snapshot.storageOptions?.tableName})}get cache(){return this.cacheIn}getSnapshot(){return this.snapshot}}

package/dist/kernel/manager/logger/LoggerManager.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:true});Object.defineProperty(exports,"LoggerManager",{enumerable:true,get:function(){return LoggerManager}});const _logger=require("@vlian/logger");const _constants=require("../../constants");const _loggerschema=require("./logger.schema");const _loggerpersistence=require("./logger.persistence");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 LoggerManager=class LoggerManager{async initialize(context){this.config=context.config.logger;this.cacheManager=context.cacheManager;const initialSnapshot=(0,_loggerschema.normalizeLoggerSnapshot)({level:this.config.level},{level:_logger.LogLevel.INFO});this.snapshot=await (0,_loggerpersistence.loadLoggerFromCache)(this.cacheManager,this.config.persistence,initialSnapshot);_logger.logger.setLevel(this.snapshot.level);this.initialized=true}subscribe(listener){this.listeners.add(listener);return()=>{this.listeners.delete(listener)}}debug(...args){_logger.logger.debug(...args)}info(...args){_logger.logger.info(...args)}warn(...args){_logger.logger.warn(...args)}error(...args){_logger.logger.error(...args)}async setLevel(level){this.ensureInitialized();const prevSnapshot=this.snapshot;const nextSnapshot=(0,_loggerschema.normalizeLoggerSnapshot)({level},prevSnapshot);if((0,_loggerschema.isLoggerEqual)(prevSnapshot,nextSnapshot)){return}this.snapshot=nextSnapshot;_logger.logger.setLevel(this.snapshot.level);if(this.cacheManager){await (0,_loggerpersistence.saveLoggerToCache)(this.cacheManager,this.config.persistence,this.snapshot)}this.emit(this.snapshot,prevSnapshot)}getSnapshot(){return{...this.snapshot}}ensureInitialized(){if(!this.initialized){throw new Error("LoggerManager must be initialized before use.")}}emit(next,prev){for(const listener of this.listeners){try{listener({...next},{...prev})}catch{}}}constructor(){_define_property(this,"snapshot",{level:_logger.LogLevel.INFO});_define_property(this,"config",_constants.DEFAULT_CONFIG.logger);_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,"LoggerManager",{enumerable:true,get:function(){return LoggerManager}});const _logger=require("@vlian/logger");const _constants=require("../../constants");const _loggerschema=require("./logger.schema");const _loggerpersistence=require("./logger.persistence");let LoggerManager=class LoggerManager{snapshot={level:_logger.LogLevel.INFO};config=_constants.DEFAULT_CONFIG.logger;listeners=new Set;cacheManager=null;initialized=false;async initialize(context){this.config=context.config.logger;this.cacheManager=context.cacheManager;const initialSnapshot=(0,_loggerschema.normalizeLoggerSnapshot)({level:this.config.level},{level:_logger.LogLevel.INFO});this.snapshot=await (0,_loggerpersistence.loadLoggerFromCache)(this.cacheManager,this.config.persistence,initialSnapshot);_logger.logger.setLevel(this.snapshot.level);this.initialized=true}subscribe(listener){this.listeners.add(listener);return()=>{this.listeners.delete(listener)}}debug(...args){_logger.logger.debug(...args)}info(...args){_logger.logger.info(...args)}warn(...args){_logger.logger.warn(...args)}error(...args){_logger.logger.error(...args)}async setLevel(level){this.ensureInitialized();const prevSnapshot=this.snapshot;const nextSnapshot=(0,_loggerschema.normalizeLoggerSnapshot)({level},prevSnapshot);if((0,_loggerschema.isLoggerEqual)(prevSnapshot,nextSnapshot)){return}this.snapshot=nextSnapshot;_logger.logger.setLevel(this.snapshot.level);if(this.cacheManager){await (0,_loggerpersistence.saveLoggerToCache)(this.cacheManager,this.config.persistence,this.snapshot)}this.emit(this.snapshot,prevSnapshot)}getSnapshot(){return{...this.snapshot}}ensureInitialized(){if(!this.initialized){throw new Error("LoggerManager must be initialized before use.")}}emit(next,prev){for(const listener of this.listeners){try{listener({...next},{...prev})}catch{}}}};

package/dist/kernel/manager/logger/LoggerManager.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{logger,LogLevel}from"@vlian/logger";import{DEFAULT_CONFIG}from"../../constants";import{isLoggerEqual,normalizeLoggerSnapshot}from"./logger.schema";import{loadLoggerFromCache,saveLoggerToCache}from"./logger.persistence";export class LoggerManager{async initialize(context){this.config=context.config.logger;this.cacheManager=context.cacheManager;const initialSnapshot=normalizeLoggerSnapshot({level:this.config.level},{level:LogLevel.INFO});this.snapshot=await loadLoggerFromCache(this.cacheManager,this.config.persistence,initialSnapshot);logger.setLevel(this.snapshot.level);this.initialized=true}subscribe(listener){this.listeners.add(listener);return()=>{this.listeners.delete(listener)}}debug(...args){logger.debug(...args)}info(...args){logger.info(...args)}warn(...args){logger.warn(...args)}error(...args){logger.error(...args)}async setLevel(level){this.ensureInitialized();const prevSnapshot=this.snapshot;const nextSnapshot=normalizeLoggerSnapshot({level},prevSnapshot);if(isLoggerEqual(prevSnapshot,nextSnapshot)){return}this.snapshot=nextSnapshot;logger.setLevel(this.snapshot.level);if(this.cacheManager){await saveLoggerToCache(this.cacheManager,this.config.persistence,this.snapshot)}this.emit(this.snapshot,prevSnapshot)}getSnapshot(){return{...this.snapshot}}ensureInitialized(){if(!this.initialized){throw new Error("LoggerManager must be initialized before use.")}}emit(next,prev){for(const listener of this.listeners){try{listener({...next},{...prev})}catch{}}}constructor(){_define_property(this,"snapshot",{level:LogLevel.INFO});_define_property(this,"config",DEFAULT_CONFIG.logger);_define_property(this,"listeners",new Set);_define_property(this,"cacheManager",null);_define_property(this,"initialized",false)}}
+import{logger,LogLevel}from"@vlian/logger";import{DEFAULT_CONFIG}from"../../constants";import{isLoggerEqual,normalizeLoggerSnapshot}from"./logger.schema";import{loadLoggerFromCache,saveLoggerToCache}from"./logger.persistence";export class LoggerManager{snapshot={level:LogLevel.INFO};config=DEFAULT_CONFIG.logger;listeners=new Set;cacheManager=null;initialized=false;async initialize(context){this.config=context.config.logger;this.cacheManager=context.cacheManager;const initialSnapshot=normalizeLoggerSnapshot({level:this.config.level},{level:LogLevel.INFO});this.snapshot=await loadLoggerFromCache(this.cacheManager,this.config.persistence,initialSnapshot);logger.setLevel(this.snapshot.level);this.initialized=true}subscribe(listener){this.listeners.add(listener);return()=>{this.listeners.delete(listener)}}debug(...args){logger.debug(...args)}info(...args){logger.info(...args)}warn(...args){logger.warn(...args)}error(...args){logger.error(...args)}async setLevel(level){this.ensureInitialized();const prevSnapshot=this.snapshot;const nextSnapshot=normalizeLoggerSnapshot({level},prevSnapshot);if(isLoggerEqual(prevSnapshot,nextSnapshot)){return}this.snapshot=nextSnapshot;logger.setLevel(this.snapshot.level);if(this.cacheManager){await saveLoggerToCache(this.cacheManager,this.config.persistence,this.snapshot)}this.emit(this.snapshot,prevSnapshot)}getSnapshot(){return{...this.snapshot}}ensureInitialized(){if(!this.initialized){throw new Error("LoggerManager must be initialized before use.")}}emit(next,prev){for(const listener of this.listeners){try{listener({...next},{...prev})}catch{}}}}

package/dist/kernel/manager-registration.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 isEagerKernelManagerRegistration(){return isEagerKernelManagerRegistration},get isKernelManager(){return isKernelManager},get isLazyKernelManagerRegistration(){return isLazyKernelManagerRegistration},get resolveKernelManagerModule(){return resolveKernelManagerModule}});function isKernelManager(value){return typeof value==="object"&&value!==null&&typeof value.initialize==="function"}function isLazyKernelManagerRegistration(value){return typeof value==="object"&&value!==null&&"load"in value}function isEagerKernelManagerRegistration(value){return typeof value==="object"&&value!==null&&"manager"in value}function resolveKernelManagerModule(module){if(isKernelManager(module)){return module}if("manager"in module&&isKernelManager(module.manager)){return module.manager}if("default"in module&&isKernelManager(module.default)){return module.default}throw new Error("Invalid lazy kernel manager module")}

package/dist/kernel/manager-registration.d.ts

@@ -0,0 +1,25 @@
+import type { KernelManager } from './types';
+export type KernelManagerModule = KernelManager | {
+    default: KernelManager;
+} | {
+    manager: KernelManager;
+};
+export type KernelManagerLoader = () => Promise<KernelManagerModule> | KernelManagerModule;
+export interface LazyKernelManagerRegistration {
+    load: KernelManagerLoader;
+    eager?: boolean;
+    config?: unknown;
+}
+export interface EagerKernelManagerRegistration {
+    manager: KernelManager;
+    eager?: boolean;
+    config?: unknown;
+}
+export type KernelManagerRegistration = KernelManager | LazyKernelManagerRegistration | EagerKernelManagerRegistration;
+export interface KernelLazyManagerOptions {
+    eager?: boolean;
+}
+export declare function isKernelManager(value: unknown): value is KernelManager;
+export declare function isLazyKernelManagerRegistration(value: KernelManagerRegistration): value is LazyKernelManagerRegistration;
+export declare function isEagerKernelManagerRegistration(value: KernelManagerRegistration): value is EagerKernelManagerRegistration;
+export declare function resolveKernelManagerModule(module: KernelManagerModule): KernelManager;

package/dist/kernel/manager-registration.js

@@ -0,0 +1 @@
+export function isKernelManager(value){return typeof value==="object"&&value!==null&&typeof value.initialize==="function"}export function isLazyKernelManagerRegistration(value){return typeof value==="object"&&value!==null&&"load"in value}export function isEagerKernelManagerRegistration(value){return typeof value==="object"&&value!==null&&"manager"in value}export function resolveKernelManagerModule(module){if(isKernelManager(module)){return module}if("manager"in module&&isKernelManager(module.manager)){return module.manager}if("default"in module&&isKernelManager(module.default)){return module.default}throw new Error("Invalid lazy kernel manager module")}

package/dist/kernel/types.d.ts

@@ -1,6 +1,7 @@
 import type { LogLevel } from '@vlian/logger';
 import type { StorageInstance } from '@vlian/utils';
 import type { StorageType } from '@vlian/utils';
+import type { KernelManagerRegistration } from './manager-registration';
 export type StorageOptions = {
     prefix: string;
     defaultExpire: number;
@@ -81,7 +82,7 @@ export interface StartOptions extends CoreStartOptions {
     config?: Partial<KernelConfig>;
     configLoader?: () => Promise<Partial<KernelConfig> | void> | Partial<KernelConfig> | void;
     render?: (context: KernelRenderContext) => Promise<void> | void;
-    customManagers?: Record<string, KernelManager>;
+    customManagers?: Record<string, KernelManagerRegistration>;
     managerConfigs?: Record<string, unknown>;
     hooks?: StartupHooks;
 }

package/dist/theme.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 DEFAULT_THEME(){return _theme.DEFAULT_THEME},get DEFAULT_THEME_MANAGER_CONFIG(){return _theme.DEFAULT_THEME_MANAGER_CONFIG},get THEME_MANAGER_NAME(){return _theme.THEME_MANAGER_NAME},get ThemeManager(){return _theme.ThemeManager},get registerThemeManager(){return _theme.registerThemeManager}});const _theme=require("./kernel/custom-manager/theme");
+"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 _theme.DEFAULT_THEME},get DEFAULT_THEME_MANAGER_CONFIG(){return _theme.DEFAULT_THEME_MANAGER_CONFIG},get THEME_MANAGER_NAME(){return _theme.THEME_MANAGER_NAME},get ThemeManager(){return _theme.ThemeManager},get registerLazyThemeManager(){return _theme.registerLazyThemeManager},get registerThemeManager(){return _theme.registerThemeManager}});const _theme=require("./kernel/custom-manager/theme");

package/dist/theme.d.ts

@@ -1,2 +1,2 @@
-export { ThemeManager, DEFAULT_THEME, DEFAULT_THEME_MANAGER_CONFIG, THEME_MANAGER_NAME, registerThemeManager, } from './kernel/custom-manager/theme';
+export { ThemeManager, DEFAULT_THEME, DEFAULT_THEME_MANAGER_CONFIG, THEME_MANAGER_NAME, registerLazyThemeManager, registerThemeManager, } from './kernel/custom-manager/theme';
 export type { ResolvedThemeMode, ResolvedThemeSnapshot, ThemeManagerConfig, ThemeSnapshot, } from './kernel/custom-manager/theme';

package/dist/theme.js

@@ -1 +1 @@
-export{ThemeManager,DEFAULT_THEME,DEFAULT_THEME_MANAGER_CONFIG,THEME_MANAGER_NAME,registerThemeManager}from"./kernel/custom-manager/theme";
+export{ThemeManager,DEFAULT_THEME,DEFAULT_THEME_MANAGER_CONFIG,THEME_MANAGER_NAME,registerLazyThemeManager,registerThemeManager}from"./kernel/custom-manager/theme";

package/dist/theme.lazy.cjs

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

package/dist/theme.lazy.d.ts

@@ -0,0 +1,2 @@
+export { registerLazyThemeManager } from './kernel/custom-manager/theme/lazy';
+export type { ThemeManagerConfig } from './kernel/custom-manager/theme';

package/dist/theme.lazy.js

@@ -0,0 +1 @@
+export{registerLazyThemeManager}from"./kernel/custom-manager/theme/lazy";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vlian/framework",
-  "version": "2.0.2",
+  "version": "2.0.3",
   "private": false,
   "packageManager": "pnpm@10.27.0",
   "description": "Secra Framework - 一个现代化的低代码框架",
@@ -20,11 +20,21 @@
       "import": "./dist/theme.js",
       "require": "./dist/theme.cjs"
     },
+    "./theme/lazy": {
+      "types": "./dist/theme.lazy.d.ts",
+      "import": "./dist/theme.lazy.js",
+      "require": "./dist/theme.lazy.cjs"
+    },
     "./i18n": {
       "types": "./dist/i18n.d.ts",
       "import": "./dist/i18n.js",
       "require": "./dist/i18n.cjs"
     },
+    "./i18n/lazy": {
+      "types": "./dist/i18n.lazy.d.ts",
+      "import": "./dist/i18n.lazy.js",
+      "require": "./dist/i18n.lazy.cjs"
+    },
     "./kernel": {
       "types": "./dist/kernel/index.d.ts",
       "import": "./dist/kernel/index.js",
@@ -42,9 +52,15 @@
       "theme": [
         "dist/theme.d.ts"
       ],
+      "theme/lazy": [
+        "dist/theme.lazy.d.ts"
+      ],
       "i18n": [
         "dist/i18n.d.ts"
       ],
+      "i18n/lazy": [
+        "dist/i18n.lazy.d.ts"
+      ],
       "kernel": [
         "dist/kernel/index.d.ts"
       ],
@@ -64,9 +80,15 @@
     "dist/theme.cjs",
     "dist/theme.d.ts",
     "dist/theme.js",
+    "dist/theme.lazy.cjs",
+    "dist/theme.lazy.d.ts",
+    "dist/theme.lazy.js",
     "dist/i18n.cjs",
     "dist/i18n.d.ts",
     "dist/i18n.js",
+    "dist/i18n.lazy.cjs",
+    "dist/i18n.lazy.d.ts",
+    "dist/i18n.lazy.js",
     "dist/kernel",
     "README.md",
     "LICENSE"