alemonjs 2.1.47 → 2.1.49

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

@@ -2,6 +2,7 @@ import 'fs';
 import 'path';
 import 'yaml';
 import { showErrorModule } from '../core/utils.js';
+import { withEventContext } from './hook-event-context.js';
 
 const createCallHandler = valueEvent => {
     const callHandler = (currents, nextEvent) => {
@@ -19,10 +20,10 @@ const createCallHandler = valueEvent => {
                 return;
             }
             try {
-                const res = await currents[index](valueEvent, (...cns) => {
+                const res = await withEventContext(valueEvent, () => currents[index](valueEvent, (...cns) => {
                     isNext = true;
                     nextEvent(...cns);
-                });
+                }));
                 if (res !== true) {
                     isClose = true;
                 }

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

@@ -1,4 +1,4 @@
-import { useState } from './hook-use-state.js';
+import { useState } from './event-utils.js';
 import { getCachedRegExp, showErrorModule } from '../core/utils.js';
 import { EventMessageText } from '../core/variable.js';
 import { ResponseMiddleware } from './store.js';

package/lib/app/event-processor.js

@@ -2,7 +2,7 @@ import { getConfigValue } from '../core/config.js';
 import { processorRepeatedClearTimeMin, processorRepeatedClearTimeMax, processorRepeatedEventTime, processorRepeatedUserTime, processorRepeatedClearSize, processorMaxMapSize } from '../core/variable.js';
 import { expendCycle } from './event-processor-cycle.js';
 import { ProcessorEventAutoClearMap, ProcessorEventUserAutoClearMap } from './store.js';
-import { getCachedRegExp, fastHash } from '../core/utils.js';
+import { getCachedRegExp, matchIn, fastHash } from '../core/utils.js';
 
 const filter = ({ Now, store, INTERVAL }, MessageId) => {
     if (store.has(MessageId)) {
@@ -69,12 +69,12 @@ const onProcessor = (name, event, data) => {
     if (disabledSelects[name]) {
         return;
     }
-    const disabledUserId = value?.disabled_user_id ?? {};
-    if (event['UserId'] && disabledUserId[event['UserId']]) {
+    const disabledUserId = value?.disabled_user_id;
+    if (event['UserId'] && matchIn(disabledUserId, event['UserId'])) {
         return;
     }
-    const disabledUserKey = value?.disabled_user_key ?? {};
-    if (event['UserKey'] && disabledUserKey[event['UserKey']]) {
+    const disabledUserKey = value?.disabled_user_key;
+    if (event['UserKey'] && matchIn(disabledUserKey, event['UserKey'])) {
         return;
     }
     const redirectRegular = value?.redirect_regular ?? value?.redirect_text_regular;
@@ -98,20 +98,20 @@ const onProcessor = (name, event, data) => {
             }
         }
     }
-    const masterId = value?.master_id ?? {};
-    const masterKey = value?.master_key ?? {};
-    if (event['UserId'] && masterId[event['UserId']]) {
+    const masterId = value?.master_id;
+    const masterKey = value?.master_key;
+    if (event['UserId'] && matchIn(masterId, event['UserId'])) {
         event['isMaster'] = true;
     }
-    else if (event['UserKey'] && masterKey[event['UserKey']]) {
+    else if (event['UserKey'] && matchIn(masterKey, event['UserKey'])) {
         event['isMaster'] = true;
     }
-    const botId = value?.bot_id ?? {};
-    const botKey = value?.bot_key ?? {};
-    if (event['UserId'] && botId[event['UserId']]) {
+    const botId = value?.bot_id;
+    const botKey = value?.bot_key;
+    if (event['UserId'] && matchIn(botId, event['UserId'])) {
         event['isBot'] = true;
     }
-    else if (event['UserKey'] && botKey[event['UserKey']]) {
+    else if (event['UserKey'] && matchIn(botKey, event['UserKey'])) {
         event['isBot'] = true;
     }
     const Now = Date.now();

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

@@ -0,0 +1,14 @@
+import { EventKeys } from '../types';
+type BaseMap = {
+    [key: string]: unknown;
+};
+export declare const unChildren: (name?: string) => void;
+export declare const onSelects: <T extends EventKeys[] | EventKeys>(values: T) => T;
+export declare const createSelects: <T extends EventKeys[] | EventKeys>(values: T) => T;
+export declare const createEventValue: <T extends keyof R, R extends BaseMap>(event: {
+    value: R[T];
+}) => R[T];
+export declare const useState: <T extends string>(name: T, defaultValue?: boolean) => [boolean, (value: boolean) => void];
+export declare const onState: <T extends string>(name: T, callback: (value: boolean) => void) => void;
+export declare const unState: <T extends string>(name: T, callback: (value: boolean) => void) => void;
+export {};

package/lib/app/event-utils.js

@@ -0,0 +1,86 @@
+import { getConfig } from '../core/config.js';
+import { ChildrenApp, State, StateSubscribe } from './store.js';
+import { ResultCode } from '../core/variable.js';
+
+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();
+};
+const onSelects = (values) => values;
+global.onSelects = onSelects;
+const createSelects = onSelects;
+const createEventValue = (event) => {
+    return event.value;
+};
+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;
+        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];
+};
+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);
+};
+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 { createEventValue, createSelects, onSelects, onState, unChildren, unState, useState };

package/lib/app/hook-event-context.d.ts

@@ -0,0 +1,3 @@
+import { EventKeys, Events } from '../types';
+export declare const withEventContext: <T extends EventKeys, R>(event: Events[T], runner: () => R) => R;
+export declare const getCurrentEvent: <T extends EventKeys>() => Events[T] | undefined;

package/lib/app/hook-event-context.js

@@ -0,0 +1,11 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+
+const eventStore = new AsyncLocalStorage();
+const withEventContext = (event, runner) => {
+    return eventStore.run(event, runner);
+};
+const getCurrentEvent = () => {
+    return eventStore.getStore();
+};
+
+export { getCurrentEvent, withEventContext };

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

@@ -0,0 +1,12 @@
+import { EventKeys, Events, Result } from './common';
+export declare const useAnnounce: <T extends EventKeys>(event?: Events[T]) => readonly [{
+    set: (params: {
+        messageId: string;
+        channelId?: string;
+        guildId?: string;
+    }) => Promise<Result>;
+    remove: (params?: {
+        messageId?: string;
+        guildId?: string;
+    }) => Promise<Result>;
+}];

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

@@ -0,0 +1,49 @@
+import { getEventOrThrow } from './common.js';
+import { createResult } from '../../core/utils.js';
+import { ResultCode } from '../../core/variable.js';
+import { sendAction } from '../../cbp/processor/actions.js';
+
+const useAnnounce = (event) => {
+    const valueEvent = getEventOrThrow(event);
+    const set = async (params) => {
+        const gid = params.guildId || valueEvent.GuildId;
+        if (!gid || !params.messageId) {
+            return createResult(ResultCode.FailParams, 'Missing GuildId or MessageId', null);
+        }
+        try {
+            const results = await sendAction({
+                action: 'channel.announce',
+                payload: { GuildId: gid, params: { messageId: params.messageId, channelId: params.channelId } }
+            });
+            const result = results.find(item => item.code === ResultCode.Ok);
+            return result || createResult(ResultCode.Warn, 'Announce set not supported or failed', null);
+        }
+        catch {
+            return createResult(ResultCode.Fail, 'Failed to set announcement', null);
+        }
+    };
+    const remove = async (params) => {
+        const gid = params?.guildId || valueEvent.GuildId;
+        if (!gid) {
+            return createResult(ResultCode.FailParams, 'Missing GuildId', null);
+        }
+        try {
+            const results = await sendAction({
+                action: 'channel.announce',
+                payload: { GuildId: gid, params: { messageId: params?.messageId || 'all', remove: true } }
+            });
+            const result = results.find(item => item.code === ResultCode.Ok);
+            return result || createResult(ResultCode.Warn, 'Announce remove not supported or failed', null);
+        }
+        catch {
+            return createResult(ResultCode.Fail, 'Failed to remove announcement', null);
+        }
+    };
+    const announce = {
+        set,
+        remove
+    };
+    return [announce];
+};
+
+export { useAnnounce };

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

@@ -0,0 +1,24 @@
+import { ChannelInfo, EventKeys, Events, Result } from './common';
+export declare const useChannel: <T extends EventKeys>(event?: Events[T]) => readonly [{
+    info: (params?: {
+        channelId?: string;
+    }) => Promise<Result<ChannelInfo | null>>;
+    list: (params?: {
+        guildId?: string;
+    }) => Promise<Result<ChannelInfo[]>>;
+    create: (params: {
+        name: string;
+        type?: string;
+        parentId?: string;
+        guildId?: string;
+    }) => Promise<Result<ChannelInfo | null>>;
+    update: (params: {
+        channelId: string;
+        name?: string;
+        topic?: string;
+        position?: number;
+    }) => Promise<Result>;
+    delete: (params: {
+        channelId: string;
+    }) => Promise<Result>;
+}];

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

@@ -0,0 +1,109 @@
+import { getEventOrThrow } from './common.js';
+import { createResult } from '../../core/utils.js';
+import { ResultCode } from '../../core/variable.js';
+import { sendAction } from '../../cbp/processor/actions.js';
+
+const useChannel = (event) => {
+    const valueEvent = getEventOrThrow(event);
+    const info = async (params) => {
+        const cid = params?.channelId || valueEvent.ChannelId;
+        if (!cid) {
+            return createResult(ResultCode.FailParams, 'Missing ChannelId', null);
+        }
+        try {
+            const results = await sendAction({
+                action: 'channel.info',
+                payload: { ChannelId: cid }
+            });
+            const result = results.find(item => item.code === ResultCode.Ok);
+            if (result) {
+                return createResult(ResultCode.Ok, 'Successfully retrieved channel info', result.data ?? null);
+            }
+            return createResult(ResultCode.Warn, 'No channel info found', null);
+        }
+        catch {
+            return createResult(ResultCode.Fail, 'Failed to get channel info', null);
+        }
+    };
+    const list = async (params) => {
+        const gid = params?.guildId || valueEvent.GuildId;
+        if (!gid) {
+            return createResult(ResultCode.FailParams, 'Missing GuildId', []);
+        }
+        try {
+            const results = await sendAction({
+                action: 'channel.list',
+                payload: { GuildId: gid }
+            });
+            const result = results.find(item => item.code === ResultCode.Ok);
+            if (result) {
+                return createResult(ResultCode.Ok, 'Successfully retrieved channel list', result.data ?? []);
+            }
+            return createResult(ResultCode.Warn, 'No channel list found', []);
+        }
+        catch {
+            return createResult(ResultCode.Fail, 'Failed to get channel list', []);
+        }
+    };
+    const create = async (params) => {
+        const gid = params.guildId || valueEvent.GuildId;
+        if (!gid) {
+            return createResult(ResultCode.FailParams, 'Missing GuildId', null);
+        }
+        try {
+            const results = await sendAction({
+                action: 'channel.create',
+                payload: { GuildId: gid, params: { name: params.name, type: params.type, parentId: params.parentId } }
+            });
+            const result = results.find(item => item.code === ResultCode.Ok);
+            return result
+                ? createResult(ResultCode.Ok, 'Channel created', result.data ?? null)
+                : createResult(ResultCode.Warn, 'Create not supported or failed', null);
+        }
+        catch {
+            return createResult(ResultCode.Fail, 'Failed to create channel', null);
+        }
+    };
+    const update = async (params) => {
+        if (!params.channelId) {
+            return createResult(ResultCode.FailParams, 'Missing ChannelId', null);
+        }
+        try {
+            const results = await sendAction({
+                action: 'channel.update',
+                payload: { ChannelId: params.channelId, params: { name: params.name, topic: params.topic, position: params.position } }
+            });
+            const result = results.find(item => item.code === ResultCode.Ok);
+            return result || createResult(ResultCode.Warn, 'Update not supported or failed', null);
+        }
+        catch {
+            return createResult(ResultCode.Fail, 'Failed to update channel', null);
+        }
+    };
+    const remove = async (params) => {
+        if (!params.channelId) {
+            return createResult(ResultCode.FailParams, 'Missing ChannelId', null);
+        }
+        try {
+            const results = await sendAction({
+                action: 'channel.delete',
+                payload: { ChannelId: params.channelId }
+            });
+            const result = results.find(item => item.code === ResultCode.Ok);
+            return result || createResult(ResultCode.Warn, 'Delete not supported or failed', null);
+        }
+        catch {
+            return createResult(ResultCode.Fail, 'Failed to delete channel', null);
+        }
+    };
+    const channel = {
+        info,
+        list,
+        create,
+        update,
+        delete: remove
+    };
+    return [channel];
+};
+
+export { useChannel };

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

@@ -0,0 +1,2 @@
+import { EventKeys, Events } from './common';
+export declare function useClient<T extends object, K extends EventKeys = EventKeys>(eventOrClass?: Events[K] | (new (...args: any[]) => T), _ApiClass?: new (...args: any[]) => T): readonly [T];

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

@@ -0,0 +1,49 @@
+import { ResultCode } from '../../core/variable.js';
+import '../store.js';
+import '../../core/utils.js';
+import 'flatted';
+import 'fs';
+import 'path';
+import 'yaml';
+import '../../cbp/processor/config.js';
+import { sendAPI } from '../../cbp/processor/api.js';
+import '../message-format-old.js';
+import { getCurrentEvent } from '../hook-event-context.js';
+
+function useClient(eventOrClass, _ApiClass) {
+    let valueEvent;
+    if (eventOrClass !== undefined && typeof eventOrClass === 'function') {
+        valueEvent = getCurrentEvent();
+    }
+    else {
+        valueEvent = eventOrClass ?? getCurrentEvent();
+    }
+    if (!valueEvent || typeof valueEvent !== '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 client = new Proxy({}, {
+        get(_target, prop) {
+            if (typeof prop === 'symbol') {
+                return undefined;
+            }
+            return (...args) => {
+                return sendAPI({
+                    action: 'client.api',
+                    payload: {
+                        event: valueEvent,
+                        key: String(prop),
+                        params: args
+                    }
+                });
+            };
+        }
+    });
+    return [client];
+}
+
+export { useClient };

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

@@ -0,0 +1,18 @@
+import { DataEnums, EventKeys, Events, User, GuildInfo, ChannelInfo, MemberInfo, RoleInfo, PaginationParams, PaginatedResult } from '../../types';
+import { ResultCode } from '../../core/variable';
+import { ChildrenApp } from '../store';
+import { createResult, Result } from '../../core/utils';
+import { sendAction } from '../../cbp/processor/actions';
+import { sendAPI } from '../../cbp/processor/api';
+import { Format } from '../message-format';
+import { getCurrentEvent } from '../hook-event-context';
+export type { DataEnums, EventKeys, Events, User, GuildInfo, ChannelInfo, MemberInfo, RoleInfo, PaginationParams, PaginatedResult, Result };
+export { ResultCode, ChildrenApp, createResult, sendAction, sendAPI, Format, getCurrentEvent };
+export type Options = {
+    UserId?: string;
+    UserKey?: string;
+    UserName?: string;
+    IsMaster?: boolean;
+    IsBot?: boolean;
+};
+export declare const getEventOrThrow: <T extends EventKeys>(event?: Events[T]) => Events[T];

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

@@ -0,0 +1,22 @@
+import { ResultCode } from '../../core/variable.js';
+export { ChildrenApp } from '../store.js';
+export { createResult } from '../../core/utils.js';
+export { sendAction } from '../../cbp/processor/actions.js';
+export { sendAPI } from '../../cbp/processor/api.js';
+export { Format } from '../message-format.js';
+import { getCurrentEvent } from '../hook-event-context.js';
+
+const getEventOrThrow = (event) => {
+    const currentEvent = event ?? getCurrentEvent();
+    if (!currentEvent || typeof currentEvent !== '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 currentEvent;
+};
+
+export { ResultCode, getCurrentEvent, getEventOrThrow };

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

@@ -0,0 +1,19 @@
+import { EventKeys, Events, GuildInfo, Result } from './common';
+export declare const useGuild: <T extends EventKeys>(event?: Events[T]) => readonly [{
+    info: (params?: {
+        guildId?: string;
+    }) => Promise<Result<GuildInfo | null>>;
+    list: () => Promise<Result<GuildInfo[]>>;
+    update(params: {
+        name?: string;
+        guildId?: string;
+    }): Promise<Result>;
+    leave(params?: {
+        guildId?: string;
+        isDismiss?: boolean;
+    }): Promise<Result>;
+    mute(params: {
+        enable: boolean;
+        guildId?: string;
+    }): Promise<Result>;
+}];

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

@@ -0,0 +1,102 @@
+import { getEventOrThrow } from './common.js';
+import { createResult } from '../../core/utils.js';
+import { ResultCode } from '../../core/variable.js';
+import { sendAction } from '../../cbp/processor/actions.js';
+
+const useGuild = (event) => {
+    const valueEvent = getEventOrThrow(event);
+    const info = async (params) => {
+        const gid = params?.guildId || valueEvent.GuildId;
+        if (!gid) {
+            return createResult(ResultCode.FailParams, 'Missing GuildId', null);
+        }
+        try {
+            const results = await sendAction({
+                action: 'guild.info',
+                payload: { GuildId: gid }
+            });
+            const result = results.find(item => item.code === ResultCode.Ok);
+            if (result) {
+                return createResult(ResultCode.Ok, 'Successfully retrieved guild info', result.data ?? null);
+            }
+            return createResult(ResultCode.Warn, 'No guild info found', null);
+        }
+        catch {
+            return createResult(ResultCode.Fail, 'Failed to get guild info', null);
+        }
+    };
+    const list = async () => {
+        try {
+            const results = await sendAction({
+                action: 'guild.list',
+                payload: {}
+            });
+            const result = results.find(item => item.code === ResultCode.Ok);
+            if (result) {
+                return createResult(ResultCode.Ok, 'Successfully retrieved guild list', result.data ?? []);
+            }
+            return createResult(ResultCode.Warn, 'No guild list found', []);
+        }
+        catch {
+            return createResult(ResultCode.Fail, 'Failed to get guild list', []);
+        }
+    };
+    const guild = {
+        info,
+        list,
+        async update(params) {
+            const gid = params.guildId || valueEvent.GuildId;
+            if (!gid) {
+                return createResult(ResultCode.FailParams, 'Missing GuildId', null);
+            }
+            try {
+                const results = await sendAction({
+                    action: 'guild.update',
+                    payload: { GuildId: gid, params: { name: params.name } }
+                });
+                const result = results.find(item => item.code === ResultCode.Ok);
+                return result || createResult(ResultCode.Warn, 'Update not supported or failed', null);
+            }
+            catch {
+                return createResult(ResultCode.Fail, 'Failed to update guild', null);
+            }
+        },
+        async leave(params) {
+            const gid = params?.guildId || valueEvent.GuildId;
+            if (!gid) {
+                return createResult(ResultCode.FailParams, 'Missing GuildId', null);
+            }
+            try {
+                const results = await sendAction({
+                    action: 'guild.leave',
+                    payload: { GuildId: gid, params: { isDismiss: params?.isDismiss } }
+                });
+                const result = results.find(item => item.code === ResultCode.Ok);
+                return result || createResult(ResultCode.Warn, 'Leave not supported or failed', null);
+            }
+            catch {
+                return createResult(ResultCode.Fail, 'Failed to leave guild', null);
+            }
+        },
+        async mute(params) {
+            const gid = params.guildId || valueEvent.GuildId;
+            if (!gid) {
+                return createResult(ResultCode.FailParams, 'Missing GuildId', null);
+            }
+            try {
+                const results = await sendAction({
+                    action: 'guild.mute',
+                    payload: { GuildId: gid, params: { enable: params.enable } }
+                });
+                const result = results.find(item => item.code === ResultCode.Ok);
+                return result || createResult(ResultCode.Warn, 'Mute not supported or failed', null);
+            }
+            catch {
+                return createResult(ResultCode.Fail, 'Failed to mute guild', null);
+            }
+        }
+    };
+    return [guild];
+};
+
+export { useGuild };

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

@@ -0,0 +1,9 @@
+import { EventKeys, Events, Result } from './common';
+export declare const useHistory: <T extends EventKeys>(event?: Events[T]) => readonly [{
+    list: (params?: {
+        channelId?: string;
+        limit?: number;
+        before?: string;
+        after?: string;
+    }) => Promise<Result>;
+}];

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

@@ -0,0 +1,31 @@
+import { getEventOrThrow } from './common.js';
+import { createResult } from '../../core/utils.js';
+import { ResultCode } from '../../core/variable.js';
+import { sendAction } from '../../cbp/processor/actions.js';
+
+const useHistory = (event) => {
+    const valueEvent = getEventOrThrow(event);
+    const list = async (params) => {
+        const cid = params?.channelId || valueEvent.ChannelId;
+        if (!cid) {
+            return createResult(ResultCode.FailParams, 'Missing ChannelId', null);
+        }
+        try {
+            const results = await sendAction({
+                action: 'history.list',
+                payload: { ChannelId: cid, params: { limit: params?.limit, before: params?.before, after: params?.after } }
+            });
+            const result = results.find(item => item.code === ResultCode.Ok);
+            return result || createResult(ResultCode.Warn, 'History list not supported or failed', null);
+        }
+        catch {
+            return createResult(ResultCode.Fail, 'Failed to get message history', null);
+        }
+    };
+    const history = {
+        list
+    };
+    return [history];
+};
+
+export { useHistory };