@yumerijs/core 1.1.0-alpha.5 → 1.1.1

package/dist/command.d.ts

@@ -6,14 +6,74 @@
 import { Core } from './core';
 import { Session } from './session';
 import { Middleware } from './middleware';
+/**
+ * 命令处理函数接口
+ * @param session 会话对象
+ * @param args 其他参数
+ * @returns Promise<any>
+ */
 interface ActionFn {
     (session: any, ...args: any[]): Promise<any>;
 }
+/**
+ * 支持的协议类型
+ * @enum {string}
+ */
+export declare enum ProtocolType {
+    /** HTTP 协议 */
+    HTTP = "http",
+    /** WebSocket 协议 */
+    WS = "ws",
+    /** 所有协议 */
+    ALL = "all"
+}
+/**
+ * 支持的 HTTP 方法
+ * @enum {string}
+ */
+export declare enum HttpMethod {
+    /** GET 请求方法 */
+    GET = "get",
+    /** POST 请求方法 */
+    POST = "post",
+    /** PUT 请求方法 */
+    PUT = "put",
+    /** DELETE 请求方法 */
+    DELETE = "delete",
+    /** PATCH 请求方法 */
+    PATCH = "patch",
+    /** HEAD 请求方法 */
+    HEAD = "head",
+    /** OPTIONS 请求方法 */
+    OPTIONS = "options",
+    /** 所有 HTTP 方法 */
+    ALL = "all"
+}
+/**
+ * 命令类，用于注册和执行命令
+ */
 export declare class Command {
+    /** 命令名称 */
     name: string;
+    /** 命令处理函数 */
     actionFn: ActionFn | null;
+    /** WebSocket 连接处理函数 */
+    connectFn: ActionFn | null;
+    /** WebSocket 关闭处理函数 */
+    closeFn: ActionFn | null;
+    /** 核心实例 */
     core: Core;
+    /** 命令特定的中间件数组 */
     middlewares: Middleware[];
+    /** 支持的协议类型，默认为所有协议 */
+    protocol: ProtocolType;
+    /** 支持的 HTTP 方法，默认为所有方法 */
+    httpMethods: HttpMethod[];
+    /**
+     * 创建命令实例
+     * @param core 核心实例
+     * @param name 命令名称
+     */
     constructor(core: Core, name: string);
     /**
      * 注册命令处理函数
@@ -21,6 +81,42 @@ export declare class Command {
      * @returns this 支持链式调用
      */
     action(fn: ActionFn): this;
+    /**
+     * 注册 WebSocket 关闭处理函数
+     * @param fn 处理函数
+     * @returns this 支持链式调用
+     */
+    close(fn: ActionFn): this;
+    /**
+     * 注册 WebSocket 连接处理函数
+     * @param fn 处理函数
+     * @returns this 支持链式调用
+     */
+    connect(fn: ActionFn): this;
+    /**
+     * 设置命令支持的协议类型
+     * @param protocol 协议类型
+     * @returns this 支持链式调用
+     */
+    setProtocol(protocol: ProtocolType): this;
+    /**
+     * 设置命令支持的 HTTP 方法
+     * @param methods 单个 HTTP 方法或 HTTP 方法数组
+     * @returns this 支持链式调用
+     */
+    setHttpMethods(methods: HttpMethod | HttpMethod[]): this;
+    /**
+     * 检查命令是否支持指定的协议类型
+     * @param protocol 协议类型
+     * @returns 是否支持
+     */
+    supportsProtocol(protocol: ProtocolType): boolean;
+    /**
+     * 检查命令是否支持指定的 HTTP 方法
+     * @param method HTTP 方法
+     * @returns 是否支持
+     */
+    supportsHttpMethod(method: string): boolean;
     /**
      * 注册命令特定的中间件
      * @param middleware 中间件函数

package/dist/command.js

@@ -5,11 +5,69 @@
  * WindyPear-Team All right reserved
  **/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Command = void 0;
+exports.Command = exports.HttpMethod = exports.ProtocolType = void 0;
+/**
+ * 支持的协议类型
+ * @enum {string}
+ */
+var ProtocolType;
+(function (ProtocolType) {
+    /** HTTP 协议 */
+    ProtocolType["HTTP"] = "http";
+    /** WebSocket 协议 */
+    ProtocolType["WS"] = "ws";
+    /** 所有协议 */
+    ProtocolType["ALL"] = "all";
+})(ProtocolType || (exports.ProtocolType = ProtocolType = {}));
+/**
+ * 支持的 HTTP 方法
+ * @enum {string}
+ */
+var HttpMethod;
+(function (HttpMethod) {
+    /** GET 请求方法 */
+    HttpMethod["GET"] = "get";
+    /** POST 请求方法 */
+    HttpMethod["POST"] = "post";
+    /** PUT 请求方法 */
+    HttpMethod["PUT"] = "put";
+    /** DELETE 请求方法 */
+    HttpMethod["DELETE"] = "delete";
+    /** PATCH 请求方法 */
+    HttpMethod["PATCH"] = "patch";
+    /** HEAD 请求方法 */
+    HttpMethod["HEAD"] = "head";
+    /** OPTIONS 请求方法 */
+    HttpMethod["OPTIONS"] = "options";
+    /** 所有 HTTP 方法 */
+    HttpMethod["ALL"] = "all";
+})(HttpMethod || (exports.HttpMethod = HttpMethod = {}));
+/**
+ * 命令类，用于注册和执行命令
+ */
 class Command {
+    /** 命令名称 */
+    name;
+    /** 命令处理函数 */
+    actionFn = null;
+    /** WebSocket 连接处理函数 */
+    connectFn = null;
+    /** WebSocket 关闭处理函数 */
+    closeFn = null;
+    /** 核心实例 */
+    core;
+    /** 命令特定的中间件数组 */
+    middlewares = [];
+    /** 支持的协议类型，默认为所有协议 */
+    protocol = ProtocolType.ALL;
+    /** 支持的 HTTP 方法，默认为所有方法 */
+    httpMethods = [HttpMethod.ALL];
+    /**
+     * 创建命令实例
+     * @param core 核心实例
+     * @param name 命令名称
+     */
     constructor(core, name) {
-        this.actionFn = null;
-        this.middlewares = []; // 存储命令特定的中间件
         this.core = core;
         this.name = name;
     }
@@ -22,6 +80,65 @@ class Command {
         this.actionFn = fn;
         return this;
     }
+    /**
+     * 注册 WebSocket 关闭处理函数
+     * @param fn 处理函数
+     * @returns this 支持链式调用
+     */
+    close(fn) {
+        this.closeFn = fn;
+        return this;
+    }
+    /**
+     * 注册 WebSocket 连接处理函数
+     * @param fn 处理函数
+     * @returns this 支持链式调用
+     */
+    connect(fn) {
+        this.connectFn = fn;
+        return this;
+    }
+    /**
+     * 设置命令支持的协议类型
+     * @param protocol 协议类型
+     * @returns this 支持链式调用
+     */
+    setProtocol(protocol) {
+        this.protocol = protocol;
+        return this;
+    }
+    /**
+     * 设置命令支持的 HTTP 方法
+     * @param methods 单个 HTTP 方法或 HTTP 方法数组
+     * @returns this 支持链式调用
+     */
+    setHttpMethods(methods) {
+        if (Array.isArray(methods)) {
+            this.httpMethods = methods;
+        }
+        else {
+            this.httpMethods = [methods];
+        }
+        return this;
+    }
+    /**
+     * 检查命令是否支持指定的协议类型
+     * @param protocol 协议类型
+     * @returns 是否支持
+     */
+    supportsProtocol(protocol) {
+        return this.protocol === ProtocolType.ALL || this.protocol === protocol;
+    }
+    /**
+     * 检查命令是否支持指定的 HTTP 方法
+     * @param method HTTP 方法
+     * @returns 是否支持
+     */
+    supportsHttpMethod(method) {
+        const lowerMethod = method.toLowerCase();
+        return this.httpMethods.includes(HttpMethod.ALL) ||
+            this.httpMethods.some(m => m.toLowerCase() === lowerMethod);
+    }
     /**
      * 注册命令特定的中间件
      * @param middleware 中间件函数

package/dist/config.js

@@ -11,6 +11,34 @@ exports.Config = exports.ConfigSchema = void 0;
  * 用于描述插件配置项的类型、默认值、描述等信息
  */
 class ConfigSchema {
+    /**
+     * 配置项类型
+     */
+    type;
+    /**
+     * 默认值
+     */
+    default;
+    /**
+     * 配置项描述
+     */
+    description;
+    /**
+     * 是否必需
+     */
+    required;
+    /**
+     * 枚举值列表（可选项）
+     */
+    enum;
+    /**
+     * 数组项类型定义（当type为array时使用）
+     */
+    items;
+    /**
+     * 对象属性定义（当type为object时使用）
+     */
+    properties;
     /**
      * 创建配置模式对象
      * @param type 配置项类型
@@ -72,6 +100,18 @@ class ConfigSchema {
 }
 exports.ConfigSchema = ConfigSchema;
 class Config {
+    /**
+     * 配置名称
+     */
+    name = '';
+    /**
+     * 配置内容
+     */
+    content = {};
+    /**
+     * 配置模式
+     */
+    schema;
     /**
      * 创建配置对象
      * @param name 配置名称
@@ -79,14 +119,6 @@ class Config {
      * @param schema 配置模式
      */
     constructor(name, content, schema) {
-        /**
-         * 配置名称
-         */
-        this.name = '';
-        /**
-         * 配置内容
-         */
-        this.content = {};
         this.name = name;
         this.content = content || {}; // 如果 content 是 undefined，则赋值为空对象
         this.schema = schema;

package/dist/context.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Context = void 0;
 const command_1 = require("./command");
 class Context {
+    core;
+    pluginname;
     constructor(core, pluginname) {
         this.core = core;
         this.pluginname = pluginname;

package/dist/core.d.ts

@@ -45,14 +45,31 @@ export declare class Core {
     evttoplu: Record<string, Record<string, ((...args: any[]) => Promise<void>)[]>>;
     mdwtoplu: Record<string, string>;
     plftoplu: Record<string, string>;
+    /**
+     * 创建Core实例
+     * @param pluginLoader 插件加载器
+     */
     constructor(pluginLoader: PluginLoader);
+    /**
+     * 加载配置文件
+     * @param configPath 配置文件路径
+     */
     loadConfig(configPath: string): Promise<void>;
     /**
      * 监听配置文件变化
      * @param configPath 配置文件路径
      */
     private watchConfig;
+    /**
+     * 获取插件配置
+     * @param pluginName 插件名称
+     * @returns 配置
+     */
     getPluginConfig(pluginName: string): Promise<Config>;
+    /**
+     * 加载插件
+     * @returns Promise<void>
+     */
     loadPlugins(): Promise<void>;
     /**
      * 监听插件目录，实现热重载
@@ -72,15 +89,73 @@ export declare class Core {
      * @param core Core实例
      */
     unloadPluginAndEmit(pluginName: string, core: Core): Promise<void>;
+    /**
+     * 注册组件
+     * @param name 组件名称
+     * @param component 组件
+     * @returns 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 name 指令名称
+     * @returns 指令对象
+     */
     command(name: string): Command;
+    /**
+     * 执行指令
+     * @param name 指令名称
+     * @param session 会话
+     * @param args 参数
+     * @returns 回话/null
+     */
     executeCommand(name: string, session: any, ...args: any[]): Promise<Session | null>;
+    /**
+     * 注册平台
+     * @param platform 平台名称
+     * @returns 启动结果
+     */
     registerPlatform(platform: Platform): any;
+    /**
+     * 取消注册插件
+     * @param pluginname 插件名称
+     */
     unregall(pluginname: string): void;
+    /**
+     * 获取指令对象
+     * @param name 指令名称
+     * @returns null/指令对象
+     */
+    getCommand(name: string): Command | null;
 }
 export {};

package/dist/core.js

@@ -51,26 +51,34 @@ const command_1 = require("./command");
 const chokidar_1 = __importDefault(require("chokidar"));
 const context_1 = require("./context");
 class Core {
+    plugins = {};
+    config = null;
+    platforms = [];
+    eventListeners = {};
+    components = {};
+    commands = {};
+    pluginLoader;
+    logger = new logger_1.Logger('core');
+    providedComponents = {};
+    pluginModules = {};
+    configPath = ''; // 存储配置文件路径
+    globalMiddlewares = {}; // 全局中间件数组
+    cmdtoplu = {}; // 存储命令与插件名的映射关系
+    comtoplu = {}; // 存储组件与插件名的映射关系
+    evttoplu = {}; // 存储事件与插件名的映射关系
+    mdwtoplu = {}; // 存储中间件与插件名的映射关系
+    plftoplu = {}; // 存储平台与插件名的映射关系
+    /**
+     * 创建Core实例
+     * @param pluginLoader 插件加载器
+     */
     constructor(pluginLoader) {
-        this.plugins = {};
-        this.config = null;
-        this.platforms = [];
-        this.eventListeners = {};
-        this.components = {};
-        this.commands = {};
-        this.logger = new logger_1.Logger('core');
-        this.providedComponents = {};
-        this.pluginModules = {};
-        this.configPath = ''; // 存储配置文件路径
-        this.globalMiddlewares = {}; // 全局中间件数组
-        this.cmdtoplu = {}; // 存储命令与插件名的映射关系
-        this.comtoplu = {}; // 存储组件与插件名的映射关系
-        this.evttoplu = {}; // 存储事件与插件名的映射关系
-        this.mdwtoplu = {}; // 存储中间件与插件名的映射关系
-        this.plftoplu = {}; // 存储平台与插件名的映射关系
         this.pluginLoader = pluginLoader;
     }
-    // 加载配置文件
+    /**
+     * 加载配置文件
+     * @param configPath 配置文件路径
+     */
     async loadConfig(configPath) {
         try {
             this.configPath = configPath; // 保存配置文件路径
@@ -116,6 +124,11 @@ class Core {
         });
         this.logger.info(`Watching for config changes at ${configPath}`);
     }
+    /**
+     * 获取插件配置
+     * @param pluginName 插件名称
+     * @returns 配置
+     */
     async getPluginConfig(pluginName) {
         // 如果插件名以~开头，则去掉~前缀获取配置
         const actualPluginName = pluginName.startsWith('~') ? pluginName.substring(1) : pluginName;
@@ -137,110 +150,81 @@ class Core {
         const config = new config_1.Config(actualPluginName, this.config.plugins[actualPluginName]);
         return config;
     }
-    // 加载插件
+    /**
+     * 加载插件
+     * @returns Promise<void>
+     */
     async loadPlugins() {
-        // 检查 plugins 配置是否存在且是对象类型
         if (!this.config || typeof this.config.plugins !== 'object' || this.config.plugins === null) {
             this.logger.info('No plugins configuration found or it is not an object. No plugins to load.');
             return;
         }
-        // 获取所有需要加载的插件名，过滤掉以~开头的插件（禁用的插件）
         const pluginNamesToLoad = Object.keys(this.config.plugins).filter(name => !name.startsWith('~'));
         if (pluginNamesToLoad.length === 0) {
             this.logger.info('No enabled plugins found in configuration. All plugins might be disabled or configuration is empty.');
             return;
         }
-        // 记录被禁用的插件
         const disabledPlugins = Object.keys(this.config.plugins).filter(name => name.startsWith('~'));
         if (disabledPlugins.length > 0) {
             this.logger.info(`Skipping disabled plugins: ${disabledPlugins.join(', ')}`);
         }
         const loadedPluginNames = [];
-        // 使用对象来跟踪尝试加载的插件名
         let loadAttempted = {};
-        // 使用插件名数组来管理剩余待加载的插件
         let remainingPluginNames = [...pluginNamesToLoad];
-        // 不加载名称以~开头的插件
-        remainingPluginNames = remainingPluginNames.filter(name => !name.startsWith('~'));
-        // 多次尝试加载插件，直到所有插件加载完毕或检测到循环依赖
         while (remainingPluginNames.length > 0) {
             let loadedInThisPass = false;
-            // 用于存储下一轮尝试加载的插件名
             const nextRemainingPluginNames = [];
-            // 遍历当前剩余待加载的插件名
             for (const pluginName of remainingPluginNames) {
-                // 如果插件已经加载或已尝试加载，则跳过
-                if (loadedPluginNames.includes(pluginName) || loadAttempted[`${pluginName}`]) {
+                if (loadedPluginNames.includes(pluginName)) {
                     continue;
                 }
-                // 标记该插件已尝试加载
-                loadAttempted[`${pluginName}`] = true;
                 try {
-                    this.logger.info(`Attempting to load plugin: ${pluginName}`);
-                    // 使用插件名加载插件实例和模块
+                    // this.logger.info(`Attempting to load plugin: ${pluginName}`);
                     const pluginInstance = await this.pluginLoader.load(pluginName);
-                    //const pluginModule = await this.importPluginModule(pluginName);
                     if (pluginInstance) {
                         const depend = pluginInstance.depend;
                         const provide = pluginInstance.provide;
-                        // 检查依赖是否满足 (此处仍然检查 this.components，请确保 this.components 在此阶段已包含必要的基准组件)
-                        const unmetDependencies = depend?.filter(dep => !this.components.hasOwnProperty(dep)) || [];
+                        // 用 providedComponents 作为依赖判断来源（比 components 更准确）
+                        const unmetDependencies = depend?.filter(dep => !this.providedComponents.hasOwnProperty(dep)) || [];
                         if (unmetDependencies.length === 0) {
-                            // 将加载成功并满足依赖的插件存储起来
-                            this.plugins[`${pluginName}`] = Object.assign(pluginInstance, { depend, provide });
-                            //this.pluginModules[`${pluginName}`] = pluginModule;
-                            //this.logger.info(`Plugin ${pluginName} loaded.`);
+                            this.plugins[pluginName] = Object.assign(pluginInstance, { depend, provide });
                             loadedPluginNames.push(pluginName);
-                            loadedInThisPass = true; // 标记本轮有插件加载成功
-                            if (loadedInThisPass && pluginInstance && pluginInstance.apply) {
+                            loadedInThisPass = true;
+                            if (pluginInstance.apply) {
                                 await pluginInstance.apply(new context_1.Context(this, pluginName), await this.getPluginConfig(pluginName));
-                                // 使用 pluginName
                                 this.pluginLoader.logger.info(`apply plugin ${pluginName}`);
                             }
-                            // 记录该插件提供了哪些组件
                             if (provide) {
                                 for (const componentName of provide) {
                                     if (this.providedComponents.hasOwnProperty(componentName)) {
-                                        this.logger.error(`Multiple plugins provide the component "${componentName}". Provided by "${this.providedComponents[`${componentName}`]}" and "${pluginName}". Only the first loaded will be active.`);
+                                        this.logger.error(`Multiple plugins provide the component "${componentName}". Provided by "${this.providedComponents[componentName]}" and "${pluginName}". Only the first loaded will be active.`);
                                     }
                                     else {
-                                        this.providedComponents[`${componentName}`] = pluginName;
+                                        this.providedComponents[componentName] = pluginName;
                                     }
                                 }
                             }
                         }
                         else {
-                            // 如果存在未满足的依赖，将插件名放回下一轮尝试加载列表
                             nextRemainingPluginNames.push(pluginName);
-                            /*this.logger.warn(
-                              `Plugin ${pluginName} has unmet dependencies: ${unmetDependencies.join(', ')}. Will try again later.`
-                            );*/
+                            // 不加入 loadAttempted，让下一轮重试
                         }
                     }
-                    else {
-                        //this.logger.warn(`Plugin "${pluginName}" could not be loaded or its module could not be imported.`);
-                    }
                 }
                 catch (err) {
                     this.pluginLoader.logger.error(`Failed to load or process plugin ${pluginName}:`, err);
-                    // 如果加载或处理失败，不将其加入下一轮尝试列表，但也不标记为已加载成功
+                    loadAttempted[pluginName] = true; // 真正失败才标记
                 }
             }
-            // 如果本轮没有插件加载成功，并且剩余插件列表没有变化，则检测到循环或无法解决的依赖
             if (!loadedInThisPass && nextRemainingPluginNames.length === remainingPluginNames.length && remainingPluginNames.length > 0) {
-                this.logger.error('Detected circular or unresolvable plugin dependencies. Remaining plugins:', nextRemainingPluginNames.map(name => name) // 映射回插件名
-                );
-                break; // 防止无限循环
+                this.logger.error('Detected circular or unresolvable plugin dependencies. Remaining plugins:', nextRemainingPluginNames);
+                break;
             }
-            // 更新剩余待加载插件列表为下一轮的列表
             remainingPluginNames = nextRemainingPluginNames;
         }
-        // 警告未加载成功的插件
         if (remainingPluginNames.length > 0) {
-            this.logger.warn('Some plugins could not be fully loaded due to unresolved dependencies or errors:', remainingPluginNames.map(name => name) // 映射回插件名
-            );
+            this.logger.warn('Some plugins could not be fully loaded due to unresolved dependencies or errors:', remainingPluginNames);
         }
-        // 开发环境下监听插件变化
         if (process.env.NODE_ENV === 'development') {
             this.watchPlugins(this);
         }
@@ -370,7 +354,12 @@ class Core {
             this.logger.error(`Failed to unload plugin ${pluginName}:`, error);
         }
     }
-    // 注册组件
+    /**
+     * 注册组件
+     * @param name 组件名称
+     * @param component 组件
+     * @returns void
+     */
     registerComponent(name, component) {
         if (this.components.hasOwnProperty(name)) {
             this.logger.warn(`Component "${name}" already registered by plugin "${this.providedComponents[`${name}`]}".`);
@@ -379,17 +368,28 @@ class Core {
         this.components[`${name}`] = component;
         this.logger.info(`Component "${name}" registered.`);
     }
-    // 获取组件
+    /**
+     * 获取组件
+     * @param name 组件名称
+     * @returns 组件
+     */
     getComponent(name) {
         return this.components[`${name}`];
     }
-    // 取消注册组件
+    /**
+     * 取消注册组件
+     * @param name 组件名称
+     */
     unregisterComponent(name) {
         delete this.components[`${name}`];
         delete this.providedComponents[`${name}`];
         delete this.comtoplu[`${name}`];
     }
-    // 事件系统：监听事件
+    /**
+     * 监听事件
+     * @param event 事件名称
+     * @param listener 回调函数
+     */
     on(event, listener) {
         if (!this.eventListeners[`${event}`]) {
             this.eventListeners[`${event}`] = [];
@@ -397,7 +397,11 @@ class Core {
         this.eventListeners[`${event}`].push(listener);
         //this.logger.info(`Listener added for event "${event}".`);
     }
-    // 事件系统：触发事件
+    /**
+     * 触发事件
+     * @param event 事件名称
+     * @param args 参数
+     */
     async emit(event, ...args) {
         if (this.eventListeners[`${event}`]) {
             // this.logger.info(`Emitting event "${event}" with args:`, args);
@@ -414,18 +418,33 @@ class Core {
             //this.logger.info(`No listeners for event "${event}".`);
         }
     }
-    // 注册全局中间件
+    /**
+     * 注册全局中间件
+     * @param name 中间件名称
+     * @param middleware 中间件
+     * @returns Core对象
+     */
     use(name, middleware) {
         this.globalMiddlewares[name] = middleware;
         return this;
     }
-    // 定义指令
+    /**
+     * 定义指令
+     * @param name 指令名称
+     * @returns 指令对象
+     */
     command(name) {
         const command = new command_1.Command(this, name); // 传递 Core 实例
         this.commands[`${name}`] = command;
         return command;
     }
-    // 执行指令
+    /**
+     * 执行指令
+     * @param name 指令名称
+     * @param session 会话
+     * @param args 参数
+     * @returns 回话/null
+     */
     async executeCommand(name, session, ...args) {
         const command = this.commands[`${name}`];
         if (command) {
@@ -453,10 +472,19 @@ class Core {
         }
         return null;
     }
+    /**
+     * 注册平台
+     * @param platform 平台名称
+     * @returns 启动结果
+     */
     registerPlatform(platform) {
         this.platforms.push(platform);
         return platform.startPlatform(this);
     }
+    /**
+     * 取消注册插件
+     * @param pluginname 插件名称
+     */
     unregall(pluginname) {
         let cmdtodel = [];
         for (const cmd in this.cmdtoplu) {
@@ -504,5 +532,18 @@ class Core {
             delete this.globalMiddlewares[mdw];
         }
     }
+    /**
+     * 获取指令对象
+     * @param name 指令名称
+     * @returns null/指令对象
+     */
+    getCommand(name) {
+        if (Object.hasOwn(this.commands, name)) {
+            return this.commands[name];
+        }
+        else {
+            return null;
+        }
+    }
 }
 exports.Core = Core;

package/dist/logger.js

@@ -11,6 +11,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Logger = void 0;
 const ansi_colors_1 = __importDefault(require("ansi-colors")); // 引入 ansi-colors
 class Logger {
+    title;
+    titleColor;
+    static coreInstance = null;
+    static logs = [];
     static setCore(core) {
         if (Logger.coreInstance !== null) {
             const logger = new Logger('Logger');
@@ -44,8 +48,6 @@ class Logger {
     }
 }
 exports.Logger = Logger;
-Logger.coreInstance = null;
-Logger.logs = [];
 function stringifyDebug(value, seen = new WeakSet(), depth = 0, indent = 2, maxDepth = 5) {
     const pad = ' '.repeat(depth * indent);
     const nextPad = ' '.repeat((depth + 1) * indent);

package/dist/platform.js

@@ -8,21 +8,21 @@ const session_1 = require("./session");
  * 各平台实现类需继承此类并实现所有抽象方法
  */
 class Platform {
+    // 平台状态
+    status = 'idle';
+    // 平台错误信息
+    errorMessage = null;
+    // 平台配置
+    config = {};
+    // 平台实例ID
+    instanceId = '';
+    // 平台事件监听器
+    eventListeners = {};
     /**
      * 构造函数
      * @param config 平台配置
      */
     constructor(config) {
-        // 平台状态
-        this.status = 'idle';
-        // 平台错误信息
-        this.errorMessage = null;
-        // 平台配置
-        this.config = {};
-        // 平台实例ID
-        this.instanceId = '';
-        // 平台事件监听器
-        this.eventListeners = {};
         if (config) {
             this.config = { ...config };
         }

package/dist/session.js

@@ -11,17 +11,23 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Session = void 0;
 const crypto_1 = __importDefault(require("crypto"));
 class Session {
+    ip;
+    cookie;
+    query;
+    sessionid;
+    data = {};
+    newCookie = {};
+    head = {};
+    status = 200;
+    body;
+    platform;
+    properties = {};
     /*
      *  @ip: string，用户IP
      *  @cookie: string，会话cookie
      *  @query: string，请求字符串
      */
     constructor(ip, cookie, platform, query) {
-        this.data = {};
-        this.newCookie = {};
-        this.head = {};
-        this.status = 200;
-        this.properties = {};
         this.ip = ip;
         this.cookie = cookie;
         this.query = query;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yumerijs/core",
-  "version": "1.1.0-alpha.5",
+  "version": "1.1.1",
   "description": "Core module for yumeri",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -32,7 +32,7 @@
   },
   "dependencies": {
     "@types/chalk": "^2.2.4",
-    "@yumerijs/loader": "1.1.0-alpha.5",
+    "@yumerijs/loader": "1.1.0",
     "ansi-colors": "^4.1.3",
     "chalk": "^5.4.1",
     "chokidar": "^4.0.3",