wenay-common2 1.0.46 → 1.0.49

package/lib/Common/events/Listen3.js

@@ -0,0 +1,249 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.funcListenCallback = void 0;
+exports.getListenByOn = getListenByOn;
+exports.isListenOn = isListenOn;
+exports.funcListenCore = funcListenCore;
+exports.funcListenCallbackBase = funcListenCallbackBase;
+exports.funcListenCallbackFast = funcListenCallbackFast;
+exports.UseListen = UseListen;
+exports.withStoreListen = withStoreListen;
+exports.funcListenCallbackStore = funcListenCallbackStore;
+exports.UseListenStore = UseListenStore;
+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 funcListenCore(options = {}) {
+    const { fast = true, onRemove, event } = options;
+    const subs = new Map();
+    let a = (...e) => { subs.forEach(z => z(...e)); };
+    let cached = null;
+    const getArr = () => cached ?? (cached = Array.from(subs.values()));
+    function rebuild() {
+        cached = null;
+        const size = subs.size;
+        if (size == 0) {
+            a = null;
+            return;
+        }
+        if (size == 1) {
+            a = subs.values().next().value;
+            return;
+        }
+        if (size == 2) {
+            const [a0, a1] = getArr();
+            a = ((...e) => { a0(...e); a1(...e); });
+            return;
+        }
+        a = ((...e) => {
+            const ar = getArr();
+            for (let i = 0, len = ar.length; i < len; i++)
+                ar[i](...e);
+        });
+    }
+    function removeOne(k) {
+        if (!subs.has(k))
+            return;
+        subs.delete(k);
+        onRemove?.(k);
+        if (fast)
+            rebuild();
+        event?.('remove', subs.size, api);
+    }
+    const api = {
+        func: ((...e) => { a?.(...e); }),
+        has: (k) => subs.has(k),
+        on: ((cb, { key } = {}) => {
+            const k = key ?? Symbol();
+            if (subs.has(k)) {
+                subs.delete(k);
+                onRemove?.(k);
+            }
+            subs.set(k, cb);
+            if (fast)
+                rebuild();
+            event?.('add', subs.size, api);
+            return function off() { removeOne(k); };
+        }),
+        addListen: (cb, opts = {}) => api.on(cb, opts),
+        removeListen: (k) => {
+            if (typeof k == 'function') {
+                for (const [kk, cb] of [...subs])
+                    if (cb === k)
+                        removeOne(kk);
+                return;
+            }
+            if (k != null)
+                removeOne(k);
+        },
+        once: (cb, opts = {}) => {
+            let off = () => { };
+            off = api.on(((...e) => { off(); cb(...e); }), opts);
+            return off;
+        },
+        close: () => {
+            subs.clear();
+            if (fast)
+                rebuild();
+        },
+        count: () => subs.size,
+        get getAllKeys() { return [...subs.keys()]; },
+    };
+    listenByOn.set(api.on, api);
+    return api;
+}
+function funcListenCallbackBase(b, options = {}) {
+    const { fast = true, event, addListenClose } = options;
+    let closeHooks = null;
+    let close = null;
+    let closeUnsubscribe = null;
+    function forgetKey(k) {
+        closeHooks?.delete(k);
+    }
+    const core = funcListenCore({
+        fast,
+        onRemove: forgetKey,
+        event: event && function forwardRemove(type, count) {
+            if (type == 'remove')
+                event(type, count, api);
+        },
+    });
+    const api = {
+        func: core.func,
+        isRun: () => close !== null,
+        run: () => {
+            close = (b(core.func) ?? (() => { }));
+            if (addListenClose && !closeUnsubscribe) {
+                closeUnsubscribe = addListenClose.on(function onOwnerClose() { api.close(); });
+            }
+        },
+        close: () => {
+            close?.();
+            close = null;
+            core.close();
+            if (closeHooks) {
+                const hooks = closeHooks;
+                closeHooks = null;
+                hooks.forEach(function fireClose(cb) { cb(); });
+            }
+            if (closeUnsubscribe) {
+                closeUnsubscribe();
+                closeUnsubscribe = null;
+            }
+        },
+        eventClose: (cb) => {
+            closeHooks = closeHooks ?? new Map();
+            closeHooks.set(cb, cb);
+            return function offClose() { closeHooks?.delete(cb); };
+        },
+        onClose: (cb) => api.eventClose(cb),
+        removeEventClose: (cb) => { closeHooks?.delete(cb); },
+        on: ((cb, { cbClose, key } = {}) => {
+            const k = key ?? Symbol();
+            const off = core.on(cb, { key: k });
+            if (cbClose) {
+                closeHooks = closeHooks ?? new Map();
+                closeHooks.set(k, cbClose);
+            }
+            event?.('add', core.count(), api);
+            return off;
+        }),
+        addListen: (cb, opts = {}) => api.on(cb, opts),
+        removeListen: core.removeListen,
+        once: (cb, opts = {}) => {
+            let off = () => { };
+            off = api.on(((...e) => { off(); cb(...e); }), opts);
+            return off;
+        },
+        count: () => core.count(),
+        get getAllKeys() { return core.getAllKeys; },
+    };
+    listenByOn.set(api.on, api);
+    return api;
+}
+function funcListenCallbackFast(a) {
+    return funcListenCallbackBase(a, { fast: true });
+}
+exports.funcListenCallback = funcListenCallbackBase;
+function UseListen(data = { fast: true }) {
+    let t;
+    const a = funcListenCallbackBase((e) => { t = e; }, { fast: true, ...data });
+    a.run();
+    t = a.func;
+    return [t, a];
+}
+function withStoreListen(base, currentProvider) {
+    function currentValue(current) {
+        if (typeof current == 'function')
+            return current();
+        return current ? currentProvider() : undefined;
+    }
+    const api = {
+        ...base,
+        on: ((cb, { cbClose, key, current } = {}) => {
+            const off = base.on(cb, { cbClose, key });
+            if (current) {
+                const m = currentValue(current);
+                if (m)
+                    cb(...m);
+            }
+            return off;
+        }),
+        addListen: (cb, opts = {}) => api.on(cb, opts),
+        once: (cb, opts = {}) => {
+            if (opts.current) {
+                const m = currentValue(opts.current);
+                if (m) {
+                    cb(...m);
+                    return () => { };
+                }
+            }
+            let off = () => { };
+            off = base.on(((...e) => { off(); cb(...e); }), { key: opts.key });
+            return off;
+        },
+        get getAllKeys() { return base.getAllKeys; },
+    };
+    listenByOn.set(api.on, api);
+    return api;
+}
+function funcListenCallbackStore(b, options) {
+    const { current, ...listenOptions } = options;
+    return withStoreListen(funcListenCallbackBase(b, listenOptions), current);
+}
+function UseListenStore(data) {
+    const { current, ...listenOptions } = data;
+    let t;
+    const base = funcListenCallbackBase((e) => { t = e; }, { fast: true, ...listenOptions });
+    const listen = withStoreListen(base, current);
+    base.run();
+    t = base.func;
+    return [t, listen];
+}
+function toListen2(full) {
+    return {
+        on: (cb, opts) => full.on(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 ks = new Set(Object.keys(obj));
+    for (const k of LISTEN_CORE)
+        if (!ks.has(k))
+            return false;
+    for (const k of LISTEN_CORE)
+        if (typeof obj[k] != 'function')
+            return false;
+    return true;
+}

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

@@ -18,26 +18,31 @@ export declare function funcListenCallbackSnapshot<T extends realSocket2<any | a
     memo: T4;
     snapshot?: (memo: T4) => T3;
 }): {
-    run: (cb: import("./Listen").Listener<[data: getTypeCallback<T>, memo: T3]>, params_1?: {
-        cbClose?: (() => void) | undefined;
-        key?: string;
+    run: (cb: import("./Listen3").Listener<[data: getTypeCallback<T>, memo: T3]>, opts?: {
+        cbClose?: () => void;
+        key?: string | symbol;
     } | undefined) => () => void;
     snapshot: () => T3 | undefined;
     memo: T4;
     listenA: {
-        func: import("./Listen").Listener<[data: getTypeCallback<T>, memo: T3]>;
+        func: import("./Listen3").Listener<[data: getTypeCallback<T>, memo: T3]>;
         isRun: () => boolean;
         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;
+        on: import("./Listen3").ListenOn<[data: getTypeCallback<T>, memo: T3]>;
+        addListen: (cb: import("./Listen3").Listener<[data: getTypeCallback<T>, memo: T3]>, opts?: {
+            cbClose?: () => void;
+            key?: string | symbol;
+        }) => () => void;
+        removeListen: (k: (string | symbol) | import("./Listen3").Listener<[data: getTypeCallback<T>, memo: T3]> | null) => void;
+        once: (cb: import("./Listen3").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)[];
     };
     connect: () => void;
     readonly disconnect: ((a: Omit<Parameters<T>[0], "callback"> & {

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

@@ -5,35 +5,45 @@ export declare function SocketServerHook(opt?: {
 }): {
     obj: {
         [k: string]: readonly [(a_0: unknown) => void, {
-            func: import("./Listen").Listener<[unknown]>;
+            func: import("./Listen3").Listener<[unknown]>;
             isRun: () => boolean;
             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;
+            on: import("./Listen3").ListenOn<[unknown]>;
+            addListen: (cb: import("./Listen3").Listener<[unknown]>, opts?: {
+                cbClose?: () => void;
+                key?: string | symbol;
+            }) => () => void;
+            removeListen: (k: (string | symbol) | import("./Listen3").Listener<[unknown]> | null) => void;
+            once: (cb: import("./Listen3").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)[];
         }];
     };
     get(tag: string): readonly [(a_0: unknown) => void, {
-        func: import("./Listen").Listener<[unknown]>;
+        func: import("./Listen3").Listener<[unknown]>;
         isRun: () => boolean;
         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;
+        on: import("./Listen3").ListenOn<[unknown]>;
+        addListen: (cb: import("./Listen3").Listener<[unknown]>, opts?: {
+            cbClose?: () => void;
+            key?: string | symbol;
+        }) => () => void;
+        removeListen: (k: (string | symbol) | import("./Listen3").Listener<[unknown]> | null) => void;
+        once: (cb: import("./Listen3").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)[];
     }];
     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;
+    on: import("./Listen3").ListenOn<NormalizeTuple<TTarget>>;
+    addListen: (cb: Listener<NormalizeTuple<TTarget>>, opts?: {
+        cbClose?: () => void;
+        key?: string | symbol;
+    }) => () => void;
+    removeListen: (k: (string | symbol) | Listener<NormalizeTuple<TTarget>> | null) => void;
+    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)[];
 }];

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

@@ -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;