alemonjs 2.1.52 → 2.1.54

package/bin/README.md

@@ -1,6 +1,6 @@
 ## alemonc
 
-AlemonJS 项目 CLI 工具，用于配置管理、平台管理、版本更新等。
+ALemonJS 项目 CLI 工具，用于配置管理、平台管理、版本更新等。
 
 ### 帮助
 

package/bin/info.js

@@ -8,7 +8,7 @@ import YAML from 'yaml';
  * 输出项目诊断信息
  */
 export function info() {
-  console.log('=== AlemonJS 项目信息 ===\n');
+  console.log('=== ALemonJS 项目信息 ===\n');
 
   // Node 版本
   console.log(`Node.js:  ${process.version}`);

package/lib/app/define-router.d.ts

@@ -2,4 +2,5 @@ import { DefineRouterFunc } from '../types';
 export declare const lazy: <T extends {
     default: any;
 }>(fnc: () => Promise<T>) => (() => Promise<T["default"]>);
+export declare function runHandler(loader: () => Promise<any>, args: any[]): Promise<any>;
 export declare const defineRouter: DefineRouterFunc;

package/lib/app/define-router.js

@@ -11,10 +11,15 @@ const lazy = (fnc) => {
     };
     return back;
 };
+async function runHandler(loader, args) {
+    const mod = await loader();
+    const handler = mod.default ?? mod;
+    return handler(...args);
+}
 const defineRouter = routes => {
     return {
         current: routes
     };
 };
 
-export { defineRouter, lazy };
+export { defineRouter, lazy, runHandler };

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

@@ -1,3 +1,4 @@
-import { Next, Events, EventKeys, StoreResponseItem } from '../types';
+import { Next, Events, EventKeys, FileTreeNode, StoreResponseItem } from '../types';
 export declare const clearModuleCache: (path?: string) => void;
 export declare const createNextStep: <T extends EventKeys>(valueEvent: Events[T], select: T, next: Next, files: StoreResponseItem[], callHandler: (currents: any, nextEvent: any) => void) => Next;
+export declare const createFileTreeStep: <T extends EventKeys>(valueEvent: Events[T], select: T, next: Next, root: FileTreeNode, callHandler: (currents: any, nextEvent: any) => void) => Next;

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

@@ -1,10 +1,26 @@
-import { useState } from './event-utils.js';
 import { getCachedRegExp, showErrorModule } from '../core/utils.js';
 import { EventMessageText } from '../core/variable.js';
-import { ResponseMiddleware } from './store.js';
 
-const responseMiddlewareSingleton = new ResponseMiddleware();
 const moduleCache = new Map();
+const shouldSkipFile = (file, select, valueEvent) => {
+    if (!moduleCache.has(file.path)) {
+        return false;
+    }
+    const app = moduleCache.get(file.path);
+    if (!app?.default?.current || !app?.default?.select) {
+        return true;
+    }
+    const selects = Array.isArray(app.default.select) ? app.default.select : [app.default.select];
+    if (!selects.includes(select)) {
+        return true;
+    }
+    if (EventMessageText.includes(select) && app?.regular) {
+        if (!getCachedRegExp(app.regular).test(valueEvent['MessageText'])) {
+            return true;
+        }
+    }
+    return false;
+};
 const clearModuleCache = (path) => {
     if (path) {
         moduleCache.delete(path);
@@ -28,13 +44,6 @@ const callHandlerFile = async (valueEvent, select, file, nextStep, callback) =>
             nextStep();
             return;
         }
-        if (file?.stateKey) {
-            const [state] = useState(file?.stateKey);
-            if (state === false) {
-                nextStep();
-                return;
-            }
-        }
         if (EventMessageText.includes(select)) {
             if (app?.regular) {
                 if (!getCachedRegExp(app.regular).test(valueEvent['MessageText'])) {
@@ -52,11 +61,11 @@ const callHandlerFile = async (valueEvent, select, file, nextStep, callback) =>
     }
     catch (err) {
         showErrorModule(err);
+        nextStep();
     }
 };
 const createNextStep = (valueEvent, select, next, files, callHandler) => {
     let valueI = 0;
-    const recordCloseMw = new Set();
     const nextStep = (cn, ...cns) => {
         if (cn) {
             next(...cns);
@@ -79,30 +88,125 @@ const createNextStep = (valueEvent, select, next, files, callHandler) => {
             nextStep();
             return;
         }
-        const currentsAndMiddleware = responseMiddlewareSingleton.find(file.appName, file.stateKey);
         const currents = [];
-        const iterItems = currentsAndMiddleware.length > 0 ? currentsAndMiddleware.concat(file) : [file];
-        for (const cm of iterItems) {
-            let isBreak = false;
-            if (recordCloseMw.has(cm.stateKey)) {
+        await callHandlerFile(valueEvent, select, file, () => {
+            nextStep();
+        }, app => {
+            const currentsItem = Array.isArray(app.default.current) ? app.default.current : [app.default.current];
+            currents.push(...currentsItem);
+        });
+        if (currents.length > 0) {
+            callHandler(currents, nextStep);
+        }
+    };
+    return nextStep;
+};
+const createFileTreeStep = (valueEvent, select, next, root, callHandler) => {
+    const processNode = (node, done) => {
+        if (node.middleware?.path) {
+            void checkMiddleware(node, done);
+        }
+        else {
+            void processContent(node, done);
+        }
+    };
+    const checkMiddleware = async (node, done) => {
+        if (shouldSkipFile(node.middleware, select, valueEvent)) {
+            void processContent(node, done);
+            return;
+        }
+        let matched = false;
+        const mwCurrents = [];
+        await callHandlerFile(valueEvent, select, node.middleware, () => {
+            void processContent(node, done);
+        }, app => {
+            matched = true;
+            const items = Array.isArray(app.default.current) ? app.default.current : [app.default.current];
+            mwCurrents.push(...items);
+        });
+        if (matched) {
+            if (mwCurrents.length === 0) {
+                void processContent(node, done);
                 return;
             }
-            const close = () => {
-                isBreak = true;
-                recordCloseMw.add(cm.stateKey);
-            };
-            await callHandlerFile(valueEvent, select, cm, close, app => {
-                const currentsItem = Array.isArray(app.default.current) ? app.default.current : [app.default.current];
-                currents.push(...currentsItem);
+            const gateCurrents = mwCurrents.concat([
+                (_event, gateNext) => {
+                    gateNext();
+                    return true;
+                }
+            ]);
+            callHandler(gateCurrents, (cn, ...cns) => {
+                if (cn) {
+                    done(true, ...cns);
+                    return;
+                }
+                void processContent(node, done);
             });
-            if (isBreak) {
-                nextStep();
+        }
+    };
+    const processContent = (node, done) => {
+        processFiles(node, 0, () => {
+            processChildNodes(node, done);
+        }, done);
+    };
+    const processFiles = (node, idx, filesDone, treeDone) => {
+        if (idx >= node.files.length) {
+            filesDone();
+            return;
+        }
+        const file = node.files[idx];
+        if (!file?.path) {
+            processFiles(node, idx + 1, filesDone, treeDone);
+            return;
+        }
+        if (shouldSkipFile(file, select, valueEvent)) {
+            processFiles(node, idx + 1, filesDone, treeDone);
+            return;
+        }
+        void callHandlerFile(valueEvent, select, file, () => {
+            processFiles(node, idx + 1, filesDone, treeDone);
+        }, app => {
+            const fileCurrents = Array.isArray(app.default.current) ? app.default.current : [app.default.current];
+            callHandler(fileCurrents, (cn, ...cns) => {
+                if (cn) {
+                    treeDone(true, ...cns);
+                }
+                else {
+                    processFiles(node, idx + 1, filesDone, treeDone);
+                }
+            });
+        });
+    };
+    const processChildNodes = (node, done) => {
+        const childKeys = Array.from(node.children.keys());
+        let childIdx = 0;
+        const nextChild = (...cns) => {
+            if (cns.length > 0 && cns[0]) {
+                done(...cns);
+                return;
+            }
+            if (childIdx >= childKeys.length) {
+                done();
                 return;
             }
+            const childNode = node.children.get(childKeys[childIdx++]);
+            if (childNode) {
+                processNode(childNode, nextChild);
+            }
+            else {
+                nextChild();
+            }
+        };
+        nextChild();
+    };
+    const startStep = (cn, ...cns) => {
+        if (cn) {
+            next(...cns);
+            return;
         }
-        callHandler(currents, nextStep);
+        processNode(root, next);
     };
-    return nextStep;
+    return startStep;
 };
 
-export { clearModuleCache, createNextStep };
+export { clearModuleCache, createFileTreeStep, createNextStep };

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

@@ -1,2 +1,2 @@
 import { Next, Events, EventKeys, ResponseRoute } from '../types';
-export declare const createRouteProcessChildren: <T extends EventKeys>(valueEvent: Events[T], select: T, nextCycle: Next, callHandler: (currents: any, nextEvent: any) => void) => (nodes: ResponseRoute[], middleware: any, next: () => Promise<void> | void) => void;
+export declare const createRouteProcessChildren: <T extends EventKeys>(valueEvent: Events[T], select: T, nextCycle: Next, callHandler: (currents: any, nextEvent: any) => void) => (nodes: ResponseRoute[], _pending: any[], next: () => Promise<void> | void) => void;

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

@@ -12,7 +12,40 @@ function isFunction(value) {
     return isAsyncFunction(value) || typeof value === 'function' || value instanceof Function;
 }
 const createRouteProcessChildren = (valueEvent, select, nextCycle, callHandler) => {
-    const processChildren = (nodes, middleware, next) => {
+    const handlerResultCache = new Map();
+    const collectHandlers = (tail) => {
+        const result = [];
+        let node = tail;
+        while (node) {
+            result.push(node.handler);
+            node = node.prev;
+        }
+        result.reverse();
+        return result;
+    };
+    const resolveHandler = async (handler) => {
+        if (handlerResultCache.has(handler)) {
+            return handlerResultCache.get(handler);
+        }
+        const app = await handler();
+        const result = { matched: true, currents: [] };
+        if (isFunction(app)) {
+            result.currents.push(app);
+        }
+        else {
+            const selects = Array.isArray(app.select) ? app.select : [app.select];
+            if (!selects.includes(select)) {
+                result.matched = false;
+            }
+            else {
+                const items = Array.isArray(app.current) ? app.current : [app.current];
+                result.currents.push(...items);
+            }
+        }
+        handlerResultCache.set(handler, result);
+        return result;
+    };
+    const processChildren = (nodes, pendingTail, next) => {
         if (!nodes || nodes.length === 0) {
             void next();
             return;
@@ -57,35 +90,25 @@ const createRouteProcessChildren = (valueEvent, select, nextCycle, callHandler)
                 void nextNode();
                 return;
             }
+            const currentNode = { handler: node.handler, prev: pendingTail };
             if (node.children && node.children.length > 0) {
-                middleware.push(node.handler);
-                processChildren(node.children, middleware, () => {
-                    middleware.pop();
+                processChildren(node.children, currentNode, () => {
                     void nextNode();
                 });
                 return;
             }
-            middleware.push(node.handler);
-            const currentsAndMiddleware = middleware;
             try {
-                const currents = [];
-                for (const item of currentsAndMiddleware) {
-                    const app = await item();
-                    if (isFunction(app)) {
-                        currents.push(app);
-                        continue;
-                    }
-                    const selects = Array.isArray(app.select) ? app.select : [app.select];
-                    if (!selects.includes(select)) {
-                        middleware.pop();
+                const allHandlers = collectHandlers(currentNode);
+                const allCurrents = [];
+                for (const h of allHandlers) {
+                    const result = await resolveHandler(h);
+                    if (!result.matched) {
                         void nextNode();
                         return;
                     }
-                    const currentsItem = Array.isArray(app.current) ? app.current : [app.current];
-                    currents.push(...currentsItem);
+                    allCurrents.push(...result.currents);
                 }
-                middleware.pop();
-                callHandler(currents, (cn, ...cns) => {
+                callHandler(allCurrents, (cn, ...cns) => {
                     if (cn) {
                         nextCycle(true, ...cns);
                         return;
@@ -94,13 +117,14 @@ const createRouteProcessChildren = (valueEvent, select, nextCycle, callHandler)
                 });
             }
             catch (err) {
-                middleware.pop();
                 showErrorModule(err);
             }
         };
         void nextNode();
     };
-    return processChildren;
+    return (nodes, _pending, next) => {
+        processChildren(nodes, null, next);
+    };
 };
 
 export { createRouteProcessChildren };

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

@@ -1,14 +1,14 @@
-import { Response, ResponseRouter } from './store.js';
+import { ResponseTree, ResponseRouter } from './store.js';
 import { createCallHandler } from './event-processor-callHandler.js';
-import { createNextStep } from './event-processor-cycleFiles.js';
+import { createFileTreeStep } from './event-processor-cycleFiles.js';
 import { createRouteProcessChildren } from './event-processor-cycleRoute.js';
 
-const responseSingleton = new Response();
+const responseTreeSingleton = new ResponseTree();
 const responseRouterSingleton = new ResponseRouter();
 const expendEvent = (valueEvent, select, next) => {
-    const StoreResponse = responseSingleton.value;
+    const root = responseTreeSingleton.value;
     const callHandler = createCallHandler(valueEvent);
-    const nextEvent = createNextStep(valueEvent, select, next, StoreResponse, callHandler);
+    const nextEvent = createFileTreeStep(valueEvent, select, next, root, callHandler);
     const routes = responseRouterSingleton.value;
     const callRouteHandler = createCallHandler(valueEvent);
     const processChildren = createRouteProcessChildren(valueEvent, select, nextEvent, callRouteHandler);

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

@@ -1,14 +1,14 @@
-import { Middleware, MiddlewareRouter } from './store.js';
+import { MiddlewareTree, MiddlewareRouter } from './store.js';
 import { createCallHandler } from './event-processor-callHandler.js';
-import { createNextStep } from './event-processor-cycleFiles.js';
+import { createFileTreeStep } from './event-processor-cycleFiles.js';
 import { createRouteProcessChildren } from './event-processor-cycleRoute.js';
 
-const middlewareSingleton = new Middleware();
+const middlewareTreeSingleton = new MiddlewareTree();
 const middlewareRouterSingleton = new MiddlewareRouter();
 const expendMiddleware = (valueEvent, select, next) => {
-    const mwFiles = middlewareSingleton.value;
+    const root = middlewareTreeSingleton.value;
     const callHandler = createCallHandler(valueEvent);
-    const nextMiddleware = createNextStep(valueEvent, select, next, mwFiles, callHandler);
+    const nextMiddleware = createFileTreeStep(valueEvent, select, next, root, callHandler);
     const routes = middlewareRouterSingleton.value;
     const callRouteHandler = createCallHandler(valueEvent);
     const processChildren = createRouteProcessChildren(valueEvent, select, nextMiddleware, callRouteHandler);

package/lib/app/event-processor.js

@@ -98,6 +98,9 @@ const onProcessor = (name, event, data) => {
             }
         }
     }
+    else {
+        event['MessageText'] = '';
+    }
     const masterId = value?.master_id;
     const masterKey = value?.master_key;
     if (event['UserId'] && matchIn(masterId, event['UserId'])) {

package/lib/app/expose.d.ts

@@ -0,0 +1,16 @@
+import { ExposeProvideConfig, ExposeListItem, ExposeWatchEvent, ExposeSchemaItem } from '../types';
+type WatchCallback = (event: ExposeWatchEvent) => void;
+export declare function registerExpose(appName: string, configs: ExposeProvideConfig[]): void;
+export declare class Expose {
+    #private;
+    static create(): Expose;
+    provide(config: ExposeProvideConfig): this;
+    getConfigs(): ExposeProvideConfig[];
+    list(protocol?: string): ExposeListItem[];
+    invoke(protocol: string, appName: string, action: string, value?: any): any;
+    schema(): ExposeSchemaItem[];
+    watch(protocolOrCallback: string | WatchCallback, callback?: WatchCallback): () => void;
+}
+export declare function disposeExpose(appName: string): void;
+export declare function clearAllExpose(): void;
+export {};

package/lib/app/expose.js

@@ -0,0 +1,190 @@
+const storeExpose = new Map();
+const protocolWatchers = new Map();
+const globalWatchers = new Set();
+function emitWatch(event) {
+    const watchers = protocolWatchers.get(event.protocol);
+    if (watchers) {
+        for (const cb of watchers) {
+            try {
+                cb(event);
+            }
+            catch {
+            }
+        }
+    }
+    for (const cb of globalWatchers) {
+        try {
+            cb(event);
+        }
+        catch {
+        }
+    }
+}
+function registerExpose(appName, configs) {
+    for (const config of configs) {
+        const protocol = config.name;
+        if (!storeExpose.has(protocol)) {
+            storeExpose.set(protocol, new Map());
+        }
+        const providers = storeExpose.get(protocol);
+        if (providers.has(appName)) {
+            console.warn(`[expose] ${appName} already provided "${protocol}", overwriting.`);
+        }
+        providers.set(appName, { appName, config });
+    }
+}
+class Expose {
+    #configs = [];
+    static create() {
+        return new Expose();
+    }
+    provide(config) {
+        this.#configs.push(config);
+        return this;
+    }
+    getConfigs() {
+        return this.#configs;
+    }
+    list(protocol) {
+        const result = [];
+        if (protocol) {
+            const providers = storeExpose.get(protocol);
+            if (!providers) {
+                return result;
+            }
+            for (const [, entry] of providers) {
+                result.push(createListItem(entry, protocol));
+            }
+        }
+        else {
+            for (const [proto, providers] of storeExpose) {
+                for (const [, entry] of providers) {
+                    result.push(createListItem(entry, proto));
+                }
+            }
+        }
+        return result;
+    }
+    invoke(protocol, appName, action, value) {
+        const providers = storeExpose.get(protocol);
+        if (!providers) {
+            throw new Error(`[expose] protocol "${protocol}" not found`);
+        }
+        const entry = providers.get(appName);
+        if (!entry) {
+            throw new Error(`[expose] provider "${appName}" not found in protocol "${protocol}"`);
+        }
+        const actionMeta = entry.config.actions[action];
+        if (!actionMeta) {
+            throw new Error(`[expose] action "${action}" not found in "${protocol}" of "${appName}"`);
+        }
+        const result = actionMeta.handler(value);
+        if (action !== 'read') {
+            emitWatch({
+                name: appName,
+                protocol,
+                action,
+                value
+            });
+        }
+        return result;
+    }
+    schema() {
+        const result = [];
+        for (const [protocol, providers] of storeExpose) {
+            const firstEntry = providers.values().next().value;
+            if (!firstEntry) {
+                continue;
+            }
+            const actions = {};
+            for (const [actionName, meta] of Object.entries(firstEntry.config.actions)) {
+                actions[actionName] = {
+                    description: meta.description,
+                    ...(meta.params ? { params: meta.params } : {}),
+                    ...(meta.returns ? { returns: meta.returns } : {})
+                };
+            }
+            result.push({
+                protocol,
+                description: firstEntry.config.description,
+                providers: Array.from(providers.keys()).map(name => ({ name })),
+                actions,
+                invoke: 'Expose.invoke(protocol, appName, action, value?)'
+            });
+        }
+        return result;
+    }
+    watch(protocolOrCallback, callback) {
+        if (typeof protocolOrCallback === 'function') {
+            const cb = protocolOrCallback;
+            globalWatchers.add(cb);
+            return () => {
+                globalWatchers.delete(cb);
+            };
+        }
+        const protocol = protocolOrCallback;
+        if (!callback) {
+            throw new Error('[expose] watch(protocol, callback) requires a callback');
+        }
+        if (!protocolWatchers.has(protocol)) {
+            protocolWatchers.set(protocol, new Set());
+        }
+        protocolWatchers.get(protocol).add(callback);
+        return () => {
+            const set = protocolWatchers.get(protocol);
+            if (set) {
+                set.delete(callback);
+                if (set.size === 0) {
+                    protocolWatchers.delete(protocol);
+                }
+            }
+        };
+    }
+}
+function createListItem(entry, protocol) {
+    const actions = {};
+    for (const [actionName, meta] of Object.entries(entry.config.actions)) {
+        actions[actionName] = {
+            description: meta.description,
+            ...(meta.params ? { params: meta.params } : {}),
+            ...(meta.returns ? { returns: meta.returns } : {})
+        };
+    }
+    return {
+        name: entry.appName,
+        protocol,
+        description: entry.config.description,
+        actions,
+        invoke(action, value) {
+            const actionMeta = entry.config.actions[action];
+            if (!actionMeta) {
+                throw new Error(`[expose] action "${action}" not found in "${protocol}" of "${entry.appName}"`);
+            }
+            const result = actionMeta.handler(value);
+            if (action !== 'read') {
+                emitWatch({
+                    name: entry.appName,
+                    protocol,
+                    action,
+                    value
+                });
+            }
+            return result;
+        }
+    };
+}
+function disposeExpose(appName) {
+    for (const [protocol, providers] of storeExpose) {
+        providers.delete(appName);
+        if (providers.size === 0) {
+            storeExpose.delete(protocol);
+        }
+    }
+}
+function clearAllExpose() {
+    storeExpose.clear();
+    protocolWatchers.clear();
+    globalWatchers.clear();
+}
+
+export { Expose, clearAllExpose, disposeExpose, registerExpose };

package/lib/app/index.d.ts

@@ -1,4 +1,5 @@
 export * from './store.js';
+export * from './expose.js';
 export * from './load_modules/index.js';
 export * from './define-children.js';
 export * from './define-platform.js';

package/lib/app/index.js

@@ -1,11 +1,12 @@
-export { ChildrenApp, Core, Logger, Middleware, MiddlewareRouter, ProcessorEventAutoClearMap, ProcessorEventUserAutoClearMap, Response, ResponseMiddleware, ResponseRouter, State, StateSubscribe, SubscribeList, bumpStoreVersion, core, getSubscribeList, logger } from './store.js';
+export { ChildrenApp, Core, Logger, Middleware, MiddlewareRouter, MiddlewareTree, ProcessorEventAutoClearMap, ProcessorEventUserAutoClearMap, Response, ResponseMiddleware, ResponseRouter, ResponseTree, State, StateSubscribe, SubscribeList, bumpStoreVersion, core, getSubscribeList, logger } from './store.js';
+export { Expose, clearAllExpose, disposeExpose, registerExpose } from './expose.js';
 export { loadModels, run } from './load_modules/load.js';
 export { loadChildren, loadChildrenFile } from './load_modules/loadChild.js';
 export { defineChildren } from './define-children.js';
 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 { defineRouter, lazy, runHandler } from './define-router.js';
 export { FormatEvent, wrapEvent } from './event-format.js';
 export { onGroup } from './event-group.js';
 export { OnMiddleware, onMiddleware } from './event-middleware.js';

package/lib/app/load_modules/loadChild.js

@@ -2,6 +2,7 @@ import { dirname, join } from 'path';
 import { existsSync } from 'fs';
 import { showErrorModule, getRecursiveDirFiles, createEventName } from '../../core/utils.js';
 import { ChildrenApp } from '../store.js';
+import { registerExpose } from '../expose.js';
 import { ResultCode, fileSuffixMiddleware } from '../../core/variable.js';
 import module$1 from 'module';
 
@@ -67,6 +68,9 @@ const loadChildren = async (mainPath, appName) => {
             if (res && (res?.response || res?.middleware || res?.responseRouter || res?.middlewareRouter)) {
                 App.register(res);
             }
+            if (res?.expose) {
+                registerExpose(appName, res.expose.getConfigs());
+            }
             App.on();
             try {
                 if (app?.onMounted) {

package/lib/app/store.d.ts

@@ -1,5 +1,5 @@
 import { SinglyLinkedList } from './SinglyLinkedList';
-import { childrenCallbackRes, ChildrenCycle, EventCycleEnum, EventKeys, StoreMiddlewareItem, StoreResponseItem, SubscribeValue } from '../types';
+import { childrenCallbackRes, ChildrenCycle, EventCycleEnum, EventKeys, FileTreeNode, StoreMiddlewareItem, StoreResponseItem, SubscribeValue } from '../types';
 export declare class Logger {
     #private;
     constructor();
@@ -8,11 +8,11 @@ export declare class Logger {
 export declare class Core {
     constructor();
     get value(): {
-        storeState: import("..").ResponseState;
-        storeStateSubscribe: import("..").StateSubscribeMap;
-        storeSubscribeList: import("..").SubscribeKeysMap;
+        storeState: import("../types").ResponseState;
+        storeStateSubscribe: import("../types").StateSubscribeMap;
+        storeSubscribeList: import("../types").SubscribeKeysMap;
         storeChildrenApp: {
-            [key: string]: import("..").StoreChildrenApp;
+            [key: string]: import("../types").StoreChildrenApp;
         };
     };
 }
@@ -24,6 +24,14 @@ export declare class Response {
 export declare class ResponseMiddleware {
     find(name: string, stateKey: string): StoreResponseItem[];
 }
+export declare class MiddlewareTree {
+    #private;
+    get value(): FileTreeNode;
+}
+export declare class ResponseTree {
+    #private;
+    get value(): FileTreeNode;
+}
 export declare class ResponseRouter {
     #private;
     get value(): any[];
@@ -67,16 +75,16 @@ export declare class ChildrenApp {
     pushCycle(data: ChildrenCycle): void;
     on(): void;
     un(): void;
-    get value(): import("..").StoreChildrenApp;
+    get value(): import("../types").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;
+    storeState: import("../types").ResponseState;
+    storeStateSubscribe: import("../types").StateSubscribeMap;
+    storeSubscribeList: import("../types").SubscribeKeysMap;
     storeChildrenApp: {
-        [key: string]: import("..").StoreChildrenApp;
+        [key: string]: import("../types").StoreChildrenApp;
     };
 };

package/lib/app/store.js

@@ -1,6 +1,7 @@
 import { SinglyLinkedList } from './SinglyLinkedList.js';
 import { mkdirSync } from 'node:fs';
 import log4js from 'log4js';
+import { disposeExpose } from './expose.js';
 
 const createLogger = () => {
     if (process.env.BROWSER_ENV === 'browser') {
@@ -157,6 +158,96 @@ class ResponseMiddleware {
         return mr;
     }
 }
+function createTreeNode() {
+    return { files: [], children: new Map() };
+}
+function buildFileTree(files, middlewareResponse) {
+    const root = createTreeNode();
+    for (const file of files) {
+        if (!file.stateKey) {
+            root.files.push(file);
+            continue;
+        }
+        const parts = file.stateKey.split(':');
+        let node = root;
+        for (const part of parts) {
+            if (!node.children.has(part)) {
+                node.children.set(part, createTreeNode());
+            }
+            node = node.children.get(part);
+        }
+        node.files.push(file);
+    }
+    if (middlewareResponse) {
+        for (const [key, mw] of Object.entries(middlewareResponse)) {
+            const parts = key.split(':');
+            let node = root;
+            for (const part of parts) {
+                if (!node.children.has(part)) {
+                    node.children.set(part, createTreeNode());
+                }
+                node = node.children.get(part);
+            }
+            node.middleware = mw;
+        }
+    }
+    return root;
+}
+function mergeFileTree(target, source) {
+    target.files.push(...source.files);
+    if (source.middleware) {
+        if (!target.middleware) {
+            target.middleware = source.middleware;
+        }
+        else {
+            console.warn(`[mergeFileTree] middleware conflict at same stateKey, keeping first (${target.middleware.path}), discarding (${source.middleware.path})`);
+        }
+    }
+    for (const [key, child] of source.children) {
+        if (target.children.has(key)) {
+            mergeFileTree(target.children.get(key), child);
+        }
+        else {
+            target.children.set(key, child);
+        }
+    }
+}
+class MiddlewareTree {
+    #cache = null;
+    #cacheVersion = -1;
+    get value() {
+        if (this.#cacheVersion === _storeVersion && this.#cache !== null) {
+            return this.#cache;
+        }
+        const root = createTreeNode();
+        for (const appKey of Object.keys(alemonjsCore.storeChildrenApp)) {
+            const app = alemonjsCore.storeChildrenApp[appKey];
+            const subTree = buildFileTree(app.middleware ?? [], undefined);
+            mergeFileTree(root, subTree);
+        }
+        this.#cache = root;
+        this.#cacheVersion = _storeVersion;
+        return this.#cache;
+    }
+}
+class ResponseTree {
+    #cache = null;
+    #cacheVersion = -1;
+    get value() {
+        if (this.#cacheVersion === _storeVersion && this.#cache !== null) {
+            return this.#cache;
+        }
+        const root = createTreeNode();
+        for (const appKey of Object.keys(alemonjsCore.storeChildrenApp)) {
+            const app = alemonjsCore.storeChildrenApp[appKey];
+            const subTree = buildFileTree(app.response ?? [], app.middlewareResponse);
+            mergeFileTree(root, subTree);
+        }
+        this.#cache = root;
+        this.#cacheVersion = _storeVersion;
+        return this.#cache;
+    }
+}
 class ResponseRouter {
     #cache = null;
     #cacheVersion = -1;
@@ -334,6 +425,7 @@ class ChildrenApp {
         bumpStoreVersion();
     }
     un() {
+        disposeExpose(this.#name);
         delete alemonjsCore.storeChildrenApp[this.#name];
         bumpStoreVersion();
     }
@@ -357,4 +449,4 @@ process?.on?.('exit', code => {
     logger.info?.(`[alemonjs][exit] 进程退出，code=${code}`);
 });
 
-export { ChildrenApp, Core, Logger, Middleware, MiddlewareRouter, ProcessorEventAutoClearMap, ProcessorEventUserAutoClearMap, Response, ResponseMiddleware, ResponseRouter, State, StateSubscribe, SubscribeList, bumpStoreVersion, core, getSubscribeList, logger };
+export { ChildrenApp, Core, Logger, Middleware, MiddlewareRouter, MiddlewareTree, ProcessorEventAutoClearMap, ProcessorEventUserAutoClearMap, Response, ResponseMiddleware, ResponseRouter, ResponseTree, State, StateSubscribe, SubscribeList, bumpStoreVersion, core, getSubscribeList, logger };

package/lib/cbp/connects/client.js

@@ -14,10 +14,10 @@ import { onProcessor } from '../../app/event-processor.js';
 import '../../app/event-response.js';
 import { createResult } from '../../core/utils.js';
 import '../../app/hook-event-context.js';
-import '../../app/event-utils.js';
 import { apiResolves, apiTimeouts, actionResolves, actionTimeouts, FULL_RECEIVE_HEADER } from '../processor/config.js';
 import { setDirectSend } from '../processor/transport.js';
 import '../../app/message-format-old.js';
+import '../../app/event-utils.js';
 import '../../app/message-api.js';
 import { createWSConnector } from './base.js';
 import { createDirectServer } from '../../process/direct-channel.js';

package/lib/cbp/routers/hello.html.js

@@ -21,8 +21,8 @@ class App extends Component {
       }
       a { color: #0099cc; }
     `;
-        const head = Head(null, Title('欢迎使用 AlemonJS！'), Style(style));
-        const body = Body(null, H1('AlemonJS 启动成功！'), P(null, '已成功通过 ', A({ href: 'https://alemonjs.com', target: '_blank' }, 'AlemonJS 框架'), ' 启动。'), Div({ className: 'footer' }, '— 感谢选择 AlemonJS。'));
+        const head = Head(null, Title('欢迎使用 ALemonJS！'), Style(style));
+        const body = Body(null, H1('ALemonJS 启动成功！'), P(null, '已成功通过 ', A({ href: 'https://alemonjs.com', target: '_blank' }, 'ALemonJS 框架'), ' 启动。'), Div({ className: 'footer' }, '— 感谢选择 ALemonJS。'));
         return Html(null, head, body);
     }
 }

package/lib/client.js

@@ -27,8 +27,8 @@ import './app/event-middleware.js';
 import './app/event-processor.js';
 import './app/event-response.js';
 import './app/hook-event-context.js';
-import './app/event-utils.js';
 import './app/message-format-old.js';
+import './app/event-utils.js';
 import './app/message-api.js';
 import './process/platform.js';
 import './process/module.js';

package/lib/index.js

@@ -5,14 +5,15 @@ export { createEventName, createHash, createResult, createUserHashKey, fastHash,
 export { cbpClient } from './cbp/connects/client.js';
 export { cbpPlatform } from './cbp/connects/platform.js';
 export { cbpServer } from './cbp/server/main.js';
-export { ChildrenApp, Core, Logger, Middleware, MiddlewareRouter, ProcessorEventAutoClearMap, ProcessorEventUserAutoClearMap, Response, ResponseMiddleware, ResponseRouter, State, StateSubscribe, SubscribeList, bumpStoreVersion, core, getSubscribeList, logger } from './app/store.js';
+export { ChildrenApp, Core, Logger, Middleware, MiddlewareRouter, MiddlewareTree, ProcessorEventAutoClearMap, ProcessorEventUserAutoClearMap, Response, ResponseMiddleware, ResponseRouter, ResponseTree, State, StateSubscribe, SubscribeList, bumpStoreVersion, core, getSubscribeList, logger } from './app/store.js';
+export { Expose, clearAllExpose, disposeExpose, registerExpose } from './app/expose.js';
 export { loadModels, run } from './app/load_modules/load.js';
 export { loadChildren, loadChildrenFile } from './app/load_modules/loadChild.js';
 export { defineChildren } from './app/define-children.js';
 export { definePlatform } from './app/define-platform.js';
 export { defineResponse } from './app/define-response.js';
 export { defineMiddleware } from './app/define-middleware.js';
-export { defineRouter, lazy } from './app/define-router.js';
+export { defineRouter, lazy, runHandler } from './app/define-router.js';
 export { FormatEvent, wrapEvent } from './app/event-format.js';
 export { onGroup } from './app/event-group.js';
 export { OnMiddleware, onMiddleware } from './app/event-middleware.js';

package/lib/server/routers/hello.html.js

@@ -21,8 +21,8 @@ class App extends Component {
       }
       a { color: #0099cc; }
     `;
-        const head = Head(null, Title('欢迎使用 AlemonJS！'), Style(style));
-        const body = Body(null, H1('AlemonJS 启动成功！'), P(null, '已成功通过 ', A({ href: 'https://alemonjs.com', target: '_blank' }, 'AlemonJS 框架'), ' 启动。'), P(null, '如果想访问主应用，请访问， ', A({ href: '/app', target: '_blank' }, '/app'), '（对应根目录index.html）'), P(null, '如果想访问其他应用，请访问 ', A({ href: '/apps/[package-name]', target: '_blank' }, '/apps/[package-name]'), '。(对应/packages/[package-name]/index.html)'), Div({ className: 'footer' }, '— 感谢选择 AlemonJS。'));
+        const head = Head(null, Title('欢迎使用 ALemonJS！'), Style(style));
+        const body = Body(null, H1('ALemonJS 启动成功！'), P(null, '已成功通过 ', A({ href: 'https://alemonjs.com', target: '_blank' }, 'ALemonJS 框架'), ' 启动。'), P(null, '如果想访问主应用，请访问， ', A({ href: '/app', target: '_blank' }, '/app'), '（对应根目录index.html）'), P(null, '如果想访问其他应用，请访问 ', A({ href: '/apps/[package-name]', target: '_blank' }, '/apps/[package-name]'), '。(对应/packages/[package-name]/index.html)'), Div({ className: 'footer' }, '— 感谢选择 ALemonJS。'));
         return Html(null, head, body);
     }
 }

package/lib/types/event/index.d.ts

@@ -2,6 +2,7 @@ import { ChildrenCycle, Next } from '../cycle';
 import { ClientAPI } from '../client';
 import { EventKeys, Events } from './map';
 import { DataEnums } from '../message';
+import { Expose } from '../../app/expose';
 export type Current<T extends EventKeys> = (event: Events[T], next: Next) => Promise<boolean | void | undefined> | boolean | void | undefined;
 export type OnResponseValue<C, T extends EventKeys> = {
     current: C;
@@ -54,6 +55,7 @@ export type childrenCallbackRes = {
     middleware?: ReturnType<defineMiddlewareFunc>;
     responseRouter?: ReturnType<DefineRouterFunc>;
     middlewareRouter?: ReturnType<DefineRouterFunc>;
+    expose?: Expose;
 } | undefined;
 export type childrenCallback = ChildrenCycle & {
     register?: () => (childrenCallbackRes | undefined) | Promise<childrenCallbackRes | undefined>;

package/lib/types/expose/index.d.ts

@@ -0,0 +1,41 @@
+export interface ExposeActionMeta {
+    description: string;
+    params?: Record<string, string>;
+    returns?: Record<string, string>;
+    handler: (...args: any[]) => any;
+}
+export interface ExposeProvideConfig {
+    name: string;
+    description: string;
+    actions: Record<string, ExposeActionMeta>;
+}
+export interface ExposeListItem {
+    name: string;
+    protocol: string;
+    description: string;
+    actions: Record<string, {
+        description: string;
+        params?: Record<string, string>;
+        returns?: Record<string, string>;
+    }>;
+    invoke: (action: string, value?: any) => any;
+}
+export interface ExposeWatchEvent {
+    name: string;
+    protocol: string;
+    action: string;
+    value?: any;
+}
+export interface ExposeSchemaItem {
+    protocol: string;
+    description: string;
+    providers: {
+        name: string;
+    }[];
+    actions: Record<string, {
+        description: string;
+        params?: Record<string, string>;
+        returns?: Record<string, string>;
+    }>;
+    invoke: string;
+}

package/lib/types/expose/index.js

@@ -0,0 +1 @@
+

package/lib/types/index.d.ts

@@ -23,6 +23,7 @@ export * from './message/index';
 export * from './package/index';
 export * from './state/index';
 export * from './store/res';
+export * from './expose/index';
 export * from './subscribe';
 export * from './standard';
 export * from './actions';

package/lib/types/store/res.d.ts

@@ -23,6 +23,11 @@ export type StoreMiddlewareItem = {
         select: string;
     } | null;
 };
+export type FileTreeNode = {
+    middleware?: StoreResponseItem;
+    files: StoreResponseItem[];
+    children: Map<string, FileTreeNode>;
+};
 export type StoreMiddleware = {
     [key in EventKeys]: StoreResponseItem[];
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "alemonjs",
-  "version": "2.1.52",
+  "version": "2.1.54",
   "description": "bot script",
   "author": "lemonade",
   "license": "MIT",
@@ -69,5 +69,5 @@
     "type": "git",
     "url": "https://github.com/lemonade-lab/alemonjs.git"
   },
-  "gitHead": "90cafaf98cefa01152764922f58e543f0c513811"
-}
+  "gitHead": "c6aa5616afe091a37610dad22fbb2d2618d943b8"
+}

package/LICENSE

@@ -1,21 +0,0 @@
-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.