alemonjs 2.1.41 → 2.1.43

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

@@ -0,0 +1,10 @@
+import { Next, Events, EventKeys, ResponseRoute } from '../../types';
+/**
+ * 创建路由处理调用函数
+ * @param valueEvent
+ * @param select
+ * @param nextCycle
+ * @param callHandler
+ * @returns
+ */
+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-processor-cycleRoute.js

@@ -0,0 +1,133 @@
+import { EventMessageText } from '../../core/variable.js';
+import { getCachedRegExp, showErrorModule } from '../../core/utils.js';
+
+// 缓存 AsyncFunction 构造函数 — 避免每次调用创建匿名 async 函数
+const AsyncFunction = (async () => { }).constructor;
+function isAsyncFunction(fn) {
+    return fn instanceof AsyncFunction;
+}
+function isFunction(value) {
+    return isAsyncFunction(value) || typeof value === 'function' || value instanceof Function;
+}
+/**
+ * 创建路由处理调用函数
+ * @param valueEvent
+ * @param select
+ * @param nextCycle
+ * @param callHandler
+ * @returns
+ */
+const createRouteProcessChildren = (valueEvent, select, nextCycle, callHandler) => {
+    // 开始处理 handler
+    const processChildren = (nodes, middleware, next) => {
+        if (!nodes || nodes.length === 0) {
+            void next();
+            return;
+        }
+        let idx = 0;
+        const nextNode = async () => {
+            idx++;
+            if (idx > nodes.length) {
+                void next();
+                return;
+            }
+            const node = nodes[idx - 1];
+            if (node?.selects) {
+                const selects = Array.isArray(node.selects) ? node.selects : [node.selects];
+                if (!selects.includes(select)) {
+                    void nextNode();
+                    return;
+                }
+            }
+            // 文本匹配（按性能从高到低：exact > prefix > regular）
+            if (EventMessageText.includes(select)) {
+                const text = valueEvent['MessageText'] ?? '';
+                // 精确匹配（最快，O(1) 字符串比较）
+                if (node.exact !== undefined) {
+                    if (text !== node.exact) {
+                        void nextNode();
+                        return;
+                    }
+                }
+                // 前缀匹配（快，O(n) startsWith）
+                if (node.prefix !== undefined) {
+                    if (!text.startsWith(node.prefix)) {
+                        void nextNode();
+                        return;
+                    }
+                }
+                // 正则匹配（使用缓存，避免每条消息重编译）
+                if (node.regular) {
+                    if (!getCachedRegExp(node.regular).test(text)) {
+                        void nextNode();
+                        return;
+                    }
+                }
+            }
+            if (!node.handler) {
+                void nextNode();
+                return;
+            }
+            // 递归：如果有children，继续递归下去
+            if (node.children && node.children.length > 0) {
+                // push/pop 回溯 — 避免每层递归 spread 创建新数组
+                middleware.push(node.handler);
+                processChildren(node.children, middleware, () => {
+                    middleware.pop();
+                    void nextNode();
+                });
+                return;
+            }
+            // 没有children，直接处理handler — 临时拼接，无需 spread
+            middleware.push(node.handler);
+            const currentsAndMiddleware = middleware;
+            // node.handler 是一个异步函数。函数执行的结果是 { current: Current[] | Current, select: xxx }
+            try {
+                const currents = [];
+                for (const item of currentsAndMiddleware) {
+                    const app = await item();
+                    // 没有 default。因为是 import x from './';
+                    if (isFunction(app)) {
+                        // 纯异步函数
+                        currents.push(app);
+                        continue;
+                    }
+                    // 中间件也有 selects。
+                    // 如果 发现 和当前要处理的 selects 不匹配。
+                    // 只要是一个不匹配。则说明处理还不是最终想要执行结果。
+                    const selects = Array.isArray(app.select) ? app.select : [app.select];
+                    // 没有匹配到
+                    if (!selects.includes(select)) {
+                        // 回溯 pop，避免中间件泄漏
+                        middleware.pop();
+                        void nextNode();
+                        return;
+                    }
+                    // 可能是数组。也可能不是数组
+                    const currentsItem = Array.isArray(app.current) ? app.current : [app.current];
+                    currents.push(...currentsItem);
+                }
+                // 回溯 pop 当前 handler
+                middleware.pop();
+                // 要把二维数组拍平
+                callHandler(currents, (cn, ...cns) => {
+                    if (cn) {
+                        // 这里的 next 要加 true。
+                        // 因为下一层是旧版本逻辑。不加一层。会出现处理了没有完全结束周期
+                        nextCycle(true, ...cns);
+                        return;
+                    }
+                    void nextNode();
+                });
+            }
+            catch (err) {
+                middleware.pop();
+                showErrorModule(err);
+            }
+        };
+        void nextNode();
+    };
+    return processChildren;
+};
+
+export { createRouteProcessChildren };

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

@@ -0,0 +1,24 @@
+/**
+ * @fileoverview 消息处理快
+ * 登录模块向核心模块发送数据
+ * 核心模块调用模块索引
+ * @module processor
+ * @author ningmengchongshui
+ */
+import { Next, Events, EventKeys } from '../../types';
+/**
+ * todo：
+ * 当前的局部中间件算法有问题
+ * ****
+ * 当前仅仅是简单的记录。被关闭的中间件。
+ * ****
+ * 在一个指令匹配多个 res 的情况下。
+ * 会出现多次计算同一个中间件的结果。即 bad case
+ * 需要一个缓存机制。
+ */
+/**
+ * 消息体处理机制
+ * @param event
+ * @param key
+ */
+export declare const expendEvent: <T extends EventKeys>(valueEvent: Events[T], select: T, next: Next) => void;

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

@@ -0,0 +1,41 @@
+import { Response, ResponseRouter } from '../../store/store.js';
+import { createCallHandler } from './event-processor-callHandler.js';
+import { createNextStep } from './event-processor-cycleFiles.js';
+import { createRouteProcessChildren } from './event-processor-cycleRoute.js';
+
+// 单例，避免每次事件处理都创建新对象
+const responseSingleton = new Response();
+const responseRouterSingleton = new ResponseRouter();
+/**
+ * todo：
+ * 当前的局部中间件算法有问题
+ * ****
+ * 当前仅仅是简单的记录。被关闭的中间件。
+ * ****
+ * 在一个指令匹配多个 res 的情况下。
+ * 会出现多次计算同一个中间件的结果。即 bad case
+ * 需要一个缓存机制。
+ */
+/**
+ * 消息体处理机制
+ * @param event
+ * @param key
+ */
+const expendEvent = (valueEvent, select, next) => {
+    // 得到所有响应体（文件）
+    const StoreResponse = responseSingleton.value;
+    // 创建调用函数（文件）
+    const callHandler = createCallHandler(valueEvent);
+    // 创建next函数（文件）
+    const nextEvent = createNextStep(valueEvent, select, next, StoreResponse, callHandler);
+    // 得到所有响应体（路由）
+    const routes = responseRouterSingleton.value;
+    // 创建调用函数（路由）
+    const callRouteHandler = createCallHandler(valueEvent);
+    // 创建 children 处理函数（路由）
+    const processChildren = createRouteProcessChildren(valueEvent, select, nextEvent, callRouteHandler);
+    // 开始先处理 路由系统，再到 文件系统
+    void processChildren(routes, [], nextEvent);
+};
+
+export { expendEvent };

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

@@ -0,0 +1,14 @@
+/**
+ * @fileoverview 消息处理快
+ * 登录模块向核心模块发送数据
+ * 核心模块调用模块索引
+ * @module processor
+ * @author ningmengchongshui
+ */
+import { Next, Events, EventKeys } from '../../types';
+/**
+ * 处理中间件
+ * @param event
+ * @param select
+ */
+export declare const expendMiddleware: <T extends EventKeys>(valueEvent: Events[T], select: T, next: Next) => void;

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

@@ -0,0 +1,31 @@
+import { Middleware, MiddlewareRouter } from '../../store/store.js';
+import { createCallHandler } from './event-processor-callHandler.js';
+import { createNextStep } from './event-processor-cycleFiles.js';
+import { createRouteProcessChildren } from './event-processor-cycleRoute.js';
+
+// 单例，避免每次事件处理都创建新对象
+const middlewareSingleton = new Middleware();
+const middlewareRouterSingleton = new MiddlewareRouter();
+/**
+ * 处理中间件
+ * @param event
+ * @param select
+ */
+const expendMiddleware = (valueEvent, select, next) => {
+    // 所有中间件（文件）
+    const mwFiles = middlewareSingleton.value;
+    // 创建处理函数（文件）
+    const callHandler = createCallHandler(valueEvent);
+    // 创建 next 处理函数（文件）
+    const nextMiddleware = createNextStep(valueEvent, select, next, mwFiles, callHandler);
+    // 所有中间件（路由）
+    const routes = middlewareRouterSingleton.value;
+    // 创建处理函数（路由）
+    const callRouteHandler = createCallHandler(valueEvent);
+    // 创建 children 处理函数（路由）
+    const processChildren = createRouteProcessChildren(valueEvent, select, nextMiddleware, callRouteHandler);
+    // 优先route系统。再到files系统
+    void processChildren(routes, [], nextMiddleware);
+};
+
+export { expendMiddleware };

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

@@ -0,0 +1,35 @@
+/**
+ * @fileoverview 观察者
+ * @module processor
+ * @author ningmengchongshui
+ */
+import { Next, Events, EventCycleEnum, EventKeys } from '../../types';
+/**
+ * 处理订阅
+ * @param valueEvent
+ * @param select
+ * @param next
+ * @param choose
+ */
+export declare const expendSubscribe: <T extends EventKeys>(valueEvent: Events[T], select: T, next: Next, choose: EventCycleEnum) => void;
+/**
+ *
+ * @param valueEvent
+ * @param select
+ * @param next
+ */
+export declare const expendSubscribeCreate: <T extends EventKeys>(valueEvent: Events[T], select: T, next: Next) => void;
+/**
+ *
+ * @param valueEvent
+ * @param select
+ * @param next
+ */
+export declare const expendSubscribeMount: <T extends EventKeys>(valueEvent: Events[T], select: T, next: Next) => void;
+/**
+ *
+ * @param valueEvent
+ * @param select
+ * @param next
+ */
+export declare const expendSubscribeUnmount: <T extends EventKeys>(valueEvent: Events[T], select: T, next: Next) => void;

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

@@ -0,0 +1,115 @@
+import { getSubscribeList } from '../../store/store.js';
+import { SubscribeStatus } from '../config.js';
+
+/**
+ * 处理订阅
+ * @param valueEvent
+ * @param select
+ * @param next
+ * @param choose
+ */
+const expendSubscribe = (valueEvent, select, next, choose) => {
+    const subListValue = getSubscribeList(choose, select);
+    subListValue.resetCursor();
+    /**
+     * 观察者下一步
+     * @returns
+     */
+    const nextObserver = (cn, ...cns) => {
+        if (cn) {
+            next(...cns);
+            return;
+        }
+        const item = subListValue.popNext(); // 弹出下一个节点
+        // 这里代表没有 下一个节点，应该进入下一个周期
+        if (!item) {
+            // 下一个节点
+            nextObserver(true);
+            return;
+        }
+        const selects = item.data.selects; // 订阅的 selects
+        const ID = item.data.id; // 订阅的 ID
+        // 查看是否激活，如果不激活，移除并继续下一个
+        if (item.data.status === SubscribeStatus.paused) {
+            subListValue.removeCurrent(); // 移除当前节点
+            // 下一个节点
+            nextObserver();
+            return;
+        }
+        // 检查 keys
+        for (const key in item.data.keys) {
+            // 只要发现不符合的，就继续
+            if (item.data.keys[key] !== valueEvent[key]) {
+                // 下一个节点
+                nextObserver();
+                return;
+            }
+        }
+        // 恢复（循环替代递归 — 避免深链表栈溢出风险）
+        const onActive = () => {
+            for (const select of selects) {
+                const subListVal = getSubscribeList(choose, select);
+                subListVal.forEach(node => {
+                    if (node.data.id === ID) {
+                        node.data.status = SubscribeStatus.active;
+                        return true; // break
+                    }
+                });
+            }
+        };
+        const onPaused = () => {
+            for (const select of selects) {
+                const subListVal = getSubscribeList(choose, select);
+                subListVal.forEach(node => {
+                    if (node.data.id === ID) {
+                        node.data.status = SubscribeStatus.paused;
+                        return true; // break
+                    }
+                });
+            }
+        };
+        // 订阅是执行则销毁
+        onPaused();
+        const Continue = (cn, ...cns) => {
+            // 重新注册。
+            onActive();
+            // true
+            if (cn) {
+                // 下一个节点 next(true)
+                nextObserver(...cns);
+            }
+        };
+        item.data.current(valueEvent, Continue);
+    };
+    // 先从观察者开始
+    nextObserver();
+};
+/**
+ *
+ * @param valueEvent
+ * @param select
+ * @param next
+ */
+const expendSubscribeCreate = (valueEvent, select, next) => {
+    expendSubscribe(valueEvent, select, next, 'create');
+};
+/**
+ *
+ * @param valueEvent
+ * @param select
+ * @param next
+ */
+const expendSubscribeMount = (valueEvent, select, next) => {
+    expendSubscribe(valueEvent, select, next, 'mount');
+};
+/**
+ *
+ * @param valueEvent
+ * @param select
+ * @param next
+ */
+const expendSubscribeUnmount = (valueEvent, select, next) => {
+    expendSubscribe(valueEvent, select, next, 'unmount');
+};
+
+export { expendSubscribe, expendSubscribeCreate, expendSubscribeMount, expendSubscribeUnmount };

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

@@ -0,0 +1,17 @@
+import { EventKeys, Events } from '../../types';
+/**
+ * 消息处理器
+ * @param name
+ * @param event
+ * @param data
+ * @returns
+ */
+export declare const onProcessor: <T extends EventKeys>(name: T, event: Events[T], data?: any) => void;
+/**
+ * 消息处理器
+ * @param event
+ * @param name
+ * @deprecated 该方法已被弃用，请使用 onProcessor() 替代。
+ * @returns
+ */
+export declare const OnProcessor: <T extends EventKeys>(event: Events[T], name: T) => void;

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

@@ -0,0 +1,207 @@
+import { getConfigValue } from '../../core/config.js';
+import { processorRepeatedClearTimeMin, processorRepeatedClearTimeMax, processorRepeatedEventTime, processorRepeatedUserTime, processorRepeatedClearSize, processorMaxMapSize } from '../../core/variable.js';
+import { expendCycle } from './event-processor-cycle.js';
+import { ProcessorEventAutoClearMap, ProcessorEventUserAutoClearMap } from '../../store/store.js';
+import { getCachedRegExp, fastHash } from '../../core/utils.js';
+
+/**
+ * 过滤掉重复消息
+ * @param param0
+ * @param MessageId
+ * @returns
+ */
+const filter = ({ Now, store, INTERVAL }, MessageId) => {
+    if (store.has(MessageId)) {
+        const time = store.get(MessageId);
+        if (Now - time < INTERVAL) {
+            // 1s内重复消息
+            store.set(MessageId, Date.now());
+            return true;
+        }
+    }
+    // 防止 Map 无限增长导致内存泄漏
+    if (store.size >= processorMaxMapSize) {
+        cleanupStore({ Now, store, INTERVAL });
+        // 清理后仍然超限，删除最早的条目
+        if (store.size >= processorMaxMapSize) {
+            const firstKey = store.keys().next().value;
+            if (firstKey !== undefined) {
+                store.delete(firstKey);
+            }
+        }
+    }
+    store.set(MessageId, Date.now());
+};
+/**
+ * 清理旧消息（带预算限制，避免大 Map 阻塞 Event Loop）
+ * @returns 是否全部清理完毕
+ */
+const CLEANUP_BUDGET = 1000;
+const cleanupStore = ({ Now, store, INTERVAL }) => {
+    let cleaned = 0;
+    for (const [ID, timestamp] of store.entries()) {
+        if (cleaned >= CLEANUP_BUDGET) {
+            return false; // 预算用尽，下次继续
+        }
+        // 超过时间间隔
+        if (Now - timestamp > INTERVAL) {
+            store.delete(ID);
+            cleaned++;
+        }
+    }
+    return true;
+};
+/**
+ * 清理所有消息
+ */
+const cleanupStoreAll = () => {
+    const Now = Date.now();
+    const value = getConfigValue();
+    const EVENT_INTERVAL = value?.event?.repeated_event_time ?? value?.processor?.repeated_event_time ?? processorRepeatedEventTime;
+    const USER_INTERVAL = value?.event?.repeated_user_time ?? value?.processor?.repeated_user_time ?? processorRepeatedUserTime;
+    const a = cleanupStore({ Now, INTERVAL: EVENT_INTERVAL, store: ProcessorEventAutoClearMap });
+    const b = cleanupStore({ Now, INTERVAL: USER_INTERVAL, store: ProcessorEventUserAutoClearMap });
+    return a && b;
+};
+// 清理消息
+const callback = () => {
+    const allDone = cleanupStoreAll();
+    // 如果预算用尽未清完，立即调度下一轮
+    if (!allDone) {
+        setImmediate(callback);
+        return;
+    }
+    // 下一次清理的时间，应该随着长度的增加而减少
+    const length = ProcessorEventAutoClearMap.size + ProcessorEventUserAutoClearMap.size;
+    // 长度控制在37个以内
+    const time = length > processorRepeatedClearSize ? processorRepeatedClearTimeMin : processorRepeatedClearTimeMax;
+    setTimeout(callback, time);
+};
+setTimeout(callback, processorRepeatedClearTimeMin);
+/**
+ * 消息处理器
+ * @param name
+ * @param event
+ * @param data
+ * @returns
+ */
+const onProcessor = (name, event, data) => {
+    // 禁用规则设置
+    const value = getConfigValue();
+    const disabledTextRegular = value?.event?.disabled?.text_regular ?? value?.disabled_text_regular;
+    // 检查文本禁用规则
+    if (disabledTextRegular && event['MessageText']) {
+        if (getCachedRegExp(disabledTextRegular).test(event['MessageText'])) {
+            return;
+        }
+    }
+    const disabledSelects = value?.event?.disabled?.selects ?? value?.disabled_selects ?? {};
+    // 检查事件禁用规则
+    if (disabledSelects[name]) {
+        return;
+    }
+    const disabledUserId = value?.event?.disabled?.user_id ?? value?.disabled_user_id ?? {};
+    // 检查用户禁用规则
+    if (event['UserId'] && disabledUserId[event['UserId']]) {
+        return;
+    }
+    const disabledUserKey = value?.event?.disabled?.user_key ?? value?.disabled_user_key ?? {};
+    // 检查用户禁用规则
+    if (event['UserKey'] && disabledUserKey[event['UserKey']]) {
+        return;
+    }
+    // 文本转换规则（合并 event.transforms + 旧的 redirect + mapping_text）
+    if (event['MessageText']) {
+        const transforms = value?.event?.transforms;
+        if (transforms && transforms.length > 0) {
+            // 新格式：event.transforms 数组
+            for (const rule of transforms) {
+                const { pattern, target } = rule ?? {};
+                if (!pattern) {
+                    continue;
+                }
+                const cachedReg = getCachedRegExp(pattern);
+                if (cachedReg.test(event['MessageText'])) {
+                    event['MessageText'] = event['MessageText'].replace(cachedReg, target);
+                }
+            }
+        }
+        else {
+            // 旧格式兼容：redirect_* + mapping_text
+            const redirectRegular = value?.redirect_regular ?? value?.redirect_text_regular;
+            const redirectTarget = value?.redirect_target ?? value?.redirect_text_target;
+            if (redirectRegular && redirectTarget) {
+                const cachedReg = getCachedRegExp(redirectRegular);
+                if (cachedReg.test(event['MessageText'])) {
+                    event['MessageText'] = event['MessageText'].replace(cachedReg, redirectTarget);
+                }
+            }
+            const mappingText = value?.mapping_text ?? [];
+            for (const mapping of mappingText) {
+                const { regular, target } = mapping ?? {};
+                if (!regular) {
+                    continue;
+                }
+                const cachedReg = getCachedRegExp(regular);
+                if (cachedReg.test(event['MessageText'])) {
+                    event['MessageText'] = event['MessageText'].replace(cachedReg, target);
+                }
+            }
+        }
+    }
+    const masterId = value?.auth?.master?.id ?? value?.master_id ?? {};
+    const masterKey = value?.auth?.master?.key ?? value?.master_key ?? {};
+    // 检查是否是 master
+    if (event['UserId'] && masterId[event['UserId']]) {
+        event['isMaster'] = true;
+    }
+    else if (event['UserKey'] && masterKey[event['UserKey']]) {
+        event['isMaster'] = true;
+    }
+    const botId = value?.auth?.bot?.id ?? value?.bot_id ?? {};
+    const botKey = value?.auth?.bot?.key ?? value?.bot_key ?? {};
+    // 检查是否是 bot
+    if (event['UserId'] && botId[event['UserId']]) {
+        event['isBot'] = true;
+    }
+    else if (event['UserKey'] && botKey[event['UserKey']]) {
+        event['isBot'] = true;
+    }
+    const Now = Date.now();
+    const EVENT_INTERVAL = value?.event?.repeated_event_time ?? value?.processor?.repeated_event_time ?? processorRepeatedEventTime;
+    if (event['MessageId']) {
+        // FNV-1a 快速哈希 — 比 SHA-256 快 ~30-50x
+        const MessageId = fastHash(event['MessageId']);
+        // 重复消息
+        if (filter({ Now, INTERVAL: EVENT_INTERVAL, store: ProcessorEventAutoClearMap }, MessageId)) {
+            return;
+        }
+    }
+    const USER_INTERVAL = value?.event?.repeated_user_time ?? value?.processor?.repeated_user_time ?? processorRepeatedUserTime;
+    if (event['UserId']) {
+        // FNV-1a 快速哈希
+        const UserId = fastHash(event['UserId']);
+        // 频繁操作
+        if (filter({ Now, INTERVAL: USER_INTERVAL, store: ProcessorEventUserAutoClearMap }, UserId)) {
+            return;
+        }
+    }
+    if (data) {
+        // 直接赋值 — 避免 defineProperty 破坏 V8 Hidden Class 优化
+        event['value'] = data;
+    }
+    event['name'] = name;
+    expendCycle(event, name, value);
+};
+/**
+ * 消息处理器
+ * @param event
+ * @param name
+ * @deprecated 该方法已被弃用，请使用 onProcessor() 替代。
+ * @returns
+ */
+const OnProcessor = (event, name) => {
+    onProcessor(name, event);
+};
+
+export { OnProcessor, onProcessor };

package/lib/app/hook-use/hook-use-api.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 卸载模块
+ * @param name
+ * @throws {Error} - 如果 name 无效，抛出错误。
+ */
+export declare const unChildren: (name?: string) => void;

package/lib/app/hook-use/hook-use-api.js

@@ -0,0 +1,22 @@
+import { ResultCode } from '../../core/variable.js';
+import { ChildrenApp } from '../../store/store.js';
+
+/**
+ * 卸载模块
+ * @param name
+ * @throws {Error} - 如果 name 无效，抛出错误。
+ */
+const unChildren = (name = 'main') => {
+    if (!name || typeof name !== 'string') {
+        logger.error({
+            code: ResultCode.FailParams,
+            message: 'Invalid name: name must be a string',
+            data: null
+        });
+        throw new Error('Invalid name: name must be a string');
+    }
+    const app = new ChildrenApp(name);
+    app.un();
+};
+
+export { unChildren };

package/lib/app/hook-use/hook-use-channel.d.ts

@@ -0,0 +1,8 @@
+import { EventKeys, Events } from '../../types';
+/**
+ * 频道处理
+ * @deprecated 待支持
+ * @param event
+ * @returns
+ */
+export declare const useChannel: <T extends EventKeys>(event: Events[T]) => readonly [{}];