alemonjs 2.1.53 → 2.1.55

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

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

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

@@ -1,44 +0,0 @@
-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,
-            message: 'Invalid callback: callback must be a function',
-            data: null
-        });
-        throw new Error('Invalid callback: callback must be a function');
-    }
-    if (typeof select === 'string' || typeof select === 'object') {
-        return { current: callback, select };
-    }
-    logger.error({
-        code: ResultCode.FailParams,
-        message: 'Invalid select: select must be a string or object',
-        data: null
-    });
-    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);
-};
-global.OnMiddleware = OnMiddleware;
-
-export { OnMiddleware, onMiddleware };

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

@@ -1,16 +0,0 @@
-import { OnResponseReversalFunc, OnResponseReversalFuncBack } from '../../types';
-/**
- * 处理响应事件
- * @param select 事件选择
- * @param callback 回调函数，处理事件和 API
- * @returns 回调函数的执行结果
- */
-export declare const onResponse: OnResponseReversalFunc;
-/**
- * 废弃，请使用 onResponse
- * @deprecated
- * @param callback
- * @param select
- * @returns
- */
-export declare const OnResponse: OnResponseReversalFuncBack;

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

@@ -1,23 +0,0 @@
-/**
- * 处理响应事件
- * @param select 事件选择
- * @param callback 回调函数，处理事件和 API
- * @returns 回调函数的执行结果
- */
-const onResponse = (select, callback) => {
-    return { current: callback, select };
-};
-global.onResponse = onResponse;
-/**
- * 废弃，请使用 onResponse
- * @deprecated
- * @param callback
- * @param select
- * @returns
- */
-const OnResponse = (callback, select) => {
-    return onResponse(select, callback);
-};
-global.OnResponse = OnResponse;
-
-export { OnResponse, onResponse };

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

@@ -1,13 +0,0 @@
-import { EventKeys } from '../../types';
-/**
- * 创建选择器
- * @param values
- * @returns
- */
-export declare const onSelects: <T extends EventKeys[] | EventKeys>(values: T) => T;
-/**
- * @deprecated 废弃,请使用onSelects
- * @param values
- * @returns
- */
-export declare const createSelects: <T extends EventKeys[] | EventKeys>(values: T) => T;

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

@@ -1,15 +0,0 @@
-/**
- * 创建选择器
- * @param values
- * @returns
- */
-const onSelects = (values) => values;
-global.onSelects = onSelects;
-/**
- * @deprecated 废弃,请使用onSelects
- * @param values
- * @returns
- */
-const createSelects = onSelects;
-
-export { createSelects, onSelects };

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

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

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

@@ -1,43 +0,0 @@
-import { showErrorModule } from '../../core/utils.js';
-
-const createCallHandler = valueEvent => {
-    // 开始处理 handler
-    const callHandler = (currents, nextEvent) => {
-        let index = 0;
-        let isClose = false;
-        let isNext = false;
-        const start = async () => {
-            if (index >= currents.length) {
-                return;
-            }
-            if (isNext) {
-                return;
-            }
-            if (isClose) {
-                return;
-            }
-            try {
-                // 统一使用 await，无需区分同步/异步函数
-                const res = await currents[index](valueEvent, (...cns) => {
-                    isNext = true;
-                    nextEvent(...cns);
-                });
-                // return true → 局部中间件放行，继续执行 children handler
-                // return void/false → 处理完毕或拦截，停止当前链
-                if (res !== true) {
-                    isClose = true;
-                }
-            }
-            catch (err) {
-                showErrorModule(err);
-                return;
-            }
-            ++index;
-            void start();
-        };
-        void start();
-    };
-    return callHandler;
-};
-
-export { createCallHandler };

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

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

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

@@ -1,97 +0,0 @@
-import { ResultCode } from '../../core/variable.js';
-import { expendEvent } from './event-processor-event.js';
-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 = {
-            Name: select
-        };
-        for (const key in event) {
-            if (Object.prototype.hasOwnProperty.call(event, key)) {
-                const value = event[key];
-                if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
-                    log[key] = value;
-                }
-            }
-        }
-        logger.debug({
-            code: ResultCode.Ok,
-            message: 'new event',
-            data: log
-        });
-    }
-    else {
-        // 批量收集非空字段后一次 join — 避免多次 typeof 检查 + 字符串 += 拼接
-        const parts = [`[Name:${select}]`];
-        const fields = ['GuildId', 'ChannelId', 'UserKey', 'UserId', 'MessageId', 'MessageText'];
-        for (const f of fields) {
-            const v = event[f];
-            if (typeof v === 'string' && v !== '') {
-                parts.push(`[${f}:${v}]`);
-            }
-        }
-        logger.info(parts.join(''));
-    }
-};
-/**
- * 消息体处理机制
- * @param event
- * @param key
- */
-const expendCycle = (valueEvent, select, config) => {
-    const nextEnd = () => { };
-    // unmount
-    const nextUnMount = (cn, ...cns) => {
-        if (cn) {
-            nextEnd(...cns);
-            return;
-        }
-        void expendSubscribeUnmount(valueEvent, select, nextEnd);
-    };
-    // event
-    const nextEvent = (cn, ...cns) => {
-        if (cn) {
-            nextUnMount(...cns);
-            return;
-        }
-        void expendEvent(valueEvent, select, nextUnMount);
-    };
-    // mount
-    const nextMount = (cn, ...cns) => {
-        if (cn) {
-            nextEvent(...cns);
-            return;
-        }
-        void expendSubscribeMount(valueEvent, select, nextEvent);
-    };
-    // middleware
-    const nextCreate = (cn, ...cns) => {
-        if (cn) {
-            nextMount(...cns);
-            return;
-        }
-        void expendMiddleware(valueEvent, select, nextMount);
-    };
-    const value = config ?? getConfigValue() ?? {};
-    if (Array.isArray(value?.logs?.channel_id)) {
-        const channelIds = value?.logs?.channel_id;
-        if (channelIds && channelIds.length > 0 && channelIds.includes(valueEvent['ChannelId'])) {
-            showLog(valueEvent, select);
-        }
-    }
-    else {
-        showLog(valueEvent, select);
-    }
-    // create
-    void expendSubscribeCreate(valueEvent, select, nextCreate);
-};
-
-export { expendCycle };

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

@@ -1,11 +0,0 @@
-import { Next, Events, EventKeys, StoreResponseItem } from '../../types';
-/**
- * 清除模块缓存（用于热更新等场景）
- */
-export declare const clearModuleCache: (path?: string) => void;
-/**
- * 创建 next 处理函数
- * @param event
- * @param select
- */
-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/event-processor-cycleFiles.js

@@ -1,147 +0,0 @@
-import { useState } from '../hook-use/hook-use-state.js';
-import { getCachedRegExp, showErrorModule } from '../../core/utils.js';
-import { EventMessageText } from '../../core/variable.js';
-import { ResponseMiddleware } from '../../store/store.js';
-
-// 模块级单例 — ResponseMiddleware 无状态，无需每文件 new
-const responseMiddlewareSingleton = new ResponseMiddleware();
-// 模块缓存，避免每次事件处理都重新 import
-const moduleCache = new Map();
-/**
- * 清除模块缓存（用于热更新等场景）
- */
-const clearModuleCache = (path) => {
-    if (path) {
-        moduleCache.delete(path);
-    }
-    else {
-        moduleCache.clear();
-    }
-};
-const loadModule = async (filePath) => {
-    if (moduleCache.has(filePath)) {
-        return moduleCache.get(filePath);
-    }
-    const mod = await import(`file://${filePath}`);
-    moduleCache.set(filePath, mod);
-    return mod;
-};
-const callHandlerFile = async (valueEvent, select, file, nextStep, callback) => {
-    try {
-        const app = await loadModule(file.path);
-        // bad case
-        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) {
-                if (!getCachedRegExp(app.regular).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);
-    }
-};
-/**
- * 创建 next 处理函数
- * @param event
- * @param select
- */
-const createNextStep = (valueEvent, select, next, files, callHandler) => {
-    let valueI = 0;
-    // 记录被close的中间件。优化下调用性能
-    const recordCloseMw = new Set();
-    /**
-     * 下一步
-     * @returns
-     */
-    const nextStep = (cn, ...cns) => {
-        if (cn) {
-            next(...cns);
-            return;
-        }
-        // 结束了
-        if (valueI >= files.length) {
-            next();
-            return;
-        }
-        // 检查所有
-        void calli();
-    };
-    /**
-     * 执行 i
-     * @returns
-     */
-    const calli = async () => {
-        // 调用完了
-        if (valueI >= files.length) {
-            // 开始调用j
-            nextStep();
-            return;
-        }
-        valueI++;
-        const file = files[valueI - 1];
-        if (!file?.path) {
-            // 继续
-            nextStep();
-            return;
-        }
-        // 调用局部中间件（使用模块级单例，避免每文件创建新实例）
-        const currentsAndMiddleware = responseMiddlewareSingleton.find(file.appName, file.stateKey);
-        const currents = [];
-        // 直接遍历 middleware 数组 + file，避免每文件 spread 创建新数组
-        const iterItems = currentsAndMiddleware.length > 0 ? currentsAndMiddleware.concat(file) : [file];
-        for (const cm of iterItems) {
-            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 { clearModuleCache, createNextStep };

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

@@ -1,10 +0,0 @@
-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

@@ -1,133 +0,0 @@
-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

@@ -1,24 +0,0 @@
-/**
- * @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

@@ -1,41 +0,0 @@
-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

@@ -1,14 +0,0 @@
-/**
- * @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;