@yumerijs/core 1.3.3 → 2.0.1

package/dist/context.d.ts

@@ -1,12 +1,14 @@
-/**
- * @time: 2025/08/14 19:10
- * @author: FireGuo
- * WindyPear-Team All right reserved
- **/
 import { Core } from './core';
 import { Route } from './route';
 import { HookHandler } from './hook';
 import { Middleware } from './middleware';
+import { Config } from './config';
+interface Plugin {
+    apply: (ctx: Context, config: Config) => Promise<void>;
+    disable: (ctx: Context) => Promise<void>;
+    depend: Array<string>;
+    provide: Array<string>;
+}
 /**
  * 插件上下文对象
  * 每个插件一个 Context，用于管理插件注册的命令、路由、事件、组件和中间件
@@ -18,9 +20,10 @@ export declare class Context {
     private components;
     private middlewares;
     private hooks;
-    /**
-     * 插件名称
-     */
+    private childContexts;
+    private childPlugins;
+    private i18ns;
+    /** 插件名称 */
     pluginname: string;
     /**
      * 创建 Context 实例
@@ -57,25 +60,19 @@ export declare class Context {
      * 执行 Hook 钩子
      * @param name Hook 点名称
      * @param args Hook 参数
-     * @returns Promise<any[]>
      */
     executeHook(name: string, ...args: any[]): Promise<any[]>;
-    /**
-     * 获取 Core 实例
-     * @returns Core
-     */
+    /** 获取 Core 实例 */
     getCore(): Core;
     /**
      * 触发事件
      * @param event 事件名称
      * @param args 事件参数
-     * @returns Promise<void>
      */
     emit(event: string, ...args: any[]): Promise<void>;
     /**
      * 获取组件实例
      * @param name 组件名称
-     * @returns 组件实例
      */
     getComponent(name: string): any;
     /**
@@ -84,9 +81,26 @@ export declare class Context {
      * @param component 组件实例
      */
     registerComponent(name: string, component: any): void;
+    /**
+     * 注册子 Context
+     * @param name 子 Context 名称
+     */
+    fork(name?: string): Context;
+    /**
+     * 注册子插件
+     * @param plugin 插件实例
+     * @param config 插件配置
+     */
+    apply(plugin: Plugin, config: Config): Promise<void>;
+    /**
+     * 注册 i18n
+     * @param content 内容（可以是嵌套对象或单个key）
+     * @param locale 可选的语言映射
+     */
+    i18n(content: string | Record<string, any>, locale?: Record<string, string>): void;
     /**
      * 卸载插件时清理注册的所有资源
-     * 包括组件、路由、中间件和事件监听器
      */
-    dispose(): void;
+    dispose(): Promise<void>;
 }
+export {};

package/dist/context.js

@@ -13,9 +13,10 @@ class Context {
     components = [];
     middlewares = [];
     hooks = {};
-    /**
-     * 插件名称
-     */
+    childContexts = [];
+    childPlugins = new Map();
+    i18ns = [];
+    /** 插件名称 */
     pluginname;
     /**
      * 创建 Context 实例
@@ -25,6 +26,7 @@ class Context {
     constructor(core, pluginname) {
         this.core = core;
         this.pluginname = pluginname;
+        this.childPlugins = new Map();
     }
     /**
      * 注册路由
@@ -45,9 +47,9 @@ class Context {
      * @param listener 事件监听器
      */
     on(name, listener) {
-        // 记录插件自己的事件监听器
+        if (!listener)
+            return;
         this.eventlisteners.push({ name, listener });
-        // 注册到 core 的全局事件监听器中
         this.core.on(name, listener);
     }
     /**
@@ -56,6 +58,8 @@ class Context {
      * @param callback 中间件回调函数
      */
     use(name, callback) {
+        if (!callback)
+            return;
         this.middlewares.push(name);
         this.core.use(name, callback);
     }
@@ -66,22 +70,22 @@ class Context {
      * @param callback 钩子回调函数
      */
     hook(name, hookname, callback) {
+        if (!callback || !hookname)
+            return;
         this.core.hook(name, hookname, callback);
+        if (!this.hooks[name])
+            this.hooks[name] = [];
         this.hooks[name].push(hookname);
     }
     /**
      * 执行 Hook 钩子
      * @param name Hook 点名称
      * @param args Hook 参数
-     * @returns Promise<any[]>
      */
     async executeHook(name, ...args) {
         return await this.core.hookExecute(name, ...args);
     }
-    /**
-     * 获取 Core 实例
-     * @returns Core
-     */
+    /** 获取 Core 实例 */
     getCore() {
         return this.core;
     }
@@ -89,7 +93,6 @@ class Context {
      * 触发事件
      * @param event 事件名称
      * @param args 事件参数
-     * @returns Promise<void>
      */
     async emit(event, ...args) {
         return await this.core.emit(event, ...args);
@@ -97,7 +100,6 @@ class Context {
     /**
      * 获取组件实例
      * @param name 组件名称
-     * @returns 组件实例
      */
     getComponent(name) {
         return this.core.getComponent(name);
@@ -108,6 +110,8 @@ class Context {
      * @param component 组件实例
      */
     registerComponent(name, component) {
+        if (!component)
+            return;
         if (this.core.components[name]) {
             this.core.logger.warn(`Plugin "${this.pluginname}" attempt to register component "${name}", but it has already been registered.`);
             return;
@@ -115,41 +119,107 @@ class Context {
         this.core.components[name] = component;
         this.components.push(name);
     }
+    /**
+     * 注册子 Context
+     * @param name 子 Context 名称
+     */
+    fork(name = this.pluginname) {
+        const ctx = new Context(this.core, name);
+        this.childContexts.push(ctx);
+        return ctx;
+    }
+    /**
+     * 注册子插件
+     * @param plugin 插件实例
+     * @param config 插件配置
+     */
+    async apply(plugin, config) {
+        if (!plugin || !plugin.apply)
+            return;
+        const ctx = this.fork();
+        await plugin.apply(ctx, config);
+        this.childPlugins.set(ctx, plugin);
+    }
+    /**
+     * 注册 i18n
+     * @param content 内容（可以是嵌套对象或单个key）
+     * @param locale 可选的语言映射
+     */
+    i18n(content, locale) {
+        if (!this.i18ns)
+            this.i18ns = [];
+        const isLangObject = (obj) => typeof obj === 'object' && Object.values(obj).every(v => typeof v === 'string');
+        const flatten = (obj, prefix = '') => {
+            const result = {};
+            for (const [key, value] of Object.entries(obj)) {
+                const fullKey = prefix ? `${prefix}.${key}` : key;
+                if (isLangObject(value)) {
+                    result[fullKey] = value;
+                }
+                else if (typeof value === 'object') {
+                    Object.assign(result, flatten(value, fullKey));
+                }
+            }
+            return result;
+        };
+        if (typeof content === 'string' && locale) {
+            this.core.i18n.register(content, locale);
+            this.i18ns.push(content);
+        }
+        else if (typeof content === 'object') {
+            const flat = flatten(content);
+            this.core.i18n.register(flat);
+            this.i18ns.push(...Object.keys(flat));
+        }
+    }
     /**
      * 卸载插件时清理注册的所有资源
-     * 包括组件、路由、中间件和事件监听器
      */
-    dispose() {
+    async dispose() {
         // 删除组件
-        this.components.forEach((name) => {
-            delete this.core.components[name];
-        });
+        this.components.forEach((name) => delete this.core.components[name]);
         // 删除路由
-        this.routes.forEach((route) => {
-            delete this.core.routes[route];
-        });
+        this.routes.forEach((route) => delete this.core.routes[route]);
         // 删除中间件
-        this.middlewares.forEach((middleware) => {
-            delete this.core.globalMiddlewares[middleware];
-        });
+        this.middlewares.forEach((middleware) => delete this.core.globalMiddlewares[middleware]);
         // 删除事件监听器
         this.eventlisteners.forEach(({ name, listener }) => {
-            if (this.core.eventListeners?.[name]) {
-                this.core.eventListeners[name] =
-                    this.core.eventListeners[name].filter((l) => l !== listener);
+            const listeners = this.core.eventListeners?.[name];
+            if (listeners) {
+                this.core.eventListeners[name] = listeners.filter(l => l !== listener);
             }
         });
         // 删除钩子
         for (const hook in this.hooks) {
             this.hooks[hook].forEach((hookname) => {
-                this.core.unhook(hook, hookname);
+                if (hookname)
+                    this.core.unhook(hook, hookname);
             });
         }
-        // 清空 Context 内部记录，避免内存泄漏
+        // 卸载子插件（异步即可，不必按顺序）
+        this.childPlugins.forEach(async (plugin, ctx) => {
+            if (plugin?.disable)
+                await plugin.disable(ctx);
+        });
+        // 删除子上下文
+        this.childContexts.forEach((ctx) => {
+            if (ctx?.dispose)
+                ctx.dispose();
+        });
+        // 删除i18n
+        if (this.i18ns?.length) {
+            for (const key of this.i18ns) {
+                this.core.i18n.delete(key);
+            }
+            this.i18ns.length = 0;
+        }
+        // 清空内部记录
         this.components = [];
         this.routes = [];
         this.middlewares = [];
         this.eventlisteners = [];
+        this.hooks = {};
+        this.childContexts = [];
     }
 }
 exports.Context = Context;

package/dist/core.d.ts

@@ -6,42 +6,27 @@ import { Route } from './route';
 import { Context } from './context';
 import { HookHandler, Hook } from './hook';
 import { Server as CoreServer } from './server';
+import { I18n } from './i18n';
 interface Plugin {
     apply: (ctx: Context, config: Config) => Promise<void>;
     disable: (ctx: Context) => Promise<void>;
     depend: Array<string>;
     provide: Array<string>;
 }
-interface PluginLoader {
-    load(pluginName: string): Promise<Plugin>;
-    unloadPlugin(pluginName: string): Promise<void>;
-    checkPluginDependencies(pluginPath: string): Promise<boolean>;
-    installPluginDependencies(pluginName: string): Promise<void>;
-    logger: Logger;
-}
 interface CoreOptions {
     port: number;
     host: string;
     staticDir: string;
     enableCors: boolean;
     enableWs: boolean;
+    lang: string[];
 }
-/**
- * 定义插件状态枚举
- */
 export declare const enum PluginStatus {
-    ENABLED = "enabled",// 正常启用
-    DISABLED = "disabled",// 已禁用
+    ENABLED = "enabled",
+    DISABLED = "disabled",
     PENDING = "pending"
 }
 export declare class Core {
-    plugins: {
-        [name: string]: Plugin & {
-            depend?: string[];
-            provide?: string[];
-        };
-    };
-    config: any;
     eventListeners: {
         [event: string]: ((...args: any[]) => Promise<void>)[];
     };
@@ -49,162 +34,28 @@ export declare class Core {
         [name: string]: any;
     };
     routes: Record<string, Route>;
-    pluginLoader: PluginLoader;
     logger: Logger;
     globalMiddlewares: Record<string, Middleware>;
-    pluginStatus: Record<string, PluginStatus>;
     hooks: Record<string, Hook>;
     coreConfig: CoreOptions;
     server: CoreServer;
-    private pluginWatchers;
-    private pluginModules;
-    private configPath;
-    /**
-     * 插件名 -> Context 映射
-     */
-    private pluginContexts;
-    constructor(pluginLoader?: PluginLoader, coreConfig?: CoreOptions);
-    /**
-     * 获取或创建插件对应 Context
-     */
-    getContext(pluginName: string): Context;
-    /**
-     * 清理指定插件注册的所有内容
-     */
-    unregall(pluginName: string): void;
-    /**
-     * 加载配置文件
-     * @param configPath 配置文件的路径
-     */
-    loadConfig(configPath: string): Promise<void>;
-    /**
-     * 启动应用
-     * @returns Promise<void>
-     */
+    i18n: I18n;
+    loader: any;
+    constructor(loader?: any, coreConfig?: CoreOptions, setCore?: boolean);
     runCore(): Promise<void>;
-    /**
-     * 监听配置文件变化，实现热重载
-     * @param configPath 配置文件的路径
-     */
-    private watchConfig;
-    /**
-     * 获取指定插件的配置
-     * @param pluginName 插件名称
-     * @returns 插件的配置对象
-     */
-    getPluginConfig(pluginName: string): Promise<Config>;
-    /**
-     * 加载所有在配置文件中启用的插件
-     * @returns Promise<void>
-     */
-    loadPlugins(): Promise<void>;
-    /**
-     * 加载单个插件
-     * @param pluginName 要加载的插件名
-     * @param triggerPendingCheck 是否在加载后触发对其他待定插件的检查，默认为 true
-     * @returns Promise<boolean> 是否加载成功
-     */
-    loadSinglePlugin(pluginName: string, triggerPendingCheck?: boolean, onlypending?: boolean): Promise<boolean>;
-    /**
-     * 尝试加载所有处于 PENDING 状态的插件
-     * @returns Promise<void>
-     */
-    private _loadPendingPlugins;
-    /**
-     * 卸载插件，并递归卸载依赖于它的其他插件
-     * @param pluginNameToUnload 要卸载的插件名
-     */
-    unloadPlugin(pluginNameToUnload: string, ispending?: boolean): Promise<void>;
-    /**
-     * 执行单个插件的卸载逻辑
-     * @param pluginName 插件名
-     * @param ispending 是否处于 PENDING 状态
-     */
-    private _unloadSinglePlugin;
-    /**
-     * 重新加载插件
-     * @param pluginName 插件名称
-     */
-    reloadPlugin(pluginName: string): Promise<void>;
-    /**
-     * 监听插件文件变化
-     * @param pluginName 插件名称
-     * @param pluginPath 插件路径
-     */
-    private watchPlugin;
-    /**
-     * 注册组件
-     * @param name 组件名称
-     * @param component 组件实例
-     */
+    getShortPluginName(pluginName: string): string;
+    plugin(pluginInstance: Plugin, context: Context, config: Config): Promise<void>;
     registerComponent(name: string, component: any): void;
-    /**
-     * 获取组件
-     * @param name 组件名称
-     * @returns 组件实例
-     */
     getComponent(name: string): any;
-    /**
-     * 注销组件
-     * @param name 组件名称
-     */
     unregisterComponent(name: string): void;
-    /**
-     * 注册事件监听器
-     * @param event 事件名称
-     * @param listener 事件回调函数
-     */
     on(event: string, listener: (...args: any[]) => Promise<void>): void;
-    /**
-     * 触发事件
-     * @param event 事件名称
-     * @param args 传递给事件监听器的参数
-     */
     emit(event: string, ...args: any[]): Promise<void>;
-    /**
-     * 注册全局中间件
-     * @param name 中间件名称
-     * @param middleware 中间件函数
-     * @returns Core 实例
-     */
     use(name: string, middleware: Middleware): Core;
-    /**
-     * 注册路由
-     * @param path 路由路径
-     * @returns Route 实例
-     */
     route(path: string): Route;
-    /**
-     * 注册 Hook 钩子
-     * @param name Hook 点名称
-     * @param hookname 钩子名称
-     * @param callback 钩子函数
-     */
     hook(name: string, hookname: string, callback: HookHandler): any;
-    /**
-     * 消除 Hook 钩子
-     */
     unhook(name: string, hookname: string): any;
-    /**
-     * 执行 Hook 钩子
-     * @param name Hook 点名称
-     * @param args 参数
-     * @return Promise<any[]>
-     */
     hookExecute(name: string, ...args: any[]): Promise<any[]>;
-    /**
-     * 执行路由
-     * @param pathname 需要匹配的URL
-     * @param session 当前会话
-     * @param queryParams URL参数
-     * @returns 是否匹配成功
-     */
     executeRoute(pathname: string, session: Session, queryParams: URLSearchParams): Promise<boolean>;
-    /**
-     * 获取路由
-     * @param path 匹配路径
-     * @return Route 实例或 false
-     */
     getRoute(path: string): Route | false;
 }
 export {};