alemonjs 2.1.41 → 2.1.43

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

@@ -0,0 +1,33 @@
+import { ResultCode } from '../../core/variable.js';
+
+/**
+ * 频道处理
+ * @deprecated 待支持
+ * @param event
+ * @returns
+ */
+const useChannel = (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');
+    }
+    // // 退出
+    // const exit = async (channel_id?: string) => {
+    //   return createResult(ResultCode.Warn, '暂未支持', channel_id)
+    // }
+    // // 加入
+    // const join = async (channel_id?: string) => {
+    //   return createResult(ResultCode.Warn, '暂未支持', channel_id)
+    // }
+    const channel = {
+    // exit,
+    // join
+    };
+    return [channel];
+};
+
+export { useChannel };

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

@@ -0,0 +1,7 @@
+/**
+ * 使用客户端
+ * @param event
+ * @param _ApiClass
+ * @returns
+ */
+export declare const useClient: <T extends object>(event: any, _ApiClass: new (...args: any[]) => T) => readonly [T];

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

@@ -0,0 +1,27 @@
+import { sendAPI } from '../../cbp/processor/api.js';
+
+/**
+ * 使用客户端
+ * @param event
+ * @param _ApiClass
+ * @returns
+ */
+const useClient = (event, _ApiClass) => {
+    const client = new Proxy({}, {
+        get(_target, prop) {
+            return (...args) => {
+                return sendAPI({
+                    action: 'client.api',
+                    payload: {
+                        event,
+                        key: String(prop),
+                        params: args
+                    }
+                });
+            };
+        }
+    });
+    return [client];
+};
+
+export { useClient };

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

@@ -0,0 +1,8 @@
+import { User } from '../../types';
+import { Result } from '../../core/utils';
+/**
+ * 获取我相关的数据
+ */
+export declare const useMe: () => readonly [{
+    info: () => Promise<Result<User | null>>;
+}];

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

@@ -0,0 +1,45 @@
+import { ResultCode } from '../../core/variable.js';
+import { createResult } from '../../core/utils.js';
+import { sendAction } from '../../cbp/processor/actions.js';
+
+/**
+ * 获取我相关的数据
+ */
+const useMe = () => {
+    /**
+     * 个人信息
+     * @returns
+     */
+    const info = async () => {
+        try {
+            const results = await sendAction({
+                action: 'me.info',
+                payload: {}
+            });
+            const result = results.find(item => item.code === ResultCode.Ok);
+            if (result) {
+                const data = result?.data ?? null;
+                return createResult(ResultCode.Ok, 'Successfully retrieved bot information', data);
+            }
+            return createResult(ResultCode.Warn, 'No bot information found', null);
+        }
+        catch {
+            return createResult(ResultCode.Fail, 'Failed to get bot information', null);
+        }
+    };
+    /**
+     * 加入的服务器列表
+     */
+    /**
+     * 好友列表
+     */
+    /**
+     * 私聊线程列表
+     */
+    const control = {
+        info
+    };
+    return [control];
+};
+
+export { useMe };

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

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

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

@@ -0,0 +1,59 @@
+import { ResultCode } from '../../core/variable.js';
+
+/**
+ * 用户处理
+ * @deprecated 待支持
+ * @param event
+ * @returns
+ */
+const useMember = (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');
+    }
+    // /**
+    //  * 获取用户信息
+    //  * @param user_id
+    //  * @returns
+    //  */
+    // const information = async (user_id?: string) => {
+    //   return createResult(ResultCode.Warn, '暂未支持', user_id)
+    // }
+    // /**
+    //  * 禁言
+    //  * @param all 是否是全体
+    //  * @returns
+    //  */
+    // const mute = async (all: boolean = false) => {
+    //   return createResult(ResultCode.Warn, '暂未支持', all)
+    // }
+    // /**
+    //  * 解除禁言
+    //  * @param all 是否是全体
+    //  * @returns
+    //  */
+    // const unmute = async (all: boolean = false) => {
+    //   return createResult(ResultCode.Warn, '暂未支持', all)
+    // }
+    // /**
+    //  * 移除用户
+    //  * @param user_id
+    //  * @returns
+    //  */
+    // const remove = async (user_id?: string) => {
+    //   return createResult(ResultCode.Warn, '暂未支持', user_id)
+    // }
+    const member = {
+    // information,
+    // mute,
+    // unmute,
+    // remove
+    };
+    return [member];
+};
+
+export { useMember };

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

@@ -0,0 +1,23 @@
+import { EventKeys, Events, User } from '../../types';
+import { Result } from '../../core/utils';
+type Options = {
+    UserId?: string;
+    UserKey?: string;
+    UserName?: string;
+    IsMaster?: boolean;
+    IsBot?: boolean;
+};
+/**
+ * 使用提及。
+ * @param {Object} event - 事件对象，包含触发提及的相关信息。
+ * @throws {Error} - 如果 event 无效，抛出错误。
+ */
+export declare const useMention: <T extends EventKeys>(event: Events[T]) => [{
+    find: (options?: Options) => Promise<Result<User[]> & {
+        count: number;
+    }>;
+    findOne: (options?: Options) => Promise<Result<User | null> & {
+        count: number;
+    }>;
+}];
+export {};

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

@@ -0,0 +1,105 @@
+import { ResultCode } from '../../core/variable.js';
+import { createResult } from '../../core/utils.js';
+import { sendAction } from '../../cbp/processor/actions.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 load = async () => {
+        if (res) {
+            return;
+        }
+        // 获取提及数据
+        const results = await sendAction({
+            action: 'mention.get',
+            payload: { event }
+        });
+        // 提及数据通常在 results 中，找到 code 为 Ok 的项目，并将其 data 作为提及数据缓存起来
+        const result = results.find(item => item.code === ResultCode.Ok);
+        if (result) {
+            res = result.data;
+        }
+    };
+    /** 按条件过滤，默认排除 bot */
+    const match = (item, options) => {
+        if (options.UserId !== undefined && item.UserId !== options.UserId) {
+            return false;
+        }
+        if (options.UserKey !== undefined && item.UserKey !== options.UserKey) {
+            return false;
+        }
+        if (options.UserName !== undefined && item.UserName !== options.UserName) {
+            return false;
+        }
+        if (options.IsMaster !== undefined && item.IsMaster !== options.IsMaster) {
+            return false;
+        }
+        if (options.IsBot !== undefined && item.IsBot !== options.IsBot) {
+            return false;
+        }
+        // 默认排除 bot
+        if (options.IsBot === undefined && item.IsBot) {
+            return false;
+        }
+        return true;
+    };
+    const mention = {
+        find: async (options = {}) => {
+            try {
+                await load();
+            }
+            catch (err) {
+                const result = createResult(ResultCode.Fail, err?.message || 'Failed to get mention data', null);
+                return {
+                    ...result,
+                    count: 0
+                };
+            }
+            if (!Array.isArray(res)) {
+                return {
+                    ...createResult(ResultCode.Warn, 'No mention data found', null),
+                    count: 0
+                };
+            }
+            const data = res.filter(item => match(item, options));
+            const result = createResult(ResultCode.Ok, 'Successfully retrieved mention data', data);
+            return {
+                ...result,
+                count: data.length || 0
+            };
+        },
+        findOne: async (options = {}) => {
+            const results = await mention.find(options);
+            if (results.code !== ResultCode.Ok || !results.data?.length) {
+                const result = createResult(results.code, results.message, null);
+                return {
+                    ...result,
+                    count: 0
+                };
+            }
+            const data = results?.data[0];
+            const result = createResult(ResultCode.Ok, results.message, data);
+            return {
+                ...result,
+                count: results.data?.length || 0
+            };
+        }
+    };
+    return [mention];
+};
+
+export { useMention };

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

@@ -0,0 +1,29 @@
+import { DataEnums, EventKeys, Events } from '../../types';
+import { Result } from '../../core/utils';
+import { Format } from '../message/message-format.js';
+/**
+ * 消息处理
+ * @param event
+ * @returns
+ */
+export declare const useMessage: <T extends EventKeys>(event: Events[T]) => readonly [{
+    send(params?: {
+        format: Format | DataEnums[];
+    } | DataEnums[]): Promise<Result[]>;
+}];
+/**
+ * 废弃，请使用 useMessage
+ * @deprecated
+ * @param event
+ * @returns
+ */
+export declare const useSend: <T extends EventKeys>(event: Events[T]) => (...val: DataEnums[]) => Promise<Result[]>;
+/**
+ * 废弃，请使用 useMessage
+ * @deprecated
+ * @param event
+ * @returns
+ */
+export declare const useSends: <T extends EventKeys>(event: Events[T]) => readonly [(params?: DataEnums[] | {
+    format: Format | DataEnums[];
+}) => Promise<Result[]>];

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

@@ -0,0 +1,88 @@
+import { ResultCode } from '../../core/variable.js';
+import { createResult } from '../../core/utils.js';
+import { sendAction } from '../../cbp/processor/actions.js';
+import { Format } from '../message/message-format.js';
+
+/**
+ * 消息处理
+ * @param event
+ * @returns
+ */
+const useMessage = (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');
+    }
+    /**
+     * 将 format 参数解析为 DataEnums[]
+     */
+    const resolveFormat = (params) => {
+        if (params.format instanceof Format) {
+            return params.format.value;
+        }
+        return params.format;
+    };
+    /**
+     * 发送消息（内部方法，兼容旧API）
+     * @param val
+     * @returns
+     */
+    const sendRaw = async (val) => {
+        if (!val || val.length === 0) {
+            return [createResult(ResultCode.FailParams, 'Invalid val: val must be a non-empty array', null)];
+        }
+        const result = await sendAction({
+            action: 'message.send',
+            payload: {
+                event,
+                params: {
+                    format: val
+                }
+            }
+        });
+        return Array.isArray(result) ? result : [result];
+    };
+    // 新的消息处理接口
+    const lightweight = {
+        send(params) {
+            // send 直接走快速路径，无需创建完整 controller
+            if (!params) {
+                return sendRaw([]);
+            }
+            if (Array.isArray(params)) {
+                return sendRaw(params.length > 0 ? params : []);
+            }
+            return sendRaw(resolveFormat(params));
+        }
+    };
+    return [lightweight];
+};
+/**
+ * 废弃，请使用 useMessage
+ * @deprecated
+ * @param event
+ * @returns
+ */
+const useSend = (event) => {
+    const [message] = useMessage(event);
+    const send = (...val) => {
+        return message.send(val);
+    };
+    return send;
+};
+/**
+ * 废弃，请使用 useMessage
+ * @deprecated
+ * @param event
+ * @returns
+ */
+const useSends = (event) => {
+    const [message] = useMessage(event);
+    return [message.send];
+};
+
+export { useMessage, useSend, useSends };

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

@@ -0,0 +1,30 @@
+/**
+ * 获取指定功能是启动还是关闭
+ * ***
+ * 当有其他地方调用时，
+ * 默认值以第一次调用为准
+ * ***
+ * 功能名相同时，
+ * 将会同时改变，因为状态是全局的
+ * @param name 功能名
+ * @param defaultValue 默认值，默认为 true
+ * @deprecated 废弃。指令管理可直接配置禁用正则
+ * @throws {Error} - 如果 name 不是字符串，或者 defaultValue 不是布尔值，抛出错误。
+ */
+export declare const useState: <T extends string>(name: T, defaultValue?: boolean) => [boolean, (value: boolean) => void];
+/**
+ * 订阅状态变化
+ * @param name 功能名
+ * @param callback 回调函数
+ * @deprecated 废弃。指令管理可直接配置禁用正则
+ * @throws {Error} - 如果 callback 无效，抛出错误。
+ */
+export declare const onState: <T extends string>(name: T, callback: (value: boolean) => void) => void;
+/**
+ * 取消订阅状态变化
+ * @param name 功能名
+ * @param callback 回调函数
+ * @deprecated 废弃。指令管理可直接配置禁用正则
+ * @throws {Error} - 如果 callback 无效，抛出错误。
+ */
+export declare const unState: <T extends string>(name: T, callback: (value: boolean) => void) => void;

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

@@ -0,0 +1,101 @@
+import { getConfig } from '../../core/config.js';
+import { ResultCode } from '../../core/variable.js';
+import { State, StateSubscribe } from '../../store/store.js';
+
+/**
+ * 获取指定功能是启动还是关闭
+ * ***
+ * 当有其他地方调用时，
+ * 默认值以第一次调用为准
+ * ***
+ * 功能名相同时，
+ * 将会同时改变，因为状态是全局的
+ * @param name 功能名
+ * @param defaultValue 默认值，默认为 true
+ * @deprecated 废弃。指令管理可直接配置禁用正则
+ * @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) => {
+        if (state.value === value) {
+            return;
+        }
+        state.value = value;
+        // 更新config
+        const cfg = getConfig();
+        cfg.value.core ??= {};
+        cfg.value.core.state ??= [];
+        const cfgState = cfg.value.core.state;
+        const exists = cfgState.includes(name);
+        if (value && exists) {
+            // 启用：从禁用列表中移除
+            cfg.value.core.state = cfg.value.core.state.filter((i) => i !== name);
+        }
+        else if (!value && !exists) {
+            // 禁用：添加到禁用列表
+            cfg.value.core.state.push(name);
+        }
+        cfg.saveValue(cfg.value);
+    };
+    return [state.value, setValue];
+};
+/**
+ * 订阅状态变化
+ * @param name 功能名
+ * @param callback 回调函数
+ * @deprecated 废弃。指令管理可直接配置禁用正则
+ * @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);
+    sub.on(callback);
+};
+/**
+ * 取消订阅状态变化
+ * @param name 功能名
+ * @param callback 回调函数
+ * @deprecated 废弃。指令管理可直接配置禁用正则
+ * @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);
+};
+
+export { onState, unState, useState };

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

@@ -0,0 +1,46 @@
+import { EventCycleEnum, Current, Events, EventKeys } from '../../types';
+/**
+ * 订阅事件
+ * @param event
+ * @param select
+ * @returns
+ */
+export declare const useSubscribe: <T extends EventKeys>(event: Events[T], selects: T | T[]) => readonly [{
+    create: (callback: Current<T>, keys: (keyof Events[T])[]) => {
+        selects: T[];
+        choose: EventCycleEnum;
+        id: string;
+    };
+    mount: (callback: Current<T>, keys: (keyof Events[T])[]) => {
+        selects: T[];
+        choose: EventCycleEnum;
+        id: string;
+    };
+    unmount: (callback: Current<T>, keys: (keyof Events[T])[]) => {
+        selects: T[];
+        choose: EventCycleEnum;
+        id: string;
+    };
+    cancel: (value: {
+        id: string;
+        selects: T[];
+        choose: EventCycleEnum;
+    }) => void;
+}];
+/**
+ * 使用观察者模式订阅事件
+ * @param event
+ * @param selects
+ * @returns
+ * 废弃，请使用 useSubscribe
+ * @deprecated
+ */
+export declare const useObserver: <T extends EventKeys>(event: Events[T], selects: T | T[]) => readonly [(callback: Current<T>, keys: (keyof Events[T])[]) => {
+    selects: T[];
+    choose: EventCycleEnum;
+    id: string;
+}, (value: {
+    id: string;
+    selects: T[];
+    choose: EventCycleEnum;
+}) => void];