wenay-common2 1.0.45 → 1.0.48

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

@@ -1,6 +1,15 @@
 export type Listener<T extends any[]> = (...r: T) => void;
 export type NormalizeTuple<T> = T extends any[] ? T : [T];
-type key = string;
+type key = string | symbol;
+declare const LISTEN_ON_BRAND: unique symbol;
+export type ListenOn<Z extends any[] = any[]> = ((cb: Listener<Z>, opts?: {
+    cbClose?: () => void;
+    key?: string;
+}) => (() => void)) & {
+    readonly [LISTEN_ON_BRAND]: Z;
+};
+export declare function getListenByOn(fn: any): any;
+export declare function isListenOn(fn: any): boolean;
 export declare function funcListenCallbackBase<T>(b: (e: Listener<NormalizeTuple<T>>) => (void | (() => void)), { fast, event, addListenClose }?: {
     event?: (type: "add" | "remove", count: number, api: ReturnType<typeof funcListenCallbackBase<T>>) => void;
     fast?: boolean;
@@ -11,12 +20,17 @@ export declare function funcListenCallbackBase<T>(b: (e: Listener<NormalizeTuple
     run: () => void;
     close: () => void;
     eventClose: (cb: () => void) => () => void;
+    onClose: (cb: () => void) => () => void;
     removeEventClose: (cb: (() => void)) => void;
     addListen: (cb: Listener<NormalizeTuple<T>>, { cbClose, key }?: {
         cbClose?: () => void;
         key?: key;
     }) => () => void;
     removeListen: (k: Listener<NormalizeTuple<T>> | null | key) => void;
+    on: ListenOn<NormalizeTuple<T>>;
+    once: (cb: Listener<NormalizeTuple<T>>, opts?: {
+        key?: key;
+    }) => () => void;
     count: () => number;
     readonly getAllKeys: (Listener<NormalizeTuple<T>> | key)[];
 };
@@ -26,14 +40,19 @@ export declare function funcListenCallbackFast<T>(a: (e: (Listener<NormalizeTupl
     run: () => void;
     close: () => void;
     eventClose: (cb: () => void) => () => void;
+    onClose: (cb: () => void) => () => void;
     removeEventClose: (cb: () => void) => void;
     addListen: (cb: Listener<NormalizeTuple<T>>, { cbClose, key }?: {
         cbClose?: (() => void) | undefined;
         key?: key;
     }) => () => void;
-    removeListen: (k: string | Listener<NormalizeTuple<T>> | null) => void;
+    removeListen: (k: key | Listener<NormalizeTuple<T>> | null) => void;
+    on: ListenOn<NormalizeTuple<T>>;
+    once: (cb: Listener<NormalizeTuple<T>>, opts?: {
+        key?: key;
+    }) => () => void;
     count: () => number;
-    readonly getAllKeys: (string | Listener<NormalizeTuple<T>>)[];
+    readonly getAllKeys: (key | Listener<NormalizeTuple<T>>)[];
 };
 export declare const funcListenCallback: typeof funcListenCallbackBase;
 export declare function UseListen<T>(data?: Parameters<typeof funcListenCallbackBase<T>>[1]): readonly [(...a: NormalizeTuple<T>) => void, {
@@ -42,14 +61,28 @@ export declare function UseListen<T>(data?: Parameters<typeof funcListenCallback
     run: () => void;
     close: () => void;
     eventClose: (cb: () => void) => () => void;
+    onClose: (cb: () => void) => () => void;
     removeEventClose: (cb: () => void) => void;
     addListen: (cb: Listener<NormalizeTuple<T>>, { cbClose, key }?: {
         cbClose?: (() => void) | undefined;
         key?: key;
     }) => () => void;
-    removeListen: (k: string | Listener<NormalizeTuple<T>> | null) => void;
+    removeListen: (k: key | Listener<NormalizeTuple<T>> | null) => void;
+    on: ListenOn<NormalizeTuple<T>>;
+    once: (cb: Listener<NormalizeTuple<T>>, opts?: {
+        key?: key;
+    }) => () => void;
     count: () => number;
-    readonly getAllKeys: (string | Listener<NormalizeTuple<T>>)[];
+    readonly getAllKeys: (key | Listener<NormalizeTuple<T>>)[];
 }];
+export type Listen2<T> = {
+    on: (cb: Listener<NormalizeTuple<T>>, opts?: {
+        key?: string;
+    }) => (() => void);
+    close: () => void;
+    count: () => number;
+};
+export declare function toListen2<T>(full: ReturnType<typeof funcListenCallbackBase<T>>): Listen2<T>;
+export declare function UseListen2<T>(data?: Parameters<typeof funcListenCallbackBase<T>>[1]): readonly [(...a: NormalizeTuple<T>) => void, Listen2<T>];
 export declare function isListenCallback(obj: any): obj is ReturnType<typeof funcListenCallbackBase>;
 export {};

package/lib/Common/events/Listen.js

@@ -1,14 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.funcListenCallback = void 0;
+exports.getListenByOn = getListenByOn;
+exports.isListenOn = isListenOn;
 exports.funcListenCallbackBase = funcListenCallbackBase;
 exports.funcListenCallbackFast = funcListenCallbackFast;
 exports.UseListen = UseListen;
+exports.toListen2 = toListen2;
+exports.UseListen2 = UseListen2;
 exports.isListenCallback = isListenCallback;
+const listenByOn = new WeakMap();
+function getListenByOn(fn) { return typeof fn == "function" ? listenByOn.get(fn) : undefined; }
+function isListenOn(fn) { return typeof fn == "function" && listenByOn.has(fn); }
 function funcListenCallbackBase(b, { fast = true, event, addListenClose } = {}) {
     const obj = new Map();
-    const evClose = new Map();
-    const sinh = new Map();
+    const cbKeys = new Map();
+    let evClose = null;
+    let sinh = null;
     let a = (...e) => { obj.forEach(z => z(...e)); };
     let close = null;
     let cached = null;
@@ -37,6 +45,34 @@ function funcListenCallbackBase(b, { fast = true, event, addListenClose } = {})
         });
     };
     const func = (...e) => { a?.(...e); };
+    function forgetKey(k) {
+        const removed = obj.get(k);
+        if (typeof removed == "function") {
+            const keys = cbKeys.get(removed);
+            if (keys) {
+                const i = keys.indexOf(k);
+                if (i >= 0)
+                    keys.splice(i, 1);
+                if (keys.length == 0)
+                    cbKeys.delete(removed);
+            }
+        }
+        const e = evClose?.get(k);
+        evClose?.delete(k);
+        if (e) {
+            evClose?.delete(e);
+            sinh?.delete(e);
+        }
+    }
+    function removeKey(k) {
+        if (!obj.has(k))
+            return;
+        obj.delete(k);
+        forgetKey(k);
+        if (fast)
+            rebuild();
+        event?.("remove", obj.size, api);
+    }
     const run = () => {
         close = (b(func) ?? (() => { }));
         if (addListenClose && !closeUnsubscribe) {
@@ -53,62 +89,69 @@ function funcListenCallbackBase(b, { fast = true, event, addListenClose } = {})
             close?.();
             close = null;
             obj.clear();
+            cbKeys.clear();
             if (fast)
                 rebuild();
-            sinh.clear();
-            evClose.forEach(cb => cb());
-            evClose.clear();
+            sinh = null;
+            if (evClose) {
+                evClose.forEach(cb => cb());
+                evClose = null;
+            }
             if (closeUnsubscribe) {
                 closeUnsubscribe();
                 closeUnsubscribe = null;
             }
         },
         eventClose: (cb) => {
+            evClose = evClose ?? new Map();
             evClose.set(cb, cb);
-            return () => { evClose.delete(cb); };
+            return () => { evClose?.delete(cb); };
         },
+        onClose: (cb) => api.eventClose(cb),
         removeEventClose: (cb) => {
-            const e = sinh.get(cb);
+            const e = sinh?.get(cb);
             if (e)
-                evClose.delete(e);
-            sinh.delete(cb);
-            evClose.delete(cb);
+                evClose?.delete(e);
+            sinh?.delete(cb);
+            evClose?.delete(cb);
         },
         addListen: (cb, { cbClose, key } = {}) => {
-            const k = key ?? cb;
+            const k = key ?? Symbol();
+            if (obj.has(k))
+                forgetKey(k);
             obj.set(k, cb);
+            let keys = cbKeys.get(cb);
+            if (!keys)
+                cbKeys.set(cb, keys = []);
+            keys.push(k);
             if (cbClose) {
-                if (evClose.has(k)) {
-                    const r = evClose.get(k);
-                    if (r !== cbClose) {
-                        evClose.delete(r);
-                        evClose.delete(k);
-                        sinh.delete(r);
-                    }
-                }
+                evClose = evClose ?? new Map();
                 evClose.set(k, cbClose);
+                sinh = sinh ?? new Map();
                 sinh.set(cbClose, cb);
             }
             if (fast)
                 rebuild();
             event?.("add", obj.size, api);
-            return () => api.removeListen(k);
+            return () => removeKey(k);
         },
         removeListen: (k) => {
-            obj.delete(k);
-            const e = evClose.get(k);
-            if (fast)
-                rebuild();
-            evClose.delete(k);
-            if (e) {
-                evClose.delete(e);
-                sinh.delete(e);
-            }
-            event?.("remove", obj.size, api);
+            if (typeof k == "function" && !obj.has(k))
+                for (const kk of [...(cbKeys.get(k) ?? [])])
+                    removeKey(kk);
+            else
+                removeKey(k);
+        },
+        on: ((cb, opts = {}) => api.addListen(cb, opts)),
+        once: (cb, opts = {}) => {
+            let off = () => { };
+            off = api.addListen(((...e) => { off(); cb(...e); }), opts);
+            return off;
         },
         count: () => obj.size,
         get getAllKeys() { return [...obj.keys()]; }
     };
+    listenByOn.set(api.on, api);
     return api;
 }
 function funcListenCallbackFast(a) {
@@ -122,35 +165,27 @@ function UseListen(data = { fast: true }) {
     t = a.func;
     return [t, a];
 }
-let referenceKeys = null;
-let referenceTypes = null;
-function getReferenceData() {
-    if (!referenceKeys || !referenceTypes) {
-        const demo = funcListenCallbackBase(() => { });
-        referenceKeys = Object.keys(demo).sort();
-        referenceTypes = new Map();
-        for (const key of referenceKeys) {
-            referenceTypes.set(key, typeof demo[key]);
-        }
-    }
-    return { keys: referenceKeys, types: referenceTypes };
+function toListen2(full) {
+    return {
+        on: (cb, opts) => full.addListen(cb, opts),
+        close: () => full.close(),
+        count: () => full.count(),
+    };
 }
+function UseListen2(data = { fast: true }) {
+    const [emit, full] = UseListen(data);
+    return [emit, toListen2(full)];
+}
+const LISTEN_CORE = ["func", "addListen", "removeListen", "eventClose", "removeEventClose"];
 function isListenCallback(obj) {
     if (obj == null || typeof obj !== "object")
         return false;
-    const objKeys = Object.keys(obj).sort();
-    const { keys: refKeys, types: refTypes } = getReferenceData();
-    if (objKeys.length !== refKeys.length)
-        return false;
-    for (let i = 0; i < refKeys.length; i++) {
-        if (objKeys[i] !== refKeys[i])
+    const ks = new Set(Object.keys(obj));
+    for (const k of LISTEN_CORE)
+        if (!ks.has(k))
             return false;
-    }
-    for (const key of refKeys) {
-        const expectedType = refTypes.get(key);
-        const actualType = typeof obj[key];
-        if (actualType !== expectedType)
+    for (const k of LISTEN_CORE)
+        if (typeof obj[k] !== "function")
             return false;
-    }
     return true;
 }

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

@@ -20,7 +20,7 @@ export declare function funcListenCallbackSnapshot<T extends realSocket2<any | a
 }): {
     run: (cb: import("./Listen").Listener<[data: getTypeCallback<T>, memo: T3]>, params_1?: {
         cbClose?: (() => void) | undefined;
-        key?: string;
+        key?: string | symbol;
     } | undefined) => () => void;
     snapshot: () => T3 | undefined;
     memo: T4;
@@ -30,14 +30,19 @@ export declare function funcListenCallbackSnapshot<T extends realSocket2<any | a
         run: () => void;
         close: () => void;
         eventClose: (cb: () => void) => () => void;
+        onClose: (cb: () => void) => () => void;
         removeEventClose: (cb: () => void) => void;
         addListen: (cb: import("./Listen").Listener<[data: getTypeCallback<T>, memo: T3]>, { cbClose, key }?: {
             cbClose?: (() => void) | undefined;
-            key?: string;
+            key?: string | symbol;
+        }) => () => void;
+        removeListen: (k: (string | symbol) | import("./Listen").Listener<[data: getTypeCallback<T>, memo: T3]> | null) => void;
+        on: import("./Listen").ListenOn<[data: getTypeCallback<T>, memo: T3]>;
+        once: (cb: import("./Listen").Listener<[data: getTypeCallback<T>, memo: T3]>, opts?: {
+            key?: string | symbol;
         }) => () => void;
-        removeListen: (k: string | import("./Listen").Listener<[data: getTypeCallback<T>, memo: T3]> | null) => void;
         count: () => number;
-        readonly getAllKeys: (string | import("./Listen").Listener<[data: getTypeCallback<T>, memo: T3]>)[];
+        readonly getAllKeys: ((string | symbol) | import("./Listen").Listener<[data: getTypeCallback<T>, memo: T3]>)[];
     };
     connect: () => void;
     readonly disconnect: ((a: Omit<Parameters<T>[0], "callback"> & {

package/lib/Common/events/SocketBuffer.js

@@ -19,6 +19,7 @@ function funcListenCallbackSnapshot({ func, memo = {}, callbackSave, snapshot })
             if (type == "remove" && count == 0) {
                 api.close();
                 d?.();
+                d = null;
             }
             if (type == "add" && count == 1)
                 api.run();

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

@@ -10,14 +10,19 @@ export declare function SocketServerHook(opt?: {
             run: () => void;
             close: () => void;
             eventClose: (cb: () => void) => () => void;
+            onClose: (cb: () => void) => () => void;
             removeEventClose: (cb: () => void) => void;
             addListen: (cb: import("./Listen").Listener<[unknown]>, { cbClose, key }?: {
                 cbClose?: (() => void) | undefined;
-                key?: string;
+                key?: string | symbol;
+            }) => () => void;
+            removeListen: (k: (string | symbol) | import("./Listen").Listener<[unknown]> | null) => void;
+            on: import("./Listen").ListenOn<[unknown]>;
+            once: (cb: import("./Listen").Listener<[unknown]>, opts?: {
+                key?: string | symbol;
             }) => () => void;
-            removeListen: (k: string | import("./Listen").Listener<[unknown]> | null) => void;
             count: () => number;
-            readonly getAllKeys: (string | import("./Listen").Listener<[unknown]>)[];
+            readonly getAllKeys: ((string | symbol) | import("./Listen").Listener<[unknown]>)[];
         }];
     };
     get(tag: string): readonly [(a_0: unknown) => void, {
@@ -26,14 +31,19 @@ export declare function SocketServerHook(opt?: {
         run: () => void;
         close: () => void;
         eventClose: (cb: () => void) => () => void;
+        onClose: (cb: () => void) => () => void;
         removeEventClose: (cb: () => void) => void;
         addListen: (cb: import("./Listen").Listener<[unknown]>, { cbClose, key }?: {
             cbClose?: (() => void) | undefined;
-            key?: string;
+            key?: string | symbol;
+        }) => () => void;
+        removeListen: (k: (string | symbol) | import("./Listen").Listener<[unknown]> | null) => void;
+        on: import("./Listen").ListenOn<[unknown]>;
+        once: (cb: import("./Listen").Listener<[unknown]>, opts?: {
+            key?: string | symbol;
         }) => () => void;
-        removeListen: (k: string | import("./Listen").Listener<[unknown]> | null) => void;
         count: () => number;
-        readonly getAllKeys: (string | import("./Listen").Listener<[unknown]>)[];
+        readonly getAllKeys: ((string | symbol) | import("./Listen").Listener<[unknown]>)[];
     }];
     provider: (tag: string, data: any) => void;
 };
@@ -41,7 +51,10 @@ export declare function WebSocketServerHook(s: ReturnType<typeof SocketServerHoo
     disconnect(): void;
     get: {
         [k: string]: {
-            callback: (z: (...args: any[]) => void) => void;
+            callback: (z: (...args: any[]) => void) => import("../rcp/listen-socket").tSubHandle;
+            on: (z: (...args: any[]) => void) => import("../rcp/listen-socket").tSubHandle;
+            once: (z: (...args: any[]) => void) => import("../rcp/listen-socket").tSubHandle;
+            close: () => void;
             removeCallback: () => boolean;
         };
     };

package/lib/Common/events/SocketServerHook.js

@@ -23,9 +23,10 @@ function SocketServerHook(opt) {
     return r;
 }
 function WebSocketServerHook(s, paramsSoc, disconnect) {
+    const wrappers = {};
     const get = new Proxy(s.obj, {
         get(target, p, receiver) {
-            return (0, listen_socket_1.listenSocketSmart)(s.get(p)[1], paramsSoc);
+            return wrappers[p] ??= (0, listen_socket_1.listenSocketSmart)(s.get(p)[1], paramsSoc);
         }
     });
     return {

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

@@ -7,12 +7,17 @@ export declare function UseListenTransform<TSource extends any[], TTarget extend
     run: () => void;
     close: () => void;
     eventClose: (cb: () => void) => () => void;
+    onClose: (cb: () => void) => () => void;
     removeEventClose: (cb: () => void) => void;
     addListen: (cb: Listener<NormalizeTuple<TTarget>>, { cbClose, key }?: {
         cbClose?: (() => void) | undefined;
-        key?: string;
+        key?: string | symbol;
+    }) => () => void;
+    removeListen: (k: (string | symbol) | Listener<NormalizeTuple<TTarget>> | null) => void;
+    on: import("./Listen").ListenOn<NormalizeTuple<TTarget>>;
+    once: (cb: Listener<NormalizeTuple<TTarget>>, opts?: {
+        key?: string | symbol;
     }) => () => void;
-    removeListen: (k: string | Listener<NormalizeTuple<TTarget>> | null) => void;
     count: () => number;
-    readonly getAllKeys: (string | Listener<NormalizeTuple<TTarget>>)[];
+    readonly getAllKeys: ((string | symbol) | Listener<NormalizeTuple<TTarget>>)[];
 }];

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

@@ -10,11 +10,17 @@ export declare class CObjectEventsArr<T extends object> {
     AddStart(data: tListEvent): void;
     AddEnd(data: tListEvent): void;
     Add(data: tListEvent): void;
+    add(data: tListEvent, opts?: {
+        at?: 'start' | 'end';
+    }): void;
     OnEvent(data?: any): void;
+    emit(data?: any): void;
     OnSpecEvent(f: (e: T) => void): void;
     Clean(): void;
+    clear(): void;
     count(): number;
     get length(): number;
+    get size(): number;
 }
 export declare class CObjectEventsList<T = unknown> {
     constructor(log?: boolean);
@@ -26,9 +32,15 @@ export declare class CObjectEventsList<T = unknown> {
     AddStart(data: tListEvent): void;
     AddEnd(data: tListEvent): void;
     Add(data: tListEvent): void;
+    add(data: tListEvent, opts?: {
+        at?: 'start' | 'end';
+    }): void;
     OnEvent(data?: T): void;
+    emit(data?: T): void;
     OnSpecEvent<R>(f: (e?: R) => void): void;
     Clean(): void;
+    clear(): void;
     count(): number;
     get length(): number;
+    get size(): number;
 }

package/lib/Common/events/event.js

@@ -16,24 +16,32 @@ class CObjectEventsArr {
             }
             console.error("элемент уже был удален");
             console.trace();
-            data.OnDel?.();
             console.log(this.count());
         };
     }
     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]); }
-    OnEvent(data) { [...this.data].forEach((e) => { e.func?.(data); e.func2?.(data); }); }
-    OnSpecEvent(f) { [...this.data].forEach((e) => { const l = e.func?.(); l && f(l); e.func2?.(); }); }
+    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 {
@@ -62,16 +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)); }
-    OnEvent(data) { this.data.forEach(e => { e.func?.(data); e.func2?.(data); }); }
-    OnSpecEvent(f) { this.data.forEach((e) => { const l = e.func?.(); if (l) {
+    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);
-    } e.func2?.(); }); }
-    Clean() { let r = this.data.First(); while (r) {
-        const buf = r;
-        r = r?.Next();
-        buf.DeleteLink();
-    } }
+    } if (e.func2) {
+        e.func2();
+        e.del?.();
+    } }); }
+    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,36 +18,44 @@ 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 = [];
     const bindPort = (portId, listener) => {
-        listener.addListen((...data) => {
+        const cb = (...data) => {
             const tid = getKey(data[0]);
             if (!buckets.has(tid))
                 buckets.set(tid, new Map());
             buckets.get(tid).set(portId, data.length <= 1 ? data[0] : data);
             tryFire(tid);
-        });
+        };
+        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

@@ -13,7 +13,6 @@ export declare function funcTimeW(): {
     add(item: tFunc): void;
     cleanByTime(type: tType, ms?: number): void;
     weight(type: tType, ms?: number): number;
-    weightNow(type: tType, ms?: number): number;
     byWeight(type: tType, weight?: number): number;
     byWeightTimeNow(type: tType, timeNow?: number, weight?: number): number;
 };
@@ -25,7 +24,34 @@ export declare const FuncTimeWait: {
     add(item: tFunc): void;
     cleanByTime(type: tType, ms?: number): void;
     weight(type: tType, ms?: number): number;
-    weightNow(type: tType, ms?: number): number;
+    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;
 };