wenay-common2 1.0.46 → 1.0.48

package/lib/Common/events/event.js

@@ -22,23 +22,26 @@ class CObjectEventsArr {
     AddStart(data) { this.data.unshift(data); this.setup(this.data[0]); }
     AddEnd(data) { this.setup(this.data[this.data.push(data) - 1]); }
     Add(data) { this.setup(this.data[this.data.push(data) - 1]); }
+    add(data, opts = {}) { opts.at == 'start' ? this.AddStart(data) : this.AddEnd(data); }
     OnEvent(data) { [...this.data].forEach((e) => { e.func?.(data); if (e.func2) {
         e.func2(data);
         e.del?.();
     } }); }
+    emit(data) { this.OnEvent(data); }
     OnSpecEvent(f) { [...this.data].forEach((e) => { const l = e.func?.(); l && f(l); if (e.func2) {
         e.func2();
         e.del?.();
     } }); }
     Clean() {
         const a = [...this.data];
-        this.data = [];
         for (let i = a.length - 1; i >= 0; i--) {
             a[i].del?.();
         }
     }
+    clear() { this.Clean(); }
     count() { return this.data.length; }
     get length() { return this.count(); }
+    get size() { return this.count(); }
 }
 exports.CObjectEventsArr = CObjectEventsArr;
 class CObjectEventsList {
@@ -67,22 +70,23 @@ class CObjectEventsList {
     AddStart(data) { this.setup(this.data.AddStart(data)); }
     AddEnd(data) { this.setup(this.data.AddEnd(data)); }
     Add(data) { this.setup(this.data.AddEnd(data)); }
+    add(data, opts = {}) { opts.at == 'start' ? this.AddStart(data) : this.AddEnd(data); }
     OnEvent(data) { const a = []; this.data.forEach(e => a.push(e)); a.forEach(e => { e.func?.(data); if (e.func2) {
         e.func2(data);
         e.del?.();
     } }); }
+    emit(data) { this.OnEvent(data); }
     OnSpecEvent(f) { const a = []; this.data.forEach(e => a.push(e)); a.forEach((e) => { const l = e.func?.(); if (l) {
         f(l);
     } if (e.func2) {
         e.func2();
         e.del?.();
     } }); }
-    Clean() { let r = this.data.First(); while (r) {
-        const buf = r;
-        r = r?.Next();
-        buf.DeleteLink();
-    } }
+    Clean() { const a = []; this.data.forEach(e => a.push(e)); for (let i = a.length - 1; i >= 0; i--)
+        a[i].del?.(); }
+    clear() { this.Clean(); }
     count() { return this.data.countRef(); }
     get length() { return this.count(); }
+    get size() { return this.count(); }
 }
 exports.CObjectEventsList = CObjectEventsList;

package/lib/Common/events/joinListens.d.ts

@@ -11,6 +11,8 @@ type JoinResult<R> = {
     listen: listen<[R, string]>[1];
     pending: Map<string, Map<string, any>>;
     clear: (tid?: string) => void;
+    destroy: () => void;
+    add: (port: listen<any>[1], key?: string) => void;
     addListen: (listener: listen<any>[1], key?: string) => void;
 };
 export declare function joinListens<T extends Record<string, any[]>>(listens: ListenMap<T>, keyExtractor?: KeyExtractor<any>): JoinResult<CollectedResult<T>>;

package/lib/Common/events/joinListens.js

@@ -18,7 +18,7 @@ function joinListens(listens, keyExtractor) {
         const result = isArray
             ? keys.map(k => bucket.get(k))
             : Object.fromEntries(bucket);
-        bucket.clear();
+        buckets.delete(tid);
         set(result, tid);
     };
     const unsubs = [];
@@ -30,31 +30,32 @@ function joinListens(listens, keyExtractor) {
             buckets.get(tid).set(portId, data.length <= 1 ? data[0] : data);
             tryFire(tid);
         };
-        listener.addListen(cb);
-        unsubs.push(() => listener.removeListen(cb));
+        unsubs.push(listener.addListen(cb));
     };
     for (const portId of keys) {
         bindPort(portId, map[portId]);
     }
+    function add(listener, key) {
+        const portId = isArray ? String(keys.length) : (key ?? String(keys.length));
+        if (map[portId])
+            return;
+        map[portId] = listener;
+        keys.push(portId);
+        bindPort(portId, listener);
+    }
     return {
         listen: out,
         pending: buckets,
         clear: (tid) => {
             tid ? buckets.delete(tid) : buckets.clear();
         },
-        destroy: (_tid) => {
+        destroy: () => {
             for (const u of unsubs)
                 u();
             unsubs.length = 0;
             buckets.clear();
         },
-        addListen: (listener, key) => {
-            const portId = isArray ? String(keys.length) : (key ?? String(keys.length));
-            if (map[portId])
-                return;
-            map[portId] = listener;
-            keys.push(portId);
-            bindPort(portId, listener);
-        }
+        add,
+        addListen: (listener, key) => add(listener, key)
     };
 }

package/lib/Common/funcTimeWait.d.ts

@@ -27,4 +27,32 @@ export declare const FuncTimeWait: {
     byWeight(type: tType, weight?: number): number;
     byWeightTimeNow(type: tType, timeNow?: number, weight?: number): number;
 };
+export declare function createRateWindow(): {
+    prune: (type: tType, ms?: number) => void;
+    sumWeight: (type: tType, ms?: number) => number;
+    readyAt: (type: tType, weight?: number) => number;
+    dStatic: {
+        [key: string]: [number, number][];
+    };
+    data: any[];
+    add(item: tFunc): void;
+    cleanByTime(type: tType, ms?: number): void;
+    weight(type: tType, ms?: number): number;
+    byWeight(type: tType, weight?: number): number;
+    byWeightTimeNow(type: tType, timeNow?: number, weight?: number): number;
+};
+export declare const rateWindow: {
+    prune: (type: tType, ms?: number) => void;
+    sumWeight: (type: tType, ms?: number) => number;
+    readyAt: (type: tType, weight?: number) => number;
+    dStatic: {
+        [key: string]: [number, number][];
+    };
+    data: any[];
+    add(item: tFunc): void;
+    cleanByTime(type: tType, ms?: number): void;
+    weight(type: tType, ms?: number): number;
+    byWeight(type: tType, weight?: number): number;
+    byWeightTimeNow(type: tType, timeNow?: number, weight?: number): number;
+};
 export {};

package/lib/Common/funcTimeWait.js

@@ -1,10 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FuncTimeWait = void 0;
+exports.rateWindow = exports.FuncTimeWait = void 0;
 exports.funcTimeW = funcTimeW;
+exports.createRateWindow = createRateWindow;
 function funcTimeW() {
     const dStatic = {};
     const data = [];
+    const sortByTime = (arr) => arr.sort((a, b) => a[0] - b[0]);
     return {
         dStatic,
         data,
@@ -13,11 +15,13 @@ function funcTimeW() {
                 dStatic[item.type] = [];
             }
             dStatic[item.type].push([item.timeStamp ?? Date.now(), item.weight]);
+            sortByTime(dStatic[item.type]);
         },
         cleanByTime(type, ms = 60 * 1000) {
             const arr = dStatic[type];
             if (!arr || arr.length === 0)
                 return;
+            sortByTime(arr);
             const timeStamp = Date.now();
             if (arr[0][0] > timeStamp - ms)
                 return;
@@ -33,6 +37,7 @@ function funcTimeW() {
             const arr = dStatic[type];
             if (!arr || arr.length === 0)
                 return 0;
+            sortByTime(arr);
             const timeStamp = Date.now();
             let sum = 0;
             let i = arr.length - 1;
@@ -51,6 +56,7 @@ function funcTimeW() {
             const arr = dStatic[type];
             if (!arr || arr.length === 0)
                 return 0;
+            sortByTime(arr);
             let sum = 0;
             let i = arr.length - 1;
             let result = 0;
@@ -70,6 +76,7 @@ function funcTimeW() {
             const arr = dStatic[type];
             if (!arr || arr.length === 0)
                 return 0;
+            sortByTime(arr);
             let sum = 0;
             let i = arr.length - 1;
             for (; i >= 0; i--) {
@@ -94,3 +101,13 @@ function funcTimeW() {
     };
 }
 exports.FuncTimeWait = funcTimeW();
+function createRateWindow() {
+    const w = funcTimeW();
+    return {
+        ...w,
+        prune: w.cleanByTime,
+        sumWeight: w.weight,
+        readyAt: w.byWeight,
+    };
+}
+exports.rateWindow = createRateWindow();

package/lib/Common/isProxy.d.ts

@@ -1,2 +1,3 @@
 export declare function isProxyInit(): void;
+export declare const installProxyTracking: typeof isProxyInit;
 export declare function isProxy(a: any): boolean;

package/lib/Common/isProxy.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.installProxyTracking = void 0;
 exports.isProxyInit = isProxyInit;
 exports.isProxy = isProxy;
 const isNode = typeof process !== 'undefined' && process.versions != null && process.versions.node != null;
@@ -31,6 +32,7 @@ function isProxyInit() {
     init = true;
     set();
 }
+exports.installProxyTracking = isProxyInit;
 function isProxy(a) {
     if (nodeIsProxy)
         return nodeIsProxy(a);

package/lib/Common/node_console.d.ts

@@ -4,3 +4,5 @@ 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[];
+export declare const callerLine: typeof __LineFile2;
+export declare const callerLines: typeof __LineFiles;

package/lib/Common/node_console.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.callerLines = exports.callerLine = void 0;
 exports.enable = enable;
 exports.disable = disable;
 exports.__LineFile = __LineFile;
@@ -9,78 +10,6 @@ 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; }
@@ -153,8 +82,6 @@ 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();
 }
@@ -162,9 +89,9 @@ 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;
 }
+exports.callerLine = __LineFile2;
+exports.callerLines = __LineFiles;

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

@@ -17,5 +17,7 @@ export declare function createRpcServerAuto2<T extends object>({ socket, object:
     getProtocol: () => ClientProtocol;
     getLegacySchema: () => any;
     getResolved: () => any;
+    dispose: (reason?: string) => void;
+    reset: () => void;
 };
 export {};

package/lib/Common/rcp/createRpcServerAutoWithProtocolDetection.js

@@ -8,42 +8,58 @@ const rpc_protocol_1 = require("./rpc-protocol");
 const old_ommonsServerMini_1 = require("./old\u0421ommonsServerMini");
 const rpc_dynamic_1 = require("./rpc-dynamic");
 const rpc_limits_1 = require("./rpc-limits");
-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();
+    const listenSockets = new Set();
+    function unsubscribeAllActive() {
+        for (const w of [...listenSockets])
+            w.removeCallback();
+    }
     function getListenSocket(parent) {
         let result = cache.get(parent);
+        if (result)
+            listenSockets.add(result);
         if (!result) {
-            result = (0, listen_socket_1.listenSocket)(parent, { addListenClose: disconnectListen });
+            const subs = new Map();
+            function subscribe(z) {
+                if (typeof z !== "function")
+                    return Promise.reject(new TypeError("Listen callback expects a function"));
+                subs.get(z)?.removeCallback();
+                const w = (0, listen_socket_1.listenSocket)(parent, { addListenClose: disconnectListen });
+                subs.set(z, w);
+                const done = w.callback(z);
+                done.then(() => { if (subs.get(z) == w)
+                    subs.delete(z); });
+                return done;
+            }
+            function subscribeOnce(z) {
+                if (typeof z !== "function")
+                    return Promise.reject(new TypeError("Listen once expects a function"));
+                subs.get(z)?.removeCallback();
+                const w = (0, listen_socket_1.listenSocket)(parent, { addListenClose: disconnectListen });
+                subs.set(z, w);
+                const done = w.once(z);
+                done.then(() => { if (subs.get(z) == w)
+                    subs.delete(z); });
+                return done;
+            }
+            function unsubscribeAll() {
+                subs.forEach(w => w.removeCallback());
+                subs.clear();
+                return true;
+            }
+            result = { callback: subscribe, removeCallback: unsubscribeAll, on: subscribe, once: subscribeOnce, close: () => parent.close?.() };
+            listenSockets.add(result);
             cache.set(parent, result);
         }
         return result;
     }
     function resolveTransform(obj) {
-        if (!(0, Listen_1.isListenCallback)(obj))
-            return obj;
-        return getListenSocket(obj);
+        if ((0, Listen_1.isListenCallback)(obj))
+            return getListenSocket(obj);
+        if ((0, Listen_1.isListenOn)(obj))
+            return getListenSocket((0, Listen_1.getListenByOn)(obj));
+        return obj;
     }
     function transformTree(obj) {
         let current = obj;
@@ -61,7 +77,7 @@ function createRpcServerAuto2({ socket, object: target, socketKey: key, debug =
                 out[k] = v;
                 continue;
             }
-            out[k] = typeof v === 'function' ? v : (v != null && typeof v === 'object') ? transformTree(v) : v;
+            out[k] = typeof v === 'function' ? resolveTransform(v) : (v != null && typeof v === 'object') ? transformTree(v) : v;
         }
         return out;
     }
@@ -96,6 +112,8 @@ function createRpcServerAuto2({ socket, object: target, socketKey: key, debug =
     let protocol = null;
     let v2Handler = null;
     let legacyHandler = null;
+    let disposed = false;
+    let activeHandler = null;
     function isLegacyStrictRequest(msg) {
         return msg === '___STRICTLY';
     }
@@ -108,7 +126,7 @@ function createRpcServerAuto2({ socket, object: target, socketKey: key, debug =
     function isV2Message(msg) {
         if (msg === rpc_protocol_1.Pkt.STRICT)
             return true;
-        if (Array.isArray(msg) && (msg[0] === rpc_protocol_1.Pkt.CALL || msg[0] === rpc_protocol_1.Pkt.PIPE))
+        if (Array.isArray(msg) && (msg[0] === rpc_protocol_1.Pkt.CALL || msg[0] === rpc_protocol_1.Pkt.PIPE || msg[0] === rpc_protocol_1.Pkt.HELLO))
             return true;
         return false;
     }
@@ -143,6 +161,7 @@ function createRpcServerAuto2({ socket, object: target, socketKey: key, debug =
             limits,
             hooks: {
                 ...hooks,
+                onDispose: () => { unsubscribeAllActive(); hooks?.onDispose?.(); },
                 resolveTransform,
             },
         });
@@ -152,7 +171,7 @@ function createRpcServerAuto2({ socket, object: target, socketKey: key, debug =
             onMsgCb(msg);
         };
     }
-    socket.on(key, (msg) => {
+    function handleMessage(msg) {
         if (debug) {
             console.log('[RPC-AUTO2 IN]', typeof msg === 'object' ? JSON.stringify(msg) : msg);
         }
@@ -197,10 +216,24 @@ function createRpcServerAuto2({ socket, object: target, socketKey: key, debug =
         }
         if (debug)
             console.warn('[RPC-AUTO2] Unknown message format, ignoring:', msg);
-    });
+    }
+    activeHandler = handleMessage;
+    socket.on(key, (msg) => activeHandler?.(msg));
+    function reset() { unsubscribeAllActive(); protocol = null; legacyHandler = null; v2Handler = null; }
+    function dispose(reason) {
+        if (disposed)
+            return;
+        disposed = true;
+        activeHandler = null;
+        reset();
+        if (debug)
+            console.log('[RPC-AUTO2] disposed', reason ?? '');
+    }
     return {
         getProtocol: () => protocol,
         getLegacySchema: () => legacySchema,
         getResolved: () => resolved,
+        dispose,
+        reset,
     };
 }

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

@@ -1,4 +1,12 @@
-import { listenSocket, listenSocketFirst, listenSocketAll, listenSocketSmart } from "./listen-socket";
+import { type ListenOn } from "../events/Listen";
+import { listenSocket, listenSocketFirst, listenSocketAll, listenSocketSmart, type tSubHandle } from "./listen-socket";
+type WithSubHandle<R> = R extends {
+    callback: (...a: infer A) => any;
+} ? Omit<R, 'callback' | 'on' | 'once'> & {
+    callback: (...a: A) => tSubHandle & Promise<void>;
+    on: (...a: A) => tSubHandle & Promise<void>;
+    once: (...a: A) => tSubHandle & Promise<void>;
+} : R;
 type Obj = Record<string, any>;
 type InferArgs<T> = T extends {
     addListen: (cb: (...args: infer R) => void, ...rest: any[]) => any;
@@ -6,22 +14,22 @@ type InferArgs<T> = T extends {
 export type DeepSocketListen<T> = {
     [K in keyof T]: T[K] extends {
         addListen: Function;
-    } ? ReturnType<typeof listenSocket<InferArgs<T[K]>>> : T[K] extends (...a: any[]) => any ? T[K] : T[K] extends typeof Promise ? T[K] : T[K] extends object ? DeepSocketListen<T[K]> : T[K];
+    } ? WithSubHandle<ReturnType<typeof listenSocket<InferArgs<T[K]>>>> : T[K] extends ListenOn<infer Z> ? WithSubHandle<ReturnType<typeof listenSocket<Z>>> : T[K] extends (...a: any[]) => any ? T[K] : T[K] extends Promise<any> ? T[K] : T[K] extends typeof Promise ? T[K] : T[K] extends object ? DeepSocketListen<T[K]> : T[K];
 };
 export type DeepSocketListenFirst<T> = {
     [K in keyof T]: T[K] extends {
         addListen: Function;
-    } ? ReturnType<typeof listenSocketFirst<InferArgs<T[K]>>> : T[K] extends (...a: any[]) => any ? T[K] : T[K] extends typeof Promise ? T[K] : T[K] extends object ? DeepSocketListenFirst<T[K]> : T[K];
+    } ? ReturnType<typeof listenSocketFirst<InferArgs<T[K]>>> : T[K] extends ListenOn<infer Z> ? ReturnType<typeof listenSocketFirst<Z>> : T[K] extends (...a: any[]) => any ? T[K] : T[K] extends Promise<any> ? T[K] : T[K] extends typeof Promise ? T[K] : T[K] extends object ? DeepSocketListenFirst<T[K]> : T[K];
 };
 export type DeepSocketListenAll<T> = {
     [K in keyof T]: T[K] extends {
         addListen: Function;
-    } ? ReturnType<typeof listenSocketAll<InferArgs<T[K]>>> : T[K] extends (...a: any[]) => any ? T[K] : T[K] extends typeof Promise ? T[K] : T[K] extends object ? DeepSocketListenAll<T[K]> : T[K];
+    } ? ReturnType<typeof listenSocketAll<InferArgs<T[K]>>> : T[K] extends ListenOn<infer Z> ? ReturnType<typeof listenSocketAll<Z>> : T[K] extends (...a: any[]) => any ? T[K] : T[K] extends Promise<any> ? T[K] : T[K] extends typeof Promise ? T[K] : T[K] extends object ? DeepSocketListenAll<T[K]> : T[K];
 };
 export type DeepSocketListenSmart<T> = {
     [K in keyof T]: NonNullable<T[K]> extends {
         addListen: Function;
-    } ? ReturnType<typeof listenSocketSmart<InferArgs<NonNullable<T[K]>>>> | Extract<T[K], undefined | null> : NonNullable<T[K]> extends (...a: any[]) => any ? T[K] : NonNullable<T[K]> extends typeof Promise ? T[K] : NonNullable<T[K]> extends object ? DeepSocketListenSmart<T[K]> : T[K];
+    } ? ReturnType<typeof listenSocketSmart<InferArgs<NonNullable<T[K]>>>> | Extract<T[K], undefined | null> : NonNullable<T[K]> extends ListenOn<infer Z> ? ReturnType<typeof listenSocketSmart<Z>> : NonNullable<T[K]> extends (...a: any[]) => any ? T[K] : NonNullable<T[K]> extends Promise<any> ? T[K] : NonNullable<T[K]> extends typeof Promise ? T[K] : NonNullable<T[K]> extends object ? DeepSocketListenSmart<T[K]> : 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;

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

@@ -1,25 +1,43 @@
 import { funcListenCallbackBase, type Listener } from "../events/Listen";
+import { type Off } from "./rpc-off";
 type ListenCallbackResult<T extends any[] = any[]> = ReturnType<typeof funcListenCallbackBase<T>>;
+export type tSubHandle = Off<void, {
+    unsubscribe: () => void;
+    removeCallback: () => void;
+}>;
 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[];
+    readonly throttle?: number;
 }): {
     callback: (z: Listener<Z>) => Promise<void>;
     removeCallback: () => boolean;
+    on: (z: Listener<Z>) => Promise<void>;
+    once: (z: Listener<Z>) => Promise<void>;
+    close: () => void;
 };
 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;
+    callback: (z: (a: Z[0]) => void) => tSubHandle;
+    on: (z: (a: Z[0]) => void) => tSubHandle;
+    once: (z: (a: Z[0]) => void) => tSubHandle;
+    close: () => 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;
+    callback: (z: (...args: Z) => void) => tSubHandle;
+    on: (z: (...args: Z) => void) => tSubHandle;
+    once: (z: (...args: Z) => void) => tSubHandle;
+    close: () => 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;
+    callback: (z: SmartCallback<Z>) => tSubHandle;
+    on: (z: SmartCallback<Z>) => tSubHandle;
+    once: (z: SmartCallback<Z>) => tSubHandle;
+    close: () => void;
     removeCallback: () => boolean;
 };
 export {};