wenay-common 1.0.231 → 1.0.236

package/lib/Common/ByteStream.js

@@ -48,7 +48,14 @@ class ByteStreamW {
         let buf = createCopyOfBuffer(this._buffer(), size);
         this._view = new DataView(buf);
     }
-    constructor(view) { this.resize(0); }
+    constructor(view) {
+        if (view) {
+            this._view = view;
+        }
+        else {
+            this.resize(0);
+        }
+    }
     get length() { return this._pos; }
     get data() { return new DataView(this._buffer(), 0, this._pos); }
     noThrow() { let other = new ByteStreamW(this._view); other._pos = this._pos; other._isThrowable = false; return other; }
@@ -183,6 +190,7 @@ class ByteStreamW {
                 array = new arrayClass(array.buffer, 0, length);
             }
             new arrayClass(this._buffer()).set(array, this._pos);
+            this._pos += length;
             return this;
         }
         let func = (stream, item) => item.write(stream) != false;
@@ -343,7 +351,9 @@ class ByteStreamR_ {
             if (size == null)
                 return null;
             let bufpos = this._view.byteOffset + this._pos;
-            new arrayClass(this._view.buffer.slice(bufpos, bufpos + size));
+            const out = new arrayClass(this._view.buffer.slice(bufpos, bufpos + size));
+            this._pos += size;
+            return Array.from(out);
         }
         return this._readArrayByFunc(this._getReadFuncForNumeric(type));
     }

package/lib/Common/Listen.d.ts

@@ -45,7 +45,7 @@ export declare function funcListenBySocket2<Z extends any[] = any[]>(e: t1<Z>, d
     callback: (z: (...params: Parameters<tr2a<tr222<Z>>>) => void) => void;
     removeCallback: () => boolean;
 };
-export declare function funcListenBySocket3<Z extends any[] = any[]>(e: t1<Z>, options: Omit<Parameters<typeof funcListenBySocket2>[1], "paramsModify">): {
+export declare function funcListenBySocket3<Z extends any[] = any[]>(e: t1<Z>, options?: Omit<Parameters<typeof funcListenBySocket2>[1], "paramsModify">): {
     callback: (z: (...params: Parameters<tr2<tr222<Z>>>) => void) => void;
     removeCallback: () => boolean;
 };
@@ -81,8 +81,8 @@ export declare function DeepCompareKeys<T, T2 extends obj, T3 extends unknown>(o
     [k: string]: any;
 } | NonNullable<T> | trr2<T> | null;
 export declare function deepModifyByListenSocket<T>(obj: T, status: () => boolean): ttt<T>;
-export declare function deepModifyByListenSocket2<T>(obj: T, data: Parameters<typeof funcListenBySocket2>[1]): ttt<T>;
-export declare function deepModifyByListenSocket3<T>(obj: T, data: Parameters<typeof funcListenBySocket3>[1]): ttt<T>;
+export declare function deepModifyByListenSocket2<T>(obj: T, data?: Parameters<typeof funcListenBySocket2>[1]): ttt<T>;
+export declare function deepModifyByListenSocket3<T>(obj: T, data?: Parameters<typeof funcListenBySocket3>[1]): ttt<T>;
 export declare const funcListenBySocketObj: typeof deepModifyByListenSocket;
 export declare function PromiseArrayListen<T extends any = unknown>(array: ((() => Promise<T>) | (() => any) | Promise<T>)[]): {
     listenOk: (a: (...d: [data: T, i: number, countOk: number, countError: number, count: number]) => any) => () => void;

package/lib/Common/Listen.js

@@ -120,7 +120,7 @@ function funcListenBySocket2(e, d) {
     };
 }
 function funcListenBySocket3(e, options) {
-    const r = funcListenBySocket2(e, { ...options, paramsModify: e => [e] });
+    const r = funcListenBySocket2(e, { ...(options ?? {}), paramsModify: e => [e] });
     const callback = r.callback;
     return {
         callback,

package/lib/Common/Math.js

@@ -34,7 +34,7 @@ function CorrelationRollingByBuffer(data) {
     function checkSize(e) {
         const a = e.length - setting.max;
         if (a > 0)
-            e.slice(0, a);
+            e.splice(0, a);
     }
     return ({
         init(data) { setting = { ...data }; },

package/lib/Common/MemoFunc.d.ts

@@ -2,7 +2,7 @@ export declare function MemoFunc(a?: {
     memo?: Map<any, any>;
     timeDelta?: number;
     maxLimits?: number;
-    compareArguments?: (args: any) => string;
+    compareArguments?: (...args: any[]) => string;
     eventUpdate?: () => void;
 }): {
     func: <T extends (...args: any[]) => any>(data: T, options?: {
@@ -17,3 +17,4 @@ export declare function MemoFunc(a?: {
 };
 export type MemoFuncOpt = Parameters<ReturnType<typeof MemoFunc>["func"]>[1];
 export declare const MemoFuncConvert: <T extends () => any>(func: T, memo: ReturnType<typeof MemoFunc>) => (opt?: MemoFuncOpt) => ReturnType<T>;
+export declare function runMemoFuncTests(): void;

package/lib/Common/MemoFunc.js

@@ -2,8 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MemoFuncConvert = void 0;
 exports.MemoFunc = MemoFunc;
+exports.runMemoFuncTests = runMemoFuncTests;
 function MemoFunc(a) {
-    const { memo = new Map(), timeDelta = 60 * 1000 * 100, maxLimits = 10000, compareArguments = (args) => JSON.stringify(args), eventUpdate } = a ?? {};
+    const { memo = new Map(), timeDelta = 60 * 1000 * 100, maxLimits = 10000, compareArguments = (...args) => JSON.stringify(args), eventUpdate } = a ?? {};
     function cleanAll(obj) {
         Object.keys(obj).forEach(key => delete obj[key]);
         eventUpdate?.();
@@ -12,9 +13,9 @@ function MemoFunc(a) {
         return ((...args) => {
             const { reSave = false, key = "", compareArguments: cmp = compareArguments, timeDelta: td = timeDelta, old = false } = options ?? {};
             const cacheForFunc = memo.get(data) ?? (() => { memo.set(data, {}); return memo.get(data); })();
-            const cacheKey = args.length ? key + cmp(args) : key;
+            const cacheKey = args.length ? key + cmp(...args) : key;
             let entry = cacheForFunc[cacheKey];
-            if (old && entry?.volume) {
+            if (old && entry) {
                 return entry.volume;
             }
             if (Object.keys(cacheForFunc).length > maxLimits) {
@@ -42,3 +43,59 @@ function MemoFunc(a) {
 }
 const MemoFuncConvert = (func, memo) => ((opt) => memo.func(func, opt)());
 exports.MemoFuncConvert = MemoFuncConvert;
+function runMemoFuncTests() {
+    console.log("MemoFunc tests: start");
+    const memo = MemoFunc({ timeDelta: 1000 });
+    let callCount = 0;
+    const sum = (a, b) => {
+        callCount += 1;
+        return a + b;
+    };
+    const memoSum = memo.func(sum, {
+        compareArguments: (a, b) => `${a}|${b}`
+    });
+    memoSum(1, 2);
+    memoSum(1, 2);
+    memoSum(2, 3);
+    console.log("compareArguments spread ok:", callCount === 2, "callCount:", callCount);
+    let zeroCallCount = 0;
+    const returnZero = () => {
+        zeroCallCount += 1;
+        return 0;
+    };
+    const memoZero = memo.func(returnZero, { old: true });
+    memoZero();
+    memoZero();
+    console.log("old returns falsy cache:", zeroCallCount === 1, "zeroCallCount:", zeroCallCount);
+    const realNow = Date.now;
+    try {
+        let now = 1_000_000;
+        Date.now = () => now;
+        let tdCallCount = 0;
+        const bump = () => {
+            tdCallCount += 1;
+            return tdCallCount;
+        };
+        const memoBump = memo.func(bump, { timeDelta: 1000 });
+        memoBump();
+        now += 999;
+        memoBump();
+        now += 2;
+        memoBump();
+        console.log("timeDelta expiry:", tdCallCount === 2, "tdCallCount:", tdCallCount);
+        let reSaveCallCount = 0;
+        const touch = () => {
+            reSaveCallCount += 1;
+            return reSaveCallCount;
+        };
+        const memoTouch = memo.func(touch);
+        memoTouch();
+        memoTouch();
+        memo.func(touch, { reSave: true })();
+        console.log("reSave forces recompute:", reSaveCallCount === 2, "reSaveCallCount:", reSaveCallCount);
+    }
+    finally {
+        Date.now = realNow;
+    }
+    console.log("MemoFunc tests: end");
+}

package/lib/Common/SocketServerHook.d.ts

@@ -1,4 +1,4 @@
-import { funcListenBySocket2 } from "./Listen";
+import { funcListenBySocket2 as soc } from "./Listen";
 type transformer = (func: (data: any) => any, tag: string, data: any) => any;
 export declare function SocketServerHook(opt?: {
     transformer?: transformer;
@@ -27,7 +27,7 @@ export declare function SocketServerHook(opt?: {
     }];
     provider: (tag: string, data: any) => void;
 };
-export declare function WebSocketServerHook(s: ReturnType<typeof SocketServerHook>, paramsSoc?: Parameters<typeof funcListenBySocket2>[1], disconnect?: () => any): {
+export declare function WebSocketServerHook(s: ReturnType<typeof SocketServerHook>, paramsSoc?: Parameters<typeof soc>[1], disconnect?: () => any): {
     disconnect(): void;
     get: {
         [k: string]: {

package/lib/Common/Time.js

@@ -188,7 +188,7 @@ class TF {
     static MN2 = TF.get("MN2");
     static MN3 = TF.get("MN3");
     static MN4 = TF.get("MN4");
-    static MN6 = TF.get("MN4");
+    static MN6 = TF.get("MN6");
     static Y1 = TF.get("Y1");
     static min(...args) {
         let tfs = ((args[0] && !(args[0] instanceof TF)) ? args[0] : args);

package/lib/Common/WebHook2.js

@@ -47,7 +47,7 @@ const loadSubscribers = () => {
         fs.writeFileSync(SUBSCRIBERS_FILE, '{}', 'utf-8');
     }
     const data = JSON.parse(fs.readFileSync(SUBSCRIBERS_FILE, 'utf-8'));
-    return new Map(Object.entries(data).map(([key, sub]) => [key, { url: sub.url, tags: sub.tag, expireAt: new Date(sub.expireAt) }]));
+    return new Map(Object.entries(data).map(([key, sub]) => [key, { url: sub.url, tags: sub.tags ?? sub.tag, expireAt: new Date(sub.expireAt) }]));
 };
 const Queue = (0, waitRun_1.createAsyncQueue)(1);
 const saveSubscribers = (subscribers) => {

package/lib/Common/commonsServerMini.d.ts

@@ -21,17 +21,36 @@ type SocketData<T> = ({
     wait?: boolean;
     callbacksId?: number[];
 };
+type PromiseServerHooks<T> = {
+    onRequest?: (ctx: {
+        key: string[];
+        request: any[];
+        fnName: string;
+        fn: Func;
+        msg: SocketData<RequestScreener<T>>;
+    }) => boolean | Promise<boolean>;
+    onInvalid?: (ctx: {
+        reason: "invalid_payload" | "not_function" | "resolve_error" | "rate_limit";
+        key?: any;
+        request?: any;
+        error?: any;
+        msg: SocketData<RequestScreener<T>>;
+    }) => void | Promise<void>;
+};
 type ScreenerSoc<T> = {
     sendMessage: (d: T) => void;
     api: (h: {
         onMessage: (m: T) => void | Promise<void>;
     }) => void;
 };
-export declare function promiseServer<T extends Obj>(soc: ScreenerSoc<SocketData<RequestScreener<T>>>, target: T): void;
+export declare function promiseServer<T extends Obj>(soc: ScreenerSoc<SocketData<RequestScreener<T>>> & {
+    hooks?: PromiseServerHooks<T>;
+}, target: T): void;
 type Func = (a: any) => any;
 export type ScreenerSoc2<T> = {
     send: (d: RequestScreener<T>, wait?: boolean, cbs?: Func[]) => Promise<any>;
     api: ScreenerSocApi<T>;
+    abortAll: (textError: string) => void;
 };
 export type ScreenerSocApi<T> = {
     log: (s: boolean) => void;

package/lib/Common/commonsServerMini.js

@@ -6,8 +6,43 @@ exports.wsWrapper = wsWrapper;
 exports.createClientProxy = createClientProxy;
 exports.createAPIFacadeClient = createAPIFacadeClient;
 exports.createAPIFacadeServer = createAPIFacadeServer;
+function createSimpleRateLimitHook(options) {
+    let count = 0;
+    let resetAt = 0;
+    return () => {
+        const now = Date.now();
+        if (now >= resetAt) {
+            resetAt = now + options.intervalMs;
+            count = 0;
+        }
+        count += 1;
+        if (count > options.max) {
+            throw new Error("Rate limit exceeded");
+        }
+        return true;
+    };
+}
 function promiseServer(soc, target) {
+    const serializeError = (err) => {
+        if (err instanceof Error) {
+            return { name: err.name, message: err.message, stack: err.stack };
+        }
+        return err;
+    };
+    const hooks = soc.hooks;
     soc.api({ onMessage: async (msg) => {
+            if (!msg || typeof msg !== "object" || !msg.data || !Array.isArray(msg.data.key) || !Array.isArray(msg.data.request)) {
+                const err = serializeError(new Error("Invalid request payload"));
+                try {
+                    await hooks?.onInvalid?.({ reason: "invalid_payload", key: msg?.data?.key, request: msg?.data?.request, error: err, msg });
+                }
+                catch (hookErr) {
+                    console.error({ error: serializeError(hookErr), where: "onInvalid" });
+                }
+                soc.sendMessage({ mapId: msg?.mapId ?? -1, error: { error: err, key: msg?.data?.key, arguments: msg?.data?.request } });
+                console.error({ error: err, key: msg?.data?.key, arguments: msg?.data?.request });
+                return;
+            }
             const { key, request } = msg.data;
             let curr = target, fnName = "";
             try {
@@ -19,11 +54,36 @@ function promiseServer(soc, target) {
                 }
             }
             catch (e) {
-                soc.sendMessage({ mapId: msg.mapId, error: { error: e, key, arguments: request } });
-                console.error({ error: e, key, arguments: request });
+                const err = serializeError(e);
+                try {
+                    await hooks?.onInvalid?.({ reason: "resolve_error", key, request, error: err, msg });
+                }
+                catch (hookErr) {
+                    console.error({ error: serializeError(hookErr), where: "onInvalid" });
+                }
+                soc.sendMessage({ mapId: msg.mapId, error: { error: err, key, arguments: request } });
+                console.error({ error: err, key, arguments: request });
                 return;
             }
             if (typeof curr[fnName] === "function") {
+                const fn = curr[fnName];
+                if (hooks?.onRequest) {
+                    try {
+                        const allowed = await hooks.onRequest({ key, request, fnName, fn, msg });
+                        if (allowed === false) {
+                            const err = serializeError(new Error("Request rejected by hook"));
+                            soc.sendMessage({ mapId: msg.mapId, error: { error: err, key, arguments: request } });
+                            console.error({ error: err, key, arguments: request });
+                            return;
+                        }
+                    }
+                    catch (hookErr) {
+                        const err = serializeError(hookErr);
+                        soc.sendMessage({ mapId: msg.mapId, error: { error: err, key, arguments: request } });
+                        console.error({ error: err, key, arguments: request });
+                        return;
+                    }
+                }
                 const { callbacksId } = msg;
                 if (callbacksId && Array.isArray(callbacksId)) {
                     const cbArr = callbacksId.map(id => (data) => {
@@ -45,11 +105,18 @@ function promiseServer(soc, target) {
                 }
                 catch (e) {
                     console.log(fnName, request, key);
-                    soc.sendMessage({ mapId: msg.mapId, error: { error: e, key, arguments: request } });
-                    console.error({ error: e, key, arguments: request });
+                    const err = serializeError(e);
+                    soc.sendMessage({ mapId: msg.mapId, error: { error: err, key, arguments: request } });
+                    console.error({ error: err, key, arguments: request });
                 }
             }
             else {
+                try {
+                    await hooks?.onInvalid?.({ reason: "not_function", key, request, msg });
+                }
+                catch (hookErr) {
+                    console.error({ error: serializeError(hookErr), where: "onInvalid" });
+                }
                 soc.sendMessage({ mapId: msg.mapId, error: JSON.stringify({ data: "это не функция", key, arguments: request }) });
                 console.error({ data: "это не функция", key, arguments: request });
             }
@@ -59,6 +126,17 @@ function wsWrapper(soc) {
     const max = soc.limit, sendMsg = soc.sendMessage;
     const pool = (() => { const free = []; let tot = 0, pos = 0; return { log: () => console.log({ free, tot, pos }), next: () => pos > 0 ? free[--pos] : ++tot, release: (id) => { free[pos++] = id; } }; })();
     const promises = new Map(), cbsMap = new Map();
+    const forceRejectAll = (reason) => {
+        promises.forEach((p, id) => {
+            p.reject({
+                error: { name: "RPC_ABORT", message: reason },
+                mapId: id
+            });
+            pool.release(id);
+        });
+        promises.clear();
+        cbsMap.clear();
+    };
     soc.api({ onMessage: (msg) => {
             const id = msg.mapId;
             if (promises.has(id)) {
@@ -77,7 +155,8 @@ function wsWrapper(soc) {
             }
             else
                 console.error("Неожиданный ответ", msg);
-        } });
+        }
+    });
     let debug = false;
     const api = {
         log: (s) => { debug = s; },
@@ -95,7 +174,10 @@ function wsWrapper(soc) {
             pool.release(key);
         } }); }
     };
-    return { api, send: (data, wait, cbs) => new Promise((resolve, reject) => {
+    return {
+        abortAll: forceRejectAll,
+        api,
+        send: (data, wait, cbs) => new Promise((resolve, reject) => {
             const msg = { mapId: pool.next(), data, wait, callbacksId: [] };
             for (const fn of cbs ?? []) {
                 const id = pool.next();
@@ -115,7 +197,8 @@ function wsWrapper(soc) {
             if (max && promises.size >= max)
                 console.log("promises.size =", promises.size);
             sendMsg(msg);
-        }) };
+        })
+    };
 }
 function createClientProxy(soc2, wait) {
     const chain = (path) => new Proxy(() => { }, {

package/lib/Common/commonsServerMini2.d.ts

@@ -0,0 +1,56 @@
+type Socket = {
+    emit: (e: string, d: any) => void;
+    on: (e: string, cb: (d: any) => void) => void;
+};
+type Func = (...args: any[]) => any;
+type PromiseServerHooks<T> = {
+    onRequest?: (ctx: {
+        key: string[];
+        request: any[];
+        fnName: string;
+        fn: Func;
+    }) => boolean | Promise<boolean>;
+    onInvalid?: (ctx: {
+        reason: "invalid_payload" | "not_function" | "resolve_error" | "rate_limit";
+        key?: any;
+        request?: any;
+        error?: any;
+    }) => void | Promise<void>;
+};
+type UnwrapPromise<T> = T extends Promise<infer R> ? R : T;
+type ClientAPI<T> = {
+    [K in keyof T]: T[K] extends (...args: infer A) => infer R ? (...args: A) => Promise<UnwrapPromise<R>> : T[K] extends object ? ClientAPI<T[K]> : T[K];
+};
+type ClientAPIStrict<T> = ClientAPI<T>;
+type ClientApiHandle = {
+    log: (s: boolean) => void;
+    promiseTotal: () => number;
+    callbackTotal: () => number;
+    promiseDeleteAll: (reject?: boolean) => void;
+    callbackDeleteAll: () => void;
+    callbackDelete: (fn: Function) => void;
+    callbackEnd: (fn: Function) => void;
+};
+declare function createAPIFacadeServer<T extends object>({ socket, object: target, socketKey: key, debug, hooks }: {
+    socket: Socket;
+    object: T;
+    socketKey: string;
+    debug?: boolean;
+    hooks?: PromiseServerHooks<T>;
+}): void;
+declare function createAPIFacadeClient<T extends object>({ socket, socketKey: key, limit }: {
+    socket: Socket;
+    socketKey: string;
+    limit?: number;
+}): {
+    func: ClientAPI<T>;
+    space: ClientAPI<T>;
+    all: ClientAPI<T>;
+    strict: ClientAPI<T>;
+    api: ClientApiHandle;
+    abortAll: (reason: string) => void;
+    infoStrict: () => any;
+    strictInit(obj?: object): Promise<unknown>;
+};
+export { createAPIFacadeServer as CreatAPIFacadeServer2, createAPIFacadeClient as CreatAPIFacadeClient2 };
+export type { ClientAPI, ClientAPIStrict, ClientApiHandle, PromiseServerHooks };

package/lib/Common/commonsServerMini2.js

@@ -0,0 +1,327 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreatAPIFacadeServer2 = createAPIFacadeServer;
+exports.CreatAPIFacadeClient2 = createAPIFacadeClient;
+const Pkt = { CALL: 0, RESP: 1, CB: 2, MAP: 3, STRICT: 4 };
+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);
+class IdPool {
+    s = [];
+    p = 0;
+    n = 0;
+    next() { return this.p > 0 ? this.s[--this.p] : ++this.n; }
+    release(id) { this.s[this.p++] = id; }
+}
+function walk(val, onLeaf) {
+    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));
+    const o = {};
+    for (const k of Object.keys(val))
+        if (isSafeKey(k))
+            o[k] = walk(val[k], onLeaf);
+    return o;
+}
+function pack(args, pool, cbStore, cbIds) {
+    return args.map(v => walk(v, leaf => {
+        if (typeof leaf === "function") {
+            const id = pool.next();
+            cbStore.set(id, leaf);
+            cbIds.push(id);
+            return { [FN_MARKER]: id };
+        }
+        return leaf;
+    }));
+}
+function unpack(args, sender) {
+    return args.map(v => walk(v, leaf => leaf != null && typeof leaf === "object" && leaf[FN_MARKER] !== undefined
+        ? (...a) => sender(leaf[FN_MARKER], a)
+        : leaf));
+}
+const errToObj = (e) => e instanceof Error ? { name: e.name, message: e.message, stack: e.stack } : e;
+const resolveCA = (path, args) => {
+    const last = path[path.length - 1];
+    if (last === "call")
+        return [path.slice(0, -1), args.slice(1)];
+    if (last === "apply")
+        return [path.slice(0, -1), args[1] ?? []];
+    return [path, args];
+};
+function createServer(socket, key, target, hooks) {
+    const methods = [];
+    const contexts = [];
+    const routeMap = {};
+    (function index(obj, prefix) {
+        for (const k of Object.keys(obj)) {
+            if (!isSafeKey(k))
+                continue;
+            const v = obj[k], path = prefix ? prefix + "." + k : k;
+            if (typeof v === "function") {
+                routeMap[path] = methods.length;
+                methods.push(v);
+                contexts.push(obj);
+            }
+            else if (v && typeof v === "object")
+                index(v, path);
+        }
+    })(target, "");
+    function serialize(obj) {
+        const out = {};
+        for (const k of Object.keys(obj)) {
+            if (!isSafeKey(k))
+                continue;
+            const v = obj[k];
+            out[k] = typeof v === "function" ? "func" : v != null && typeof v === "object" ? serialize(v) : v == null ? "null" : "unknown";
+        }
+        return out;
+    }
+    const strictSchema = serialize(target);
+    const send = (d) => socket.emit(key, d);
+    send([Pkt.MAP, routeMap, strictSchema]);
+    socket.on(key, async (msg) => {
+        if (msg === Pkt.STRICT) {
+            send([Pkt.MAP, routeMap, strictSchema]);
+            return;
+        }
+        if (!Array.isArray(msg) || msg[0] !== Pkt.CALL)
+            return;
+        const [, reqId, ref, rawArgs, w] = msg;
+        const wait = w !== false;
+        if (typeof reqId !== "number" || !Number.isFinite(reqId)) {
+            hooks?.onInvalid?.({ reason: "invalid_payload", key: ref, request: rawArgs, error: "reqId is not a valid number" });
+            return;
+        }
+        if (typeof ref !== "number" && !Array.isArray(ref)) {
+            hooks?.onInvalid?.({ reason: "invalid_payload", key: ref, request: rawArgs, error: "ref must be number or string[]" });
+            if (wait)
+                send([Pkt.RESP, reqId, null, errToObj(new Error("Invalid ref type"))]);
+            return;
+        }
+        if (!Array.isArray(rawArgs)) {
+            hooks?.onInvalid?.({ reason: "invalid_payload", key: ref, request: rawArgs, error: "args must be an array" });
+            if (wait)
+                send([Pkt.RESP, reqId, null, errToObj(new Error("Invalid args: expected array"))]);
+            return;
+        }
+        try {
+            let fn, ctx;
+            if (typeof ref === "number") {
+                fn = methods[ref];
+                ctx = contexts[ref];
+            }
+            else {
+                if (!ref.every((s) => typeof s === "string" && isSafeKey(s))) {
+                    hooks?.onInvalid?.({ reason: "invalid_payload", key: ref, request: rawArgs });
+                    if (wait)
+                        send([Pkt.RESP, reqId, null, errToObj(new Error("Forbidden path segment"))]);
+                    return;
+                }
+                const idx = routeMap[ref.join(".")];
+                if (idx !== undefined) {
+                    fn = methods[idx];
+                    ctx = contexts[idx];
+                }
+                else {
+                    let curr = target;
+                    for (let i = 0; i < ref.length - 1; i++) {
+                        const seg = ref[i];
+                        if (curr == null || typeof curr !== "object" || !hasOwn(curr, seg)) {
+                            curr = undefined;
+                            break;
+                        }
+                        curr = curr[seg];
+                    }
+                    const last = ref[ref.length - 1];
+                    if (curr != null && typeof curr === "object" && hasOwn(curr, last)) {
+                        ctx = curr;
+                        fn = curr[last];
+                    }
+                }
+            }
+            if (typeof fn !== "function") {
+                hooks?.onInvalid?.({ reason: "not_function", key: ref, request: rawArgs });
+                if (wait)
+                    send([Pkt.RESP, reqId, null, errToObj(new Error("Not a function: " + ref))]);
+                return;
+            }
+            if (hooks?.onRequest) {
+                const keyArr = typeof ref === "number"
+                    ? Object.keys(routeMap).find(k => routeMap[k] === ref)?.split(".") ?? []
+                    : ref;
+                const allowed = await hooks.onRequest({ key: keyArr, request: rawArgs, fnName: keyArr[keyArr.length - 1] ?? "", fn: fn });
+                if (allowed === false) {
+                    if (wait)
+                        send([Pkt.RESP, reqId, null, errToObj(new Error("Rejected by hook"))]);
+                    return;
+                }
+            }
+            const args = unpack(rawArgs, (cbId, cbArgs) => send([Pkt.CB, cbId, cbArgs]));
+            const res = await fn.apply(ctx, args);
+            if (wait)
+                send([Pkt.RESP, reqId, res]);
+        }
+        catch (e) {
+            if (wait)
+                send([Pkt.RESP, reqId, null, errToObj(e)]);
+        }
+    });
+}
+function createClient(socket, key, opts) {
+    const limit = opts?.limit ?? 10000;
+    const pool = new IdPool();
+    const pending = new Map();
+    const callbacks = new Map();
+    const routeCache = {};
+    let strictData = {};
+    let strictWaiters = [];
+    let debug = false;
+    socket.on(key, (msg) => {
+        if (!Array.isArray(msg))
+            return;
+        switch (msg[0]) {
+            case Pkt.RESP: {
+                const req = pending.get(msg[1]);
+                if (!req)
+                    break;
+                pending.delete(msg[1]);
+                pool.release(msg[1]);
+                for (const cbId of req.cbs) {
+                    callbacks.delete(cbId);
+                    pool.release(cbId);
+                }
+                msg[3] ? req.fail(msg[3]) : req.ok(msg[2]);
+                break;
+            }
+            case Pkt.CB: {
+                callbacks.get(msg[1])?.(...(msg[2] || []));
+                break;
+            }
+            case Pkt.MAP: {
+                if (msg[1])
+                    Object.assign(routeCache, msg[1]);
+                if (msg[2]) {
+                    for (const k of Object.keys(strictData))
+                        delete strictData[k];
+                    Object.assign(strictData, msg[2]);
+                    for (const r of strictWaiters)
+                        r(undefined);
+                    strictWaiters = [];
+                }
+                break;
+            }
+        }
+    });
+    const sendCall = (path, args, wait) => {
+        const cbIds = [];
+        const clean = pack(args, pool, callbacks, cbIds);
+        const ref = routeCache[path.join(".")] ?? path;
+        if (!wait) {
+            socket.emit(key, [Pkt.CALL, 0, ref, clean, false]);
+            return Promise.resolve();
+        }
+        return new Promise((resolve, reject) => {
+            if (pending.size >= limit)
+                return reject(new Error("RPC limit"));
+            const reqId = pool.next();
+            pending.set(reqId, { ok: resolve, fail: reject, cbs: cbIds });
+            if (debug)
+                console.log("[RPC]", path.join("."), "id=", reqId);
+            socket.emit(key, [Pkt.CALL, reqId, ref, clean]);
+        });
+    };
+    const buildProxy = (path, wait) => new Proxy(function () { }, {
+        get(_, p) {
+            if (p === "then" || p === "catch" || p === Symbol.toPrimitive)
+                return undefined;
+            return buildProxy([...path, String(p)], wait);
+        },
+        apply(_, __, args) {
+            const [fp, fa] = resolveCA(path, args);
+            return sendCall(fp, fa, wait);
+        },
+    });
+    const buildStrict = (path, wait) => {
+        let tgt = strictData;
+        for (const seg of path) {
+            tgt = tgt?.[seg];
+            if (tgt == null || tgt === "null")
+                return undefined;
+        }
+        return new Proxy(tgt === "func" ? function () { } : {}, {
+            has: (_, p) => tgt?.[String(p)] !== "null",
+            ownKeys: () => tgt && typeof tgt === "object" ? Object.keys(tgt) : [],
+            getOwnPropertyDescriptor: () => ({ enumerable: true, configurable: true }),
+            getPrototypeOf: () => !tgt || tgt === "null" ? Object.prototype : tgt === "func" ? Function.prototype : null,
+            get(_, p) {
+                if (p === "then" || p === "catch" || p === Symbol.toPrimitive)
+                    return undefined;
+                if (p === "call" && tgt === "func")
+                    return (_, ...args) => sendCall(path, args, wait);
+                const child = tgt?.[String(p)];
+                return child === "null" || child === undefined ? undefined : buildStrict([...path, String(p)], wait);
+            },
+            apply(_, __, args) {
+                const [fp, fa] = resolveCA(path, args);
+                return sendCall(fp, fa, wait);
+            },
+        });
+    };
+    const releaseCbs = (fn) => {
+        callbacks.forEach((cb, id) => { if (cb === fn) {
+            callbacks.delete(id);
+            pool.release(id);
+        } });
+    };
+    const clearAll = (rejectReason) => {
+        pending.forEach((p, id) => { pool.release(id); p.fail(rejectReason ?? "aborted"); });
+        pending.clear();
+        callbacks.forEach((_, id) => pool.release(id));
+        callbacks.clear();
+    };
+    const api = {
+        log: s => { debug = s; },
+        promiseTotal: () => pending.size,
+        callbackTotal: () => callbacks.size,
+        promiseDeleteAll: (rej = true) => {
+            pending.forEach((p, id) => { pool.release(id); rej ? p.fail("promiseDeleteAll") : p.ok(undefined); });
+            pending.clear();
+        },
+        callbackDeleteAll: () => { callbacks.forEach((_, id) => pool.release(id)); callbacks.clear(); },
+        callbackDelete: releaseCbs,
+        callbackEnd: releaseCbs,
+    };
+    const func = buildProxy([], true);
+    return {
+        func,
+        space: buildProxy([], false),
+        all: func,
+        strict: buildStrict([], true),
+        api,
+        abortAll: (reason) => clearAll({ error: { name: "RPC_ABORT", message: reason } }),
+        infoStrict: () => strictData,
+        async strictInit(obj) {
+            if (obj) {
+                strictData = obj;
+            }
+            else {
+                socket.emit(key, Pkt.STRICT);
+                return new Promise(r => { strictWaiters.push(r); });
+            }
+        },
+    };
+}
+function createAPIFacadeServer({ socket, object: target, socketKey: key, debug = false, hooks }) {
+    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);
+}
+function createAPIFacadeClient({ socket, socketKey: key, limit }) {
+    return createClient(socket, key, { limit });
+}

package/lib/Common/funcTimeWait.d.ts

@@ -9,7 +9,6 @@ export declare function funcTimeW(): {
     dStatic: {
         [key: string]: [number, number][];
     };
-    data: any[];
     add(item: tFunc): void;
     cleanByTime(type: tType, ms?: number): void;
     weight(type: tType, ms?: number): number;
@@ -21,7 +20,6 @@ export declare const FuncTimeWait: {
     dStatic: {
         [key: string]: [number, number][];
     };
-    data: any[];
     add(item: tFunc): void;
     cleanByTime(type: tType, ms?: number): void;
     weight(type: tType, ms?: number): number;
@@ -29,4 +27,5 @@ export declare const FuncTimeWait: {
     byWeight(type: tType, weight?: number): number;
     byWeightTimeNow(type: tType, timeNow?: number, weight?: number): number;
 };
+export declare function testFuncTimeW(): void;
 export {};

package/lib/Common/funcTimeWait.js

@@ -2,30 +2,46 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FuncTimeWait = void 0;
 exports.funcTimeW = funcTimeW;
+exports.testFuncTimeW = testFuncTimeW;
+const common_1 = require("./common");
 function funcTimeW() {
     const dStatic = {};
-    const data = [];
+    function getInsertIndex(arr, timeStamp) {
+        if (arr.length === 0)
+            return 0;
+        if (timeStamp >= arr[arr.length - 1][0])
+            return arr.length;
+        if (timeStamp <= arr[0][0])
+            return 0;
+        const index = (0, common_1.BSearch)(arr, timeStamp, (a, b) => a[0] - b, "greatOrEqual", "ascend");
+        return index === -1 ? arr.length : index;
+    }
     return {
         dStatic,
-        data,
         add(item) {
-            if (!dStatic[item.type]) {
-                dStatic[item.type] = [];
+            const arr = (dStatic[item.type] ??= []);
+            const timeStamp = item.timeStamp ?? Date.now();
+            const insertIndex = getInsertIndex(arr, timeStamp);
+            if (insertIndex === arr.length) {
+                arr.push([timeStamp, item.weight]);
+            }
+            else {
+                arr.splice(insertIndex, 0, [timeStamp, item.weight]);
             }
-            dStatic[item.type].push([item.timeStamp ?? Date.now(), item.weight]);
         },
         cleanByTime(type, ms = 60 * 1000) {
             const arr = dStatic[type];
             if (!arr || arr.length === 0)
                 return;
             const timeStamp = Date.now();
-            if (arr[0][0] > timeStamp - ms)
+            const cutoff = timeStamp - ms;
+            if (arr[0][0] > cutoff)
                 return;
-            let cutIndex = 0;
-            while (cutIndex < arr.length && arr[cutIndex][0] < timeStamp - ms) {
-                cutIndex++;
+            const cutIndex = (0, common_1.BSearch)(arr, cutoff, (a, b) => a[0] - b, "greatOrEqual", "ascend");
+            if (cutIndex === -1) {
+                arr.splice(0, arr.length);
             }
-            if (cutIndex > 0) {
+            else if (cutIndex > 0) {
                 arr.splice(0, cutIndex);
             }
         },
@@ -43,7 +59,7 @@ function funcTimeW() {
                 sum += _weight;
             }
             if (i >= 0) {
-                arr.splice(0, i);
+                arr.splice(0, i + 1);
             }
             return sum;
         },
@@ -61,7 +77,7 @@ function funcTimeW() {
                 sum += _weight;
             }
             if (i >= 0) {
-                arr.splice(0, i);
+                arr.splice(0, i + 1);
             }
             return sum;
         },
@@ -112,3 +128,16 @@ function funcTimeW() {
     };
 }
 exports.FuncTimeWait = funcTimeW();
+function testFuncTimeW() {
+    const tracker = funcTimeW();
+    const type = "UID";
+    const now = Date.now();
+    tracker.add({ type, weight: 1, timeStamp: now });
+    tracker.add({ type, weight: 2, timeStamp: now - 500 });
+    tracker.add({ type, weight: 3, timeStamp: now + 500 });
+    console.log("funcTimeW order", tracker.dStatic[type]);
+    tracker.cleanByTime(type, 200);
+    console.log("funcTimeW cleanByTime", tracker.dStatic[type]);
+    const w = tracker.weight(type, 1000);
+    console.log("funcTimeW weight 1s", w, tracker.dStatic[type]);
+}

package/lib/Exchange/CParams.d.ts

@@ -200,7 +200,6 @@ 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,7 +4,6 @@ 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;
@@ -33,7 +32,7 @@ function isParamGroupOrArray(param) {
 function isParamGroup(param) {
     return isParamGroupOrArray(param) && !Array.isArray(param.value);
 }
-function isSimpleParams2(params) {
+function isSimpleParams(params) {
     let t = false;
     for (let key in params) {
         const tr = params[key]["value"];
@@ -49,24 +48,6 @@ function isSimpleParams2(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);
@@ -183,48 +164,6 @@ 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 r2 = {
-        kBorrow: {
-            value: 1,
-            name: 'borrow step',
-            range: { max: 3, min: 1, step: 0.1 }
-        },
-        checkBorrow: { value: false, 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 i = mergeParamValuesToInfos(base, r2);
-    console.log(i);
-}
 function convert_(valuesObj, srcObj) {
     let resObj = {};
     if (srcObj instanceof Array)

package/lib/index.d.ts

@@ -7,6 +7,7 @@ export * from "./Common/Time";
 export * from "./Common/common";
 export * from "./Common/commonsServer";
 export * from "./Common/commonsServerMini";
+export * from "./Common/commonsServerMini2";
 export * from "./Common/event";
 export * from "./Common/funcTimeWait";
 export * from "./Common/List";

package/lib/index.js

@@ -47,6 +47,7 @@ __exportStar(require("./Common/Time"), exports);
 __exportStar(require("./Common/common"), exports);
 __exportStar(require("./Common/commonsServer"), exports);
 __exportStar(require("./Common/commonsServerMini"), exports);
+__exportStar(require("./Common/commonsServerMini2"), exports);
 __exportStar(require("./Common/event"), exports);
 __exportStar(require("./Common/funcTimeWait"), exports);
 __exportStar(require("./Common/List"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wenay-common",
-  "version": "1.0.231",
+  "version": "1.0.236",
   "description": "Common library",
   "strict": true,
   "main": "lib/index.js",
@@ -19,16 +19,16 @@
     "url": "https://github.com/wenayr/math.git"
   },
   "dependencies": {
-    "axios": "^1.12.2",
+    "axios": "^1.13.2",
     "create-hmac": "^1.1.7",
-    "express": "^4.21.2",
-    "socket.io": "^4.8.1",
-    "socket.io-client": "^4.8.1",
+    "express": "^5.2.1",
+    "socket.io": "^4.8.3",
+    "socket.io-client": "^4.8.3",
     "source-map-support": "^0.5.21",
     "xmlhttprequest": "^1.8.0"
   },
   "optionalDependencies": {
-    "utf-8-validate": "^6.0.5"
+    "utf-8-validate": "^6.0.6"
   },
   "exports": {
     ".": "./lib/index.js",

package/lib/Common/commonsServerTest.js

@@ -1 +0,0 @@
-"use strict";

package/lib/Common/node_test.d.ts

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

package/lib/Common/node_test.js

@@ -1,14 +0,0 @@
-"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()}`);
-}