alemonjs 2.1.49 → 2.1.52

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2013-present, Yuxi (Evan) You
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIdED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

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

@@ -20,10 +20,11 @@ const createCallHandler = valueEvent => {
                 return;
             }
             try {
-                const res = await withEventContext(valueEvent, () => currents[index](valueEvent, (...cns) => {
+                const nextFn = (...cns) => {
                     isNext = true;
                     nextEvent(...cns);
-                }));
+                };
+                const res = await withEventContext(valueEvent, nextFn, () => currents[index](valueEvent, nextFn));
                 if (res !== true) {
                     isClose = true;
                 }

package/lib/app/event-utils.js

@@ -1,5 +1,5 @@
 import { getConfig } from '../core/config.js';
-import { ChildrenApp, State, StateSubscribe } from './store.js';
+import { StateSubscribe, ChildrenApp, State } from './store.js';
 import { ResultCode } from '../core/variable.js';
 
 const unChildren = (name = 'main') => {

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

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

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

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

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

@@ -10,6 +10,26 @@ 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') {
@@ -26,23 +46,7 @@ function useClient(eventOrClass, _ApiClass) {
         });
         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
-                    }
-                });
-            };
-        }
-    });
+    const client = createDeepProxy(valueEvent);
     return [client];
 }
 

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

@@ -5,9 +5,9 @@ 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';
+import { getCurrentEvent, getCurrentNext } 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 { ResultCode, ChildrenApp, createResult, sendAction, sendAPI, Format, getCurrentEvent, getCurrentNext };
 export type Options = {
     UserId?: string;
     UserKey?: string;

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

@@ -5,6 +5,7 @@ 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';
+export { getCurrentNext } from '../hook-event-context.js';
 
 const getEventOrThrow = (event) => {
     const currentEvent = event ?? getCurrentEvent();

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

@@ -0,0 +1,33 @@
+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>, (...args: boolean[]) => void];
+export declare function useEvent<T extends EventKeys>(event?: Events[T], options?: UseEventOptions<T>): readonly [UseEventResult<T>, (...args: boolean[]) => void];
+export declare function createEvent<T extends EventKeys>(options: {
+    event: any;
+    selects: T | T[];
+    regular?: RegExp;
+    prefix?: string;
+    exact?: string;
+}): Events[T] & {
+    value: Events[T]["value"];
+    selects: boolean;
+    regular: boolean;
+    prefix: boolean;
+    exact: boolean;
+};
+export {};

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

@@ -0,0 +1,51 @@
+import { getEventOrThrow } from './common.js';
+import { getCurrentNext } from '../hook-event-context.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;
+        }
+    });
+    const next = getCurrentNext() ?? (() => { });
+    return [r, next];
+}
+function createEvent(options) {
+    const { event, selects, regular, prefix, exact } = options;
+    const [eventRef] = useEvent(event, { selects, regular, prefix, exact });
+    const o = eventRef.match;
+    const e = eventRef.current;
+    return {
+        ...e,
+        ...o,
+        value: eventRef.value
+    };
+}
+
+export { createEvent, useEvent };

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

@@ -13,3 +13,5 @@ export * from './reaction';
 export * from './request';
 export * from './role';
 export * from './user';
+export * from './subscribe';
+export * from './event';

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

@@ -13,3 +13,5 @@ export { useReaction } from './reaction.js';
 export { useRequest } from './request.js';
 export { useRole } from './role.js';
 export { useUser } from './user.js';
+export { useObserver, useSubscribe } from './subscribe.js';
+export { createEvent, useEvent } from './event.js';

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

@@ -0,0 +1,73 @@
+import { EventCycleEnum, Current, Events, EventKeys } from '../../types';
+export declare function useSubscribe<T extends EventKeys>(selects: T | T[]): readonly [
+    {
+        create: (callback: Current<T>, keys: (keyof Events[T])[]) => {
+            id: string;
+            selects: T[];
+            choose: EventCycleEnum;
+        };
+        mount: (callback: Current<T>, keys: (keyof Events[T])[]) => {
+            id: string;
+            selects: T[];
+            choose: EventCycleEnum;
+        };
+        unmount: (callback: Current<T>, keys: (keyof Events[T])[]) => {
+            id: string;
+            selects: T[];
+            choose: EventCycleEnum;
+        };
+        cancel: (value: {
+            id: string;
+            selects: T[];
+            choose: EventCycleEnum;
+        }) => void;
+    }
+];
+export declare function useSubscribe<T extends EventKeys>(event: Events[T] | undefined, selects: T | T[]): readonly [
+    {
+        create: (callback: Current<T>, keys: (keyof Events[T])[]) => {
+            id: string;
+            selects: T[];
+            choose: EventCycleEnum;
+        };
+        mount: (callback: Current<T>, keys: (keyof Events[T])[]) => {
+            id: string;
+            selects: T[];
+            choose: EventCycleEnum;
+        };
+        unmount: (callback: Current<T>, keys: (keyof Events[T])[]) => {
+            id: string;
+            selects: T[];
+            choose: EventCycleEnum;
+        };
+        cancel: (value: {
+            id: string;
+            selects: T[];
+            choose: EventCycleEnum;
+        }) => void;
+    }
+];
+export declare function useObserver<T extends EventKeys>(selects: T | T[]): readonly [
+    (callback: Current<T>, keys: (keyof Events[T])[]) => {
+        id: string;
+        selects: T[];
+        choose: EventCycleEnum;
+    },
+    (value: {
+        id: string;
+        selects: T[];
+        choose: EventCycleEnum;
+    }) => void
+];
+export declare function useObserver<T extends EventKeys>(event: Events[T] | undefined, selects: T | T[]): readonly [
+    (callback: Current<T>, keys: (keyof Events[T])[]) => {
+        id: string;
+        selects: T[];
+        choose: EventCycleEnum;
+    },
+    (value: {
+        id: string;
+        selects: T[];
+        choose: EventCycleEnum;
+    }) => void
+];

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

@@ -0,0 +1,112 @@
+import { ResultCode } from '../../core/variable.js';
+import { SubscribeList } from '../store.js';
+import { SubscribeStatus } from '../config.js';
+import { getCurrentEvent } from '../hook-event-context.js';
+
+function useSubscribe(eventOrSelects, maybeSelects) {
+    const selects = (maybeSelects === undefined ? eventOrSelects : maybeSelects);
+    const event = (maybeSelects === undefined ? undefined : eventOrSelects);
+    const valueEvent = event ?? getCurrentEvent();
+    if (typeof valueEvent !== 'object' || valueEvent === null) {
+        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');
+    }
+    const register = (callback, keys, choose) => {
+        const curSelects = Array.isArray(selects) ? selects : [selects];
+        const ID = Date.now().toString(36) + Math.random().toString(36).substring(2, 15);
+        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);
+            const values = {};
+            for (const key of keys) {
+                if (typeof key === 'string' && (typeof valueEvent[key] === 'string' || typeof valueEvent[key] === 'number' || typeof valueEvent[key] === 'boolean')) {
+                    values[key] = valueEvent[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
+        };
+    };
+    const create = (callback, keys) => {
+        return register(callback, keys, 'create');
+    };
+    const mountBefore = (callback, keys) => {
+        return register(callback, keys, 'mount');
+    };
+    const unmount = (callback, keys) => {
+        return register(callback, keys, 'unmount');
+    };
+    const cancel = (value) => {
+        const selects = value.selects;
+        const ID = value.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;
+                }
+            });
+        }
+    };
+    const subscribe = {
+        create,
+        mount: mountBefore,
+        unmount,
+        cancel
+    };
+    return [subscribe];
+}
+function useObserver(eventOrSelects, maybeSelects) {
+    const selects = (maybeSelects === undefined ? eventOrSelects : maybeSelects);
+    const event = (maybeSelects === undefined ? undefined : eventOrSelects);
+    if (selects === undefined) {
+        logger.error({
+            code: ResultCode.FailParams,
+            message: 'select is not string or array',
+            data: null
+        });
+        throw new Error('select is not string or array');
+    }
+    const [subscribe] = useSubscribe(event, selects);
+    return [subscribe.mount, subscribe.cancel];
+}
+
+export { useObserver, useSubscribe };

package/lib/app/index.d.ts

@@ -5,6 +5,7 @@ export * from './define-platform.js';
 export * from './define-response.js';
 export * from './define-middleware.js';
 export * from './define-router.js';
+export * from './event-format.js';
 export * from './event-group.js';
 export * from './event-middleware';
 export * from './event-processor';
@@ -16,6 +17,5 @@ export * from './event-processor-subscribe.js';
 export * from './hook-use/index.js';
 export * from './hook-event-context.js';
 export * from './event-utils.js';
-export * from './hook-use-subscribe.js';
 export * from './message-api.js';
 export * from './message-format.js';

package/lib/app/index.js

@@ -6,6 +6,7 @@ export { definePlatform } from './define-platform.js';
 export { defineResponse } from './define-response.js';
 export { defineMiddleware } from './define-middleware.js';
 export { defineRouter, lazy } from './define-router.js';
+export { FormatEvent, wrapEvent } from './event-format.js';
 export { onGroup } from './event-group.js';
 export { OnMiddleware, onMiddleware } from './event-middleware.js';
 export { OnProcessor, onProcessor } from './event-processor.js';
@@ -29,9 +30,10 @@ export { useReaction } from './hook-use/reaction.js';
 export { useRequest } from './hook-use/request.js';
 export { useRole } from './hook-use/role.js';
 export { useUser } from './hook-use/user.js';
-export { getCurrentEvent, withEventContext } from './hook-event-context.js';
+export { useObserver, useSubscribe } from './hook-use/subscribe.js';
+export { createEvent, useEvent } from './hook-use/event.js';
+export { getCurrentEvent, getCurrentNext, withEventContext } from './hook-event-context.js';
 export { createEventValue, createSelects, onSelects, onState, unChildren, unState, useState } from './event-utils.js';
-export { useObserver, useSubscribe } from './hook-use-subscribe.js';
 export { MessageDirect, createDataFormat, format, getMessageIntent, sendToChannel, sendToUser } from './message-api.js';
-export { Format, FormatButtonGroup, FormatMarkDown, createEvent } from './message-format.js';
+export { Format, FormatButtonGroup, FormatMarkDown } from './message-format.js';
 export { Attachment, Audio, BT, Button, Image, ImageFile, ImageURL, Link, MD, Markdown, MarkdownOriginal, Mention, Text, Video } from './message-format-old.js';

package/lib/app/load_modules/load.js

@@ -8,7 +8,7 @@ const loadApps = () => {
     const cfg = getConfig();
     const apps = Array.isArray(cfg.value?.apps) ? cfg.value.apps : Object.keys(cfg.value?.apps ?? {}).filter(Boolean);
     const uniqueApps = Array.from(new Set(apps));
-    void Promise.all(uniqueApps.map(app => loadChildrenFile(app)));
+    uniqueApps.forEach(app => void loadChildrenFile(app));
 };
 const run = (input) => {
     if (!input) {

package/lib/app/load_modules/loadChild.js

@@ -3,11 +3,11 @@ import { existsSync } from 'fs';
 import { showErrorModule, getRecursiveDirFiles, createEventName } from '../../core/utils.js';
 import { ChildrenApp } from '../store.js';
 import { ResultCode, fileSuffixMiddleware } from '../../core/variable.js';
-import module from 'module';
+import module$1 from 'module';
 
 const initRequire = () => { };
 initRequire.resolve = () => '';
-const require = module?.createRequire?.(import.meta.url) ?? initRequire;
+const require$1 = module$1?.createRequire?.(import.meta.url) ?? initRequire;
 const loadChildren = async (mainPath, appName) => {
     if (!mainPath || typeof mainPath !== 'string') {
         logger.error({
@@ -168,7 +168,7 @@ const loadChildrenFile = (appName) => {
         return;
     }
     try {
-        const mainPath = require.resolve(appName);
+        const mainPath = require$1.resolve(appName);
         if (!existsSync(mainPath)) {
             logger.error({
                 code: ResultCode.FailParams,

package/lib/app/message-api.d.ts

@@ -7,12 +7,12 @@ export declare class MessageDirect {
     static create(): MessageDirect;
     sendToChannel(params: {
         SpaceId: string;
-        format: Format;
+        format: Format | DataEnums[];
         replyId?: string;
     }): Promise<Result[]>;
     sendToUser(params: {
         OpenID: string;
-        format: Format;
+        format: Format | DataEnums[];
     }): Promise<Result[]>;
 }
 export declare const sendToChannel: (SpaceId: string, data: DataEnums[]) => Promise<Result[]>;