alemonjs 2.1.48 → 2.1.50

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

@@ -0,0 +1,19 @@
+import { Events, EventKeys, EventBuilder, ReservedEventKeys, User, Guild, Channel, Message, MessageText, MessageMedia, MessageOpen, Platform } from '../types';
+export declare class FormatEvent<T extends EventKeys = EventKeys> {
+    #private;
+    private constructor();
+    static create<T extends EventKeys>(name: T): EventBuilder<T>;
+    addPlatform(params: Platform): this;
+    addGuild(params: Guild): this;
+    addChannel(params: Channel): this;
+    addUser(params: User): this;
+    addMessage(params: Message): this;
+    addText(params: MessageText): this;
+    addMedia(params: MessageMedia): this;
+    addOpen(params: MessageOpen): this;
+    add<E extends Record<string, unknown>>(fields: {
+        [K in keyof E]: K extends ReservedEventKeys ? never : E[K];
+    }): this;
+    get value(): Events[T];
+}
+export declare function wrapEvent<E extends Record<string, unknown>>(event: object): Readonly<E>;

package/lib/app/event-format.js

@@ -0,0 +1,128 @@
+class FormatEvent {
+    #data;
+    constructor(name) {
+        this.#data = { name, Timestamp: Date.now() };
+    }
+    static create(name) {
+        return new FormatEvent(name);
+    }
+    addPlatform(params) {
+        const { value, ...otherParams } = params;
+        Object.assign(this.#data, otherParams);
+        Object.defineProperty(this.#data, 'value', {
+            value,
+            enumerable: false
+        });
+        return this;
+    }
+    addGuild(params) {
+        Object.assign(this.#data, {
+            GuildId: params.GuildId,
+            SpaceId: params.SpaceId
+        });
+        return this;
+    }
+    addChannel(params) {
+        Object.assign(this.#data, {
+            ChannelId: params.ChannelId
+        });
+        return this;
+    }
+    addUser(params) {
+        Object.assign(this.#data, {
+            UserId: params.UserId,
+            UserKey: params.UserKey,
+            IsMaster: params.IsMaster,
+            IsBot: params.IsBot,
+            ...(params.UserName !== undefined && { UserName: params.UserName }),
+            ...(params.UserAvatar !== undefined && { UserAvatar: params.UserAvatar })
+        });
+        return this;
+    }
+    addMessage(params) {
+        const assign = { MessageId: params.MessageId };
+        if (params.ReplyId !== undefined) {
+            assign.ReplyId = params.ReplyId;
+        }
+        Object.assign(this.#data, assign);
+        return this;
+    }
+    addText(params) {
+        Object.assign(this.#data, {
+            MessageText: params.MessageText
+        });
+        return this;
+    }
+    addMedia(params) {
+        Object.assign(this.#data, {
+            MessageMedia: params.MessageMedia
+        });
+        return this;
+    }
+    addOpen(params) {
+        Object.assign(this.#data, {
+            OpenId: params.OpenId
+        });
+        return this;
+    }
+    add(fields) {
+        for (const key of Object.keys(fields)) {
+            this.#data[`_${key}`] = fields[key];
+        }
+        return this;
+    }
+    get value() {
+        return this.#data;
+    }
+}
+function wrapEvent(event) {
+    return new Proxy(event, {
+        get(target, prop, receiver) {
+            if (typeof prop === 'string' && !prop.startsWith('_')) {
+                const privateKey = `_${prop}`;
+                if (privateKey in target) {
+                    return Reflect.get(target, privateKey, receiver);
+                }
+            }
+            return Reflect.get(target, prop, receiver);
+        },
+        has(target, prop) {
+            if (typeof prop === 'string' && !prop.startsWith('_')) {
+                if (`_${prop}` in target) {
+                    return true;
+                }
+            }
+            return Reflect.has(target, prop);
+        },
+        set() {
+            return false;
+        },
+        deleteProperty() {
+            return false;
+        },
+        ownKeys(target) {
+            return Reflect.ownKeys(target).map(key => {
+                if (typeof key === 'string' && key.startsWith('_')) {
+                    return key.slice(1);
+                }
+                return key;
+            });
+        },
+        getOwnPropertyDescriptor(target, prop) {
+            if (typeof prop === 'string' && !prop.startsWith('_')) {
+                const privateKey = `_${prop}`;
+                const desc = Reflect.getOwnPropertyDescriptor(target, privateKey);
+                if (desc) {
+                    return { ...desc, configurable: true, writable: false };
+                }
+            }
+            const desc = Reflect.getOwnPropertyDescriptor(target, prop);
+            if (desc) {
+                return { ...desc, writable: false };
+            }
+            return desc;
+        }
+    });
+}
+
+export { FormatEvent, wrapEvent };

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-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 { StateSubscribe, ChildrenApp, State } 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,53 @@
+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';
+
+const createDeepProxy = (event, path = []) => {
+    return new Proxy((() => { }), {
+        get(_target, prop) {
+            if (typeof prop === 'symbol') {
+                return undefined;
+            }
+            return createDeepProxy(event, [...path, String(prop)]);
+        },
+        apply(_target, _thisArg, args) {
+            return sendAPI({
+                action: 'client.api',
+                payload: {
+                    event,
+                    key: path.join('.'),
+                    params: args
+                }
+            });
+        }
+    });
+};
+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 = createDeepProxy(valueEvent);
+    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/event.d.ts

@@ -0,0 +1,20 @@
+import { EventKeys, Events } from 'types';
+type UseEventOptions<T extends EventKeys> = {
+    selects: T | T[];
+    regular?: RegExp;
+    prefix?: string;
+    exact?: string;
+};
+type UseEventResult<T extends EventKeys> = {
+    current: Events[T];
+    value: Events[T]['value'];
+    match: {
+        selects: boolean;
+        regular: boolean;
+        prefix: boolean;
+        exact: boolean;
+    };
+};
+export declare function useEvent<T extends EventKeys>(options?: UseEventOptions<T>): readonly [UseEventResult<T>];
+export declare function useEvent<T extends EventKeys>(event?: Events[T], options?: UseEventOptions<T>): readonly [UseEventResult<T>];
+export {};

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

@@ -0,0 +1,38 @@
+import { getEventOrThrow } from './common.js';
+
+const isOptions = (v) => {
+    return typeof v === 'object' && 'selects' in v;
+};
+function useEvent(eventOrOptions, options) {
+    let eventArg;
+    let opts;
+    if (eventOrOptions && isOptions(eventOrOptions)) {
+        opts = eventOrOptions;
+    }
+    else {
+        eventArg = eventOrOptions;
+        opts = options;
+    }
+    const { selects, regular, prefix, exact } = opts ?? {};
+    const eventValue = getEventOrThrow(eventArg);
+    const { name, MessageText } = eventValue;
+    const selectsArr = Array.isArray(selects) ? selects : [selects];
+    const match = {
+        selects: selectsArr.includes(name),
+        exact: !!(exact && MessageText === exact),
+        prefix: !!(prefix && MessageText?.startsWith(prefix)),
+        regular: !!(regular && MessageText && regular.test(MessageText))
+    };
+    const r = {
+        current: { ...eventValue },
+        match
+    };
+    Object.defineProperty(r, 'value', {
+        get() {
+            return eventValue.value;
+        }
+    });
+    return [r];
+}
+
+export { useEvent };

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>;
+}];