alemonjs 2.1.0-alpha.20 → 2.1.0-alpha.22

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

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

package/lib/app/event-group.js

@@ -0,0 +1,28 @@
+/**
+ * 定义一组标准执行导出
+ * @param calls
+ * @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);
+        }
+        else {
+            return acc.concat(item.current);
+        }
+    }, []);
+    return {
+        select: baseSelects,
+        current: currents
+    };
+};
+global.onGroup = onGroup;
+
+export { onGroup };

package/lib/app/event-middleware.js

@@ -36,8 +36,9 @@ global.onMiddleware = onMiddleware;
  * @param callback
  * @returns
  */
-const OnMiddleware = (select, callback) => {
-    return onMiddleware(callback, select);
+const OnMiddleware = (callback, select) => {
+    return onMiddleware(select, callback);
 };
+global.OnMiddleware = OnMiddleware;
 
 export { OnMiddleware, onMiddleware };

package/lib/cbp/config.js

@@ -9,6 +9,10 @@ const fullClient = new Map();
 const deviceId = v4();
 // 连接类型
 const USER_AGENT_HEADER = 'user-agent';
+//
+const USER_AGENT_HEADER_VALUE_MAP = {
+    platform: 'platform',
+    client: 'client'};
 // 设备 ID
 const DEVICE_ID_HEADER = 'x-device-id';
 // 是否全量接收
@@ -34,4 +38,4 @@ const reconnectInterval = 1000 * 6; // 6秒
 // 心跳间隔
 const HEARTBEAT_INTERVAL = 1000 * 18; // 18秒
 
-export { DEVICE_ID_HEADER, FULL_RECEIVE_HEADER, HEARTBEAT_INTERVAL, USER_AGENT_HEADER, actionResolves, actionTimeouts, apiResolves, apiTimeouts, childrenBind, childrenClient, deviceId, fullClient, generateUniqueId, platformClient, reconnectInterval, timeoutTime };
+export { DEVICE_ID_HEADER, FULL_RECEIVE_HEADER, HEARTBEAT_INTERVAL, USER_AGENT_HEADER, USER_AGENT_HEADER_VALUE_MAP, actionResolves, actionTimeouts, apiResolves, apiTimeouts, childrenBind, childrenClient, deviceId, fullClient, generateUniqueId, platformClient, reconnectInterval, timeoutTime };

package/lib/cbp/index.js

@@ -1,23 +1,23 @@
 import Koa from 'koa';
 import { WebSocketServer, WebSocket } from 'ws';
 import router from './router.js';
-import koaStatic from 'koa-static';
 import koaCors from '@koa/cors';
 import { ResultCode } from '../core/code.js';
-import { USER_AGENT_HEADER, DEVICE_ID_HEADER, FULL_RECEIVE_HEADER, platformClient, childrenClient, fullClient, childrenBind } from './config.js';
+import { USER_AGENT_HEADER, USER_AGENT_HEADER_VALUE_MAP, DEVICE_ID_HEADER, FULL_RECEIVE_HEADER, platformClient, fullClient, childrenClient, childrenBind } from './config.js';
 import { getConfig } from '../core/config.js';
 import * as flattedJSON from 'flatted';
+import { connectionTestOne } from './testone.js';
 
 const cbpServer = (port, listeningListener) => {
     if (global.chatbotServer) {
         delete global.chatbotServer;
     }
+    // create
     const app = new Koa();
+    // MessageRouter
     app.use(router.routes());
     app.use(router.allowedMethods());
-    // 读取静态文件夹 gui
-    app.use(koaStatic('/gui'));
-    // 允许跨域
+    // Cors
     app.use(koaCors({
         origin: '*', // 允许所有来源
         allowMethods: ['GET', 'POST', 'PUT', 'DELETE'] // 允许的 HTTP 方法
@@ -43,6 +43,149 @@ const cbpServer = (port, listeningListener) => {
         }
         // 设置平台客户端
         platformClient.set(originId, ws);
+        // 处理api
+        const handleApi = (DeviceId, message) => {
+            // 指定的设备 处理消费。终端有记录每个客户端是谁
+            if (childrenClient.has(DeviceId)) {
+                const clientWs = childrenClient.get(DeviceId);
+                if (clientWs && clientWs.readyState === WebSocket.OPEN) {
+                    // 发送消息到指定的子客户端
+                    clientWs.send(message);
+                }
+                else {
+                    // 如果连接已关闭，删除该客户端
+                    childrenClient.delete(DeviceId);
+                }
+            }
+            else if (fullClient.has(DeviceId)) {
+                const clientWs = fullClient.get(DeviceId);
+                if (clientWs && clientWs.readyState === WebSocket.OPEN) {
+                    // 发送消息到指定的全量客户端
+                    clientWs.send(message);
+                }
+                else {
+                    // 如果连接已关闭，删除该客户端
+                    fullClient.delete(DeviceId);
+                }
+            }
+        };
+        // 处理 action
+        const handleAction = (DeviceId, message) => {
+            if (childrenClient.has(DeviceId)) {
+                const clientWs = childrenClient.get(DeviceId);
+                if (clientWs && clientWs.readyState === WebSocket.OPEN) {
+                    // 发送消息到指定的子客户端
+                    clientWs.send(message);
+                }
+                else {
+                    // 如果连接已关闭，删除该客户端
+                    childrenClient.delete(DeviceId);
+                }
+            }
+            else if (fullClient.has(DeviceId)) {
+                const clientWs = fullClient.get(DeviceId);
+                if (clientWs && clientWs.readyState === WebSocket.OPEN) {
+                    // 发送消息到指定的全量客户端
+                    clientWs.send(message);
+                }
+                else {
+                    // 如果连接已关闭，删除该客户端
+                    fullClient.delete(DeviceId);
+                }
+            }
+        };
+        // 处理事件
+        const handleEvent = (message, ID) => {
+            // 全量客户端
+            fullClient.forEach((clientWs, clientId) => {
+                // 检查状态 并检查状态
+                if (clientWs.readyState === WebSocket.OPEN) {
+                    clientWs.send(message);
+                }
+                else {
+                    // 如果连接已关闭，删除该客户端
+                    childrenClient.delete(clientId);
+                }
+            });
+            // 根据所在群进行分流。
+            // 确保同一个频道的消息。都流向同一个客户端。
+            if (!ID) {
+                logger.error({
+                    code: ResultCode.Fail,
+                    message: '消息缺少标识符 ID',
+                    data: null
+                });
+                return;
+            }
+            // 重新绑定并发送消息
+            const reBind = () => {
+                if (childrenClient.size === 0) {
+                    return;
+                }
+                else if (childrenClient.size === 1) {
+                    // 只有一个客户端，直接绑定
+                    const [bindId, clientWs] = childrenClient.entries().next().value;
+                    childrenBind.set(ID, bindId);
+                    clientWs.send(message);
+                    return;
+                }
+                // 有多个客户端，找到绑定最少的那个。
+                // 如果大家都一样。就拿最近的第一个直接绑定。
+                let minBindCount = Infinity;
+                let bindId = null;
+                childrenClient.forEach((_, id) => {
+                    const count = Array.from(childrenBind.values()).filter(v => v === id).length;
+                    if (count < minBindCount) {
+                        minBindCount = count;
+                        bindId = id;
+                    }
+                });
+                if (bindId) {
+                    const clientWs = childrenClient.get(bindId);
+                    if (clientWs && clientWs.readyState === WebSocket.OPEN) {
+                        // 进行绑定
+                        childrenBind.set(ID, bindId);
+                        // 发送消息到绑定的客户端
+                        clientWs.send(message);
+                    }
+                    else {
+                        // 如果连接已关闭，删除该客户端
+                        childrenClient.delete(bindId);
+                        // 重新进行绑定
+                        reBind();
+                    }
+                }
+                else {
+                    logger.error({
+                        code: ResultCode.Fail,
+                        message: '服务端出现意外，无法绑定客户端',
+                        data: null
+                    });
+                }
+            };
+            // 判断该id是否被分配过
+            if (!childrenBind.has(ID)) {
+                // 进行绑定
+                reBind();
+                return;
+            }
+            const bindId = childrenBind.get(ID);
+            if (!childrenClient.has(bindId)) {
+                // 出现意外。
+                // 重新进行绑定。
+                reBind();
+                return;
+            }
+            const clientWs = childrenClient.get(bindId);
+            if (!clientWs || clientWs.readyState !== WebSocket.OPEN) {
+                // 如果连接已关闭，删除该客户端
+                childrenClient.delete(bindId);
+                // 重新进行绑定
+                reBind();
+                return;
+            }
+            clientWs.send(message);
+        };
         // 得到平台客户端的消息
         ws.on('message', (message) => {
             try {
@@ -51,6 +194,7 @@ const cbpServer = (port, listeningListener) => {
                 // 1. 解析得到 actionId ，说明是消费行为请求。要广播告诉所有客户端。
                 // 2. 解析得到 name ，说明是一个事件请求。
                 // 3. 解析得到 apiId ，说明是一个接口请求。
+                // 4. 解析得到 testID ，说明是一个测试请求。
                 logger.debug({
                     code: ResultCode.Ok,
                     message: '服务端接收到消息',
@@ -59,146 +203,19 @@ const cbpServer = (port, listeningListener) => {
                 if (parsedMessage.apiId) {
                     // 指定的设备 处理消费。终端有记录每个客户端是谁
                     const DeviceId = parsedMessage.DeviceId;
-                    if (childrenClient.has(DeviceId)) {
-                        const clientWs = childrenClient.get(DeviceId);
-                        if (clientWs && clientWs.readyState === WebSocket.OPEN) {
-                            // 发送消息到指定的子客户端
-                            clientWs.send(message);
-                        }
-                        else {
-                            // 如果连接已关闭，删除该客户端
-                            childrenClient.delete(DeviceId);
-                        }
-                    }
-                    else if (fullClient.has(DeviceId)) {
-                        const clientWs = fullClient.get(DeviceId);
-                        if (clientWs && clientWs.readyState === WebSocket.OPEN) {
-                            // 发送消息到指定的全量客户端
-                            clientWs.send(message);
-                        }
-                        else {
-                            // 如果连接已关闭，删除该客户端
-                            fullClient.delete(DeviceId);
-                        }
-                    }
+                    handleApi(DeviceId, message);
                 }
                 else if (parsedMessage?.actionId) {
                     // 指定的设备 处理消费。终端有记录每个客户端是谁
                     const DeviceId = parsedMessage.DeviceId;
-                    if (childrenClient.has(DeviceId)) {
-                        const clientWs = childrenClient.get(DeviceId);
-                        if (clientWs && clientWs.readyState === WebSocket.OPEN) {
-                            // 发送消息到指定的子客户端
-                            clientWs.send(message);
-                        }
-                        else {
-                            // 如果连接已关闭，删除该客户端
-                            childrenClient.delete(DeviceId);
-                        }
-                    }
-                    else if (fullClient.has(DeviceId)) {
-                        const clientWs = fullClient.get(DeviceId);
-                        if (clientWs && clientWs.readyState === WebSocket.OPEN) {
-                            // 发送消息到指定的全量客户端
-                            clientWs.send(message);
-                        }
-                        else {
-                            // 如果连接已关闭，删除该客户端
-                            fullClient.delete(DeviceId);
-                        }
-                    }
+                    handleAction(DeviceId, message);
                 }
                 else if (parsedMessage?.name) {
-                    // 全量客户端
-                    fullClient.forEach((clientWs, clientId) => {
-                        // 检查状态 并检查状态
-                        if (clientWs.readyState === WebSocket.OPEN) {
-                            clientWs.send(message);
-                        }
-                        else {
-                            // 如果连接已关闭，删除该客户端
-                            childrenClient.delete(clientId);
-                        }
-                    });
-                    // 根据所在群进行分流。
-                    // 确保同一个频道的消息。都流向同一个客户端。
                     const ID = parsedMessage.ChannelId || parsedMessage.GuildId || parsedMessage.DeviceId;
-                    if (!ID) {
-                        logger.error({
-                            code: ResultCode.Fail,
-                            message: '消息缺少标识符 ID',
-                            data: null
-                        });
-                        return;
-                    }
-                    // 重新绑定并发送消息
-                    const reBind = () => {
-                        if (childrenClient.size === 0) {
-                            return;
-                        }
-                        else if (childrenClient.size === 1) {
-                            // 只有一个客户端，直接绑定
-                            const [bindId, clientWs] = childrenClient.entries().next().value;
-                            childrenBind.set(ID, bindId);
-                            clientWs.send(message);
-                            return;
-                        }
-                        // 有多个客户端，找到绑定最少的那个。
-                        // 如果大家都一样。就拿最近的第一个直接绑定。
-                        let minBindCount = Infinity;
-                        let bindId = null;
-                        childrenClient.forEach((_, id) => {
-                            const count = Array.from(childrenBind.values()).filter(v => v === id).length;
-                            if (count < minBindCount) {
-                                minBindCount = count;
-                                bindId = id;
-                            }
-                        });
-                        if (bindId) {
-                            const clientWs = childrenClient.get(bindId);
-                            if (clientWs && clientWs.readyState === WebSocket.OPEN) {
-                                // 进行绑定
-                                childrenBind.set(ID, bindId);
-                                // 发送消息到绑定的客户端
-                                clientWs.send(message);
-                            }
-                            else {
-                                // 如果连接已关闭，删除该客户端
-                                childrenClient.delete(bindId);
-                                // 重新进行绑定
-                                reBind();
-                            }
-                        }
-                        else {
-                            logger.error({
-                                code: ResultCode.Fail,
-                                message: '服务端出现意外，无法绑定客户端',
-                                data: null
-                            });
-                        }
-                    };
-                    // 判断该id是否被分配过
-                    if (!childrenBind.has(ID)) {
-                        // 进行绑定
-                        reBind();
-                        return;
-                    }
-                    const bindId = childrenBind.get(ID);
-                    if (!childrenClient.has(bindId)) {
-                        // 出现意外。
-                        // 重新进行绑定。
-                        reBind();
-                        return;
-                    }
-                    const clientWs = childrenClient.get(bindId);
-                    if (!clientWs || clientWs.readyState !== WebSocket.OPEN) {
-                        // 如果连接已关闭，删除该客户端
-                        childrenClient.delete(bindId);
-                        // 重新进行绑定
-                        reBind();
-                        return;
-                    }
-                    clientWs.send(message);
+                    handleEvent(message, ID);
+                }
+                else if (parsedMessage?.testID) {
+                    // 继续解析数据。测试请求。
                 }
             }
             catch (error) {
@@ -298,9 +315,14 @@ const cbpServer = (port, listeningListener) => {
     };
     // 处理客户端连接
     global.chatbotServer.on('connection', (ws, request) => {
+        // 测试平台的连接
+        if (request.url === '/testone') {
+            connectionTestOne(ws);
+            return;
+        }
         // 读取请求头中的 来源
         const headers = request.headers;
-        const origin = headers[USER_AGENT_HEADER] || 'client';
+        const origin = headers[USER_AGENT_HEADER] || USER_AGENT_HEADER_VALUE_MAP.client;
         // 来源id
         const originId = headers[DEVICE_ID_HEADER];
         if (!originId) {
@@ -314,28 +336,30 @@ const cbpServer = (port, listeningListener) => {
             data: null
         });
         // 根据来源进行分类
-        if (origin === 'platform') {
+        if (origin === USER_AGENT_HEADER_VALUE_MAP.platform) {
             setPlatformClient(originId, ws);
             return;
         }
-        // 连接时，需要给客户端发送主动消息
-        ws.send(flattedJSON.stringify({
-            active: 'sync',
-            payload: {
-                value: getConfig().value,
-                args: getConfig().argv,
-                package: {
-                    version: getConfig().package?.version
+        else if (origin === USER_AGENT_HEADER_VALUE_MAP.client) {
+            // 连接时，需要给客户端发送主动消息
+            ws.send(flattedJSON.stringify({
+                active: 'sync',
+                payload: {
+                    value: getConfig().value,
+                    args: getConfig().argv,
+                    package: {
+                        version: getConfig().package?.version
+                    },
+                    env: {
+                        login: process.env.login,
+                        platform: process.env.platform,
+                        port: process.env.port
+                    }
                 },
-                env: {
-                    login: process.env.login,
-                    platform: process.env.platform,
-                    port: process.env.port
-                }
-            },
-            // 主动消息
-            activeId: originId
-        }));
+                // 主动消息
+                activeId: originId
+            }));
+        }
         const isFullReceive = headers[FULL_RECEIVE_HEADER] === '1';
         // 如果是全量接收
         if (isFullReceive) {

package/lib/cbp/testone.js

@@ -0,0 +1,18 @@
+/**
+ * @param ws
+ * @param request
+ */
+const connectionTestOne = (ws, request) => {
+    // 处理消息事件
+    ws.on('message', (message) => {
+        // 支持 读取 文件信息
+        logger.info(message.toString());
+    });
+    // 处理关闭事件
+    ws.on('close', () => {
+        logger.info('WebSocket connection closed');
+        // 可以在这里处理连接关闭的逻辑
+    });
+};
+
+export { connectionTestOne };

package/lib/core/config.js

@@ -161,6 +161,6 @@ const getConfig = () => {
 /**
  * @returns
  */
-const getConfigValue = () => getConfig()?.value;
+const getConfigValue = () => getConfig()?.value || {};
 
 export { ConfigCore, getConfig, getConfigValue };

package/lib/global.d.ts

@@ -1,4 +1,4 @@
-import { OnResponseReversalFunc, OnResponseReversalFuncBack, OnMiddlewareReversalFunc, DefineChildrenFunc, OnSelectsFunc, OnDataFormatFunc } from './typing/event/index.js';
+import { OnResponseReversalFunc, OnResponseReversalFuncBack, OnMiddlewareReversalFunc, OnMiddlewareReversalFuncBack, DefineChildrenFunc, OnSelectsFunc, OnDataFormatFunc, OnGroupFunc } from './typing/event/index.js';
 import { StoreChildrenApp } from './typing/store/res.js';
 import { StateSubscribeMap, SubscribeKeysMap } from './typing/subscribe/index.js';
 import { LoggerUtils } from './typing/logger/index.js';
@@ -53,6 +53,11 @@ declare global {
      * 定义中间件
      */
     var onMiddleware: OnMiddlewareReversalFunc;
+    /**
+     * 定义中间件
+     * @deprecated
+     */
+    var OnMiddleware: OnMiddlewareReversalFuncBack;
     /**
      * 定义一个子模块
      */
@@ -65,6 +70,10 @@ declare global {
      * 定义数据格式
      */
     var format: OnDataFormatFunc;
+    /**
+     * 定义一组标准执行
+     */
+    var onGroup: OnGroupFunc;
     namespace NodeJS {
         interface ProcessEnv {
             login?: string;

package/lib/index.d.ts

@@ -11,7 +11,7 @@ export { PublicEventMessageCreate, PublicEventMessageDelete, PublicEventMessageR
 export { PrivateEventMessageCreate, PrivateEventMessageDelete, PrivateEventMessageUpdate } from './typing/event/message/private.message.js';
 export { PrivateEventRequestFriendAdd, PrivateEventRequestGuildAdd } from './typing/event/request/index.js';
 export { ActionsEventEnum } from './typing/event/actions.js';
-export { Current, CurrentResult, CurrentResultValue, DefineChildrenCallback, DefineChildrenFunc, DefineChildrenValue, DefinePlatformCallback, DefinePlatformFunc, DefinePlatformValue, OnDataFormatFunc, OnMiddlewareFunc, OnMiddlewareReversalFunc, OnMiddlewareReversalFuncBack, OnMiddlewareValue, OnResponseFunc, OnResponseReversalFunc, OnResponseReversalFuncBack, OnResponseValue, OnSelectsFunc } from './typing/event/index.js';
+export { Current, CurrentResult, CurrentResultValue, DefineChildrenCallback, DefineChildrenFunc, DefineChildrenValue, DefinePlatformCallback, DefinePlatformFunc, DefinePlatformValue, OnDataFormatFunc, OnGroupFunc, OnGroupItem, OnMiddlewareFunc, OnMiddlewareReversalFunc, OnMiddlewareReversalFuncBack, OnMiddlewareValue, OnResponseFunc, OnResponseReversalFunc, OnResponseReversalFuncBack, OnResponseValue, OnSelectsFunc } from './typing/event/index.js';
 export { EventKeys, Events, EventsEnum, EventsMessageCreate, EventsMessageCreateEnum, EventsMessageCreateKeys } from './typing/event/map.js';
 export { LoggerUtils } from './typing/logger/index.js';
 export { ClientAPI, ClientAPIMessageResult } from './typing/client/index.js';
@@ -21,6 +21,7 @@ export { StateSubscribeMap, SubscribeKeysMap, SubscribeMap, SubscribeValue } fro
 export { core, logger } from './global.js';
 export { ConfigCore, getConfig, getConfigValue } from './core/config.js';
 export { defineChildren } from './app/define-chidren.js';
+export { onGroup } from './app/event-group.js';
 export { OnMiddleware, onMiddleware } from './app/event-middleware.js';
 export { OnProcessor, onProcessor } from './app/event-processor.js';
 export { OnResponse, onResponse } from './app/event-response.js';

package/lib/index.js

@@ -2,6 +2,7 @@ export { ActionsEventEnum } from './typing/event/actions.js';
 export { core, logger } from './global.js';
 export { ConfigCore, getConfig, getConfigValue } from './core/config.js';
 export { defineChildren } from './app/define-chidren.js';
+export { onGroup } from './app/event-group.js';
 export { OnMiddleware, onMiddleware } from './app/event-middleware.js';
 export { OnProcessor, onProcessor } from './app/event-processor.js';
 export { OnResponse, onResponse } from './app/event-response.js';

package/lib/main.js

@@ -2,6 +2,7 @@ import { getConfig, getConfigValue } from './core/config.js';
 import { loadChildren, loadChildrenFile } from './app/load.js';
 import { getInputExportPath } from './core/utils.js';
 import './app/define-chidren.js';
+import './app/event-group.js';
 import './app/event-middleware.js';
 import './app/event-processor.js';
 import './app/event-response.js';

package/lib/typing/event/index.d.ts

@@ -42,7 +42,7 @@ type OnMiddlewareReversalFunc = <T extends EventKeys, C extends Current<T> | Cur
  * 废弃
  * @deprecated
  */
-type OnMiddlewareReversalFuncBack = <T extends EventKeys, C extends Current<T> | Current<T>[]>(callback: C, select: T | T[]) => OnMiddlewareValue<C, T>;
+type OnMiddlewareReversalFuncBack = <C extends Current<T> | Current<T>[], T extends EventKeys>(callback: C, select: T | T[]) => OnMiddlewareValue<C, T>;
 /**
  *
  */
@@ -88,5 +88,7 @@ type OnSelectsFunc = <T extends EventKeys[] | EventKeys>(values: T) => T;
  * 定义数据格式
  */
 type OnDataFormatFunc = (...data: DataEnums[]) => DataEnums[];
+type OnGroupItem<C = any, T extends EventKeys = EventKeys> = OnResponseValue<C, T> | OnMiddlewareValue<C, T>;
+type OnGroupFunc = <C, T extends EventKeys, TFirst extends OnGroupItem<C, T>>(...calls: [TFirst, ...Array<TFirst>]) => TFirst;
 
-export type { Current, CurrentResult, CurrentResultValue, DefineChildrenCallback, DefineChildrenFunc, DefineChildrenValue, DefinePlatformCallback, DefinePlatformFunc, DefinePlatformValue, OnDataFormatFunc, OnMiddlewareFunc, OnMiddlewareReversalFunc, OnMiddlewareReversalFuncBack, OnMiddlewareValue, OnResponseFunc, OnResponseReversalFunc, OnResponseReversalFuncBack, OnResponseValue, OnSelectsFunc };
+export type { Current, CurrentResult, CurrentResultValue, DefineChildrenCallback, DefineChildrenFunc, DefineChildrenValue, DefinePlatformCallback, DefinePlatformFunc, DefinePlatformValue, OnDataFormatFunc, OnGroupFunc, OnGroupItem, OnMiddlewareFunc, OnMiddlewareReversalFunc, OnMiddlewareReversalFuncBack, OnMiddlewareValue, OnResponseFunc, OnResponseReversalFunc, OnResponseReversalFuncBack, OnResponseValue, OnSelectsFunc };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "alemonjs",
-  "version": "2.1.0-alpha.20",
+  "version": "2.1.0-alpha.22",
   "description": "bot script",
   "author": "lemonade",
   "license": "MIT",
@@ -25,29 +25,30 @@
     }
   },
   "dependencies": {
+    "@koa/cors": "^5.0.0",
+    "axios": "^1.10.0",
     "chalk": "^5.3.0",
     "commander": "^13.1.0",
-    "log4js": "^6.9.1",
-    "yaml": "^2.5.1",
+    "file-type": "21.0.0",
+    "flatted": "^3.3.3",
     "koa": "^2.15.3",
     "koa-router": "^13.0.1",
     "koa-static": "^5.0.0",
-    "@koa/cors": "^5.0.0",
-    "ws": "^8.18.0",
-    "flatted": "^3.3.3",
-    "uuid": "11.1.0",
+    "log4js": "^6.9.1",
     "public-ip": "^7.0.1",
-    "axios": "^1.10.0",
-    "file-type": "21.0.0",
-    "qrcode": "^1.5.4"
+    "qrcode": "^1.5.4",
+    "uuid": "11.1.0",
+    "ws": "^8.18.0",
+    "yaml": "^2.5.1"
   },
   "devDependencies": {
-    "@types/uuid": "^10.0.0",
     "@types/koa": "^2.15.0",
     "@types/koa-bodyparser": "^4.3.12",
     "@types/koa-mount": "^4.0.5",
     "@types/koa-router": "^7.4.8",
-    "@types/koa-static": "^4.0.4"
+    "@types/koa-static": "^4.0.4",
+    "@types/koa__cors": "^5.0.0",
+    "@types/uuid": "^10.0.0"
   },
   "bin": {
     "alemonc": "./bin/alemonc.js"