wenay-common2 1.0.32 → 1.0.33

package/lib/Common/rcp/createRpcServerAutoWithProtocolDetection.d.ts

@@ -0,0 +1,20 @@
+import { funcListenCallbackBase } from "../events/Listen";
+import { type PromiseServerHooks, type RpcLimits } from "./rpc-server";
+import { DeepSocketListen } from "./listen-deep";
+import { type SocketTmpl } from "./rpc-protocol";
+type ListenCallbackBase<T extends any[] = any[]> = ReturnType<typeof funcListenCallbackBase<T>>;
+type ClientProtocol = 'v2' | 'legacy' | null;
+export declare function createRpcServerAuto2<T extends object>({ socket, object: target, socketKey: key, debug, hooks, disconnectListen, limits, onProtocolDetect, }: {
+    socket: SocketTmpl;
+    object: T;
+    socketKey: string;
+    debug?: boolean;
+    hooks?: Omit<PromiseServerHooks<DeepSocketListen<T>>, "resolveTransform">;
+    disconnectListen?: ListenCallbackBase<any>;
+    limits?: RpcLimits;
+    onProtocolDetect?: (protocol: 'v2' | 'legacy') => void;
+}): {
+    getProtocol: () => ClientProtocol;
+    getSchema: () => any;
+};
+export {};

package/lib/Common/rcp/createRpcServerAutoWithProtocolDetection.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRpcServerAuto2 = createRpcServerAuto2;
+const Listen_1 = require("../events/Listen");
+const listen_socket_1 = require("./listen-socket");
+const rpc_server_1 = require("./rpc-server");
+const rpc_protocol_1 = require("./rpc-protocol");
+const old_ommonsServerMini_1 = require("./old\u0421ommonsServerMini");
+function createRpcServerAuto_({ 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, listen_socket_1.listenSocket)(parent, { addListenClose: disconnectListen });
+            cache.set(parent, result);
+        }
+        return result;
+    }
+    (0, rpc_server_1.createRpcServer)({
+        socket, object: target, socketKey: key, debug, limits,
+        hooks: {
+            ...hooks,
+            resolveTransform: (obj) => {
+                if (!(0, Listen_1.isListenCallback)(obj))
+                    return obj;
+                return getListenSocket(obj, disconnectListen);
+            },
+        },
+    });
+}
+function createRpcServerAuto2({ socket, object: target, socketKey: key, debug = false, hooks, disconnectListen, limits, onProtocolDetect, }) {
+    const cache = new WeakMap();
+    function getListenSocket(parent) {
+        let result = cache.get(parent);
+        if (!result) {
+            result = (0, listen_socket_1.listenSocket)(parent, { addListenClose: disconnectListen });
+            cache.set(parent, result);
+        }
+        return result;
+    }
+    function resolveTransform(obj) {
+        if (!(0, Listen_1.isListenCallback)(obj))
+            return obj;
+        return getListenSocket(obj);
+    }
+    function transformTree(obj) {
+        if (obj == null || typeof obj !== 'object')
+            return obj;
+        const transformed = resolveTransform(obj);
+        if (transformed !== obj)
+            return transformed;
+        const out = {};
+        for (const k of Object.keys(obj)) {
+            const v = obj[k];
+            out[k] = typeof v === 'function' ? v : (v != null && typeof v === 'object') ? transformTree(v) : v;
+        }
+        return out;
+    }
+    function serialize(obj) {
+        const out = {};
+        for (const k of Object.keys(obj)) {
+            const v = obj[k];
+            if (v == null)
+                out[k] = 'null';
+            else if (typeof v === 'function')
+                out[k] = 'func';
+            else if (typeof v === 'object')
+                out[k] = serialize(v);
+            else
+                out[k] = 'unknown';
+        }
+        return out;
+    }
+    const resolved = transformTree(target);
+    const strictSchema = serialize(resolved);
+    let protocol = null;
+    let v2Handler = null;
+    let legacyHandler = null;
+    function isLegacyMessage(msg) {
+        return (typeof msg === 'object' &&
+            msg !== null &&
+            !Array.isArray(msg) &&
+            typeof msg.mapId === 'number' &&
+            (msg.data !== undefined || msg.error !== undefined));
+    }
+    function isLegacyStrictRequest(msg) {
+        return msg === '___STRICTLY';
+    }
+    function isV2Message(msg) {
+        return (Array.isArray(msg) && (msg[0] === rpc_protocol_1.Pkt.CALL || msg[0] === rpc_protocol_1.Pkt.PIPE)) || msg === rpc_protocol_1.Pkt.STRICT;
+    }
+    function initLegacy() {
+        if (legacyHandler)
+            return;
+        let onMessageCb = null;
+        (0, old_ommonsServerMini_1.promiseServer)({
+            sendMessage: (msg) => socket.emit(key, msg),
+            api: ({ onMessage }) => { onMessageCb = onMessage; },
+        }, resolved);
+        legacyHandler = (msg) => onMessageCb?.(msg);
+    }
+    function initV2() {
+        if (v2Handler)
+            return;
+        let onMsgCb = null;
+        const innerSocket = {
+            emit: (e, d) => socket.emit(e, d),
+            on: (e, cb) => { if (e === key)
+                onMsgCb = cb; },
+        };
+        if (debug) {
+            const origOn = innerSocket.on.bind(innerSocket);
+            innerSocket.on = (e, cb) => origOn(e, (d) => { console.log('[RPC IN]', typeof d === 'object' ? JSON.stringify(d) : d); cb(d); });
+        }
+        (0, rpc_server_1.createRpcServer)({
+            socket: innerSocket,
+            object: target,
+            socketKey: key,
+            debug: false,
+            limits,
+            hooks: {
+                ...hooks,
+                resolveTransform,
+            },
+        });
+        v2Handler = (msg) => onMsgCb?.(msg);
+    }
+    socket.on(key, (msg) => {
+        if (debug) {
+            console.log('[RPC-AUTO2]', typeof msg === 'object' ? JSON.stringify(msg) : msg);
+        }
+        if (protocol === null) {
+            if (isLegacyStrictRequest(msg)) {
+                protocol = 'legacy';
+                onProtocolDetect?.('legacy');
+                socket.emit(key, { STRICTLY: strictSchema });
+                initLegacy();
+                return;
+            }
+            if (isLegacyMessage(msg)) {
+                protocol = 'legacy';
+                onProtocolDetect?.('legacy');
+                initLegacy();
+                legacyHandler(msg);
+                return;
+            }
+            if (isV2Message(msg)) {
+                protocol = 'v2';
+                onProtocolDetect?.('v2');
+                initV2();
+                v2Handler(msg);
+                return;
+            }
+            return;
+        }
+        if (protocol === 'legacy') {
+            if (isLegacyStrictRequest(msg)) {
+                socket.emit(key, { STRICTLY: strictSchema });
+                return;
+            }
+            legacyHandler(msg);
+        }
+        else {
+            v2Handler(msg);
+        }
+    });
+    return {
+        getProtocol: () => protocol,
+        getSchema: () => strictSchema,
+    };
+}

package/lib/Common/rcp/oldCommonsServer.d.ts

@@ -0,0 +1,117 @@
+type tSocket = {
+    emit: (marker: string, object: any) => any;
+    on: (marker: string, callback: (a: any) => any) => any;
+};
+export type tRequestScreenerT<T> = {
+    key: string[];
+    callbacksId?: string[];
+    request: any[];
+};
+type tt = {
+    [k: string]: any;
+};
+export declare function funcPromiseServer<T extends tt>(data: screenerSoc<tSocketData<tRequestScreenerT<T>>>, obj: T): void;
+export declare function funcPromiseServer2<T extends object>(sendMessage: screenerSoc222<tSocketData<tRequestScreenerT<T>>>, obj: T): (datum: any) => Promise<void>;
+type tSocketData<T> = ({
+    data: T;
+    error?: undefined;
+} | {
+    error: any;
+    data?: undefined;
+}) & {
+    mapId: number;
+    wait?: boolean;
+    callbacksId?: number[];
+};
+type screenerSoc<T> = {
+    sendMessage: (data: T) => void;
+    api: (data: {
+        onMessage: (data: T) => void | Promise<void>;
+    }) => void;
+};
+type screenerSoc222<T> = (data: T) => void;
+export declare function funcForWebSocket<T>(data: screenerSoc<tSocketData<tRequestScreenerT<T>>> & {
+    limit?: number;
+}): screenerSoc2<T>;
+type tFunc = (a: any) => any;
+export type screenerSoc2<T> = {
+    send: (data: tRequestScreenerT<T>, wait?: boolean, callbacksId?: tFunc[]) => Promise<any>;
+    api: screenerSocApi<T>;
+};
+export type screenerSocApi<T> = {
+    log: (status: boolean) => void;
+    promiseTotal: () => number;
+    callbackTotal: () => number;
+    promiseDeleteAll: (reject: boolean) => void;
+    callbackDeleteAll: () => void;
+    callbackDelete: (func: tFunc) => void;
+};
+export type tMethodToPromise2<T extends object> = {
+    [P in keyof T]: T[P] extends ((...args: infer Z) => infer X) ? X extends Promise<any> ? T[P] : (...args: Z) => Promise<X> : T[P] extends object ? tMethodToPromise2<T[P]> : never;
+};
+export type tMethodToPromise4<T extends object> = {
+    [P in keyof T]: T[P] extends ((...args: infer Z) => infer X) ? X extends Promise<any> ? T[P] : (...args: Z) => Promise<X> : T[P] extends object ? tMethodToPromise4<T[P]> : T[P];
+};
+type tt5<T extends any> = T extends Promise<infer R> ? R : T;
+export type tMethodToPromise5<T extends object> = {
+    [P in keyof T]: T[P] extends ((...args: infer Z) => infer X) ? (...args: Z) => Promise<tt5<X>> : T[P] extends object ? tMethodToPromise5<T[P]> : never;
+};
+export type tMethodToPromise6<T extends object> = {
+    [P in keyof T]: T[P] extends ((...args: infer Z) => infer X) ? (...args: Z) => Promise<tt5<X>> : T[P] extends object ? tMethodToPromise6<T[P]> : T[P];
+};
+export declare function funcScreenerClient2<T extends object>(data: screenerSoc2<T>, wait?: boolean): tMethodToPromise5<T>;
+type tAndB<T> = {
+    data: T;
+    void: () => void;
+};
+export type screenerSoc3<T> = {
+    send: (data: tRequestScreenerT<T>) => tAndB<Promise<any>>;
+};
+export type tMethodToPromise3<T extends object> = {
+    [P in keyof T]: T[P] extends ((...args: infer Z) => infer X) ? (...args: Z) => (X extends Promise<any> ? tAndB<X> : tAndB<Promise<X>>) : tAndB<Promise<T[P]>>;
+};
+export type typeVoid2<T> = {
+    [P in Exclude<keyof T, {
+        [P in keyof T]: T[P] extends (any: any) => any ? ReturnType<T[P]> extends void ? P : never : never;
+    }[keyof T]>]: T[P];
+};
+export type typeNoVoid2<T> = {
+    [P in Exclude<keyof T, {
+        [P in keyof T]: T[P] extends (any: any) => any ? ReturnType<T[P]> extends void ? never : P : never;
+    }[keyof T]>]: T[P];
+};
+export type UnAwaited<T extends Promise<any>> = T extends Promise<infer R> ? R : never;
+export type UnAwaitedArr<T extends Promise<any>[]> = T extends Promise<infer R>[] ? R[] : never;
+export type ReturnTypePromise<T extends (...args: any) => any> = T extends (...args: any) => infer R ? R extends Promise<any> ? UnAwaited<R> : R : any;
+export type UnObject<T extends object> = T extends {
+    [k: string]: infer R;
+} ? R : never;
+export type UnArray<T extends any[]> = T extends (infer R)[] ? R : never;
+export type tElArr<T extends any[]> = UnArray<T>;
+export declare function CreatAPIFacadeClientOld<T extends object>({ socketKey, socket, limit }: {
+    socket: tSocket;
+    socketKey: string;
+    limit?: number;
+}): {
+    api: screenerSocApi<any>;
+    func: tMethodToPromise5<typeVoid2<T>>;
+    space: tMethodToPromise5<typeNoVoid2<T>>;
+    all: tMethodToPromise5<T>;
+    strictly: tMethodToPromise6<T>;
+    infoStrictly(): any;
+    strictlyInit(obj?: object): Promise<unknown>;
+};
+export declare function CreatAPIFacadeServerOld<T extends object>({ object, socket, socketKey, debug }: {
+    socket: tSocket;
+    object: T;
+    socketKey: string;
+    debug?: boolean;
+}): void;
+export declare function fMiniTest(): void;
+export declare class CTestWeb {
+    func(a: number, b: number): number;
+    func2(a: number, b: number): Promise<number>;
+    fun3(a: number, b: number): number;
+    test(): string;
+}
+export {};

package/lib/Common/rcp/oldCommonsServer.js

@@ -0,0 +1,372 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CTestWeb = void 0;
+exports.funcPromiseServer = funcPromiseServer;
+exports.funcPromiseServer2 = funcPromiseServer2;
+exports.funcForWebSocket = funcForWebSocket;
+exports.funcScreenerClient2 = funcScreenerClient2;
+exports.CreatAPIFacadeClientOld = CreatAPIFacadeClientOld;
+exports.CreatAPIFacadeServerOld = CreatAPIFacadeServerOld;
+exports.fMiniTest = fMiniTest;
+const common_1 = require("../core/common");
+function funcPromiseServer(data, obj) {
+    const buf = data;
+    data.api({
+        onMessage: async (datum) => {
+            const { key, request } = datum.data;
+            let buf2 = obj;
+            let nameF = "";
+            try {
+                for (let k of key) {
+                    nameF = k;
+                    if (typeof buf2[nameF] == "function")
+                        break;
+                    buf2 = buf2[nameF];
+                }
+            }
+            catch (e) {
+                data.sendMessage({ mapId: datum.mapId, error: { error: e, key: key, arguments: request } });
+                console.error({ error: e, key: key, arguments: request });
+                return;
+            }
+            const buf = buf2;
+            if (typeof buf[nameF] == "function") {
+                const { callbacksId } = datum;
+                if (callbacksId && Array.isArray(callbacksId)) {
+                    const arr = callbacksId.map((e) => {
+                        return (d) => {
+                            try {
+                                data.sendMessage({ mapId: e, data: d ?? undefined });
+                            }
+                            catch (e) {
+                                console.log("errrrr  !!!!!!", e);
+                            }
+                        };
+                    });
+                    let r = 0;
+                    request.forEach((e, i) => {
+                        if (e == "___FUNC")
+                            request[i] = arr[r++];
+                    });
+                }
+                const trt = async () => buf[nameF](...request);
+                await trt()
+                    .then(a => {
+                    if (datum.wait !== false)
+                        data.sendMessage({ mapId: datum.mapId, data: a ?? undefined });
+                })
+                    .catch((e) => {
+                    console.log(nameF, request, key);
+                    data.sendMessage({ mapId: datum.mapId, error: { error: e, key: key, arguments: request } });
+                    console.error({ error: e, key: key, arguments: request });
+                });
+            }
+            else {
+                data.sendMessage({
+                    mapId: datum.mapId,
+                    error: JSON.stringify({ data: "это не функция", key: key, arguments: request })
+                });
+                console.error({ data: "это не функция", key: key, arguments: request });
+            }
+        }
+    });
+}
+function funcPromiseServer2(sendMessage, obj) {
+    return async (datum) => {
+        const { key, request } = datum.data;
+        const buf = obj[key];
+        if (!buf)
+            return;
+        if (typeof buf == "function") {
+            const a = await (async () => buf(...request))();
+            sendMessage({ mapId: datum.mapId, data: a ?? undefined });
+        }
+        else
+            throw "это не функция";
+    };
+}
+function funcForWebSocket(data) {
+    const limit = data.limit;
+    const sendMessage = data.sendMessage;
+    const free = (() => {
+        const freeNums = [];
+        let [total, _poz] = [0, 0];
+        return {
+            log() {
+                console.log({ freeNums, total, _poz });
+            },
+            next() {
+                return _poz > 0 ? freeNums[--_poz] : ++total;
+            },
+            numsSet(num) {
+                freeNums[_poz++] = num;
+            }
+        };
+    })();
+    const map = new Map();
+    const callbackMany = new Map();
+    data.api({
+        onMessage: (data) => {
+            const { mapId } = data;
+            if (map.has(mapId)) {
+                const buf = map.get(mapId);
+                map.delete(mapId);
+                free.numsSet(mapId);
+                if (data.error)
+                    buf?.reject(data.error);
+                else
+                    buf?.resolve(data.data);
+            }
+            else if (callbackMany.has(mapId)) {
+                const buf = callbackMany.get(mapId);
+                if (data.data == "___STOP") {
+                    callbackMany.delete(mapId);
+                    free.numsSet(mapId);
+                }
+                buf?.(data.data);
+            }
+            else {
+                console.error("пришел ответ которого не ждали ", data);
+            }
+        }
+    });
+    let status = false;
+    const api = {
+        log(_status) { status = _status; },
+        promiseTotal: () => map.size,
+        callbackTotal: () => callbackMany.size,
+        promiseDeleteAll: (reject = true) => {
+            const arr = [...map.values()];
+            const arrKey = [...map.keys()];
+            map.clear();
+            arrKey.forEach(e => free.numsSet(+e));
+            arr.forEach((e) => reject ? e.reject("promiseDeleteAll") : e.resolve(undefined));
+        },
+        callbackDeleteAll: () => {
+            const arr = [...callbackMany.keys()];
+            callbackMany.clear();
+            arr.forEach(e => free.numsSet(+e));
+        },
+        callbackDelete: (func) => {
+            callbackMany.forEach((e, key) => {
+                if (e == func) {
+                    callbackMany.delete(key);
+                    free.numsSet(+key);
+                }
+            });
+        },
+    };
+    return {
+        api,
+        send: (data, wait, callbacksId) => new Promise((resolve, reject) => {
+            const send = {
+                mapId: free.next(),
+                data,
+                wait: wait,
+                callbacksId: []
+            };
+            for (const el of callbacksId ?? []) {
+                const id = free.next();
+                send.callbacksId?.push(id);
+                if (status) {
+                    console.log("ключ стрмиа ", id, " ", send);
+                }
+                callbackMany.set(id, el);
+            }
+            if (wait !== false)
+                map.set(send.mapId, { resolve, reject });
+            if (status) {
+                free.log();
+                console.log("ключ сокета ", send.mapId, " ", send);
+            }
+            if (limit && callbackMany.size >= limit)
+                console.log("callbackMany.size = ", callbackMany.size);
+            if (limit && map.size >= limit)
+                console.log("map.size = ", map.size);
+            sendMessage(send);
+        })
+    };
+}
+function funcScreenerClient2(data, wait) {
+    const tr = (address) => new Proxy((() => { }), {
+        get(target, p, receiver) {
+            address.push(p);
+            return tr(address);
+        },
+        apply(target, thisArg, argArray) {
+            const callback = [];
+            const callback2 = [];
+            argArray.forEach((el, i) => {
+                if (typeof el == "function") {
+                    callback.push({ func: el, poz: i });
+                    callback2.push(el);
+                    argArray[i] = "___FUNC";
+                }
+            });
+            return data.send({ key: address, request: argArray }, wait, callback2);
+        }
+    });
+    const tr2 = () => new Proxy({}, {
+        get(target, p, receiver) {
+            return tr([String(p)]);
+        },
+    });
+    return tr2();
+}
+function funcScreenerClient3(data, obj, wait) {
+    const tr = (address) => new Proxy((() => { }), {
+        has(target, p) {
+            let o = obj();
+            for (let a of address) {
+                o = o?.[a];
+                if (!o)
+                    break;
+                if (o == "null")
+                    return false;
+            }
+            o = o?.[p];
+            if (o == "null")
+                return false;
+            return true;
+        },
+        get(target, p, receiver) {
+            let o = obj();
+            for (let a of address) {
+                o = o?.[a];
+                if (!o)
+                    break;
+                if (o == "null")
+                    return undefined;
+            }
+            o = o?.[p];
+            if (o == "null")
+                return undefined;
+            return tr([...address, String(p)]);
+        },
+        apply(target, thisArg, argArray) {
+            let o = obj();
+            for (let a of address) {
+                o = o?.[a];
+                if (!o)
+                    break;
+                if (o == "null")
+                    return undefined;
+            }
+            if (address.at(-1) == "call") {
+                address.length = address.length - 1;
+                argArray.splice(0, 1);
+            }
+            const callback = [];
+            const callback2 = [];
+            argArray.forEach((el, i) => {
+                if (typeof el == "function") {
+                    callback.push({ func: el, poz: i });
+                    callback2.push(el);
+                    argArray[i] = "___FUNC";
+                }
+            });
+            return data.send({ key: address, request: argArray }, wait, callback2);
+        }
+    });
+    const tr2 = () => new Proxy({}, {
+        has(target, p) {
+            let o = obj();
+            o = o?.[p];
+            if (o == "null")
+                return false;
+            return true;
+        },
+        get(target, p, receiver) {
+            let o = obj();
+            if (o) {
+                if (o[p] == "null")
+                    return undefined;
+            }
+            return tr([String(p)]);
+        },
+    });
+    return tr2();
+}
+function CreatAPIFacadeClientOld({ socketKey, socket, limit }) {
+    let strictlyObj = {};
+    let promiseStrictly = Promise.resolve();
+    let funcPromise;
+    const tr = funcForWebSocket({
+        sendMessage: (data) => socket.emit(socketKey, data),
+        api: (data) => {
+            socket.on(socketKey, (d) => {
+                if (typeof d == "object" && d?.STRICTLY) {
+                    Object.keys(strictlyObj).forEach(k => { delete strictlyObj[k]; });
+                    Object.assign(strictlyObj, d.STRICTLY);
+                    funcPromise?.(undefined);
+                }
+                else
+                    data.onMessage(d);
+            });
+        },
+        limit
+    });
+    const func = funcScreenerClient2(tr);
+    const strictly = funcScreenerClient3(tr, () => strictlyObj);
+    const space = funcScreenerClient2(tr, false);
+    return {
+        api: tr.api,
+        func,
+        space,
+        all: func,
+        strictly,
+        infoStrictly() { return strictlyObj; },
+        async strictlyInit(obj) {
+            if (obj)
+                strictlyObj = obj;
+            else {
+                socket.emit(socketKey, "___STRICTLY");
+                return new Promise(resolve => {
+                    funcPromise = resolve;
+                });
+            }
+        }
+    };
+}
+function CreatAPIFacadeServerOld({ object, socket, socketKey, debug = false }) {
+    function ff(obj) {
+        return Object.fromEntries(Object.entries(obj).map(([k, v]) => {
+            return [
+                k, typeof v == "object" && v != null ? ff(v) : typeof v == "function" ? "func" : !v ? "null" : "unknow"
+            ];
+        }));
+    }
+    const t = ff(object);
+    funcPromiseServer({
+        sendMessage: (data) => socket.emit(socketKey, data),
+        api: (api) => {
+            socket.on(socketKey, (d) => {
+                if (debug)
+                    console.log(typeof d == "object" ? JSON.stringify(d) : d);
+                if (d == "___STRICTLY") {
+                    socket.emit(socketKey, { STRICTLY: t });
+                }
+                else
+                    api.onMessage(d);
+            });
+        }
+    }, object);
+}
+function fMiniTest() {
+}
+class CTestWeb {
+    func(a, b) {
+        return a + b;
+    }
+    async func2(a, b) {
+        await (0, common_1.sleepAsync)(1000);
+        return a * b;
+    }
+    fun3(a, b) {
+        return a ** b;
+    }
+    test() {
+        return "status ok";
+    }
+}
+exports.CTestWeb = CTestWeb;

package/lib/Common/rcp/old/320/241ommonsServerMini.d.ts

@@ -0,0 +1,105 @@
+type Socket = {
+    emit: (e: string, p: any) => any;
+    on: (e: string, cb: (d: any) => any) => any;
+};
+export type RequestScreener<T> = {
+    key: string[];
+    callbacksId?: string[];
+    request: any[];
+};
+type Obj = {
+    [k: string]: any;
+};
+type SocketData<T> = ({
+    data: T;
+    error?: undefined;
+} | {
+    error: any;
+    data?: undefined;
+}) & {
+    mapId: number;
+    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>>> & {
+    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;
+    promiseTotal: () => number;
+    callbackTotal: () => number;
+    promiseDeleteAll: (rej: boolean) => void;
+    callbackDeleteAll: () => void;
+    callbackDelete: (fn: Func) => void;
+};
+type UnwrapPromise<T> = T extends Promise<infer R> ? R : T;
+export type MethodToPromise<T extends object> = {
+    [P in keyof T]: T[P] extends (...args: infer Z) => infer X ? (...args: Z) => Promise<UnwrapPromise<X>> : T[P] extends object ? MethodToPromise<T[P]> : never;
+};
+export type MethodToPromiseStrict<T extends object> = {
+    [P in keyof T]: T[P] extends (...args: infer Z) => infer X ? (...args: Z) => Promise<UnwrapPromise<X>> : T[P] extends object ? MethodToPromiseStrict<T[P]> : T[P];
+};
+export declare function wsWrapper<T>(soc: ScreenerSoc<SocketData<RequestScreener<T>>> & {
+    limit?: number;
+}): ScreenerSoc2<T>;
+export declare function createClientProxy<T extends object>(soc2: ScreenerSoc2<T>, wait?: boolean): MethodToPromise<T>;
+export type NoVoid<T> = {
+    [P in Exclude<keyof T, {
+        [K in keyof T]: T[K] extends (...args: any[]) => any ? ReturnType<T[K]> extends void ? K : never : never;
+    }[keyof T]>]: T[P];
+};
+export type OnlyVoid<T> = {
+    [P in Exclude<keyof T, {
+        [K in keyof T]: T[K] extends (...args: any[]) => any ? ReturnType<T[K]> extends void ? never : K : never;
+    }[keyof T]>]: T[P];
+};
+export declare function createAPIFacadeClient<T extends object>({ socket: sock, socketKey: key, limit }: {
+    socket: Socket;
+    socketKey: string;
+    limit?: number;
+}): {
+    api: ScreenerSocApi<any>;
+    func: MethodToPromise<NoVoid<T>>;
+    space: MethodToPromise<OnlyVoid<T>>;
+    all: MethodToPromise<T>;
+    strict: MethodToPromiseStrict<T>;
+    infoStrict: () => any;
+    strictInit(obj?: object): Promise<unknown>;
+};
+export declare function createAPIFacadeServer<T extends object>({ socket: sock, object: targetObj, socketKey: key, debug }: {
+    socket: Socket;
+    object: T;
+    socketKey: string;
+    debug?: boolean;
+}): void;
+export declare const CreatAPIFacadeServer: typeof createAPIFacadeServer;
+export declare const CreatAPIFacadeClient: typeof createAPIFacadeClient;
+export {};

package/lib/Common/rcp/old/320/241ommonsServerMini.js

@@ -0,0 +1,320 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreatAPIFacadeClient = exports.CreatAPIFacadeServer = void 0;
+exports.promiseServer = promiseServer;
+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 {
+                for (const k of key) {
+                    fnName = k;
+                    if (typeof curr[fnName] === "function")
+                        break;
+                    curr = curr[fnName];
+                }
+            }
+            catch (e) {
+                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) => {
+                        try {
+                            soc.sendMessage({ mapId: id, data: data ?? undefined });
+                        }
+                        catch (err) {
+                            console.log("Ошибка callback", err);
+                        }
+                    });
+                    let idx = 0;
+                    request.forEach((item, i) => { if (item === "___FUNC")
+                        request[i] = cbArr[idx++]; });
+                }
+                try {
+                    const res = await curr[fnName](...request);
+                    if (msg.wait !== false)
+                        soc.sendMessage({ mapId: msg.mapId, data: res ?? undefined });
+                }
+                catch (e) {
+                    console.log(fnName, request, key);
+                    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 });
+            }
+        } });
+}
+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)) {
+                const p = promises.get(id);
+                promises.delete(id);
+                pool.release(id);
+                msg.error ? p.reject(msg.error) : p.resolve(msg.data);
+            }
+            else if (cbsMap.has(id)) {
+                const cb = cbsMap.get(id);
+                if (msg.data === "___STOP") {
+                    cbsMap.delete(id);
+                    pool.release(id);
+                }
+                cb(msg.data);
+            }
+            else
+                console.error("Неожиданный ответ", msg);
+        }
+    });
+    let debug = false;
+    const api = {
+        log: (s) => { debug = s; },
+        promiseTotal: () => promises.size,
+        callbackTotal: () => cbsMap.size,
+        promiseDeleteAll: (rej = true) => {
+            const arr = [...promises.values()], keys = [...promises.keys()];
+            promises.clear();
+            keys.forEach(k => pool.release(k));
+            arr.forEach(p => (rej ? p.reject("promiseDeleteAll") : p.resolve(undefined)));
+        },
+        callbackDeleteAll: () => { const keys = [...cbsMap.keys()]; cbsMap.clear(); keys.forEach(k => pool.release(k)); },
+        callbackDelete: (fn) => { cbsMap.forEach((cb, key) => { if (cb === fn) {
+            cbsMap.delete(key);
+            pool.release(key);
+        } }); }
+    };
+    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();
+                msg.callbacksId.push(id);
+                if (debug)
+                    console.log("Ключ callback", id, msg);
+                cbsMap.set(id, fn);
+            }
+            if (wait !== false)
+                promises.set(msg.mapId, { resolve, reject });
+            if (debug) {
+                pool.log();
+                console.log("Ключ сокета", msg.mapId, msg);
+            }
+            if (max && cbsMap.size >= max)
+                console.log("callbacksMap.size =", cbsMap.size);
+            if (max && promises.size >= max)
+                console.log("promises.size =", promises.size);
+            sendMsg(msg);
+        })
+    };
+}
+function createClientProxy(soc2, wait) {
+    const chain = (path) => new Proxy(() => { }, {
+        get: (_, p) => { path.push(String(p)); return chain(path); },
+        apply: (_, __, args) => {
+            const fns = [];
+            args.forEach((arg, i) => { if (typeof arg === "function") {
+                fns.push(arg);
+                args[i] = "___FUNC";
+            } });
+            return soc2.send({ key: path, request: args }, wait, fns);
+        }
+    });
+    return new Proxy({}, { get: (_, p) => chain([String(p)]) });
+}
+function createClientProxyStrict(soc2, getTarget, wait) {
+    const chain = (path) => {
+        let tgt = getTarget();
+        for (const a of path) {
+            tgt = tgt?.[a];
+        }
+        if (!tgt || tgt === "null" || tgt === "unknown")
+            return undefined;
+        const baseObject = tgt === "func" ? function () { } : {};
+        const r = new Proxy(baseObject, {
+            has: (_, p) => {
+                console.log(_, p, "has", path);
+                return tgt?.[p] !== "null";
+            },
+            getPrototypeOf(_) {
+                if (!tgt || tgt === "null")
+                    return Object.prototype;
+                if (tgt == "func")
+                    return Function.prototype;
+                return null;
+            },
+            ownKeys: typeof tgt != "object" ? undefined : (target) => Object.keys(tgt),
+            getOwnPropertyDescriptor: typeof tgt != "object" ? undefined : (target, prop) => ({ enumerable: true, configurable: true }),
+            get: (_, p) => {
+                if (p == "call" && tgt == "func") {
+                    return (_, ...args) => {
+                        const fns = [];
+                        args.forEach((arg, i) => { if (typeof arg === "function") {
+                            fns.push(arg);
+                            args[i] = "___FUNC";
+                        } });
+                        return soc2.send({ key: path, request: args }, wait, fns);
+                    };
+                }
+                return tgt?.[p] === "null" ? undefined : chain([...path, String(p)]);
+            },
+            apply: (_, __, args) => {
+                console.log(path);
+                if (path.at(-1) === "call") {
+                    path.length--;
+                    args.splice(0, 1);
+                }
+                const fns = [];
+                args.forEach((arg, i) => { if (typeof arg === "function") {
+                    fns.push(arg);
+                    args[i] = "___FUNC";
+                } });
+                return soc2.send({ key: path, request: args }, wait, fns);
+            }
+        });
+        return r;
+    };
+    return new Proxy({}, {
+        has: (_, p) => getTarget()?.[p] !== "null",
+        get: (_, p) => (getTarget() && getTarget()[p] === "null" ? undefined : chain([String(p)]))
+    });
+}
+function createAPIFacadeClient({ socket: sock, socketKey: key, limit }) {
+    let strictData = {}, resolveStrict;
+    const wsWrap = wsWrapper({
+        sendMessage: (msg) => sock.emit(key, msg),
+        api: ({ onMessage }) => {
+            sock.on(key, (d) => {
+                if (typeof d === "object" && d?.STRICTLY) {
+                    Object.keys(strictData).forEach(k => delete strictData[k]);
+                    Object.assign(strictData, d.STRICTLY);
+                    resolveStrict?.(undefined);
+                }
+                else
+                    onMessage(d);
+            });
+        },
+        limit,
+    });
+    const func = createClientProxy(wsWrap);
+    const strict = createClientProxyStrict(wsWrap, () => strictData);
+    const space = createClientProxy(wsWrap, false);
+    return { api: wsWrap.api, func, space, all: func, strict, infoStrict: () => strictData, async strictInit(obj) {
+            if (obj)
+                strictData = obj;
+            else {
+                sock.emit(key, "___STRICTLY");
+                return new Promise(resolve => { resolveStrict = resolve; });
+            }
+        } };
+}
+function createAPIFacadeServer({ socket: sock, object: targetObj, socketKey: key, debug = false }) {
+    function serialize(obj) {
+        return Object.fromEntries(Object.entries(obj).map(([k, v]) => [k, typeof v === "object" && v != null ? serialize(v) : typeof v === "function" ? "func" : !v ? "null" : "unknown"]));
+    }
+    const ser = serialize(targetObj);
+    promiseServer({ sendMessage: (msg) => sock.emit(key, msg), api: ({ onMessage }) => {
+            sock.on(key, (d) => {
+                if (debug)
+                    console.log(typeof d === "object" ? JSON.stringify(d) : d);
+                if (d === "___STRICTLY")
+                    sock.emit(key, { STRICTLY: ser });
+                else
+                    onMessage(d);
+            });
+        } }, targetObj);
+}
+exports.CreatAPIFacadeServer = createAPIFacadeServer;
+exports.CreatAPIFacadeClient = createAPIFacadeClient;

package/lib/Common/rcp/rpc-index.d.ts

@@ -9,3 +9,4 @@ export * from "./rpc-server";
 export * from "./rpc-client-auto";
 export * from "./rpc-server-auto";
 export * from "./rpc-clientHub";
+export { createRpcServerAuto2 } from "./createRpcServerAutoWithProtocolDetection";

package/lib/Common/rcp/rpc-index.js

@@ -14,6 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRpcServerAuto2 = void 0;
 __exportStar(require("./listen-socket"), exports);
 __exportStar(require("./listen-deep"), exports);
 __exportStar(require("./rpc-dynamic"), exports);
@@ -25,3 +26,5 @@ __exportStar(require("./rpc-server"), exports);
 __exportStar(require("./rpc-client-auto"), exports);
 __exportStar(require("./rpc-server-auto"), exports);
 __exportStar(require("./rpc-clientHub"), exports);
+var createRpcServerAutoWithProtocolDetection_1 = require("./createRpcServerAutoWithProtocolDetection");
+Object.defineProperty(exports, "createRpcServerAuto2", { enumerable: true, get: function () { return createRpcServerAutoWithProtocolDetection_1.createRpcServerAuto2; } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wenay-common2",
-  "version": "1.0.32",
+  "version": "1.0.33",
   "description": "Common library",
   "strict": true,
   "main": "lib/index.js",