alemonjs 2.1.0-alpha.50 → 2.1.0-alpha.52

package/README.md

@@ -3,91 +3,3 @@
 [alemonjs](https://alemonjs.com) 是一个专门用于开发聊天机器人的 Node.js 框架，它提供了完整的事件驱动架构来处理各种聊天平台的消息和交互。
 
 https://alemonjs.com
-
-## 🏗️ 架构设计特点
-
-1. 事件驱动架构
-
-基于事件选择器(onSelects)和响应处理器(onResponse)的模式
-
-支持多种事件类型（如 message.create、private.message.create 等）
-
-事件处理包含完整的生命周期：创建、挂载、卸载
-
-2. CBP 通信协议
-
-实现了自定义的 WebSocket 通信协议
-
-支持客户端-服务器架构，可以作为服务器运行也可以连接到远程服务器
-
-包含心跳机制、重连机制、消息去重等可靠性保障
-
-3. 模块化插件系统
-
-支持动态加载应用模块(apps)和响应模块(response)
-
-提供中间件机制用于消息预处理
-
-状态管理系统，支持模块的启用/禁用
-
-4. 多平台适配器
-
-通过环境变量动态加载不同的聊天平台适配器
-
-支持统一的消息格式处理（文本、图片、按钮、卡片等）
-
-## 🔧 核心组件分析
-
-5. 事件处理器
-
-实现消息去重机制（防止重复处理同一消息）
-
-用户操作频率限制（防止恶意刷屏）
-
-自动清理过期的消息记录
-
-6. Hook 系统
-
-类似 React Hooks 的设计模式
-
-提供 useMessage、useMention、useState 等常用 Hook
-
-简化了消息处理的复杂性
-
-7.  消息格式化系统
-
-统一的消息格式定义
-
-支持文本、图片、按钮、Markdown、ARK 卡片等多种消息类型
-
-通过 format() 函数进行消息格式化
-
-8. 配置管理系统
-
-支持命令行参数、配置文件、环境变量多层配置
-
-动态配置加载和热更新
-
-平台特定的配置管理
-
-## 💡 设计优势
-
-高度模块化：每个功能都是独立的模块，便于维护和扩展
-
-TypeScript 全支持：完整的类型定义，提供良好的开发体验
-
-事件驱动：响应式编程模型，代码逻辑清晰
-
-可扩展性强：支持自定义中间件、Hook 和平台适配器
-
-性能优化：包含消息去重、频率限制、内存清理等优化机制
-
-## 🔄 工作流程
-
-启动阶段：加载配置 → 启动 CBP 服务器 → 连接平台适配器
-
-消息接收：平台消息 → CBP 协议转换 → 事件分发
-
-消息处理：事件选择 → 中间件处理 → 响应函数执行
-
-消息发送：格式化消息 → CBP 协议传输 → 平台发送

package/lib/{datastructure → app}/SinglyLinkedList.d.ts

@@ -3,7 +3,7 @@ declare class ListNode<T> {
     next: ListNode<T> | null;
     constructor(data: T);
 }
-declare class SinglyLinkedList<T> {
+export declare class SinglyLinkedList<T> {
     private head;
     private size;
     private current;
@@ -13,5 +13,4 @@ declare class SinglyLinkedList<T> {
     removeCurrent(): void;
     getSize(): number;
 }
-
-export { SinglyLinkedList };
+export {};

package/lib/{datastructure → app}/SinglyLinkedList.js

@@ -1,24 +1,23 @@
 class ListNode {
-    data; // 节点数据
-    next; // 指向下一个节点的指针
+    data;
+    next;
     constructor(data) {
         this.data = data;
         this.next = null;
     }
 }
 class SinglyLinkedList {
-    head; // 链表的头节点
-    size; // 链表的大小
-    current; // 当前节点指针
+    head;
+    size;
+    current;
     constructor(initialValues) {
         this.head = null;
         this.size = 0;
-        this.current = null; // 初始化当前节点为 null
+        this.current = null;
         if (initialValues) {
-            initialValues.forEach(value => this.append(value)); // 初始化链表
+            initialValues.forEach(value => this.append(value));
         }
     }
-    // 在链表末尾添加新节点
     append(data) {
         const newNode = new ListNode(data);
         if (!this.head) {
@@ -33,24 +32,22 @@ class SinglyLinkedList {
         }
         this.size++;
     }
-    // 获取下一个节点并移动指针
     popNext() {
         if (!this.current) {
-            this.current = this.head; // 如果当前节点为 null，从头节点开始
+            this.current = this.head;
         }
         else {
-            this.current = this.current.next; // 移动到下一个节点
+            this.current = this.current.next;
         }
-        return this.current; // 返回当前节点
+        return this.current;
     }
-    // 删除当前节点
     removeCurrent() {
         if (!this.head) {
             return;
         }
         if (this.current === this.head) {
-            this.head = this.head.next; // 移除头节点
-            this.current = null; // 重置当前节点
+            this.head = this.head.next;
+            this.current = null;
             this.size--;
             return;
         }
@@ -59,12 +56,11 @@ class SinglyLinkedList {
             previous = previous.next;
         }
         if (previous && this.current) {
-            previous.next = this.current.next; // 跳过当前节点
-            this.current = null; // 重置当前节点
+            previous.next = this.current.next;
+            this.current = null;
             this.size--;
         }
     }
-    // 获取链表的大小
     getSize() {
         return this.size;
     }

package/lib/app/define-chidren.d.ts

@@ -1,11 +1,2 @@
-import { DefineChildrenFunc } from '../types/event/index.js';
-
-/**
- * 定义子事件
- * @param callback
- * @throws {Error} - 如果 callback 无效，抛出错误。
- * @returns
- */
-declare const defineChildren: DefineChildrenFunc;
-
-export { defineChildren };
+import { DefineChildrenFunc } from '../types';
+export declare const defineChildren: DefineChildrenFunc;

package/lib/app/define-chidren.js

@@ -1,11 +1,5 @@
 import { ResultCode } from '../core/variable.js';
 
-/**
- * 定义子事件
- * @param callback
- * @throws {Error} - 如果 callback 无效，抛出错误。
- * @returns
- */
 const defineChildren = callback => {
     if (typeof callback === 'function' || typeof callback === 'object') {
         return {

package/lib/app/define-middleware.d.ts

@@ -1,5 +1,2 @@
-import { defineMiddlewareFunc } from '../types/event/index.js';
-
-declare const defineMiddleware: defineMiddlewareFunc;
-
-export { defineMiddleware };
+import { defineMiddlewareFunc } from '../types';
+export declare const defineMiddleware: defineMiddlewareFunc;

package/lib/app/define-response.d.ts

@@ -1,11 +1,3 @@
-import { DefineResponseFunc } from '../types/event/index.js';
-
-/**
- * Lazy load a response handler
- * @param fnc
- * @returns
- */
-declare const lazy: (fnc: () => Promise<any>) => () => Promise<any>;
-declare const defineResponse: DefineResponseFunc;
-
-export { defineResponse, lazy };
+import { DefineResponseFunc } from '../types';
+export declare const lazy: (fnc: () => Promise<any>) => () => Promise<any>;
+export declare const defineResponse: DefineResponseFunc;

package/lib/app/define-response.js

@@ -1,8 +1,3 @@
-/**
- * Lazy load a response handler
- * @param fnc
- * @returns
- */
 const lazy = (fnc) => {
     return async () => (await fnc()).default;
 };

package/lib/app/event-group.d.ts

@@ -1,11 +1,3 @@
-import { OnGroupFunc } from '../types/event/index.js';
-
-/**
- * 定义一组标准执行导出
- * @param calls
- * @deprecated 废弃
- * @returns
- */
+import { OnGroupFunc } from '../types';
 declare const onGroup: OnGroupFunc;
-
 export { onGroup };

package/lib/app/event-group.js

@@ -1,16 +1,9 @@
-/**
- * 定义一组标准执行导出
- * @param calls
- * @deprecated 废弃
- * @returns
- */
 const onGroup = (...calls) => {
     if (calls.length === 0) {
         throw new Error('onGroup: 至少需要一个响应或中间件');
     }
     const firstItem = calls[0];
     const baseSelects = firstItem.select;
-    // 把如果item是数组的，豆扁平起来。
     const currents = calls.reduce((acc, item) => {
         if (Array.isArray(item.current)) {
             return acc.concat(item.current);

package/lib/app/event-middleware.d.ts

@@ -1,27 +1,3 @@
-import { OnMiddlewareReversalFunc, OnMiddlewareReversalFuncBack } from '../types/event/index.js';
-
-/**
- * @fileoverview 中间件
- * @module middleware
- * @author ningmengchongshui
- */
-
-/**
- * 中间件
- * @param select 事件选择
- * @param callback 回调函数，处理事件和 API
- * @throws {Error} - 如果 select 无效，抛出错误。
- * @throws {Error} - 如果 callback 无效，抛出错误。
- * @returns
- */
-declare const onMiddleware: OnMiddlewareReversalFunc;
-/**
- * 废弃，请使用 onMiddleware
- * @deprecated
- * @param select
- * @param callback
- * @returns
- */
-declare const OnMiddleware: OnMiddlewareReversalFuncBack;
-
-export { OnMiddleware, onMiddleware };
+import { OnMiddlewareReversalFunc, OnMiddlewareReversalFuncBack } from '../types';
+export declare const onMiddleware: OnMiddlewareReversalFunc;
+export declare const OnMiddleware: OnMiddlewareReversalFuncBack;

package/lib/app/event-middleware.js

@@ -1,15 +1,6 @@
 import { ResultCode } from '../core/variable.js';
 
-/**
- * 中间件
- * @param select 事件选择
- * @param callback 回调函数，处理事件和 API
- * @throws {Error} - 如果 select 无效，抛出错误。
- * @throws {Error} - 如果 callback 无效，抛出错误。
- * @returns
- */
 const onMiddleware = (select, callback) => {
-    // 参数检查
     if (typeof callback !== 'function') {
         logger.error({
             code: ResultCode.FailParams,
@@ -29,13 +20,6 @@ const onMiddleware = (select, callback) => {
     throw new Error('Invalid select: select must be a string or object');
 };
 global.onMiddleware = onMiddleware;
-/**
- * 废弃，请使用 onMiddleware
- * @deprecated
- * @param select
- * @param callback
- * @returns
- */
 const OnMiddleware = (callback, select) => {
     return onMiddleware(select, callback);
 };

package/lib/app/event-processor-callHandler.d.ts

@@ -0,0 +1 @@
+export declare const createCallHandler: (valueEvent: any) => (currents: any, nextEvent: any) => void;

package/lib/app/event-processor-callHandler.js

@@ -7,7 +7,6 @@ import { useMessage } from './hook-use-api.js';
 
 const createCallHandler = valueEvent => {
     const [message] = useMessage(valueEvent);
-    // 开始处理 heandler
     const callHandler = (currents, nextEvent) => {
         let index = 0;
         let isClose = false;
@@ -19,14 +18,12 @@ const createCallHandler = valueEvent => {
             }
             if (Array.isArray(res)) {
                 if (res.length > 0) {
-                    // 发送数据
                     void message.send(res);
                 }
                 isClose = true;
             }
             else if (typeof res === 'object') {
                 if (Array.isArray(res.data)) {
-                    // 发送数据
                     void message.send(res.data);
                 }
                 if (!res.allowGrouping) {

package/lib/app/event-processor-cycle.d.ts

@@ -1,18 +1,2 @@
-import { EventKeys, Events } from '../types/event/map.js';
-
-/**
- * @fileoverview 消息处理快
- * 登录模块向核心模块发送数据
- * 核心模块调用模块索引
- * @module processor
- * @author ningmengchongshui
- */
-
-/**
- * 消息体处理机制
- * @param event
- * @param key
- */
-declare const expendCycle: <T extends EventKeys>(valueEvent: Events[T], select: T) => void;
-
-export { expendCycle };
+import { Events, EventKeys } from '../types';
+export declare const expendCycle: <T extends EventKeys>(valueEvent: Events[T], select: T) => void;

package/lib/app/event-processor-cycle.js

@@ -4,11 +4,6 @@ import { expendMiddleware } from './event-processor-middleware.js';
 import { expendSubscribeCreate, expendSubscribeMount, expendSubscribeUnmount } from './event-processor-subscribe.js';
 import { getConfigValue } from '../core/config.js';
 
-/**
- * 打印日志
- * @param event
- * @param select
- */
 const showLog = (event, select) => {
     if (process.env.NODE_ENV === 'development') {
         const log = {
@@ -51,14 +46,8 @@ const showLog = (event, select) => {
         logger.info(baseLog);
     }
 };
-/**
- * 消息体处理机制
- * @param event
- * @param key
- */
 const expendCycle = (valueEvent, select) => {
     const nextEnd = () => { };
-    // unmount
     const nextUnMount = (cn, ...cns) => {
         if (cn) {
             nextEnd(...cns);
@@ -66,7 +55,6 @@ const expendCycle = (valueEvent, select) => {
         }
         void expendSubscribeUnmount(valueEvent, select, nextEnd);
     };
-    // event
     const nextEvent = (cn, ...cns) => {
         if (cn) {
             nextUnMount(...cns);
@@ -74,7 +62,6 @@ const expendCycle = (valueEvent, select) => {
         }
         void expendEvent(valueEvent, select, nextUnMount);
     };
-    // mount
     const nextMount = (cn, ...cns) => {
         if (cn) {
             nextEvent(...cns);
@@ -82,7 +69,6 @@ const expendCycle = (valueEvent, select) => {
         }
         void expendSubscribeMount(valueEvent, select, nextEvent);
     };
-    // middleware
     const nextCreate = (cn, ...cns) => {
         if (cn) {
             nextMount(...cns);
@@ -100,7 +86,6 @@ const expendCycle = (valueEvent, select) => {
     else {
         showLog(valueEvent, select);
     }
-    // create
     void expendSubscribeCreate(valueEvent, select, nextCreate);
 };
 

package/lib/app/event-processor-cycleFiles.d.ts

@@ -0,0 +1,2 @@
+import { Next, Events, EventKeys, StoreResponseItem } from '../types';
+export declare const createNextStep: <T extends EventKeys>(valueEvent: Events[T], select: T, next: Next, files: StoreResponseItem[], callHandler: (currents: any, nextEvent: any) => void) => Next;

package/lib/app/event-processor-cycleFiles.js

@@ -0,0 +1,91 @@
+import { useState } from './hook-use-state.js';
+import { showErrorModule } from '../core/utils.js';
+import { EventMessageText } from '../core/variable.js';
+import { ResponseMiddleware } from './store.js';
+
+const callHandlerFile = async (valueEvent, select, file, nextStep, callback) => {
+    try {
+        const app = await import(`file://${file.path}`);
+        if (!app?.default?.current || !app?.default?.select) {
+            nextStep();
+            return;
+        }
+        if (file?.stateKey) {
+            const [state] = useState(file?.stateKey);
+            if (state === false) {
+                nextStep();
+                return;
+            }
+        }
+        if (EventMessageText.includes(select)) {
+            if (app?.regular) {
+                const reg = new RegExp(app.regular);
+                if (!reg.test(valueEvent['MessageText'])) {
+                    nextStep();
+                    return;
+                }
+            }
+        }
+        const selects = Array.isArray(app.default.select) ? app.default.select : [app.default.select];
+        if (!selects.includes(select)) {
+            nextStep();
+            return;
+        }
+        callback(app);
+    }
+    catch (err) {
+        showErrorModule(err);
+    }
+};
+const createNextStep = (valueEvent, select, next, files, callHandler) => {
+    let valueI = 0;
+    const recordCloseMw = new Set();
+    const nextStep = (cn, ...cns) => {
+        if (cn) {
+            next(...cns);
+            return;
+        }
+        if (valueI >= files.length) {
+            next();
+            return;
+        }
+        void calli();
+    };
+    const calli = async () => {
+        if (valueI >= files.length) {
+            nextStep();
+            return;
+        }
+        valueI++;
+        const file = files[valueI - 1];
+        if (!file?.path) {
+            nextStep();
+            return;
+        }
+        const responseMiddleware = new ResponseMiddleware();
+        const currentsAndMiddleware = responseMiddleware.find(file.appName, file.stateKey);
+        const currents = [];
+        for (const cm of [...currentsAndMiddleware, file]) {
+            let isBreak = false;
+            if (recordCloseMw.has(cm.stateKey)) {
+                return;
+            }
+            const close = () => {
+                isBreak = true;
+                recordCloseMw.add(cm.stateKey);
+            };
+            await callHandlerFile(valueEvent, select, cm, close, app => {
+                const currentsItem = Array.isArray(app.default.current) ? app.default.current : [app.default.current];
+                currents.push(...currentsItem);
+            });
+            if (isBreak) {
+                nextStep();
+                return;
+            }
+        }
+        callHandler(currents, nextStep);
+    };
+    return nextStep;
+};
+
+export { createNextStep };

package/lib/app/event-processor-cycleRoute.d.ts

@@ -0,0 +1,2 @@
+import { Next, Events, EventKeys, ResponseRoute } from '../types';
+export declare const createRouteProcessChildren: <T extends EventKeys>(valueEvent: Events[T], select: T, nextCycle: Next, callHandler: (currents: any, nextEvent: any) => void) => (nodes: ResponseRoute[], middleware: any, next: () => Promise<void> | void) => void;

package/lib/app/{event-processor-event-route.js → event-processor-cycleRoute.js}

@@ -1,35 +1,21 @@
 import { isAsyncFunction } from 'util/types';
-import { ResponseRouter } from './store.js';
 import { EventMessageText } from '../core/variable.js';
 import 'fs';
 import 'path';
 import 'yaml';
 import { showErrorModule } from '../core/utils.js';
-import { createCallHandler } from './event-processor-callHandler.js';
 
-/**
- * @fileoverview 消息处理快
- * 登录模块向核心模块发送数据
- * 核心模块调用模块索引
- * @module processor
- * @author ningmengchongshui
- */
-const expendEventRoute = (valueEvent, select, nextCycle) => {
-    const resRoute = new ResponseRouter();
-    const routes = resRoute.value;
-    // 开始处理 heandler
-    const callHandler = createCallHandler(valueEvent);
-    // 开始处理 handler
+const createRouteProcessChildren = (valueEvent, select, nextCycle, callHandler) => {
     const processChildren = (nodes, middleware, next) => {
         if (!nodes || nodes.length === 0) {
-            next();
+            void next();
             return;
         }
         let idx = 0;
         const nextNode = async () => {
             idx++;
             if (idx > nodes.length) {
-                next();
+                void next();
                 return;
             }
             const node = nodes[idx - 1];
@@ -40,7 +26,6 @@ const expendEventRoute = (valueEvent, select, nextCycle) => {
                     return;
                 }
             }
-            // 正则匹配
             if (EventMessageText.includes(select) && node.regular) {
                 const reg = new RegExp(node.regular);
                 if (!reg.test(valueEvent['MessageText'])) {
@@ -52,39 +37,25 @@ const expendEventRoute = (valueEvent, select, nextCycle) => {
                 void nextNode();
                 return;
             }
-            // 递归：如果有children，继续递归下去
             if (node.children && node.children.length > 0) {
-                // middleware 追加自身 handler
                 processChildren(node.children, [...middleware, node.handler], nextNode);
                 return;
             }
-            // 没有children，直接处理handler
             const currentsAndMiddleware = [...middleware, node.handler];
-            // node.handler 是一个异步函数。函数执行的结果是 { current: Current[] | Current, select: xxx }
             try {
                 const currents = [];
                 for (const item of currentsAndMiddleware) {
                     const app = isAsyncFunction(item) ? await item() : item();
-                    // 没有 default。因为是 import x from './';
-                    // 中间件也有 selects。
-                    // 如果 发现 和当前要处理的 selects 不匹配。
-                    // 只要是一个不匹配。则说明处理还不是最终想要执行结果。
                     const selects = Array.isArray(app.select) ? app.select : [app.select];
-                    // 没有匹配到
                     if (!selects.includes(select)) {
-                        // 需要继续。
                         void nextNode();
                         return;
                     }
-                    // 可能是数组。也可能不是数组
                     const currentsItem = Array.isArray(app.current) ? app.current : [app.current];
                     currents.push(...currentsItem);
                 }
-                // 要把二维数组拍平
                 callHandler(currents, (cn, ...cns) => {
                     if (cn) {
-                        // 这里的 next 要加 true。
-                        // 因为下一层是旧版本逻辑。不加一层。会出现处理了没有完全结束周期
                         nextCycle(true, ...cns);
                         return;
                     }
@@ -97,7 +68,7 @@ const expendEventRoute = (valueEvent, select, nextCycle) => {
         };
         void nextNode();
     };
-    void processChildren(routes, [], nextCycle);
+    return processChildren;
 };
 
-export { expendEventRoute };
+export { createRouteProcessChildren };

package/lib/app/event-processor-event.d.ts

@@ -1,19 +1,2 @@
-import { Next } from '../types/cycle/index.js';
-import { EventKeys, Events } from '../types/event/map.js';
-
-/**
- * @fileoverview 消息处理快
- * 登录模块向核心模块发送数据
- * 核心模块调用模块索引
- * @module processor
- * @author ningmengchongshui
- */
-
-/**
- * 消息体处理机制
- * @param event
- * @param key
- */
-declare const expendEvent: <T extends EventKeys>(valueEvent: Events[T], select: T, next: Next) => void;
-
-export { expendEvent };
+import { Next, Events, EventKeys } from '../types';
+export declare const expendEvent: <T extends EventKeys>(valueEvent: Events[T], select: T, next: Next) => void;