alemonjs 2.1.53 → 2.1.55

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

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

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

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

@@ -1,30 +0,0 @@
-/**
- * 获取指定功能是启动还是关闭
- * ***
- * 当有其他地方调用时，
- * 默认值以第一次调用为准
- * ***
- * 功能名相同时，
- * 将会同时改变，因为状态是全局的
- * @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

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

@@ -1,46 +0,0 @@
-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];

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

@@ -1,143 +0,0 @@
-import { ResultCode } from '../../core/variable.js';
-import { SubscribeList } from '../../store/store.js';
-import { SubscribeStatus } from '../config.js';
-
-/**
- * 订阅事件
- * @param event
- * @param select
- * @returns
- */
-const useSubscribe = (event, selects) => {
-    // 检查参数
-    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 selects !== 'string' && !Array.isArray(selects)) {
-        logger.error({
-            code: ResultCode.FailParams,
-            message: 'select is not string or array',
-            data: null
-        });
-        throw new Error('select is not string or array');
-    }
-    /**
-     * 运行订阅
-     * @param callback
-     * @param keys
-     * @param choose
-     * @returns
-     */
-    const register = (callback, keys, choose) => {
-        const curSelects = Array.isArray(selects) ? selects : [selects];
-        // 分配id
-        const ID = Date.now().toString(36) + Math.random().toString(36).substring(2, 15);
-        // 没有选择任何 key，无法绑定订阅
-        if (keys.length === 0) {
-            logger.warn({
-                code: ResultCode.FailParams,
-                message: 'subscribe keys is empty',
-                data: null
-            });
-            return { selects: curSelects, choose, id: ID };
-        }
-        // 创建 订阅 列表
-        for (const select of curSelects) {
-            const subList = new SubscribeList(choose, select);
-            // 只能选择基础数据类型的key
-            const values = {};
-            for (const key of keys) {
-                if (typeof key === 'string' && (typeof event[key] === 'string' || typeof event[key] === 'number' || typeof event[key] === 'boolean')) {
-                    values[key] = event[key];
-                }
-                else {
-                    logger.warn({
-                        code: ResultCode.FailParams,
-                        message: `Invalid key: ${key?.toString()} must be a string, number or boolean`,
-                        data: null
-                    });
-                }
-            }
-            subList.value.append({
-                choose,
-                selects: curSelects,
-                keys: values,
-                current: callback,
-                status: SubscribeStatus.active,
-                id: ID
-            });
-        }
-        return {
-            selects: curSelects,
-            choose,
-            id: ID
-        };
-    };
-    /**
-     * res 创建时 运行订阅
-     * @param callback
-     * @param keys
-     */
-    const create = (callback, keys) => {
-        return register(callback, keys, 'create');
-    };
-    /**
-     * res 挂载时 运行订阅
-     * @param callback
-     * @param keys
-     */
-    const mountBefore = (callback, keys) => {
-        return register(callback, keys, 'mount');
-    };
-    /**
-     * res 卸载时 运行订阅
-     * @param callback
-     * @param keys
-     */
-    const unmount = (callback, keys) => {
-        return register(callback, keys, 'unmount');
-    };
-    /**
-     * 清除订阅
-     * @param id
-     */
-    const cancel = (value) => {
-        const selects = value.selects;
-        const ID = value.id; // 订阅的 ID
-        for (const select of selects) {
-            const subList = new SubscribeList(value.choose, select);
-            subList.value.forEach(node => {
-                if (node.data.id === ID) {
-                    node.data.status = SubscribeStatus.paused; // 标记为已暂停
-                    return true; // break
-                }
-            });
-        }
-    };
-    const subscribe = {
-        create,
-        mount: mountBefore,
-        unmount,
-        cancel
-    };
-    return [subscribe];
-};
-/**
- * 使用观察者模式订阅事件
- * @param event
- * @param selects
- * @returns
- * 废弃，请使用 useSubscribe
- * @deprecated
- */
-const useObserver = (event, selects) => {
-    const [subscribe] = useSubscribe(event, selects);
-    return [subscribe.mount, subscribe.cancel];
-};
-
-export { useObserver, useSubscribe };