alemonjs 2.1.53 → 2.1.54

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.js

@@ -121,9 +121,7 @@ const createFileTreeStep = (valueEvent, select, next, root, callHandler) => {
             void processContent(node, done);
         }, app => {
             matched = true;
-            const items = Array.isArray(app.default.current)
-                ? app.default.current
-                : [app.default.current];
+            const items = Array.isArray(app.default.current) ? app.default.current : [app.default.current];
             mwCurrents.push(...items);
         });
         if (matched) {
@@ -168,9 +166,7 @@ const createFileTreeStep = (valueEvent, select, next, root, callHandler) => {
         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];
+            const fileCurrents = Array.isArray(app.default.current) ? app.default.current : [app.default.current];
             callHandler(fileCurrents, (cn, ...cns) => {
                 if (cn) {
                     treeDone(true, ...cns);

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, 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

@@ -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;
         };
     };
 }
@@ -75,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') {
@@ -424,6 +425,7 @@ class ChildrenApp {
         bumpStoreVersion();
     }
     un() {
+        disposeExpose(this.#name);
         delete alemonjsCore.storeChildrenApp[this.#name];
         bumpStoreVersion();
     }

package/lib/index.js

@@ -6,13 +6,14 @@ 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, 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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "alemonjs",
-  "version": "2.1.53",
+  "version": "2.1.54",
   "description": "bot script",
   "author": "lemonade",
   "license": "MIT",