alemonjs 2.0.2 → 2.0.4

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

@@ -1,6 +1,8 @@
 import { isAsyncFunction } from 'util/types';
 import { useState } from './hook-use-state.js';
 import { showErrorModule } from './utils.js';
+import { Middleware } from './store.js';
+import { useSend } from './hook-use-api.js';
 
 /**
  * @fileoverview 消息处理快
@@ -15,12 +17,12 @@ import { showErrorModule } from './utils.js';
  * @param select
  */
 const expendMiddleware = async (valueEvent, select, next) => {
-    // 得到所有 apps
-    const mwFiles = [...alemonjsCore.storeMiddleware];
-    // 得到对应类型的消息
-    const mws = [...alemonjsCore.storeMiddlewareGather[select]];
+    const mw = new Middleware();
+    const Send = useSend(valueEvent);
+    // 得到所有 mws
+    const mwFiles = mw.value;
     let valueI = 0;
-    let valueJ = 0;
+    // let valueJ = 0
     /**
      * 下一步
      * @returns
@@ -30,19 +32,13 @@ const expendMiddleware = async (valueEvent, select, next) => {
             next(...cns);
             return;
         }
-        // i 结束了
+        // 结束了
         if (valueI >= mwFiles.length) {
-            // j 结束了
-            if (valueJ >= mws.length) {
-                next();
-                return;
-            }
-            // 走 j，检查所有分毫类型的
-            await callj();
+            next();
             return;
         }
-        // 走 i，检查所有 apps
-        await calli();
+        // 检查所有
+        calli();
     };
     /**
      * 执行 i
@@ -52,37 +48,47 @@ const expendMiddleware = async (valueEvent, select, next) => {
         // 调用完了
         if (valueI >= mwFiles.length) {
             // 开始调用j
-            await nextMiddleware();
+            nextMiddleware();
             return;
         }
         valueI++;
         const file = mwFiles[valueI - 1];
         if (!file?.path) {
             // 继续
-            await nextMiddleware();
+            nextMiddleware();
             return;
         }
         try {
             const app = await import(`file://${file.path}`);
             if (!app?.default) {
                 // 继续
-                await nextMiddleware();
+                nextMiddleware();
                 return;
             }
             if (!app.default.current) {
                 // 继续
-                await nextMiddleware();
+                nextMiddleware();
                 return;
             }
             // 检查状态
-            if (file?.state) {
-                const [state] = useState(file?.state);
+            if (file?.stateKey) {
+                const [state] = useState(file?.stateKey);
                 if (state == false) {
                     // 继续
-                    await nextMiddleware();
+                    nextMiddleware();
                     return;
                 }
             }
+            if (['message.create', 'private.message.create'].includes(select)) {
+                if (app?.regular) {
+                    const reg = new RegExp(app.regular);
+                    if (!reg.test(valueEvent['MessageText'])) {
+                        // 继续
+                        nextMiddleware();
+                        return;
+                    }
+                }
+            }
             // 是数组
             if (Array.isArray(app.default?.select)) {
                 // 不包含
@@ -100,98 +106,40 @@ const expendMiddleware = async (valueEvent, select, next) => {
                     nextMiddleware();
                     return;
                 }
-                // 不是数组，进行分类存储
-                // 判断是否已经存储
-                if (!alemonjsCore.storeMiddlewareGather[select].find(v => v.path === file.path)) {
-                    // 索引
-                    const index = alemonjsCore.storeMiddleware.findIndex(v => v.path === file.path);
-                    // 去除
-                    alemonjsCore.storeMiddleware.splice(index, 1);
-                    // 存储
-                    alemonjsCore.storeMiddlewareGather[select].push({
-                        source: file.source,
-                        dir: file.dir,
-                        path: file.path,
-                        name: file.name,
-                        node: file.node,
-                        value: {
-                            select: app.default?.select ?? select
-                        }
-                    });
-                }
             }
             if (Array.isArray(app.default.current)) {
                 let i = 0;
                 let T = true;
-                const start = async () => {
-                    if (i >= app.default.current.length)
-                        return;
-                    // 不是真的
-                    if (!T)
+                let isNext = false;
+                /**
+                 *
+                 * @param res
+                 * @returns
+                 */
+                const onRes = (res) => {
+                    if (isNext) {
+                        // 被调用了next
                         return;
-                    if (isAsyncFunction(app.default.current[i])) {
-                        T = await app.default.current[i](valueEvent, nextMiddleware);
                     }
-                    else {
-                        T = await app.default.current[i](valueEvent, nextMiddleware);
+                    if (typeof res === 'boolean') {
+                        T = res;
+                    }
+                    else if (Array.isArray(res)) {
+                        if (res.length > 0) {
+                            // 发送数据
+                            Send(...res);
+                        }
+                    }
+                    else if (typeof res === 'object') {
+                        if (typeof res?.allowGrouping === 'boolean') {
+                            T = res.allowGrouping;
+                        }
+                        if (Array.isArray(res.data)) {
+                            // 发送数据
+                            Send(...res.data);
+                        }
                     }
-                    ++i;
-                    await start();
                 };
-                await start();
-            }
-            else {
-                // 这里是否继续时 next 说了算
-                if (isAsyncFunction(app.default?.current)) {
-                    app.default?.current(valueEvent, nextMiddleware);
-                }
-                else {
-                    app.default?.current(valueEvent, nextMiddleware);
-                }
-            }
-        }
-        catch (err) {
-            showErrorModule(err);
-        }
-    };
-    /**
-     * 被分类好的
-     * @returns
-     */
-    const callj = async () => {
-        // 调用完了
-        if (valueJ >= mws.length) {
-            return;
-        }
-        valueJ++;
-        const file = mws[valueJ - 1];
-        if (!file?.path) {
-            await nextMiddleware();
-            return;
-        }
-        try {
-            const app = await import(`file://${file.path}`);
-            if (!app?.default) {
-                // 继续
-                await nextMiddleware();
-                return;
-            }
-            if (!app.default.current) {
-                // 继续
-                await nextMiddleware();
-                return;
-            }
-            if (file?.state) {
-                const [state] = useState(file?.state);
-                if (state == false) {
-                    // 继续
-                    await nextMiddleware();
-                    return;
-                }
-            }
-            if (Array.isArray(app.default.current)) {
-                let i = 0;
-                let T = true;
                 const start = async () => {
                     if (i >= app.default.current.length)
                         return;
@@ -199,10 +147,18 @@ const expendMiddleware = async (valueEvent, select, next) => {
                     if (!T)
                         return;
                     if (isAsyncFunction(app.default.current[i])) {
-                        T = await app.default.current[i](valueEvent, nextMiddleware);
+                        const res = await app.default.current[i](valueEvent, (...cns) => {
+                            isNext = true;
+                            nextMiddleware(...cns);
+                        });
+                        onRes(res);
                     }
                     else {
-                        T = await app.default.current[i](valueEvent, nextMiddleware);
+                        const res = app.default.current[i](valueEvent, (...cns) => {
+                            isNext = true;
+                            nextMiddleware(...cns);
+                        });
+                        onRes(res);
                     }
                     ++i;
                     await start();
@@ -210,22 +166,54 @@ const expendMiddleware = async (valueEvent, select, next) => {
                 await start();
             }
             else {
+                let isNext = false;
+                const onRes = (res) => {
+                    if (isNext) {
+                        // 被调用了next
+                        return;
+                    }
+                    if (typeof res === 'boolean') {
+                        // T = res
+                    }
+                    else if (Array.isArray(res)) {
+                        if (res.length > 0) {
+                            // 发送数据
+                            Send(...res);
+                        }
+                    }
+                    else if (typeof res === 'object') {
+                        if (typeof res?.allowGrouping === 'boolean') {
+                            // T = res.allowGrouping
+                        }
+                        if (Array.isArray(res.data)) {
+                            // 发送数据
+                            Send(...res.data);
+                        }
+                    }
+                };
                 // 这里是否继续时 next 说了算
                 if (isAsyncFunction(app.default?.current)) {
-                    app.default?.current(valueEvent, nextMiddleware);
+                    const res = await app.default?.current(valueEvent, (...cns) => {
+                        isNext = true;
+                        nextMiddleware(...cns);
+                    });
+                    onRes(res);
                 }
                 else {
-                    app.default?.current(valueEvent, nextMiddleware);
+                    const res = app.default?.current(valueEvent, (...cns) => {
+                        isNext = true;
+                        nextMiddleware(...cns);
+                    });
+                    onRes(res);
                 }
             }
         }
         catch (err) {
             showErrorModule(err);
         }
-        //
     };
     // 开始修正模式
-    await nextMiddleware();
+    nextMiddleware();
 };
 
 export { expendMiddleware };

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

@@ -1,4 +1,4 @@
-import { SinglyLinkedList } from '../datastructure/SinglyLinkedList.js';
+import { SubscribeList } from './store.js';
 
 /**
  * 处理订阅
@@ -8,9 +8,7 @@ import { SinglyLinkedList } from '../datastructure/SinglyLinkedList.js';
  * @param chioce
  */
 const expendSubscribe = async (valueEvent, select, next, chioce) => {
-    if (!alemonjsCore.storeSubscribeList[chioce][select]) {
-        alemonjsCore.storeSubscribeList[chioce][select] = new SinglyLinkedList();
-    }
+    const subList = new SubscribeList(chioce, select);
     /**
      * 观察者下一步
      * @returns
@@ -20,7 +18,7 @@ const expendSubscribe = async (valueEvent, select, next, chioce) => {
             next(...cns);
             return;
         }
-        const item = alemonjsCore.storeSubscribeList[chioce][select].popNext(); // 弹出下一个节点
+        const item = subList.value.popNext(); // 弹出下一个节点
         // 可能是 undefined
         if (!item || !item.data.current) {
             // 继续 next
@@ -36,16 +34,16 @@ const expendSubscribe = async (valueEvent, select, next, chioce) => {
             }
         }
         // 订阅是执行则销毁
-        alemonjsCore.storeSubscribeList[chioce][select].removeCurrent(); // 移除当前节点
+        subList.value.removeCurrent(); // 移除当前节点
         const Continue = (cn, ...cns) => {
             // next() 订阅继续
-            alemonjsCore.storeSubscribeList[chioce][select].append(item.data); // 重新连接
+            subList.value.append(item.data); // 重新连接
             if (cn) {
                 nextObserver(...cns);
                 return;
             }
             if (typeof cn === 'boolean') {
-                alemonjsCore.storeSubscribeList[chioce][select].removeCurrent(); // 移除当前节点
+                subList.value.removeCurrent(); // 移除当前节点
                 nextObserver(...cns);
                 return;
             }

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

@@ -1,5 +1,4 @@
-import '../global.js';
-import { Events } from '../typing/event/map.js';
+import { EventKeys, Events } from '../typing/event/map.js';
 
 /**
  * 消息处理器
@@ -8,7 +7,7 @@ import { Events } from '../typing/event/map.js';
  * @param data
  * @returns
  */
-declare const onProcessor: <T extends keyof Events>(name: T, event: Events[T], data?: any) => void;
+declare const onProcessor: <T extends EventKeys>(name: T, event: Events[T], data?: any) => void;
 /**
  * 消息处理器
  * @param event
@@ -16,6 +15,6 @@ declare const onProcessor: <T extends keyof Events>(name: T, event: Events[T], d
  * @deprecated 该方法已被弃用，请使用 onProcessor() 替代。
  * @returns
  */
-declare const OnProcessor: <T extends keyof Events>(event: Events[T], name: T) => void;
+declare const OnProcessor: <T extends EventKeys>(event: Events[T], name: T) => void;
 
 export { OnProcessor, onProcessor };

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

@@ -0,0 +1,16 @@
+import { OnResponseReversalFunc, OnResponseFunc } from '../typing/event/index.js';
+
+/**
+ * 处理响应事件
+ * @param select 事件选择
+ * @param callback 回调函数，处理事件和 API
+ * @returns 回调函数的执行结果
+ */
+declare const onResponse: OnResponseReversalFunc;
+/**
+ * 废弃，请使用 onResponse
+ * @deprecated
+ */
+declare const OnResponse: OnResponseFunc;
+
+export { OnResponse, onResponse };

package/lib/app/{event-utlis.js → event-response.js}

@@ -1,21 +1,20 @@
 /**
  * 处理响应事件
+ * @param select 事件选择
  * @param callback 回调函数，处理事件和 API
- * @param event 事件类型
- * @param reg
  * @returns 回调函数的执行结果
  */
-const OnResponse = (callback, select) => {
+const onResponse = (select, callback) => {
     return { current: callback, select };
 };
-global.OnResponse = OnResponse;
+global.onResponse = onResponse;
 /**
- * 废弃
+ * 废弃，请使用 onResponse
  * @deprecated
  */
-const onResponse = (select, callback) => {
+const OnResponse = (callback, select) => {
     return { current: callback, select };
 };
-global.onResponse = onResponse;
+global.OnResponse = OnResponse;
 
 export { OnResponse, onResponse };

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

@@ -1,42 +1,35 @@
-import '../global.js';
-import { Events } from '../typing/event/map.js';
+import { EventKeys, Events } from '../typing/event/map.js';
 import { User } from '../typing/event/base/user.js';
 import { DataEnums } from '../typing/message/index.js';
+import '../global.js';
 
 /**
  * 使用提及。
  * @param {Object} event - 事件对象，包含触发提及的相关信息。
- * @returns {any} - 返回提及操作的结果。
  */
-declare const useMention: (event: {
-    [key: string]: any;
-}) => Promise<User[]>;
+declare const useMention: <T extends EventKeys>(event: Events[T]) => Promise<User[]>;
 /**
  * 使用发送消息。
  * @param {Object} event - 事件对象，包含触发发送的相关信息。
  * @returns {Function} - 返回一个异步函数，用于发送消息。
  * @throws {Error} - 如果 event 无效，抛出错误。
  */
-declare const useSend: (event: {
-    [key: string]: any;
-}) => (...val: DataEnums[]) => Promise<any[]>;
+declare const useSend: <T extends EventKeys>(event: Events[T]) => (...val: DataEnums[]) => Promise<any[]>;
 /**
- * 卸载模块。
- * 从全局存储中移除与指定模块相关的数据。
- * @param {string} mainDir - 模块的主目录路径。
- * @throws {Error} - 如果 mainDir 无效，抛出错误。
+ * 卸载模块
+ * @param name
  */
-declare const unChildren: (mainDir: string) => void;
+declare const unChildren: (name?: string) => void;
 /**
  * 废弃,请使用unChildren
  * @deprecated
  */
-declare const unMount: (mainDir: string) => void;
+declare const unMount: () => void;
 /**
  *
  * @param values
  * @returns
  */
-declare const createSelects: <T extends (keyof Events)[] | keyof Events>(values: T) => T;
+declare const createSelects: <T extends EventKeys[] | EventKeys>(values: T) => T;
 
 export { createSelects, unChildren, unMount, useMention, useSend };

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

@@ -1,7 +1,8 @@
+import { ChildrenApp } from './store.js';
+
 /**
  * 使用提及。
  * @param {Object} event - 事件对象，包含触发提及的相关信息。
- * @returns {any} - 返回提及操作的结果。
  */
 const useMention = async (event) => {
     if (!event || typeof event !== 'object') {
@@ -42,48 +43,21 @@ const useSend = (event) => {
     };
 };
 /**
- * 卸载模块。
- * 从全局存储中移除与指定模块相关的数据。
- * @param {string} mainDir - 模块的主目录路径。
- * @throws {Error} - 如果 mainDir 无效，抛出错误。
+ * 卸载模块
+ * @param name
  */
-const unChildren = (mainDir) => {
-    if (!mainDir || typeof mainDir !== 'string') {
-        throw new Error('Invalid mainDir: mainDir must be a non-empty string');
-    }
-    // 从 storeMains 中移除
-    const storeMainsIndex = alemonjsCore.storeMains.indexOf(mainDir);
-    if (storeMainsIndex !== -1) {
-        alemonjsCore.storeMains.splice(storeMainsIndex, 1);
-    }
-    // 从 storeResponse 中移除
-    if (alemonjsCore.storeResponse.find(item => item.source == mainDir)) {
-        alemonjsCore.storeResponse = alemonjsCore.storeResponse.filter(item => item.source !== mainDir);
-    }
-    // 从 storeMiddleware 中移除
-    if (alemonjsCore.storeMiddleware.find(item => item.source == mainDir)) {
-        alemonjsCore.storeMiddleware = alemonjsCore.storeMiddleware.filter(item => item.source !== mainDir);
-    }
-    // 从 storeResponseGather 中移除
-    for (const key in alemonjsCore.storeResponseGather) {
-        if (Array.isArray(alemonjsCore.storeResponseGather[key]) &&
-            alemonjsCore.storeResponseGather[key].find(item => item.source == mainDir)) {
-            alemonjsCore.storeResponseGather[key] = alemonjsCore.storeResponseGather[key].filter(item => item.source !== mainDir);
-        }
-    }
-    // 从 storeMiddlewareGather 中移除
-    for (const key in alemonjsCore.storeMiddlewareGather) {
-        if (Array.isArray(alemonjsCore.storeMiddlewareGather[key]) &&
-            alemonjsCore.storeMiddlewareGather[key].find(item => item.source == mainDir)) {
-            alemonjsCore.storeMiddlewareGather[key] = alemonjsCore.storeMiddlewareGather[key].filter(item => item.source !== mainDir);
-        }
-    }
+const unChildren = (name = 'main') => {
+    const app = new ChildrenApp(name);
+    app.un();
 };
 /**
  * 废弃,请使用unChildren
  * @deprecated
  */
-const unMount = unChildren;
+const unMount = () => {
+    // 警告，已废弃。
+    console.warn('unMount 已废弃，请使用 unChildren');
+};
 /**
  *
  * @param values

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

@@ -18,7 +18,7 @@ declare const useState: <T extends string>(name: T, defaultValue?: boolean) => [
  */
 declare const onState: <T extends string>(name: T, callback: (value: boolean) => void) => void;
 /**
- * 废弃
+ * 废弃，请使用 onState
  * @deprecated
  */
 declare const eventState: <T extends string>(name: T, callback: (value: boolean) => void) => void;
@@ -29,7 +29,7 @@ declare const eventState: <T extends string>(name: T, callback: (value: boolean)
  */
 declare const unState: <T extends string>(name: T, callback: (value: boolean) => void) => void;
 /**
- * 废弃
+ * 废弃，请使用 unState
  * @deprecated
  */
 declare const unEventState: <T extends string>(name: T, callback: (value: boolean) => void) => void;

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

@@ -1,23 +1,5 @@
-// 存储订阅者
-const subscriptions = {};
-if (!alemonjsCore.storeState) {
-    // 初始化全局状态
-    alemonjsCore.storeState = new Proxy({}, {
-        get(target, prop) {
-            return prop in target ? target[prop] : false;
-        },
-        set(target, prop, value) {
-            target[prop] = value;
-            // 通知所有订阅者
-            if (subscriptions[prop]) {
-                for (const callback of subscriptions[prop]) {
-                    callback(value);
-                }
-            }
-            return true; // 表示设置成功
-        }
-    });
-}
+import { State, StateSubscribe } from './store.js';
+
 /**
  * 获取指定功能是启动还是关闭
  * ***
@@ -31,15 +13,12 @@ if (!alemonjsCore.storeState) {
  * @returns 当前状态和设置函数
  */
 const useState = (name, defaultValue = true) => {
-    // 如果不存在则设置默认值
-    if (!(name in alemonjsCore.storeState)) {
-        alemonjsCore.storeState[name] = defaultValue;
-    }
+    const state = new State(name, defaultValue);
     // 设置值的函数
     const setValue = (value) => {
-        alemonjsCore.storeState[name] = value;
+        state.value = value;
     };
-    return [alemonjsCore.storeState[name], setValue];
+    return [state.value, setValue];
 };
 /**
  * 订阅状态变化
@@ -50,13 +29,11 @@ const onState = (name, callback) => {
     if (typeof callback !== 'function') {
         throw new Error('Callback must be a function');
     }
-    if (!subscriptions[name]) {
-        subscriptions[name] = [];
-    }
-    subscriptions[name].push(callback);
+    const sub = new StateSubscribe(name);
+    sub.on(callback);
 };
 /**
- * 废弃
+ * 废弃，请使用 onState
  * @deprecated
  */
 const eventState = onState;
@@ -66,12 +43,11 @@ const eventState = onState;
  * @param callback 回调函数
  */
 const unState = (name, callback) => {
-    if (subscriptions[name]) {
-        subscriptions[name] = subscriptions[name].filter(cb => cb !== callback);
-    }
+    const sub = new StateSubscribe(name);
+    sub.un(callback);
 };
 /**
- * 废弃
+ * 废弃，请使用 unState
  * @deprecated
  */
 const unEventState = unState;

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

@@ -1,5 +1,4 @@
-import '../global.js';
-import { Events } from '../typing/event/map.js';
+import { EventKeys, Events } from '../typing/event/map.js';
 import { Current } from '../typing/event/index.js';
 
 /**
@@ -8,13 +7,13 @@ import { Current } from '../typing/event/index.js';
  * @param option
  * @returns
  */
-declare const useSubscribe: <T extends keyof Events>(event: any, select: T) => ((callback: Current<T>, keys: (keyof Events[T])[]) => void)[];
+declare const useSubscribe: <T extends EventKeys>(event: Events[T], select: T) => ((callback: Current<T>, keys: (keyof Events[T])[]) => void)[];
 /**
  * 使用观察者
  * @param event
  * @param option
  * @returns
  */
-declare const useObserver: <T extends keyof Events>(event: any, option: T) => (callback: Current<T>, keys: (keyof Events[T])[]) => void;
+declare const useObserver: <T extends EventKeys>(event: Events[T], option: T) => (callback: Current<T>, keys: (keyof Events[T])[]) => void;
 
 export { useObserver, useSubscribe };