wenay-common 1.0.243 → 1.0.245

package/lib/Common/Listen.d.ts

@@ -1,46 +1,55 @@
 export type Listener<T extends any[]> = (...r: T) => void;
 type NormalizeTuple<T> = T extends any[] ? T : [T];
 export declare function funcListenCallbackBase<T>(b: (e: Listener<NormalizeTuple<T>>) => (void | (() => void)), data?: {
-    event?: (type: "add" | "remove", count: number, api: ReturnType<typeof funcListenCallbackBase<any>>) => void;
+    event?: (type: "add" | "remove", count: number, api: ReturnType<typeof funcListenCallbackBase<T>>) => void;
     fast?: boolean;
 }): {
     func: Listener<NormalizeTuple<T>>;
     isRun: () => boolean;
     run: () => void;
     close: () => void;
-    addListen: (cb: Listener<NormalizeTuple<T>>) => () => void;
+    eventClose: (cb: () => void) => () => void;
+    removeEventClose: (cb: () => void) => void;
+    addListen: (cb: Listener<NormalizeTuple<T>>, cbClose?: () => void) => () => void;
     removeListen: (cb: Listener<NormalizeTuple<T>> | null) => void;
     count: () => number;
     readonly getAllKeys: Listener<NormalizeTuple<T>>[];
 };
-export declare function funcListenCallback<T>(a: (e: (Listener<NormalizeTuple<T>> | null)) => (void | (() => void)), event?: (type: "add" | "remove", count: number, api: ReturnType<typeof funcListenCallbackBase<T>>) => void, fast?: boolean): {
+export declare function funcListenCallbackFast<T>(a: (e: (Listener<NormalizeTuple<T>> | null)) => (void | (() => void))): {
     func: Listener<NormalizeTuple<T>>;
     isRun: () => boolean;
     run: () => void;
     close: () => void;
-    addListen: (cb: Listener<NormalizeTuple<T>>) => () => void;
+    eventClose: (cb: () => void) => () => void;
+    removeEventClose: (cb: () => void) => void;
+    addListen: (cb: Listener<NormalizeTuple<T>>, cbClose?: (() => void) | undefined) => () => void;
     removeListen: (cb: Listener<NormalizeTuple<T>> | null) => void;
     count: () => number;
     readonly getAllKeys: Listener<NormalizeTuple<T_1>>[];
 };
-export declare function funcListenCallbackFast<T>(a: (e: (Listener<NormalizeTuple<T>> | null)) => (void | (() => void))): {
+export declare function funcListenCallback<T>(a: (e: (Listener<NormalizeTuple<T>> | null)) => (void | (() => void)), event?: (type: "add" | "remove", count: number, api: ReturnType<typeof funcListenCallbackBase<T>>) => void, fast?: boolean): {
     func: Listener<NormalizeTuple<T>>;
     isRun: () => boolean;
     run: () => void;
     close: () => void;
-    addListen: (cb: Listener<NormalizeTuple<T>>) => () => void;
+    eventClose: (cb: () => void) => () => void;
+    removeEventClose: (cb: () => void) => void;
+    addListen: (cb: Listener<NormalizeTuple<T>>, cbClose?: (() => void) | undefined) => () => void;
     removeListen: (cb: Listener<NormalizeTuple<T>> | null) => void;
     count: () => number;
     readonly getAllKeys: Listener<NormalizeTuple<T_1>>[];
 };
-export declare function UseListen<T>(data?: Parameters<typeof funcListenCallbackBase>[1]): readonly [(...a: NormalizeTuple<T>) => void, {
+export declare function UseListen<T>(data?: Parameters<typeof funcListenCallbackBase<T>>[1]): readonly [(...a: NormalizeTuple<T>) => void, {
     func: Listener<NormalizeTuple<T>>;
     isRun: () => boolean;
     run: () => void;
     close: () => void;
-    addListen: (cb: Listener<NormalizeTuple<T>>) => () => void;
+    eventClose: (cb: () => void) => () => void;
+    removeEventClose: (cb: () => void) => void;
+    addListen: (cb: Listener<NormalizeTuple<T>>, cbClose?: (() => void) | undefined) => () => void;
     removeListen: (cb: Listener<NormalizeTuple<T>> | null) => void;
     count: () => number;
     readonly getAllKeys: Listener<NormalizeTuple<T_1>>[];
 }];
+export declare function isListenCallback(obj: any): obj is ReturnType<typeof funcListenCallbackBase>;
 export {};

package/lib/Common/Listen.js

@@ -1,12 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.funcListenCallbackBase = funcListenCallbackBase;
-exports.funcListenCallback = funcListenCallback;
 exports.funcListenCallbackFast = funcListenCallbackFast;
+exports.funcListenCallback = funcListenCallback;
 exports.UseListen = UseListen;
+exports.isListenCallback = isListenCallback;
 function funcListenCallbackBase(b, data) {
-    const { fast = false, event } = data ?? {};
+    const { fast = true, event } = data ?? {};
     const obj = new Map();
+    const evClose = new Map();
+    const sinh = new Map();
     let a = (...e) => { obj.forEach(z => z(...e)); };
     let close = null;
     let cached = null;
@@ -42,9 +45,38 @@ function funcListenCallbackBase(b, data) {
         close: () => {
             close?.();
             close = null;
+            obj.clear();
+            if (fast)
+                rebuild();
+            sinh.clear();
+            evClose.forEach(cb => cb());
+            evClose.clear();
         },
-        addListen: (cb) => {
+        eventClose: (cb) => {
+            evClose.set(cb, cb);
+            return () => { evClose.delete(cb); };
+        },
+        removeEventClose: (cb) => {
+            const e = sinh.get(cb);
+            if (e)
+                evClose.delete(e);
+            sinh.delete(cb);
+            evClose.delete(cb);
+        },
+        addListen: (cb, cbClose) => {
             obj.set(cb, cb);
+            if (cbClose) {
+                if (evClose.has(cb)) {
+                    const r = evClose.get(cb);
+                    if (r !== cbClose) {
+                        evClose.delete(r);
+                        evClose.delete(cb);
+                        sinh.delete(r);
+                    }
+                }
+                evClose.set(cb, cbClose);
+                sinh.set(cbClose, cb);
+            }
             if (fast)
                 rebuild();
             event?.("add", obj.size, api);
@@ -52,8 +84,14 @@ function funcListenCallbackBase(b, data) {
         },
         removeListen: (cb) => {
             obj.delete(cb);
+            const e = evClose.get(cb);
             if (fast)
                 rebuild();
+            evClose.delete(cb);
+            if (e) {
+                evClose.delete(e);
+                sinh.delete(e);
+            }
             event?.("remove", obj.size, api);
         },
         count: () => obj.size,
@@ -61,12 +99,12 @@ function funcListenCallbackBase(b, data) {
     };
     return api;
 }
-function funcListenCallback(a, event, fast = true) {
-    return funcListenCallbackBase(a, { event, fast });
-}
 function funcListenCallbackFast(a) {
     return funcListenCallbackBase(a, { fast: true });
 }
+function funcListenCallback(a, event, fast = true) {
+    return funcListenCallbackBase(a, { event, fast });
+}
 function UseListen(data = { fast: true }) {
     let t;
     const a = funcListenCallbackBase((e) => { t = e; }, { fast: true, ...data });
@@ -74,3 +112,18 @@ function UseListen(data = { fast: true }) {
     t = a.func;
     return [t, a];
 }
+function isListenCallback(obj) {
+    if (obj == null || typeof obj !== "object")
+        return false;
+    const obj2 = obj;
+    return (typeof obj2.addListen === "function" &&
+        typeof obj2.removeListen === "function" &&
+        typeof obj2.eventClose === "function" &&
+        typeof obj2.func === "function" &&
+        typeof obj2.count === "function");
+}
+function f() {
+    const [set, out] = UseListen();
+    out.addListen(e => {
+    });
+}

package/lib/Common/ListenBySocket.js

@@ -28,7 +28,7 @@ function isLeafValue(value) {
 }
 function funcListenBySocket2(e, d) {
     const { stop, addListenClose, status, paramsModify } = d ?? {};
-    const { addListen, removeListen } = e;
+    const { addListen, removeListen, eventClose } = e;
     let last = null;
     let active = null;
     function removeCallback() {

package/lib/Common/ListenBySocket2.d.ts

@@ -0,0 +1,39 @@
+import { funcListenCallback, funcListenCallbackBase, Listener } from "./Listen";
+type ListenCallbackResult<T extends any[] = any[]> = ReturnType<typeof funcListenCallback<T>>;
+export declare function listenSocket<Z extends any[] = any[]>(e: ListenCallbackResult<Z>, d?: {
+    readonly status?: () => boolean;
+    readonly addListenClose?: ListenCallbackResult<any>;
+    readonly stop?: (x: Listener<Z>) => any;
+    readonly paramsModify?: (...e: Z) => any[];
+}): {
+    callback: (z: Listener<Z>) => Promise<void>;
+    removeCallback: () => boolean;
+};
+export declare function listenSocketFirst<Z extends any[] = any[]>(e: ListenCallbackResult<Z>, options?: Omit<Parameters<typeof listenSocket>[1], "paramsModify">): {
+    callback: (z: (a: Z[0]) => void) => void;
+    removeCallback: () => boolean;
+};
+export declare function listenSocketAll<Z extends any[] = any[]>(e: ListenCallbackResult<Z>, options?: Omit<Parameters<typeof listenSocket>[1], "paramsModify">): {
+    callback: (z: (...args: Z) => void) => void;
+    removeCallback: () => boolean;
+};
+type SmartCallback<Z extends any[]> = Z extends [infer Single] ? (a: Single) => void : (...args: Z) => void;
+export declare function listenSocketSmart<Z extends any[] = any[]>(e: ListenCallbackResult<Z>, options?: Omit<Parameters<typeof listenSocket>[1], "paramsModify">): {
+    callback: (z: SmartCallback<Z>) => void;
+    removeCallback: () => boolean;
+};
+type Obj = Record<string, any>;
+export declare function matchKeys<T extends Obj, T2 extends Obj>(obj1: T, obj2: T2): boolean;
+export declare function matchKeysList<T extends Obj>(obj1: T, keys: string[]): boolean;
+export declare function deepMapByKeysList<T, T3>(obj1: T, keys: string[], func: (a: any) => T3): T | T3 | null;
+type ListenBase<T extends any[]> = ReturnType<typeof funcListenCallbackBase<T>>;
+type InferArgs<T> = T extends ListenBase<infer R> ? R : never;
+type SocketResult<T extends any[]> = ReturnType<typeof listenSocket<T>>;
+export type DeepSocketListen<T> = {
+    [K in keyof T]: T[K] extends ListenBase<any> ? SocketResult<InferArgs<T[K]>> : T[K] extends typeof Promise ? T[K] : T[K] extends (...a: any) => any ? T[K] : T[K] extends object ? DeepSocketListen<T[K]> : T[K];
+};
+export declare function deepMapByKeys<T, T2 extends Obj, T3>(obj1: T, obj2: T2, func: (a: T2) => T3): T3 | T | null;
+export declare function deepListenFirst<T>(obj: T, data?: Parameters<typeof listenSocketFirst>[1]): DeepSocketListen<T>;
+export declare function deepListenAll<T>(obj: T, data?: Parameters<typeof listenSocketAll>[1]): DeepSocketListen<T>;
+export declare function deepListenSmart<T>(obj: T, data?: Parameters<typeof listenSocketSmart>[1]): DeepSocketListen<T>;
+export {};

package/lib/Common/ListenBySocket2.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listenSocket = listenSocket;
+exports.listenSocketFirst = listenSocketFirst;
+exports.listenSocketAll = listenSocketAll;
+exports.listenSocketSmart = listenSocketSmart;
+exports.matchKeys = matchKeys;
+exports.matchKeysList = matchKeysList;
+exports.deepMapByKeysList = deepMapByKeysList;
+exports.deepMapByKeys = deepMapByKeys;
+exports.deepListenFirst = deepListenFirst;
+exports.deepListenAll = deepListenAll;
+exports.deepListenSmart = deepListenSmart;
+const isProxy_1 = require("./isProxy");
+const Listen_1 = require("./Listen");
+function isLeafValue(value) {
+    return (value == null ||
+        typeof value === "function" ||
+        value instanceof Function ||
+        typeof value !== "object" ||
+        (0, isProxy_1.isProxy)(value));
+}
+function listenSocket(e, d) {
+    const { stop, addListenClose, status, paramsModify } = d ?? {};
+    const { addListen, removeListen, eventClose, removeEventClose } = e;
+    let last = null;
+    let active = null;
+    let resolveWait = null;
+    function finish() {
+        if (resolveWait) {
+            resolveWait();
+            resolveWait = null;
+        }
+    }
+    function removeCallback() {
+        if (last) {
+            stop?.(last);
+            last = null;
+        }
+        if (active) {
+            removeListen(active);
+            active = null;
+        }
+        addListenClose?.removeListen(removeCallback);
+        finish();
+        return true;
+    }
+    async function callback(z) {
+        if (last)
+            stop?.(last);
+        if (active) {
+            removeListen(active);
+        }
+        if (resolveWait) {
+            resolveWait();
+            resolveWait = null;
+        }
+        last = z;
+        let handler = z;
+        if (paramsModify) {
+            const orig = handler;
+            handler = (...a) => orig(...paramsModify(...a));
+        }
+        if (status) {
+            const wrapped = handler;
+            handler = (...a) => {
+                if (status())
+                    wrapped(...a);
+                else
+                    removeCallback();
+            };
+        }
+        const inner = handler;
+        active = (...a) => {
+            if (a[0] === "___STOP") {
+                z(...a);
+                if (last) {
+                    stop?.(last);
+                }
+                last = null;
+                if (active) {
+                    removeListen(active);
+                    active = null;
+                }
+                addListenClose?.removeListen(removeCallback);
+                finish();
+                return;
+            }
+            inner(...a);
+        };
+        addListen(active, removeCallback);
+        addListenClose?.addListen(removeCallback);
+        return new Promise((resolve) => {
+            resolveWait = () => { resolve(); };
+        });
+    }
+    return { callback, removeCallback };
+}
+function listenSocketFirst(e, options) {
+    const r = listenSocket(e, {
+        ...options,
+        paramsModify: ((...args) => [args[0]]),
+    });
+    return {
+        callback: r.callback,
+        removeCallback: r.removeCallback,
+    };
+}
+function listenSocketAll(e, options) {
+    const r = listenSocket(e, { ...options });
+    return {
+        callback: r.callback,
+        removeCallback: r.removeCallback,
+    };
+}
+function listenSocketSmart(e, options) {
+    const r = listenSocket(e, { ...options });
+    return {
+        callback: r.callback,
+        removeCallback: r.removeCallback,
+    };
+}
+function matchKeys(obj1, obj2) {
+    return matchKeysList(obj1, Object.keys(obj2));
+}
+function matchKeysList(obj1, keys) {
+    const k1 = Object.keys(obj1);
+    return k1.length === keys.length && new Set([...k1, ...keys]).size === keys.length;
+}
+function deepMapByKeysList(obj1, keys, func) {
+    if (isLeafValue(obj1))
+        return obj1;
+    if (matchKeysList(obj1, keys))
+        return func(obj1);
+    return Object.fromEntries(Object.entries(obj1).map(([k, v]) => [k, deepMapByKeysList(v, keys, func)]));
+}
+function deepMapByKeys(obj1, obj2, func) {
+    if (isLeafValue(obj1))
+        return obj1;
+    const keys = Object.keys(obj2);
+    if (matchKeysList(obj1, keys))
+        return func(obj1);
+    return Object.fromEntries(Object.entries(obj1).map(([k, v]) => [k, deepMapByKeysList(v, keys, func)]));
+}
+const NOOP_LISTEN = (0, Listen_1.funcListenCallbackBase)((_e) => { });
+function deepListenFirst(obj, data) {
+    return deepMapByKeys(obj, NOOP_LISTEN, (e) => listenSocketFirst(e, data));
+}
+function deepListenAll(obj, data) {
+    return deepMapByKeys(obj, NOOP_LISTEN, (e) => listenSocketAll(e, data));
+}
+function deepListenSmart(obj, data) {
+    return deepMapByKeys(obj, NOOP_LISTEN, (e) => listenSocketSmart(e, data));
+}

package/lib/Common/SocketBuffer.d.ts

@@ -18,7 +18,7 @@ export declare function funcListenCallbackSnapshot<T extends realSocket2<any | a
     memo: T4;
     snapshot?: (memo: T4) => T3;
 }): {
-    run: (cb: import("./Listen").Listener<[data: getTypeCallback<T>, memo: T3]>) => () => void;
+    run: (cb: import("./Listen").Listener<[data: getTypeCallback<T>, memo: T3]>, cbClose?: (() => void) | undefined) => () => void;
     snapshot: () => T3 | undefined;
     memo: T4;
     listenA: {
@@ -26,7 +26,9 @@ export declare function funcListenCallbackSnapshot<T extends realSocket2<any | a
         isRun: () => boolean;
         run: () => void;
         close: () => void;
-        addListen: (cb: import("./Listen").Listener<[data: getTypeCallback<T>, memo: T3]>) => () => void;
+        eventClose: (cb: () => void) => () => void;
+        removeEventClose: (cb: () => void) => void;
+        addListen: (cb: import("./Listen").Listener<[data: getTypeCallback<T>, memo: T3]>, cbClose?: (() => void) | undefined) => () => void;
         removeListen: (cb: import("./Listen").Listener<[data: getTypeCallback<T>, memo: T3]> | null) => void;
         count: () => number;
         readonly getAllKeys: import("./Listen").Listener<T_1 extends any[] ? T_1 : [T_1]>[];

package/lib/Common/SocketServerHook.d.ts

@@ -9,7 +9,9 @@ export declare function SocketServerHook(opt?: {
             isRun: () => boolean;
             run: () => void;
             close: () => void;
-            addListen: (cb: import("./Listen").Listener<[unknown]>) => () => void;
+            eventClose: (cb: () => void) => () => void;
+            removeEventClose: (cb: () => void) => void;
+            addListen: (cb: import("./Listen").Listener<[unknown]>, cbClose?: (() => void) | undefined) => () => void;
             removeListen: (cb: import("./Listen").Listener<[unknown]> | null) => void;
             count: () => number;
             readonly getAllKeys: import("./Listen").Listener<T extends any[] ? T : [T]>[];
@@ -20,7 +22,9 @@ export declare function SocketServerHook(opt?: {
         isRun: () => boolean;
         run: () => void;
         close: () => void;
-        addListen: (cb: import("./Listen").Listener<[unknown]>) => () => void;
+        eventClose: (cb: () => void) => () => void;
+        removeEventClose: (cb: () => void) => void;
+        addListen: (cb: import("./Listen").Listener<[unknown]>, cbClose?: (() => void) | undefined) => () => void;
         removeListen: (cb: import("./Listen").Listener<[unknown]> | null) => void;
         count: () => number;
         readonly getAllKeys: import("./Listen").Listener<T extends any[] ? T : [T]>[];

package/lib/Common/commonsServerMini2.d.ts

@@ -1,4 +1,13 @@
-type Socket = {
+export type RpcLimits = {
+    maxDepth?: number;
+    maxKeys?: number;
+    maxArgs?: number;
+    maxArrayLen?: number;
+    maxStringLen?: number;
+    maxCallbacks?: number;
+    maxPathLen?: number;
+};
+export type SocketTmpl = {
     emit: (e: string, d: any) => void;
     on: (e: string, cb: (d: any) => void) => void;
 };
@@ -21,6 +30,7 @@ type PromiseServerHooks<T> = {
         request?: any;
         error?: any;
     }) => void | Promise<void>;
+    resolveTransform?: (value: any, key: string, parent: any) => any;
 };
 type UnwrapPromise<T> = T extends Promise<infer R> ? R : T;
 type ClientAPI<T> = {
@@ -36,15 +46,16 @@ type ClientApiHandle = {
     callbackDelete: (fn: Function) => void;
     callbackEnd: (fn: Function) => void;
 };
-declare function createAPIFacadeServer<T extends object>({ socket, object: target, socketKey: key, debug, hooks }: {
-    socket: Socket;
+declare function createAPIFacadeServer<T extends object>({ socket, object: target, socketKey: key, debug, hooks, limits }: {
+    socket: SocketTmpl;
     object: T;
     socketKey: string;
     debug?: boolean;
     hooks?: PromiseServerHooks<T>;
+    limits?: RpcLimits;
 }): void;
 declare function createAPIFacadeClient<T extends object>({ socket, socketKey: key, limit }: {
-    socket: Socket;
+    socket: SocketTmpl;
     socketKey: string;
     limit?: number;
 }): {

package/lib/Common/commonsServerMini2.js

@@ -9,6 +9,22 @@ const FN_MARKER = "$_f";
 const BANNED_KEYS = new Set(["__proto__", "constructor", "prototype"]);
 const isSafeKey = (k) => !BANNED_KEYS.has(k);
 const hasOwn = (obj, k) => Object.prototype.hasOwnProperty.call(obj, k);
+const DEFAULT_LIMITS = {
+    maxDepth: 32,
+    maxKeys: 1000,
+    maxArgs: 64,
+    maxArrayLen: 10_000,
+    maxStringLen: 1_000_000,
+    maxCallbacks: 100,
+    maxPathLen: 16,
+};
+const resolveLimits = (opts) => opts ? { ...DEFAULT_LIMITS, ...opts } : DEFAULT_LIMITS;
+class PayloadLimitError extends Error {
+    constructor(reason) {
+        super(`Payload limit exceeded: ${reason}`);
+        this.name = "PayloadLimitError";
+    }
+}
 const createIdPool = () => {
     const s = [];
     let n = 0;
@@ -18,17 +34,29 @@ const createIdPool = () => {
     };
 };
 exports.createIdPool = createIdPool;
-function walk(val, onLeaf) {
+function walk(val, onLeaf, lim, depth = 0) {
+    if (lim) {
+        if (depth > lim.maxDepth)
+            throw new PayloadLimitError("max depth exceeded");
+        if (typeof val === "string" && val.length > lim.maxStringLen)
+            throw new PayloadLimitError("string too long");
+    }
     if (val == null || typeof val !== "object")
         return onLeaf(val);
     if (val[FN_MARKER] !== undefined)
         return onLeaf(val);
-    if (Array.isArray(val))
-        return val.map(v => walk(v, onLeaf));
+    if (Array.isArray(val)) {
+        if (lim && val.length > lim.maxArrayLen)
+            throw new PayloadLimitError("array too long");
+        return val.map(v => walk(v, onLeaf, lim, depth + 1));
+    }
+    const keys = Object.keys(val);
+    if (lim && keys.length > lim.maxKeys)
+        throw new PayloadLimitError("too many keys in object");
     const o = {};
-    for (const k of Object.keys(val))
+    for (const k of keys)
         if (isSafeKey(k))
-            o[k] = walk(val[k], onLeaf);
+            o[k] = walk(val[k], onLeaf, lim, depth + 1);
     return o;
 }
 function pack(args, pool, cbStore, cbIds) {
@@ -42,10 +70,15 @@ function pack(args, pool, cbStore, cbIds) {
         return leaf;
     }));
 }
-function unpack(args, sender, onEnd) {
+function unpack(args, sender, onEnd, lim) {
+    let cbCount = 0;
     return args.map(v => walk(v, leaf => {
         if (leaf != null && typeof leaf === "object" && leaf[FN_MARKER] !== undefined) {
+            if (lim && ++cbCount > lim.maxCallbacks)
+                throw new PayloadLimitError("too many callbacks");
             const id = leaf[FN_MARKER];
+            if (typeof id !== "number" || !Number.isFinite(id))
+                throw new PayloadLimitError("invalid callback id");
             const wrapper = (...a) => {
                 if (a[0] === "___STOP") {
                     onEnd(id);
@@ -57,7 +90,7 @@ function unpack(args, sender, onEnd) {
             return wrapper;
         }
         return leaf;
-    }));
+    }, lim));
 }
 const errToObj = (e) => e instanceof Error ? { name: e.name, message: e.message, stack: e.stack } : e;
 const _stopRegistry = new WeakMap();
@@ -72,15 +105,32 @@ const resolveCA = (path, args) => {
         return [path.slice(0, -1), args[1] ?? []];
     return [path, args];
 };
-function createServer(socket, key, target, hooks) {
+function createServer(socket, key, target, hooks, limits) {
+    const lim = resolveLimits(limits);
     const methods = [];
     const contexts = [];
     const routeMap = {};
+    function transformTree(obj) {
+        if (obj == null || typeof obj !== "object")
+            return obj;
+        const out = {};
+        for (const k of Object.keys(obj)) {
+            if (!isSafeKey(k))
+                continue;
+            let v = obj[k];
+            if (hooks?.resolveTransform)
+                v = hooks.resolveTransform(v, k, obj);
+            out[k] = typeof v === "function" ? v : v != null && typeof v === "object" ? transformTree(v) : v;
+        }
+        return out;
+    }
+    const resolved = hooks?.resolveTransform ? transformTree(target) : target;
     (function index(obj, prefix) {
         for (const k of Object.keys(obj)) {
             if (!isSafeKey(k))
                 continue;
-            const v = obj[k], path = prefix ? prefix + "." + k : k;
+            const v = obj[k];
+            const path = prefix ? prefix + "." + k : k;
             if (typeof v === "function") {
                 routeMap[path] = methods.length;
                 methods.push(v);
@@ -89,7 +139,7 @@ function createServer(socket, key, target, hooks) {
             else if (v && typeof v === "object")
                 index(v, path);
         }
-    })(target, "");
+    })(resolved, "");
     function serialize(obj) {
         const out = {};
         for (const k of Object.keys(obj)) {
@@ -100,7 +150,7 @@ function createServer(socket, key, target, hooks) {
         }
         return out;
     }
-    const strictSchema = serialize(target);
+    const strictSchema = serialize(resolved);
     const send = (d) => socket.emit(key, d);
     send([Pkt.MAP, routeMap, strictSchema]);
     socket.on(key, async (msg) => {
@@ -154,12 +204,17 @@ function createServer(socket, key, target, hooks) {
                             curr = undefined;
                             break;
                         }
+                        const parent = curr;
                         curr = curr[seg];
+                        if (hooks?.resolveTransform)
+                            curr = hooks.resolveTransform(curr, seg, parent);
                     }
                     const last = ref[ref.length - 1];
                     if (curr != null && typeof curr === "object" && hasOwn(curr, last)) {
                         ctx = curr;
                         fn = curr[last];
+                        if (hooks?.resolveTransform)
+                            fn = hooks.resolveTransform(fn, last, curr);
                     }
                 }
             }
@@ -180,7 +235,7 @@ function createServer(socket, key, target, hooks) {
                     return;
                 }
             }
-            const args = unpack(rawArgs, (cbId, cbArgs) => send([Pkt.CB, cbId, cbArgs]), (cbId) => send([Pkt.CB_END, cbId]));
+            const args = unpack(rawArgs, (cbId, cbArgs) => send([Pkt.CB, cbId, cbArgs]), (cbId) => send([Pkt.CB_END, cbId]), lim);
             const res = await fn.apply(ctx, args);
             if (wait)
                 send([Pkt.RESP, reqId, res]);
@@ -341,12 +396,12 @@ function createClient(socket, key, opts) {
         },
     };
 }
-function createAPIFacadeServer({ socket, object: target, socketKey: key, debug = false, hooks }) {
+function createAPIFacadeServer({ socket, object: target, socketKey: key, debug = false, hooks, limits }) {
     if (debug) {
         const origOn = socket.on.bind(socket);
         socket.on = (e, cb) => origOn(e, (d) => { console.log("[RPC IN]", typeof d === "object" ? JSON.stringify(d) : d); cb(d); });
     }
-    createServer(socket, key, target, hooks);
+    createServer(socket, key, target, hooks, limits);
 }
 function createAPIFacadeClient({ socket, socketKey: key, limit }) {
     return createClient(socket, key, { limit });

package/lib/Common/commonsServerMiniAuto.d.ts

@@ -0,0 +1,20 @@
+import { funcListenCallbackBase } from "./Listen";
+import { type PromiseServerHooks } from "./commonsServerMini2";
+type Socket = {
+    emit: (e: string, d: any) => void;
+    on: (e: string, cb: (d: any) => void) => void;
+};
+type ListenCallbackBase<T extends any[] = any[]> = ReturnType<typeof funcListenCallbackBase<T>>;
+type AutoClientAPI<T> = {
+    [K in keyof T]: T[K] extends ListenCallbackBase<infer Args> ? (callback: (...args: Args) => void) => void : T[K] extends (...args: infer A) => infer R ? T[K] : T[K] extends object ? AutoClientAPI<T[K]> : T[K];
+};
+export declare function CreatAPIFacadeServerAuto<T extends object>({ socket, object: target, socketKey: key, debug, hooks }: {
+    socket: Socket;
+    object: T;
+    socketKey: string;
+    debug?: boolean;
+    hooks?: PromiseServerHooks<AutoClientAPI<T>>;
+}): {
+    wrapped: AutoClientAPI<T>;
+};
+export type { AutoClientAPI };

package/lib/Common/commonsServerMiniAuto.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreatAPIFacadeServerAuto = CreatAPIFacadeServerAuto;
+const Listen_1 = require("./Listen");
+const isProxy_1 = require("./isProxy");
+const commonsServerMini2_1 = require("./commonsServerMini2");
+const listenCache = new WeakMap();
+function wrapIfListen(value) {
+    if (value == null || typeof value !== "object")
+        return value;
+    if (listenCache.has(value)) {
+        return listenCache.get(value) ?? value;
+    }
+    if ((0, Listen_1.isListenCallback)(value)) {
+        const wrapper = (callback) => {
+            value.addListen(callback, () => {
+                try {
+                    callback("___STOP");
+                }
+                catch (_) { }
+            });
+        };
+        listenCache.set(value, wrapper);
+        return wrapper;
+    }
+    listenCache.set(value, null);
+    return value;
+}
+const proxyCache = new WeakMap();
+function autoWrap(obj) {
+    if (proxyCache.has(obj))
+        return proxyCache.get(obj);
+    const proxy = new Proxy(obj, {
+        get(target, prop, receiver) {
+            const raw = Reflect.get(target, prop, receiver);
+            if (raw == null || typeof raw !== "object")
+                return raw;
+            if (typeof raw === "function")
+                return raw;
+            const converted = wrapIfListen(raw);
+            if (converted !== raw)
+                return converted;
+            if (!(0, isProxy_1.isProxy)(raw))
+                return autoWrap(raw);
+            return autoWrap(raw);
+        },
+        ownKeys(target) {
+            return Reflect.ownKeys(target);
+        },
+        getOwnPropertyDescriptor(target, prop) {
+            return Reflect.getOwnPropertyDescriptor(target, prop);
+        },
+        has(target, prop) {
+            return Reflect.has(target, prop);
+        },
+    });
+    proxyCache.set(obj, proxy);
+    return proxy;
+}
+function CreatAPIFacadeServerAuto({ socket, object: target, socketKey: key, debug, hooks }) {
+    const wrapped = autoWrap(target);
+    (0, commonsServerMini2_1.CreatAPIFacadeServer2)({
+        socket,
+        object: wrapped,
+        socketKey: key,
+        debug,
+        hooks,
+    });
+    return { wrapped };
+}

package/lib/Common/commonsServerMiniAuto2.d.ts

@@ -0,0 +1,15 @@
+import { funcListenCallbackBase } from "./Listen";
+import { DeepSocketListen } from "./ListenBySocket2";
+import { type PromiseServerHooks, type ClientAPI, SocketTmpl, type RpcLimits } from "./commonsServerMini2";
+type ListenCallbackBase<T extends any[] = any[]> = ReturnType<typeof funcListenCallbackBase<T>>;
+export declare function CreatAPIFacadeServerAuto2<T extends object>({ socket, object: target, socketKey: key, debug, hooks, disconnectListen, limits }: {
+    socket: SocketTmpl;
+    object: T;
+    socketKey: string;
+    debug?: boolean;
+    hooks?: Omit<PromiseServerHooks<DeepSocketListen<T>>, "resolveTransform">;
+    disconnectListen?: ListenCallbackBase<any>;
+    limits?: RpcLimits;
+}): void;
+export type AutoClientAPI<T> = ClientAPI<DeepSocketListen<T>>;
+export {};

package/lib/Common/commonsServerMiniAuto2.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreatAPIFacadeServerAuto2 = CreatAPIFacadeServerAuto2;
+const Listen_1 = require("./Listen");
+const ListenBySocket2_1 = require("./ListenBySocket2");
+const commonsServerMini2_1 = require("./commonsServerMini2");
+function CreatAPIFacadeServerAuto2({ socket, object: target, socketKey: key, debug, hooks, disconnectListen, limits }) {
+    const cache = new WeakMap();
+    function getListenSocket(parent, disconnectListen) {
+        let result = cache.get(parent);
+        if (!result) {
+            result = (0, ListenBySocket2_1.listenSocket)(parent, { addListenClose: disconnectListen });
+            cache.set(parent, result);
+        }
+        return result;
+    }
+    (0, commonsServerMini2_1.CreatAPIFacadeServer2)({
+        socket, object: target, socketKey: key, debug, limits,
+        hooks: {
+            ...hooks,
+            resolveTransform: (value, k, parent) => {
+                if (k !== "callback" && k !== "removeCallback")
+                    return value;
+                if (!(0, Listen_1.isListenCallback)(parent))
+                    return value;
+                return getListenSocket(parent, disconnectListen)[k];
+            },
+        },
+    });
+}

package/lib/Common/createIterableObject.d.ts

@@ -0,0 +1,6 @@
+type IterableObjectOptions<V> = {
+    resolve: () => Map<string, V>;
+    onChange?: (type: "set" | "delete", key: string, value?: V) => void;
+};
+declare function createIterableObject<V>(options: IterableObjectOptions<V>): Iterable<[string, V]> & Record<string, V>;
+declare function test2(): void;

package/lib/Common/createIterableObject.js

@@ -0,0 +1,64 @@
+"use strict";
+function createIterableObject(options) {
+    const { resolve, onChange } = options;
+    return new Proxy({}, {
+        get(_, key) {
+            if (key === Symbol.iterator)
+                return () => resolve()[Symbol.iterator]();
+            if (typeof key === "string")
+                return resolve().get(key);
+        },
+        set(_, key, value) {
+            if (!onChange || typeof key !== "string")
+                return false;
+            onChange("set", key, value);
+            return true;
+        },
+        deleteProperty(_, key) {
+            if (!onChange || typeof key !== "string")
+                return false;
+            onChange("delete", key);
+            return true;
+        },
+        has(_, key) {
+            return typeof key === "string" && resolve().has(key);
+        },
+        ownKeys() {
+            return [...resolve().keys()];
+        },
+        getOwnPropertyDescriptor(_, key) {
+            if (typeof key === "string" && resolve().has(key)) {
+                return {
+                    configurable: true,
+                    enumerable: true,
+                    writable: !!onChange,
+                    value: resolve().get(key)
+                };
+            }
+        }
+    });
+}
+function test2() {
+    const storage = new Map();
+    storage.set("a", 1);
+    const ro = createIterableObject({ resolve: () => storage });
+    for (const [k, v] of ro) {
+        console.log(ro[k], k, v);
+    }
+    const rw = createIterableObject({
+        resolve: () => storage,
+        onChange(type, key, value) {
+            if (type === "set")
+                storage.set(key, value);
+            if (type === "delete")
+                storage.delete(key);
+            console.log(`[${type}] ${key}`, value);
+        }
+    });
+    rw["b"] = 2;
+    delete rw["a"];
+    for (const [k, v] of rw) {
+        console.log(k, v);
+        rw["c"] = 3;
+    }
+}

package/lib/Common/joinListens.js

@@ -26,7 +26,7 @@ function joinListens(listens, keyExtractor) {
             const tid = getKey(data[0]);
             if (!buckets.has(tid))
                 buckets.set(tid, new Map());
-            buckets.get(tid).set(portId, data);
+            buckets.get(tid).set(portId, data.length <= 1 ? data[0] : data);
             tryFire(tid);
         });
     }

package/lib/Common/node_test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/Common/node_test.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+console.log("=== ОБЫЧНЫЙ ERROR.STACK ===");
+console.log(new Error().stack);
+console.log("=== PREPARE STACK TRACE ===");
+const originalPrepareStackTrace = Error.prepareStackTrace;
+Error.prepareStackTrace = (_, stack) => stack;
+const stack = new Error().stack;
+Error.prepareStackTrace = originalPrepareStackTrace;
+console.log("Stack frames:");
+for (let i = 0; i < Math.min(stack.length, 3); i++) {
+    const frame = stack[i];
+    console.log(`Frame[${i}]: ${frame.getFileName()}:${frame.getLineNumber()}:${frame.getColumnNumber()}`);
+}

package/lib/Exchange/CParams.d.ts

@@ -200,6 +200,7 @@ export type IParamsExpandable = {
 export type IParamsExpandableReadonly = ReadonlyFull<IParamsExpandable>;
 export declare function isParamGroupOrArray<TParam extends IParamReadonly>(param: TParam): param is Extract<TParam, ReadonlyFull<IParamGroup | IParamArr<any>>>;
 export declare function isParamGroup<TParam extends IParamReadonly>(param: TParam): param is Extract<TParam, ReadonlyFull<IParamGroup>>;
+export declare function isSimpleParams2<TParams extends IParamsReadonly>(params: TParams | SimpleParams): boolean;
 export declare function isSimpleParams<TParams extends IParamsReadonly>(params: TParams | SimpleParams): boolean;
 type ObjectKeyPath<TObject extends object = object, TValue = unknown> = readonly string[];
 export declare function iterateParams<TObj extends IParamsReadonly, TVal extends IParamReadonly = TObj[string]>(obj: TObj, currentPath?: ObjectKeyPath<TObj, TVal>): Generator<[key: string, value: TVal, path: ObjectKeyPath<TObj, TVal>]>;

package/lib/Exchange/CParams.js

@@ -4,6 +4,7 @@ exports.CParamsReadonly = exports.CParams = void 0;
 exports.isParamBase = isParamBase;
 exports.isParamGroupOrArray = isParamGroupOrArray;
 exports.isParamGroup = isParamGroup;
+exports.isSimpleParams2 = isSimpleParams2;
 exports.isSimpleParams = isSimpleParams;
 exports.iterateParams = iterateParams;
 exports.enableAllParams = enableAllParams;
@@ -32,7 +33,7 @@ function isParamGroupOrArray(param) {
 function isParamGroup(param) {
     return isParamGroupOrArray(param) && !Array.isArray(param.value);
 }
-function isSimpleParams(params) {
+function isSimpleParams2(params) {
     let t = false;
     for (let key in params) {
         const tr = params[key]["value"];
@@ -48,6 +49,24 @@ function isSimpleParams(params) {
     }
     return false;
 }
+function isSimpleParams(params) {
+    for (let key in params) {
+        const param = params[key];
+        if (param == null || typeof param !== "object") {
+            return true;
+        }
+        if (!("value" in param)) {
+            return true;
+        }
+        const val = param.value;
+        if (typeof val === "object" && val !== null && !(val instanceof Date) && !Array.isArray(val)) {
+            const r = isSimpleParams(val);
+            if (r)
+                return true;
+        }
+    }
+    return false;
+}
 function* iterateParams(obj, currentPath = []) {
     for (let [key, param] of Object.entries(obj)) {
         let keyPath = currentPath.concat(key);
@@ -164,6 +183,51 @@ let p0 = p.p1;
 let p3 = p.p3;
 let p4 = p.p4;
 let p5 = p.p5?.p1;
+function test22() {
+    const base = {
+        kBorrow: {
+            value: 1,
+            name: 'borrow step',
+            range: { max: 3, min: 1, step: 0.1 }
+        },
+        checkBorrow: { value: false, name: 'check borrow' },
+        checkBorrowFutures: { value: false, name: 'check borrow for futures' },
+        depoMulti: {
+            value: 1,
+            name: 'koef depoMulti',
+            range: { min: 0.01, max: 4, step: 0.01 }
+        },
+        depoMulti2: {
+            value: 2,
+            name: 'koef depoMulti',
+            range: { min: 0.01, max: 4, step: 0.01 }
+        }
+    };
+    const params = {
+        kBorrow: {
+            value: 2,
+            name: 'borrow step',
+            range: { max: 3, min: 1, step: 0.1 }
+        },
+        checkBorrow: { value: true, name: 'check borrow' },
+        checkBorrowFutures: { value: true, name: 'check borrow for futures' },
+        depoMulti: {
+            value: 1.32,
+            name: 'koef depoMulti',
+            range: { min: 0.01, max: 4, step: 0.01 }
+        },
+        depoMulti3: {
+            value: 1,
+            name: 'koef depoMulti',
+            range: { min: 0.01, max: 4, step: 0.01 }
+        }
+    };
+    const tr = GetSimpleParams(params);
+    console.log(tr);
+    const i = mergeParamValuesToInfos(base, tr);
+    console.log(i);
+}
+test22();
 function convert_(valuesObj, srcObj) {
     let resObj = {};
     if (srcObj instanceof Array)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wenay-common",
-  "version": "1.0.243",
+  "version": "1.0.245",
   "description": "Common library",
   "strict": true,
   "main": "lib/index.js",