alemonjs 2.0.5 → 2.0.7

package/lib/app/code.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 结果反馈码
+ */
+/**
+ * 结果反馈码
+ * @description
+ * - 2000: 成功
+ * - 4000: 未知错误
+ * - 4001: 参数错误
+ * - 4002: 权限不足
+ */
+declare const ResultCode: {
+    readonly Ok: 2000;
+    readonly Fail: 4000;
+    readonly FailParams: 4001;
+    readonly Warn: 2100;
+    readonly FailAuth: 4002;
+    readonly FailInternal: 5000;
+};
+type ResultCode = typeof ResultCode[keyof typeof ResultCode];
+
+export { ResultCode };

package/lib/app/code.js

@@ -0,0 +1,32 @@
+/**
+ * 结果反馈码
+ */
+// 成功码
+const Ok = 2000; // 成功
+// 警惕码
+const Warn = 2100; // 任意警告
+// 失败码
+const Fail = 4000; // 未知错误
+const FailParams = 4001; // 参数错误
+// 权限错误
+const FailAuth = 4002; // 权限不足
+// 内部错误
+const FailInternal = 5000; // 内部错误
+/**
+ * 结果反馈码
+ * @description
+ * - 2000: 成功
+ * - 4000: 未知错误
+ * - 4001: 参数错误
+ * - 4002: 权限不足
+ */
+const ResultCode = {
+    Ok,
+    Fail,
+    FailParams,
+    Warn,
+    FailAuth,
+    FailInternal
+};
+
+export { ResultCode };

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

@@ -1,8 +1,10 @@
 import { DefinePlatformFunc } from '../typing/event/index.js';
+import '../global.js';
 
 /**
  * 定义机器人
  * @param callback
+ * @throws {Error} - 如果 callback 无效，抛出错误。
  * @returns
  */
 declare const definePlatform: DefinePlatformFunc;

package/lib/app/define-bot.js

@@ -1,11 +1,19 @@
+import { ResultCode } from '../code.js';
+
 /**
  * 定义机器人
  * @param callback
+ * @throws {Error} - 如果 callback 无效，抛出错误。
  * @returns
  */
 const definePlatform = 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');
     }
     return {
@@ -18,7 +26,14 @@ global.definePlatform = definePlatform;
  * 废弃，请使用 definePlatform
  * @deprecated
  */
-const defineBot = definePlatform;
+const defineBot = callback => {
+    logger.warn({
+        code: ResultCode.Warn,
+        message: 'defineBot is deprecated, please use definePlatform',
+        data: null
+    });
+    return definePlatform(callback);
+};
 global.defineBot = defineBot;
 
 export { defineBot, definePlatform };

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

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

package/lib/app/define-chidren.js

@@ -1,6 +1,9 @@
+import { ResultCode } from '../code.js';
+
 /**
  * 定义子事件
  * @param callback
+ * @throws {Error} - 如果 callback 无效，抛出错误。
  * @returns
  */
 const defineChildren = callback => {
@@ -10,6 +13,11 @@ const defineChildren = callback => {
             callback
         };
     }
+    logger.error({
+        code: ResultCode.FailParams,
+        message: 'Invalid callback: callback must be a object or function',
+        data: null
+    });
     throw new Error('Invalid callback: callback must be a object or function');
 };
 global.defineChildren = defineChildren;

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

@@ -1,4 +1,5 @@
 import { OnMiddlewareReversalFunc, OnMiddlewareFunc } from '../typing/event/index.js';
+import '../global.js';
 
 /**
  * @fileoverview 中间件
@@ -10,6 +11,8 @@ import { OnMiddlewareReversalFunc, OnMiddlewareFunc } from '../typing/event/inde
  * 中间件
  * @param select 事件选择
  * @param callback 回调函数，处理事件和 API
+ * @throws {Error} - 如果 select 无效，抛出错误。
+ * @throws {Error} - 如果 callback 无效，抛出错误。
  * @returns
  */
 declare const onMiddleware: OnMiddlewareReversalFunc;

package/lib/app/event-middleware.js

@@ -1,19 +1,46 @@
+import { ResultCode } from '../code.js';
+
 /**
  * 中间件
  * @param select 事件选择
  * @param callback 回调函数，处理事件和 API
+ * @throws {Error} - 如果 select 无效，抛出错误。
+ * @throws {Error} - 如果 callback 无效，抛出错误。
  * @returns
  */
-const onMiddleware = (select, callback) => ({
-    select,
-    current: callback
-});
+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
  */
-const OnMiddleware = (callback, select) => ({ select, current: callback });
+const OnMiddleware = (callback, select) => {
+    logger.warn({
+        code: ResultCode.Warn,
+        message: 'OnMiddleware is deprecated, please use onMiddleware',
+        data: null
+    });
+    return ({ select, current: callback });
+};
 global.OnMiddleware = OnMiddleware;
 
 export { OnMiddleware, onMiddleware };

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

@@ -1,3 +1,4 @@
+import { ResultCode } from '../code.js';
 import { expendEvent } from './event-processor-event.js';
 import { expendMiddleware } from './event-processor-middleware.js';
 import { expendSubscribeCreate, expendSubscribeMount, expendSubscribeUnmount } from './event-processor-subscribe.js';
@@ -8,19 +9,31 @@ import { expendSubscribeCreate, expendSubscribeMount, expendSubscribeUnmount } f
  * @param select
  */
 const showLog = (event, select) => {
-    const logs = [`[${select}]`];
+    const log = {
+        'Name': select
+    };
     if (typeof event['ChannelId'] == 'string' && event['ChannelId'] != '') {
-        logs.push(`[${event['ChannelId']}]`);
+        log['ChannelId'] = event['ChannelId'];
     }
     if (typeof event['UserKey'] == 'string' && event['UserKey'] != '') {
-        logs.push(`[${event['UserKey']}]`);
+        log['UserKey'] = event['UserKey'];
+    }
+    if (typeof event['UserId'] == 'string' && event['UserId'] != '') {
+        log['UserId'] = event['UserId'];
+    }
+    if (typeof event['MessageId'] == 'string' && event['MessageId'] != '') {
+        log['MessageId'] = event['MessageId'];
     }
     if (Array.isArray(event['MessageBody'])) {
         const content = event['MessageBody'].filter(item => item.type == 'Text').map(item => item.value);
         const txt = content.join('');
-        logs.push(`[${txt}]`);
+        log['text'] = txt;
     }
-    return logs;
+    logger.info({
+        code: ResultCode.Ok,
+        message: 'new event',
+        data: log
+    });
 };
 /**
  * 消息体处理机制
@@ -63,8 +76,7 @@ const expendCycle = async (valueEvent, select) => {
         }
         expendMiddleware(valueEvent, select, nextMount);
     };
-    const log = showLog(valueEvent, select);
-    logger.info(log.join(''));
+    showLog(valueEvent, select);
     // create
     expendSubscribeCreate(valueEvent, select, nextCreate);
 };

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

@@ -1,4 +1,5 @@
 import { EventKeys, Events } from '../typing/event/map.js';
+import '../global.js';
 
 /**
  * 消息处理器

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

@@ -1,4 +1,5 @@
 import { OnResponseReversalFunc, OnResponseFunc } from '../typing/event/index.js';
+import '../global.js';
 
 /**
  * 处理响应事件

package/lib/app/event-response.js

@@ -1,3 +1,5 @@
+import { ResultCode } from '../code.js';
+
 /**
  * 处理响应事件
  * @param select 事件选择
@@ -13,6 +15,11 @@ global.onResponse = onResponse;
  * @deprecated
  */
 const OnResponse = (callback, select) => {
+    logger.warn({
+        code: ResultCode.Warn,
+        message: 'OnResponse is deprecated, please use onResponse',
+        data: null
+    });
     return { current: callback, select };
 };
 global.OnResponse = OnResponse;

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

@@ -1,10 +1,12 @@
+import { Result } from './utils.js';
 import { EventKeys, Events } from '../typing/event/map.js';
-import { User } from '../typing/event/base/user.js';
+import '../global.js';
 import { DataEnums } from '../typing/message/index.js';
 
 /**
  * 使用提及。
  * @param {Object} event - 事件对象，包含触发提及的相关信息。
+ * @throws {Error} - 如果 event 无效，抛出错误。
  */
 declare const useMention: <T extends EventKeys>(event: Events[T]) => {
     find: (options: {
@@ -13,25 +15,25 @@ declare const useMention: <T extends EventKeys>(event: Events[T]) => {
         UserName?: string;
         IsMaster?: boolean;
         IsBot?: boolean;
-    }) => Promise<User[]>;
+    }) => Promise<Result>;
     findOne: (options?: {
         UserId?: string;
         UserKey?: string;
         UserName?: string;
         IsMaster?: boolean;
         IsBot?: boolean;
-    }) => Promise<User>;
+    }) => Promise<Result>;
 }[];
 /**
  * 使用发送消息。
  * @param {Object} event - 事件对象，包含触发发送的相关信息。
- * @returns {Function} - 返回一个异步函数，用于发送消息。
  * @throws {Error} - 如果 event 无效，抛出错误。
  */
-declare const useSend: <T extends EventKeys>(event: Events[T]) => (...val: DataEnums[]) => Promise<any[]>;
+declare const useSend: <T extends EventKeys>(event: Events[T]) => (...val: DataEnums[]) => Promise<Result>;
 /**
  * 卸载模块
  * @param name
+ * @throws {Error} - 如果 name 无效，抛出错误。
  */
 declare const unChildren: (name?: string) => void;
 /**
@@ -40,7 +42,7 @@ declare const unChildren: (name?: string) => void;
  */
 declare const unMount: () => void;
 /**
- *
+ * 创建选择器
  * @param values
  * @returns
  */

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

@@ -1,18 +1,34 @@
+import { ResultCode } from '../code.js';
 import { ChildrenApp } from './store.js';
+import { createResult } from './utils.js';
 
 /**
  * 使用提及。
  * @param {Object} event - 事件对象，包含触发提及的相关信息。
+ * @throws {Error} - 如果 event 无效，抛出错误。
  */
 const useMention = (event) => {
     if (!event || typeof event !== 'object') {
+        logger.error({
+            code: ResultCode.FailParams,
+            message: 'Invalid event: event must be an object',
+            data: null
+        });
         throw new Error('Invalid event: event must be an object');
     }
     let res = null;
     const mention = {
         find: async (options) => {
-            if (!res) {
-                res = await alemonjsBot.api.use.mention(event);
+            try {
+                if (!res) {
+                    res = await alemonjsBot.api.use.mention(event);
+                }
+            }
+            catch (err) {
+                return createResult(ResultCode.Fail, err?.message || 'Failed to get mention data', null);
+            }
+            if (!Array.isArray(res)) {
+                return createResult(ResultCode.Fail, 'No mention data found', null);
             }
             // 过滤出符合条件的数据
             const data = res.filter(item => {
@@ -33,13 +49,21 @@ const useMention = (event) => {
                 }
                 return true;
             });
-            return data;
+            return createResult(ResultCode.Ok, 'Successfully retrieved mention data', data);
         },
         findOne: async (options = {
             IsBot: false
         }) => {
-            if (!res) {
-                res = await alemonjsBot.api.use.mention(event);
+            try {
+                if (!res) {
+                    res = await alemonjsBot.api.use.mention(event);
+                }
+            }
+            catch (err) {
+                return createResult(ResultCode.Fail, err?.message || 'Failed to get mention data', null);
+            }
+            if (!Array.isArray(res)) {
+                return createResult(ResultCode.Fail, 'No mention data found', null);
             }
             // 根据条件查找
             const data = res.find(item => {
@@ -60,7 +84,10 @@ const useMention = (event) => {
                 }
                 return true;
             });
-            return data;
+            if (!data) {
+                return createResult(ResultCode.Fail, 'No mention data found', null);
+            }
+            return createResult(ResultCode.Ok, 'Successfully retrieved mention data', data);
         }
     };
     return [mention];
@@ -68,33 +95,38 @@ const useMention = (event) => {
 /**
  * 使用发送消息。
  * @param {Object} event - 事件对象，包含触发发送的相关信息。
- * @returns {Function} - 返回一个异步函数，用于发送消息。
  * @throws {Error} - 如果 event 无效，抛出错误。
  */
 const useSend = (event) => {
     if (!event || typeof event !== 'object') {
+        logger.error({
+            code: ResultCode.FailParams,
+            message: 'Invalid event: event must be an object',
+            data: null
+        });
         throw new Error('Invalid event: event must be an object');
     }
     return async (...val) => {
         if (!val || val.length === 0) {
-            logger.error('Invalid val: val must be a non-empty array');
-            return;
-        }
-        try {
-            return await alemonjsBot.api.use.send(event, val);
-        }
-        catch (e) {
-            logger.error('Failed to send message:', e);
-            // 弹出错误
-            throw e;
+            return createResult(ResultCode.FailParams, 'Invalid val: val must be a non-empty array', null);
         }
+        return await alemonjsBot.api.use.send(event, val);
     };
 };
 /**
  * 卸载模块
  * @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();
 };
@@ -103,11 +135,14 @@ const unChildren = (name = 'main') => {
  * @deprecated
  */
 const unMount = () => {
-    // 警告，已废弃。
-    console.warn('unMount 已废弃，请使用 unChildren');
+    logger.warn({
+        code: ResultCode.Warn,
+        message: 'unMount is deprecated, please use unChildren',
+        data: null
+    });
 };
 /**
- *
+ * 创建选择器
  * @param values
  * @returns
  */

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

@@ -8,13 +8,14 @@
  * 将会同时改变，因为状态是全局的
  * @param name 功能名
  * @param defaultValue 默认值，默认为 true
- * @returns 当前状态和设置函数
+ * @throws {Error} - 如果 name 不是字符串，或者 defaultValue 不是布尔值，抛出错误。
  */
 declare const useState: <T extends string>(name: T, defaultValue?: boolean) => [boolean, (value: boolean) => void];
 /**
  * 订阅状态变化
  * @param name 功能名
  * @param callback 回调函数
+ * @throws {Error} - 如果 callback 无效，抛出错误。
  */
 declare const onState: <T extends string>(name: T, callback: (value: boolean) => void) => void;
 /**
@@ -26,6 +27,7 @@ declare const eventState: <T extends string>(name: T, callback: (value: boolean)
  * 取消订阅状态变化
  * @param name 功能名
  * @param callback 回调函数
+ * @throws {Error} - 如果 callback 无效，抛出错误。
  */
 declare const unState: <T extends string>(name: T, callback: (value: boolean) => void) => void;
 /**

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

@@ -1,4 +1,5 @@
 import { getConfig } from '../config.js';
+import { ResultCode } from '../code.js';
 import { State, StateSubscribe } from './store.js';
 
 /**
@@ -11,9 +12,26 @@ import { State, StateSubscribe } from './store.js';
  * 将会同时改变，因为状态是全局的
  * @param name 功能名
  * @param defaultValue 默认值，默认为 true
- * @returns 当前状态和设置函数
+ * @throws {Error} - 如果 name 不是字符串，或者 defaultValue 不是布尔值，抛出错误。
  */
 const useState = (name, defaultValue = true) => {
+    // 检查参数
+    if (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');
+    }
+    if (typeof defaultValue !== 'boolean') {
+        logger.error({
+            code: ResultCode.FailParams,
+            message: 'Invalid defaultValue: defaultValue must be a boolean',
+            data: null
+        });
+        throw new Error('Invalid defaultValue: defaultValue must be a boolean');
+    }
     const state = new State(name, defaultValue);
     // 设置值的函数
     const setValue = (value) => {
@@ -47,9 +65,15 @@ const useState = (name, defaultValue = true) => {
  * 订阅状态变化
  * @param name 功能名
  * @param callback 回调函数
+ * @throws {Error} - 如果 callback 无效，抛出错误。
  */
 const onState = (name, callback) => {
     if (typeof callback !== 'function') {
+        logger.error({
+            code: ResultCode.FailParams,
+            message: 'Callback must be a function',
+            data: null
+        });
         throw new Error('Callback must be a function');
     }
     const sub = new StateSubscribe(name);
@@ -59,13 +83,31 @@ const onState = (name, callback) => {
  * 废弃，请使用 onState
  * @deprecated
  */
-const eventState = onState;
+const eventState = (name, callback) => {
+    // 废弃警告
+    logger.warn({
+        code: ResultCode.Warn,
+        message: 'eventState is deprecated, please use onState',
+        data: null
+    });
+    return onState(name, callback);
+};
 /**
  * 取消订阅状态变化
  * @param name 功能名
  * @param callback 回调函数
+ * @throws {Error} - 如果 callback 无效，抛出错误。
  */
 const unState = (name, callback) => {
+    if (typeof callback !== 'function') {
+        logger.error({
+            code: ResultCode.FailParams,
+            message: 'Callback must be a function',
+            data: null
+        });
+        throw new Error('Callback must be a function');
+    }
+    // 取消订阅
     const sub = new StateSubscribe(name);
     sub.un(callback);
 };
@@ -73,24 +115,14 @@ const unState = (name, callback) => {
  * 废弃，请使用 unState
  * @deprecated
  */
-const unEventState = unState;
-// let lastDependencies;
-// let lastValue;
-// export const useMemo = (create, dependencies) => {
-//   if (lastDependencies) {
-//     // 检查依赖项是否变化
-//     const hasChanged = dependencies.some((dep, i) =>
-//       !Object.is(dep, lastDependencies[i])
-//     );
-//     if (!hasChanged) {
-//       // 依赖未变化，返回缓存值
-//       return lastValue;
-//     }
-//   }
-//   // 依赖变化，重新计算
-//   lastValue = create();
-//   lastDependencies = dependencies;
-//   return lastValue;
-// }
+const unEventState = (name, callback) => {
+    // 废弃警告
+    logger.warn({
+        code: ResultCode.Warn,
+        message: 'unEventState is deprecated, please use unState',
+        data: null
+    });
+    return unState(name, callback);
+};
 
 export { eventState, onState, unEventState, unState, useState };

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

@@ -1,11 +1,12 @@
 import { EventKeys, Events } from '../typing/event/map.js';
 import { Current } from '../typing/event/index.js';
+import '../global.js';
 
 /**
  * 使用订阅
  * @param event
  * @param option
- * @returns
+ * @throws {Error} - 如果 event 不是对象，或者 select 不是字符串，抛出错误。
  */
 declare const useSubscribe: <T extends EventKeys>(event: Events[T], select: T) => ((callback: Current<T>, keys: (keyof Events[T])[]) => void)[];
 /**

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

@@ -1,12 +1,30 @@
+import { ResultCode } from '../code.js';
 import { SubscribeList } from './store.js';
 
 /**
  * 使用订阅
  * @param event
  * @param option
- * @returns
+ * @throws {Error} - 如果 event 不是对象，或者 select 不是字符串，抛出错误。
  */
 const useSubscribe = (event, select) => {
+    // 检查参数
+    if (typeof event !== 'object') {
+        logger.error({
+            code: ResultCode.FailParams,
+            message: 'event is not object',
+            data: null
+        });
+        throw new Error('event is not object');
+    }
+    if (typeof select !== 'string') {
+        logger.error({
+            code: ResultCode.FailParams,
+            message: 'select is not string',
+            data: null
+        });
+        throw new Error('select is not string');
+    }
     const run = (callback, keys, chioce) => {
         const subList = new SubscribeList(chioce, select);
         // 没有选择

package/lib/app/load.d.ts

@@ -1,6 +1,8 @@
 /**
- * 加载模块
+ * 加载子模块
  * @param mainPath
+ * @param appName
+ * @throws {Error} - 如果 mainPath 无效，抛出错误。
  */
 declare const loadChildren: (mainPath: string, appName: string) => Promise<void>;
 /**