alemonjs 2.1.53 → 2.1.55

package/lib/process/client.js

@@ -1,109 +0,0 @@
-import '../types/event/actions.js';
-import { getConfigValue } from '../core/config.js';
-import { defaultPort } from '../core/variable.js';
-import { cbpClient } from '../cbp/connects/client.js';
-import 'flatted';
-import 'ws';
-import '../cbp/processor/config.js';
-import 'net';
-import 'v8';
-import 'os';
-import 'path';
-import 'fs';
-import 'koa';
-import '@koa/cors';
-import '../cbp/routers/router.js';
-import { logger } from '../store/store.js';
-import { loadModels } from '../app/load_modules/load.js';
-import '../app/load_modules/loadChild.js';
-import '../app/define/define-children.js';
-import '../app/define/define-response.js';
-import '../app/define/define-middleware.js';
-import '../app/event-processor/event-processor.js';
-import '../core/utils.js';
-import '../app/message/message-format-old.js';
-import '../app/event/event-group.js';
-import '../app/event/event-middleware.js';
-import '../app/event/event-response.js';
-import '../app/event/event-selects.js';
-import '../app/message/message-api.js';
-import './platform.js';
-import './module.js';
-
-// 标记当前为客户端进程，防止 definePlatform 被 import 时的副作用
-global.__client_loaded = true;
-// 连接 CBP 服务器
-const main = () => {
-    const login = process.env.login ?? '';
-    const platform = process.env.platform ?? '';
-    const url = process.env.url ?? '';
-    const port = process.env.port ?? defaultPort;
-    const isFullReceive = process.env.is_full_receive === 'true' || process.env.is_full_receive === '1';
-    // 当 login 和 platform 都没有指定时，且指定了 url，则连接到指定的 url
-    if (!login && !platform && url) {
-        logger.info(`[Connecting to CBP server at ${url}]`);
-        cbpClient(url);
-    }
-    else {
-        const httpURL = `http://127.0.0.1:${port}`;
-        cbpClient(httpURL, { isFullReceive });
-    }
-    loadModels();
-};
-const mainProcess = () => {
-    // unhandledRejection 捕获未处理的 Promise 拒绝，记录后继续运行，不退出进程
-    process.on('unhandledRejection', (reason) => {
-        logger.error('[unhandledRejection] 未捕获的 Promise 拒绝:', reason);
-    });
-    // uncaughtException 捕获未捕获的异常，记录后继续运行，不退出进程
-    process.on('uncaughtException', (error) => {
-        logger.error('[uncaughtException] 未捕获的异常:', error);
-    });
-    // ==================== 信号处理 ====================
-    ['SIGINT', 'SIGTERM', 'SIGQUIT', 'disconnect'].forEach(sig => {
-        process?.on?.(sig, () => {
-            logger.info?.(`[alemonjs][${sig}] 收到信号，正在关闭...`);
-            setImmediate(() => process.exit(0));
-        });
-    });
-    // 监听进程退出事件，记录退出码
-    process?.on?.('exit', code => {
-        logger.info?.(`[alemonjs][exit] 进程退出，code=${code}`);
-    });
-    // 监听来自主进程的消息，处理启动和停止命令
-    process.on('message', msg => {
-        try {
-            const data = typeof msg === 'string' ? JSON.parse(msg) : msg;
-            if (data?.type === 'start') {
-                main();
-                const values = getConfigValue() || {};
-                // plugins 优先，回退到旧的 apps_plugins
-                const startOptions = values.plugins || values.apps_plugins || {};
-                // start 插件。在apps进程启动中使用
-                for (const key in startOptions) {
-                    const moduleOptions = startOptions[key];
-                    // 检查 enable 字段，显式设为 false 时跳过
-                    if (typeof moduleOptions === 'object' && moduleOptions?.enable === false) {
-                        continue;
-                    }
-                    void import(key).then(mod => {
-                        if (mod?.default) {
-                            mod.default(moduleOptions);
-                        }
-                    });
-                }
-            }
-            else if (data?.type === 'stop') {
-                process.exit(0);
-            }
-        }
-        catch {
-            //
-        }
-    });
-    // 主动发送 ready 消息（serialization: 'advanced' 直接发送对象，无需 JSON.stringify）
-    if (process.send) {
-        process.send({ type: 'ready' });
-    }
-};
-mainProcess();

package/lib/store/SinglyLinkedList.d.ts

@@ -1,22 +0,0 @@
-/**
- * 单向链表实现
- */
-declare class ListNode<T> {
-    data: T;
-    next: ListNode<T> | null;
-    constructor(data: T);
-}
-export declare class SinglyLinkedList<T> {
-    private head;
-    private tail;
-    private size;
-    private current;
-    constructor(initialValues?: T[]);
-    append(data: T): void;
-    popNext(): ListNode<T> | null;
-    removeCurrent(): void;
-    getSize(): number;
-    resetCursor(): void;
-    forEach(callback: (node: ListNode<T>) => boolean | undefined): void;
-}
-export {};

package/lib/store/SinglyLinkedList.js

@@ -1,97 +0,0 @@
-/**
- * 单向链表实现
- */
-class ListNode {
-    data; // 节点数据
-    next; // 指向下一个节点的指针
-    constructor(data) {
-        this.data = data;
-        this.next = null;
-    }
-}
-class SinglyLinkedList {
-    head; // 链表的头节点
-    tail; // 链表的尾节点，用于 O(1) append
-    size; // 链表的大小
-    current; // 当前节点指针
-    constructor(initialValues) {
-        this.head = null;
-        this.tail = null;
-        this.size = 0;
-        this.current = null; // 初始化当前节点为 null
-        if (initialValues) {
-            initialValues.forEach(value => this.append(value)); // 初始化链表
-        }
-    }
-    // 在链表末尾添加新节点 - O(1)
-    append(data) {
-        const newNode = new ListNode(data);
-        if (!this.head) {
-            this.head = newNode;
-            this.tail = newNode;
-        }
-        else {
-            this.tail.next = newNode;
-            this.tail = newNode;
-        }
-        this.size++;
-    }
-    // 获取下一个节点并移动指针
-    popNext() {
-        if (!this.current) {
-            this.current = this.head; // 如果当前节点为 null，从头节点开始
-        }
-        else {
-            this.current = this.current.next; // 移动到下一个节点
-        }
-        return this.current; // 返回当前节点
-    }
-    // 删除当前节点
-    removeCurrent() {
-        if (!this.head || !this.current) {
-            return;
-        }
-        if (this.current === this.head) {
-            this.head = this.head.next; // 移除头节点
-            if (!this.head) {
-                this.tail = null; // 链表变空，重置 tail
-            }
-            this.current = null; // 重置当前节点
-            this.size--;
-            return;
-        }
-        let previous = this.head;
-        while (previous && previous.next !== this.current) {
-            previous = previous.next;
-        }
-        if (previous && this.current) {
-            previous.next = this.current.next; // 跳过当前节点
-            // 如果删除的是尾节点，更新 tail
-            if (this.current === this.tail) {
-                this.tail = previous;
-            }
-            this.current = previous; // 设置为前驱节点，使 popNext() 从正确位置继续
-            this.size--;
-        }
-    }
-    // 获取链表的大小
-    getSize() {
-        return this.size;
-    }
-    // 重置游标到起点，使 popNext() 下次从 head 开始
-    resetCursor() {
-        this.current = null;
-    }
-    // 遍历链表（不改变 current 游标）—— 回调返回 true 时提前终止
-    forEach(callback) {
-        let node = this.head;
-        while (node) {
-            if (callback(node) === true) {
-                break;
-            }
-            node = node.next;
-        }
-    }
-}
-
-export { SinglyLinkedList };

package/lib/store/store.d.ts

@@ -1,127 +0,0 @@
-/**
- * 全部挂在全局变量上，
- * 要求一个nodejs中，
- * 出现不同位置的模块也读取同一个数据
- * @description 存储器
- */
-import { SinglyLinkedList } from './SinglyLinkedList';
-import { childrenCallbackRes, ChildrenCycle, EventCycleEnum, EventKeys, StoreMiddlewareItem, StoreResponseItem, SubscribeValue } from '../types';
-export declare class Logger {
-    #private;
-    /**
-     * 创建一个 logger，如果未存在全局变量则赋值
-     * @returns
-     */
-    constructor();
-    get value(): any;
-}
-export declare class Core {
-    constructor();
-    get value(): {
-        storeState: import("..").ResponseState;
-        storeStateSubscribe: import("..").StateSubscribeMap;
-        storeSubscribeList: import("..").SubscribeKeysMap;
-        storeChildrenApp: {
-            [key: string]: import("..").StoreChildrenApp;
-        };
-    };
-}
-export declare const bumpStoreVersion: () => void;
-export declare class Response {
-    #private;
-    get value(): StoreResponseItem[];
-}
-export declare class ResponseMiddleware {
-    find(name: string, stateKey: string): StoreResponseItem[];
-}
-export declare class ResponseRouter {
-    #private;
-    get value(): any[];
-}
-export declare class MiddlewareRouter {
-    #private;
-    get value(): any[];
-}
-export declare class Middleware {
-    #private;
-    get value(): StoreMiddlewareItem[];
-}
-export declare class SubscribeList<T extends EventKeys> {
-    #private;
-    constructor(choice: EventCycleEnum, select: T);
-    get value(): SinglyLinkedList<SubscribeValue>;
-}
-/**
- * 纯函数版 SubscribeList 访问 — 避免每次创建类实例的 GC 开销
- */
-export declare const getSubscribeList: <T extends EventKeys>(choice: EventCycleEnum, select: T) => SinglyLinkedList<SubscribeValue>;
-export declare class StateSubscribe {
-    #private;
-    constructor(name: string);
-    on(callback: (value: boolean) => void): void;
-    un(callback: (value: boolean) => void): void;
-    get value(): ((value: boolean) => void)[];
-}
-/**
- * @deprecated 废弃。指令管理可直接配置禁用正则
- */
-export declare class State {
-    #private;
-    /**
-     *
-     * @param name
-     * @param defaultValue 默认，允许匹配
-     */
-    constructor(name: string, defaultValue?: boolean);
-    get value(): boolean;
-    set value(value: boolean);
-}
-export declare class ChildrenApp {
-    #private;
-    constructor(name?: string);
-    register(config: childrenCallbackRes): void;
-    /**
-     * 推送响应体
-     * @param data
-     */
-    pushResponse(data: StoreResponseItem[]): void;
-    /**
-     * 推送响应下的中间件
-     */
-    pushResponseMiddleware(data: {
-        [key: string]: StoreResponseItem;
-    }): void;
-    /**
-     * 推送中间件
-     * @param data
-     */
-    pushMiddleware(data: StoreMiddlewareItem[]): void;
-    /**
-     * 推送周期
-     * @param data
-     */
-    pushCycle(data: ChildrenCycle): void;
-    /**
-     * 挂载
-     */
-    on(): void;
-    /**
-     * 卸载
-     */
-    un(): void;
-    /**
-     * 获取
-     */
-    get value(): import("..").StoreChildrenApp;
-}
-export declare const ProcessorEventAutoClearMap: Map<any, any>;
-export declare const ProcessorEventUserAutoClearMap: Map<any, any>;
-export declare const logger: any;
-export declare const core: {
-    storeState: import("..").ResponseState;
-    storeStateSubscribe: import("..").StateSubscribeMap;
-    storeSubscribeList: import("..").SubscribeKeysMap;
-    storeChildrenApp: {
-        [key: string]: import("..").StoreChildrenApp;
-    };
-};