wenay-common2 1.0.1

package/lib/Common/math/Math.d.ts

@@ -0,0 +1,12 @@
+type tCorrelationByBuffer = {
+    max: number;
+    bufferOn?: boolean;
+};
+export declare function CorrelationRollingByBuffer(data: tCorrelationByBuffer): {
+    init(data: tCorrelationByBuffer): void;
+    clear(data?: tCorrelationByBuffer): void;
+    corr2(val1: number, val2: number, key1: any, key2: any): {
+        corr: number;
+    };
+};
+export {};

package/lib/Common/math/Math.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CorrelationRollingByBuffer = CorrelationRollingByBuffer;
+function CorrelationRollingByBuffer(data) {
+    let setting = { ...data };
+    const map = new Map();
+    const defBuf = () => ({
+        sum1: 0, sum2: 0,
+        pow1: 0, pow2: 0,
+        mulSum: 0, step: 0,
+        history1: [], history2: []
+    });
+    const getBuffer = (key1, key2) => {
+        let a1 = map.get(key1);
+        if (!a1)
+            map.set(key1, a1 = new Map());
+        let a2 = a1.get(key2);
+        if (!a2)
+            a1.set(key2, a2 = defBuf());
+        return a2;
+    };
+    return {
+        init(data) { setting = { ...data }; },
+        clear(data) {
+            map.clear();
+            if (data)
+                this.init(data);
+        },
+        corr2(val1, val2, key1, key2) {
+            const buffer = setting.bufferOn ? getBuffer(key1, key2) : defBuf();
+            buffer.history1.push(val1);
+            buffer.history2.push(val2);
+            let dropped1 = 0;
+            let dropped2 = 0;
+            if (buffer.history1.length > setting.max) {
+                dropped1 = buffer.history1.shift();
+                dropped2 = buffer.history2.shift();
+            }
+            else {
+                buffer.step++;
+            }
+            buffer.sum1 = buffer.sum1 + val1 - dropped1;
+            buffer.sum2 = buffer.sum2 + val2 - dropped2;
+            buffer.pow1 = buffer.pow1 + val1 ** 2 - dropped1 ** 2;
+            buffer.pow2 = buffer.pow2 + val2 ** 2 - dropped2 ** 2;
+            buffer.mulSum = buffer.mulSum + (val1 * val2) - (dropped1 * dropped2);
+            return calculatePearson(buffer, buffer.history1.length);
+        }
+    };
+}
+function calculatePearson(buffer, count) {
+    if (count < 2)
+        return { corr: 0 };
+    const { sum1, sum2, pow1, pow2, mulSum } = buffer;
+    const { sqrt } = Math;
+    if (!Number.isFinite(sum1) || !Number.isFinite(sum2) || !Number.isFinite(mulSum)) {
+        console.error("Invalid math values in correlation calculation", { sum1, sum2, mulSum });
+        return { corr: 0 };
+    }
+    const variance1 = count * pow1 - sum1 ** 2;
+    const variance2 = count * pow2 - sum2 ** 2;
+    if (variance1 <= 0 || variance2 <= 0) {
+        return { corr: 0 };
+    }
+    const dense = sqrt(variance1 * variance2);
+    const numerator = count * mulSum - (sum1 * sum2);
+    const result = numerator / dense;
+    if (result > 1)
+        return { corr: 1 };
+    if (result < -1)
+        return { corr: -1 };
+    return { corr: result };
+}

package/lib/Common/math/other.d.ts

@@ -0,0 +1,23 @@
+type tDatum = {
+    price: number[];
+    key: string | object | number;
+};
+type tfLeaderResult = {};
+declare function PriceTOSumPercent(price: number[]): number[];
+declare function strategyStepOfStepAll(symbols_: tDatum[]): {
+    leadersKey: {
+        key: string | object | number;
+        score: number;
+    }[];
+    leadersId: (number)[];
+    id: number;
+    key: string | object | number;
+}[];
+type tStepOfStep = {
+    t1: number[];
+    t2: number[];
+    minK?: number;
+    percentM?: number;
+    onlyBuy?: boolean;
+};
+declare function strategyStepOfStep({ t1, t2, minK: _minK, percentM: _percentM, onlyBuy: _onlyBuy }: tStepOfStep): number;

package/lib/Common/math/other.js

@@ -0,0 +1,70 @@
+"use strict";
+function PriceTOSumPercent(price) {
+    return price.map(e => e / price[0]);
+}
+function strategyStepOfStepAll(symbols_) {
+    const symbols = symbols_.map(e => ({ price: PriceTOSumPercent(e.price), key: e.key }));
+    const minK = 0;
+    const percentM = 1 / 100;
+    const result = [];
+    for (let i = 0; i < symbols.length; i++) {
+        const tt = { key: symbols[i].key, id: i, leadersId: [], leadersKey: [] };
+        result.push(tt);
+        for (let y = 0; y < symbols.length; y++) {
+            if (i == y)
+                continue;
+            const r = strategyStepOfStep({ t1: symbols[i].price, t2: symbols[y].price, minK, percentM });
+            if (r > 0) {
+                tt.leadersKey.push({ key: symbols[y].key, score: r });
+                tt.leadersId.push(y);
+            }
+        }
+        tt.leadersKey = tt.leadersKey.sort((a, b) => b.score - a.score);
+    }
+    return result;
+}
+function strategyStepOfStep({ t1, t2, minK: _minK, percentM: _percentM, onlyBuy: _onlyBuy }) {
+    const onlyBuy = !!_onlyBuy;
+    const minK = _minK ?? 0;
+    const percentM = _percentM ?? 1 / 100;
+    const conArr = (arr) => {
+        let last = arr[0], result = 0;
+        return arr.map(e => {
+            const r = e - last;
+            last = e;
+            result += r;
+            result = result * (1 - percentM);
+            return result;
+        });
+    };
+    const [r1, r2] = [t1, t2].map(e => conArr(e));
+    const length = r1.length;
+    let m1 = 0, m2 = 0;
+    const result1 = [0];
+    let [lastD1, lastD2] = [0, 0];
+    for (let i = 1; i < length; i++) {
+        const [d1, d2] = [r1[i], r2[i]];
+        const [p1, p2] = [t1[i] - t1[i - 1], t2[i] - t2[i - 1]];
+        result1.push((p1) * (d2 - d1));
+        [lastD1, lastD2] = [d1, d2];
+    }
+    const day = { profitDays: 0, lossDays: 0, profit: 0, loss: 0 };
+    for (let i = 0; i < result1.length; i++) {
+        if (result1[i] > 0) {
+            day.profitDays++;
+            day.profit += result1[i];
+        }
+        if (result1[i] < 0) {
+            day.lossDays++;
+            day.loss += result1[i];
+        }
+    }
+    const k1 = day.profitDays / result1.length;
+    const k1b = day.loss / result1.length;
+    const k2 = day.profit / ((day.profit + Math.abs(day.loss)) || 1);
+    let flag = -1;
+    if (day.profitDays > day.lossDays && day.profit > day.loss) {
+        flag = 1;
+    }
+    return k1 * k2 * flag;
+}

package/lib/Common/math/scoreLana.d.ts

@@ -0,0 +1,22 @@
+type tDatumL = {
+    price: number[];
+    key: string | object | number;
+};
+export declare function strategyStepOfStepAllL(symbols: tDatumL[]): {
+    leadersKey: {
+        key: string | object | number;
+        score: number;
+    }[];
+    leadersId: (number)[];
+    id: number;
+    key: string | object | number;
+}[];
+type tStepOfStepL = {
+    t1: number[];
+    t2: number[];
+    minK?: number;
+    percentM?: number;
+    onlyBuy?: boolean;
+};
+export declare function strategyStepOfStepL({ t1, t2, minK: _minK, percentM: _percentM, onlyBuy: _onlyBuy }: tStepOfStepL): number;
+export {};

package/lib/Common/math/scoreLana.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.strategyStepOfStepAllL = strategyStepOfStepAllL;
+exports.strategyStepOfStepL = strategyStepOfStepL;
+function strategyStepOfStepAllL(symbols) {
+    const minK = 0;
+    const percentM = 1 / 100;
+    const result = [];
+    for (let i = 0; i < symbols.length; i++) {
+        const tt = { key: symbols[i].key, id: i, leadersId: [], leadersKey: [] };
+        result.push(tt);
+        for (let y = 0; y < symbols.length; y++) {
+            if (i == y)
+                continue;
+            const r = strategyStepOfStepL({ t1: symbols[i].price, t2: symbols[y].price, minK, percentM });
+            if (r > 0) {
+                tt.leadersKey.push({ key: symbols[y].key, score: r });
+                tt.leadersId.push(y);
+            }
+        }
+    }
+    return result;
+}
+function PriceTOSumPercentL(price) {
+    return price.map(e => e / price[0]);
+}
+function strategyStepOfStepL({ t1, t2, minK: _minK, percentM: _percentM, onlyBuy: _onlyBuy }) {
+    const onlyBuy = !!_onlyBuy;
+    const minK = _minK ?? 0;
+    const percentM = _percentM ?? 1 / 100;
+    const conArr = (arr) => {
+        let last = arr[0], result = 0;
+        return arr.map(e => {
+            const r = e - last;
+            last = e;
+            result += r;
+            result = result * (1 - percentM);
+            return result;
+        });
+    };
+    const [r1, r2] = [t1, t2].map(e => conArr(e));
+    const length = r1.length;
+    let m1 = 0, m2 = 0;
+    const result1 = [0];
+    let [lastD1, lastD2] = [0, 0];
+    for (let i = 1; i < length; i++) {
+        const [d1, d2] = [r1[i], r2[i]];
+        const [p1, p2] = [t1[i] - t1[i - 1], t2[i] - t2[i - 1]];
+        const pLana = p1 - p2;
+        result1.push(p1 * d2);
+        [lastD1, lastD2] = [d1, d2];
+    }
+    const day = { profitDays: 0, lossDays: 0, profit: 0, loss: 0 };
+    for (let i = 0; i < result1.length; i++) {
+        if (result1[i] > 0) {
+            day.profitDays++;
+            day.profit += result1[i];
+        }
+        if (result1[i] < 0) {
+            day.lossDays++;
+            day.loss += result1[i];
+        }
+    }
+    const k1 = day.profitDays / result1.length;
+    const k2 = day.profit / ((day.profit + day.loss) || 1);
+    return k1 * k2;
+}

package/lib/Common/node_console.d.ts

@@ -0,0 +1,6 @@
+export {};
+export declare function enable(flag?: boolean): void;
+export declare function disable(): void;
+export declare function __LineFile(lvl?: number): string;
+export declare function __LineFile2(lvl?: number): string;
+export declare function __LineFiles(lvlStart?: number, lvlEnd?: number | undefined): string[];

package/lib/Common/node_console.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enable = enable;
+exports.disable = disable;
+exports.__LineFile = __LineFile;
+exports.__LineFile2 = __LineFile2;
+exports.__LineFiles = __LineFiles;
+const { self, window } = globalThis;
+let _enabled = false;
+function enable(flag = true) { _enabled = flag; }
+function disable() { _enabled = false; }
+let wrapCallSite;
+function setupLogs2() {
+    if (typeof self != 'object' && typeof window != "object") {
+        function moduleName(name) { return name; }
+        let inspector = require(moduleName('inspector'));
+        if (inspector.url() != undefined)
+            return;
+        try {
+            let module = require(moduleName('source-map-support'));
+            module.install();
+            wrapCallSite = module.wrapCallSite;
+        }
+        catch (e) {
+            console.warn(e);
+            return;
+        }
+        _enabled = true;
+        const origLogMethod = console.log;
+        const origErrorMethod = console.error;
+        let _callee;
+        for (let methodName of [
+            'debug', 'info', 'log', 'warn', 'error', 'group', 'groupCollapsed', 'table', 'timeLog', 'timeEnd',
+            'count', 'assert', 'dir', 'dirxml'
+        ]) {
+            const origMethod = console[methodName];
+            console[methodName] = ((...args) => {
+                if (!_enabled)
+                    return origMethod(...args);
+                const originalPrepareStackTrace = Error.prepareStackTrace;
+                Error.prepareStackTrace = (_, stack) => stack;
+                let callee = new Error().stack[1];
+                Error.prepareStackTrace = originalPrepareStackTrace;
+                if (!callee) {
+                    origErrorMethod("сallee is not found in node_console");
+                    _enabled = false;
+                    return origMethod(...args);
+                }
+                if (!methodName.match(/debug|info|log|warn|error|dirxml/)) {
+                    _callee ??= callee;
+                    return origMethod(...args);
+                }
+                if (_callee) {
+                    callee = _callee;
+                    _callee = undefined;
+                }
+                if (wrapCallSite)
+                    callee = wrapCallSite(callee);
+                const fileName = callee.getFileName();
+                if (fileName?.includes("source-map-support")) {
+                    origMethod(...args);
+                    return;
+                }
+                let fileAndLine = `${fileName}:${callee.getLineNumber()}:${callee.getColumnNumber()}  ` + callee.getFunctionName();
+                fileAndLine = fileAndLine.replaceAll("\\", "/");
+                fileAndLine = fileAndLine.replace("webpack:///", "");
+                fileAndLine = fileAndLine.replace("?", "");
+                if (!fileAndLine.startsWith("./"))
+                    if (!fileAndLine.toLowerCase().startsWith("file:///"))
+                        fileAndLine = "file:///" + fileAndLine;
+                let [firstArg, ...otherArgs] = args;
+                if (1)
+                    origMethod(...args, "", fileAndLine);
+                else if (typeof firstArg === 'string') {
+                    origMethod(fileAndLine + ' ' + firstArg, ...otherArgs);
+                }
+                else {
+                    origMethod(fileAndLine, ...args);
+                }
+            });
+        }
+    }
+}
+function setupLogs() {
+    if (typeof self != 'object' && typeof window != "object") {
+        function moduleName(name) { return name; }
+        let inspector = require(moduleName('inspector'));
+        if (inspector.url() != undefined)
+            return;
+        _enabled = true;
+        const origLogMethod = console.log;
+        const origErrorMethod = console.error;
+        let _callee;
+        for (let methodName of [
+            'debug', 'info', 'log', 'warn', 'error', 'group', 'groupCollapsed', 'table', 'timeLog', 'timeEnd',
+            'count', 'assert', 'dir', 'dirxml'
+        ]) {
+            const origMethod = console[methodName];
+            console[methodName] = ((...args) => {
+                if (!_enabled)
+                    return origMethod(...args);
+                const stack = new Error().stack;
+                if (!stack)
+                    return origMethod(...args);
+                const lines = stack.split('\n');
+                const callerLine = lines[2];
+                if (!callerLine)
+                    return origMethod(...args);
+                const match = callerLine.match(/at\s+(?:(.+?)\s+\()?(.+?):(\d+):(\d+)\)?/);
+                if (!match)
+                    return origMethod(...args);
+                const [, functionName, fileName, lineNumber, columnNumber] = match;
+                const funcName = functionName || '<anonymous>';
+                let fileAndLine = `${fileName}:${lineNumber}:${columnNumber}  ${funcName}`;
+                fileAndLine = fileAndLine.replaceAll("\\", "/");
+                fileAndLine = fileAndLine.replace("webpack:///", "");
+                fileAndLine = fileAndLine.replace("?", "");
+                if (!fileAndLine.startsWith("./"))
+                    if (!fileAndLine.toLowerCase().startsWith("file:///"))
+                        fileAndLine = "file:///" + fileAndLine;
+                if (!methodName.match(/debug|info|log|warn|error|dirxml/)) {
+                    _callee ??= fileAndLine;
+                    return origMethod(...args);
+                }
+                if (_callee) {
+                    fileAndLine = _callee;
+                    _callee = undefined;
+                }
+                origMethod(...args, "", fileAndLine);
+            });
+        }
+    }
+}
+if (1)
+    setupLogs();
+function __LineFile(lvl = 0) {
+    const stack = new Error().stack;
+    if (!stack)
+        return "";
+    const lines = stack.split('\n');
+    const targetLine = lines[lvl + 2];
+    if (!targetLine)
+        return "";
+    const match = targetLine.match(/at\s+(?:(.+?)\s+\()?(.+?):(\d+):(\d+)\)?/);
+    if (match) {
+        const [, functionName, fileName, lineNumber, columnNumber] = match;
+        const funcName = functionName || '<anonymous>';
+        return `${fileName}:${lineNumber}:${columnNumber}  ${funcName}`;
+    }
+    return targetLine.trim();
+}
+function __LineFile2(lvl = 0) {
+    const originalPrepareStackTrace = Error.prepareStackTrace;
+    Error.prepareStackTrace = (_, stack) => stack;
+    let e = new Error().stack[lvl + 1];
+    if (wrapCallSite)
+        e = wrapCallSite(e);
+    Error.prepareStackTrace = originalPrepareStackTrace;
+    return `${e.getFileName()}:${e.getLineNumber()}:${e.getColumnNumber()}  ` + e.getFunctionName();
+}
+function __LineFiles(lvlStart = 0, lvlEnd = 5) {
+    const originalPrepareStackTrace = Error.prepareStackTrace;
+    Error.prepareStackTrace = (_, stack) => stack;
+    let e = new Error().stack.slice(lvlStart + 1, lvlEnd);
+    if (wrapCallSite)
+        e = e.map(e => wrapCallSite(e));
+    const msgs = e.map(e => `${e.getFileName()}:${e.getLineNumber()}:${e.getColumnNumber()}  ` + e.getFunctionName());
+    Error.prepareStackTrace = originalPrepareStackTrace;
+    return msgs;
+}

package/lib/Common/rcp/listen-deep.d.ts

@@ -0,0 +1,20 @@
+import { funcListenCallbackBase } from "../events/Listen";
+import { listenSocket, listenSocketFirst, listenSocketAll, listenSocketSmart } from "./listen-socket";
+type Obj = Record<string, any>;
+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>>;
+type TransformValue<V> = V extends ListenBase<any> ? SocketResult<InferArgs<V>> : V extends typeof Promise ? V : V extends (...a: any) => any ? V : V extends object ? {
+    [K in keyof V]: TransformValue<V[K]>;
+} : V;
+export type DeepSocketListen<T> = {
+    [K in keyof T]: TransformValue<T[K]>;
+};
+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;
+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/rcp/listen-deep.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchKeys = matchKeys;
+exports.matchKeysList = matchKeysList;
+exports.deepMapByKeysList = deepMapByKeysList;
+exports.deepMapByKeys = deepMapByKeys;
+exports.deepListenFirst = deepListenFirst;
+exports.deepListenAll = deepListenAll;
+exports.deepListenSmart = deepListenSmart;
+const Listen_1 = require("../events/Listen");
+const listen_socket_1 = require("./listen-socket");
+function isLeafValue(value) {
+    return (value == null ||
+        typeof value === "function" ||
+        value instanceof Function ||
+        typeof value !== "object");
+}
+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) => (0, listen_socket_1.listenSocketFirst)(e, data));
+}
+function deepListenAll(obj, data) {
+    return deepMapByKeys(obj, NOOP_LISTEN, (e) => (0, listen_socket_1.listenSocketAll)(e, data));
+}
+function deepListenSmart(obj, data) {
+    return deepMapByKeys(obj, NOOP_LISTEN, (e) => (0, listen_socket_1.listenSocketSmart)(e, data));
+}

package/lib/Common/rcp/listen-socket.d.ts

@@ -0,0 +1,25 @@
+import { funcListenCallback, type Listener } from "../events/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;
+};
+export {};

package/lib/Common/rcp/listen-socket.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listenSocket = listenSocket;
+exports.listenSocketFirst = listenSocketFirst;
+exports.listenSocketAll = listenSocketAll;
+exports.listenSocketSmart = listenSocketSmart;
+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,
+    };
+}

package/lib/Common/rcp/rpc-client-auto.d.ts

@@ -0,0 +1,12 @@
+import { funcListenCallbackBase } from "../events/Listen";
+import type { DeepSocketListen } from "./listen-deep";
+import type { ClientAPI } from "./rpc-client";
+type ClientAutoOptions = {
+    readonly mode?: "smart" | "first" | "all";
+    readonly status?: () => boolean;
+    readonly addListenClose?: ReturnType<typeof funcListenCallbackBase<any>>;
+};
+export type ClientAutoResult<T> = DeepSocketListen<T>;
+export type AutoClientAPI<T> = ClientAPI<DeepSocketListen<T>>;
+export declare function createRpcClientAuto<T>(api: T, options?: ClientAutoOptions): ClientAutoResult<T>;
+export {};