wenay-common2 1.0.1

package/lib/Common/data/List.js

@@ -0,0 +1,193 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CList = void 0;
+class CListNode {
+    value;
+    list;
+    next;
+    prev;
+    [Symbol.species] = this;
+    constructor(list, value) { this.list = list; this.value = value; }
+}
+class CList {
+    _first;
+    _last;
+    _count = 0;
+    _immutableList;
+    get first() { return this._first; }
+    get last() { return this._last; }
+    get count() { return this._count; }
+    get length() { return this._count; }
+    [Symbol.iterator] = this.nodes;
+    constructor(values = []) { for (let value of values)
+        this.add(value); }
+    *nodes() { for (let node = this._first, next = node?.next; node != null; node = next, next = next?.next)
+        yield node; }
+    *values() { for (let node of this)
+        yield node.value; }
+    *reversedNodes() { for (let node = this._last, next = node?.prev; node != null; node = next, next = next?.prev)
+        yield node; }
+    *reversedValues() { for (let node of this.reversedNodes())
+        yield node.value; }
+    *entries() { return this.nodes; }
+    next(node) { return this.validateNode(node) ? node.next : (() => { throw "Wrong node list"; })(); }
+    ;
+    prev(node) { return this.validateNode(node) ? node.prev : (() => { throw "Wrong node list"; })(); }
+    ;
+    find(value) { for (let node of this.nodes())
+        if (node.value == value)
+            return node; return undefined; }
+    findLast(value) { for (let node of this.reversedNodes())
+        if (node.value == value)
+            return node; return undefined; }
+    containsValue(value) { return this.find(value) != undefined; }
+    containsNode(node) { return this.validateNode(node); }
+    has(data) { return data instanceof CListNode ? this.containsNode(data) : this.containsValue(data); }
+    toImmutable() { return this._immutableList ??= new CList(this.values()); }
+    _addFirst(value) {
+        this._count = 1;
+        this._immutableList = undefined;
+        return this._first = this._last = this.newNode(value);
+    }
+    addFirst(value) {
+        if (this._first)
+            return this.addBefore(this._first, value);
+        return this._addFirst(value);
+    }
+    addLast(value) {
+        if (this._last)
+            return this.addAfter(this._last, value);
+        return this._addFirst(value);
+    }
+    addAfter(node, value) {
+        if (!this.validateNode(node))
+            throw "Wrong node list";
+        let newNode = this.newNode(value);
+        newNode.prev = node;
+        newNode.next = node.next;
+        if (node.next)
+            node.next.prev = newNode;
+        else
+            this._last = newNode;
+        node.next = newNode;
+        this._count++;
+        this._immutableList = undefined;
+        return newNode;
+    }
+    addBefore(node, value) {
+        if (!this.validateNode(node))
+            throw "Wrong node list";
+        let newNode = this.newNode(value);
+        newNode.next = node;
+        newNode.prev = node.prev;
+        if (node.prev)
+            node.prev.next = newNode;
+        else
+            this._first = newNode;
+        node.prev = newNode;
+        this._count++;
+        this._immutableList = undefined;
+        return newNode;
+    }
+    add(value) { return this.addLast(value); }
+    set(node, value) {
+        if (!this.validateNode(node))
+            throw "Wrong node list";
+        node.value = value;
+        return node;
+    }
+    replace(node, value) {
+        if (!this.validateNode(node))
+            throw "Wrong node list";
+        let newNode = this.newNode(value);
+        newNode.next = node.next;
+        newNode.prev = node.prev;
+        node.list = undefined;
+        this._immutableList = undefined;
+        return newNode;
+    }
+    deleteNode(node) {
+        if (!this.validateNode(node))
+            throw "Wrong node list";
+        if (node.prev)
+            node.prev.next = node.next;
+        if (node.next)
+            node.next.prev = node.prev;
+        if (node == this._first)
+            this._first = node.next;
+        if (node == this._last)
+            this._last = node.prev;
+        node.list = undefined;
+        this._count--;
+        this._immutableList = undefined;
+    }
+    delete(nodeOrValue) {
+        { }
+        if (nodeOrValue instanceof CListNode)
+            return this.deleteNode(nodeOrValue);
+        for (let node of this.nodes())
+            if (node.value == nodeOrValue)
+                this.deleteNode(node);
+    }
+    deleteFirst() { if (this._first)
+        this.delete(this._first); }
+    deleteLast() { if (this._last)
+        this.delete(this._last); }
+    clear() {
+        for (let node = this._first; node != null; node = node.next)
+            this.delete(node);
+    }
+    validateNode(node) {
+        if (!(node instanceof CListNode))
+            throw "Wrong node object";
+        return node.list == this;
+    }
+    newNode(value) { return new CListNode(this, value); }
+}
+exports.CList = CList;
+function test() {
+    function print(...args) { console.log(...args); }
+    let list = new CList();
+    let node10 = list.add(10);
+    print(...list.values());
+    let node20 = list.add(20);
+    print(...list.values());
+    let node15 = list.addAfter(node10, 15);
+    print(...list.values());
+    let node30 = list.addAfter(node20, 30);
+    print(...list.values());
+    let node25 = list.addBefore(node30, 25);
+    print(...list.values());
+    let node5 = list.addBefore(node10, 5);
+    print(...list.values());
+    let node0 = list.addFirst(0);
+    print(...list.values());
+    print("count:", list.count);
+    print("deleting node20");
+    list.delete(node20);
+    print(...list.values());
+    print("count:", list.count);
+    print("contains node20:", list.has(node20));
+    print("contains 20:", list.has(20));
+    print("find 20 -> value:", list.find(20)?.value);
+    print("contains node10:", list.has(node10));
+    print("contains 10:", list.has(10));
+    print("find 10 -> value:", list.find(10)?.value);
+    print("adding last 5");
+    let nodeLast = list.add(5);
+    print(...list.values());
+    let listImm = list.toImmutable();
+    print("findLast 5 -> prevValue: ", listImm.findLast(5)?.prev?.value);
+    print("node15 prev:", list.prev(node15)?.value);
+    print("node15 next:", list.next(node15)?.value);
+    print("node0 prev:", list.prev(node0)?.value);
+    print("nodeLast next:", listImm.next(nodeLast)?.next);
+    print("reversed: ", ...list.reversedValues());
+    print("deleting 5");
+    list.delete(5);
+    print(...list.values());
+    print("clearing");
+    list.clear();
+    print(...list.values());
+    print("count:", list.count);
+}

package/lib/Common/data/ListNodeAnd.d.ts

@@ -0,0 +1,46 @@
+declare class CBaseList<T> {
+    data: T | undefined;
+}
+export declare class CListNodeAnd<T> extends CBaseList<T> implements iListNodeMini {
+    get count(): number;
+    private _stop;
+    protected _count: number;
+    private _prev;
+    private _next;
+    private _home;
+    private _Init;
+    constructor(prev?: CListNodeAnd<T>, next?: CListNodeAnd<T>, home?: CListNodeAnd<T>);
+    static _valueG: number;
+    static _valueG2: number;
+    readonly id: number;
+    valueOf(): number;
+    countRef(): number;
+    Prev(): CListNodeAnd<T> | undefined;
+    Next(): CListNodeAnd<T> | undefined;
+    isPrev(): boolean;
+    isNext(): boolean;
+    private _First;
+    private _End;
+    First(): CListNodeAnd<T> | undefined;
+    End(): CListNodeAnd<T> | undefined;
+    get dataFirst(): T | undefined;
+    get dataEnd(): T | undefined;
+    get dataPrev(): T | undefined;
+    get dataNext(): T | undefined;
+    get dataThis(): T | undefined;
+    isForbidden(): boolean;
+    isExists(): boolean;
+    private static _Add;
+    AddNext(a?: CListNodeAnd<T> | T): CListNodeAnd<T>;
+    AddPrev(a?: CListNodeAnd<T> | T): CListNodeAnd<T>;
+    AddEnd(a?: CListNodeAnd<T> | T): CListNodeAnd<T>;
+    AddStart(a?: CListNodeAnd<T> | T): CListNodeAnd<T>;
+    forEach(el: (item: T, e?: CListNodeAnd<T>) => void): void;
+    GetArray(): T[];
+    find(el: (e: CListNodeAnd<T>) => boolean): CListNodeAnd<T> | undefined;
+    DeleteLink(): void;
+}
+export interface iListNodeMini {
+    DeleteLink(): void;
+}
+export {};

package/lib/Common/data/ListNodeAnd.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CListNodeAnd = void 0;
+class CBaseList {
+    data;
+}
+class CListNodeAnd extends CBaseList {
+    get count() {
+        return this._home?._count ?? -1;
+    }
+    _stop = false;
+    _count = 0;
+    _prev = this;
+    _next = this;
+    _home;
+    _Init(prev, next, home) {
+        this._prev = prev;
+        this._next = next;
+        prev._next = next._prev = this;
+        this._home = home;
+        this.countRef();
+        return this;
+    }
+    constructor(prev, next, home) {
+        super();
+        CListNodeAnd._valueG++;
+        CListNodeAnd._valueG2++;
+        this.id = CListNodeAnd._valueG;
+        if (prev && next && home) {
+            this._Init(prev, next, home);
+        }
+        else {
+            this._stop = true;
+            this._home = this;
+        }
+    }
+    ;
+    static _valueG = 0;
+    static _valueG2 = 0;
+    id = CListNodeAnd._valueG;
+    valueOf() { return this.id; }
+    countRef() {
+        let count = 0;
+        for (let i = this.First(); i; i = i.Next()) {
+            count++;
+        }
+        if (this._home)
+            this._home._count = count;
+        return count;
+    }
+    Prev() { return !this._prev._stop ? this._prev : undefined; }
+    Next() { return !this._next._stop ? this._next : undefined; }
+    isPrev() { return !this._prev._stop; }
+    isNext() { return !this._next._stop; }
+    _First() { let buf = this; while (!buf._stop) {
+        buf = buf._prev;
+    } return buf; }
+    _End() { let buf = this; while (!buf._stop) {
+        buf = buf._next;
+    } return buf; }
+    First() { return this._First().Next(); }
+    End() { return this._End().Prev(); }
+    get dataFirst() { return this._First().dataNext; }
+    get dataEnd() { return this._End().dataPrev; }
+    get dataPrev() { return this.Prev()?.data; }
+    get dataNext() { return this.Next()?.data; }
+    get dataThis() { return this._stop ? undefined : this.data; }
+    isForbidden() { return this._stop; }
+    isExists() { return this.isForbidden() || this._prev._stop || this._next._stop; }
+    static _Add(prev, next, home, a) { let buf = new CListNodeAnd(prev, next, home); buf.data = a; return buf; }
+    AddNext(a) { return a instanceof CListNodeAnd ? a._Init(this, this._next, this) : a ? CListNodeAnd._Add(this, this._next, this._home, a) : new CListNodeAnd(this, this._next); }
+    AddPrev(a) { return a instanceof CListNodeAnd ? a._Init(this._prev, this, this) : a ? CListNodeAnd._Add(this._prev, this, this._home, a) : new CListNodeAnd(this._prev, this); }
+    AddEnd(a) { return this._stop ? this.AddPrev(a) : this._End().AddNext(a); }
+    AddStart(a) { return this._stop ? this.AddNext(a) : this._First().AddPrev(a); }
+    forEach(el) {
+        for (let buf = this.First(); buf?.data && !buf.isForbidden();) {
+            let t = buf.Next();
+            el(buf.data, buf);
+            buf = t;
+        }
+    }
+    GetArray() { let a = []; this.forEach(e => a.push(e)); return a; }
+    find(el) { let buf = this.First(); for (; buf; buf = buf.Next()) {
+        if (el(buf))
+            return buf;
+    } return undefined; }
+    DeleteLink() { this._prev._next = this._next; this._next._prev = this._prev; this._prev = this._next = this; this._stop = true; this._home?.countRef(); CListNodeAnd._valueG2--; this._home = undefined; }
+}
+exports.CListNodeAnd = CListNodeAnd;

package/lib/Common/data/objectPath.d.ts

@@ -0,0 +1,11 @@
+export type ObjectKeyPath<TObject extends object = object, TValue = unknown> = readonly string[];
+export declare function objectSetValueByPath<TObj extends {
+    [key: string]: any;
+}, TVal>(obj: TObj, path: ObjectKeyPath<TObj, TVal>, value: TVal): void;
+export declare function objectGetValueByPath<TObj extends {
+    readonly [key: string]: any;
+}, TVal>(object: TObj, path: ObjectKeyPath<TObj, TVal>): TVal;
+export declare function objectDeleteValueByPath<TObj extends {
+    readonly [key: string]: any;
+}, TVal>(object: TObj, path: ObjectKeyPath<TObj, TVal>): boolean;
+export declare function iterateDeepObjectEntries<TObj extends object>(obj: TObj, filter?: (key: string, value: unknown, path: ObjectKeyPath<TObj>) => boolean, currentPath?: ObjectKeyPath<TObj>): Generator<[key: string, value: unknown, path: ObjectKeyPath<TObj>]>;

package/lib/Common/data/objectPath.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.objectSetValueByPath = objectSetValueByPath;
+exports.objectGetValueByPath = objectGetValueByPath;
+exports.objectDeleteValueByPath = objectDeleteValueByPath;
+exports.iterateDeepObjectEntries = iterateDeepObjectEntries;
+function objectSetValueByPath(obj, path, value) {
+    if (path.length == 0)
+        throw "empty path!";
+    let key = path[0];
+    if (path.length == 1) {
+        obj[key] = value;
+        return;
+    }
+    let val = obj[key];
+    if (typeof val != "object")
+        throw "value is not an object: " + val;
+    return objectSetValueByPath(val, path.slice(1), value);
+}
+function objectGetValueByPath(object, path) {
+    if (path.length == 0)
+        throw "empty path!";
+    let key = path[0];
+    if (!(key in object))
+        throw "key is not in object: " + key;
+    let val = object[key];
+    if (path.length == 1)
+        return val;
+    if (typeof val != "object")
+        throw "value is not an object: " + val;
+    return objectGetValueByPath(val, path.slice(1));
+}
+function objectDeleteValueByPath(object, path) {
+    if (path.length == 0)
+        throw "empty path!";
+    let key = path[0];
+    if (path.length == 1)
+        if (!(key in object))
+            return false;
+        else {
+            delete object[key];
+            return true;
+        }
+    let val = object[key];
+    if (typeof val != "object")
+        throw "value is not an object: " + val;
+    return objectDeleteValueByPath(val, path.slice(1));
+}
+function* iterateDeepObjectEntries(obj, filter, currentPath = []) {
+    if (obj)
+        for (let [key, val] of Object.entries(obj)) {
+            let keyPath = currentPath.concat(key);
+            if (filter?.(key, val, keyPath) == false)
+                continue;
+            yield [key, val, keyPath];
+            if (typeof (val) == "object")
+                yield* iterateDeepObjectEntries(val, filter, keyPath);
+        }
+}

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

@@ -0,0 +1,55 @@
+export type Listener<T extends any[]> = (...r: T) => void;
+type NormalizeTuple<T> = T extends any[] ? T : [T];
+export declare function funcListenCallbackBase<T>(b: (e: Listener<NormalizeTuple<T>>) => (void | (() => void)), data?: {
+    event?: (type: "add" | "remove", count: number, api: ReturnType<typeof funcListenCallbackBase<T>>) => void;
+    fast?: boolean;
+}): {
+    func: Listener<NormalizeTuple<T>>;
+    isRun: () => boolean;
+    run: () => void;
+    close: () => void;
+    eventClose: (cb: () => void) => () => void;
+    removeEventClose: (cb: () => void) => void;
+    addListen: (cb: Listener<NormalizeTuple<T>>, cbClose?: () => void) => () => void;
+    removeListen: (cb: Listener<NormalizeTuple<T>> | null) => void;
+    count: () => number;
+    readonly getAllKeys: Listener<NormalizeTuple<T>>[];
+};
+export declare function funcListenCallbackFast<T>(a: (e: (Listener<NormalizeTuple<T>> | null)) => (void | (() => void))): {
+    func: Listener<NormalizeTuple<T>>;
+    isRun: () => boolean;
+    run: () => void;
+    close: () => void;
+    eventClose: (cb: () => void) => () => void;
+    removeEventClose: (cb: () => void) => void;
+    addListen: (cb: Listener<NormalizeTuple<T>>, cbClose?: (() => void) | undefined) => () => void;
+    removeListen: (cb: Listener<NormalizeTuple<T>> | null) => void;
+    count: () => number;
+    readonly getAllKeys: Listener<NormalizeTuple<T_1>>[];
+};
+export declare function funcListenCallback<T>(a: (e: (Listener<NormalizeTuple<T>> | null)) => (void | (() => void)), event?: (type: "add" | "remove", count: number, api: ReturnType<typeof funcListenCallbackBase<T>>) => void, fast?: boolean): {
+    func: Listener<NormalizeTuple<T>>;
+    isRun: () => boolean;
+    run: () => void;
+    close: () => void;
+    eventClose: (cb: () => void) => () => void;
+    removeEventClose: (cb: () => void) => void;
+    addListen: (cb: Listener<NormalizeTuple<T>>, cbClose?: (() => void) | undefined) => () => void;
+    removeListen: (cb: Listener<NormalizeTuple<T>> | null) => void;
+    count: () => number;
+    readonly getAllKeys: Listener<NormalizeTuple<T_1>>[];
+};
+export declare function UseListen<T>(data?: Parameters<typeof funcListenCallbackBase<T>>[1]): readonly [(...a: NormalizeTuple<T>) => void, {
+    func: Listener<NormalizeTuple<T>>;
+    isRun: () => boolean;
+    run: () => void;
+    close: () => void;
+    eventClose: (cb: () => void) => () => void;
+    removeEventClose: (cb: () => void) => void;
+    addListen: (cb: Listener<NormalizeTuple<T>>, cbClose?: (() => void) | undefined) => () => void;
+    removeListen: (cb: Listener<NormalizeTuple<T>> | null) => void;
+    count: () => number;
+    readonly getAllKeys: Listener<NormalizeTuple<T_1>>[];
+}];
+export declare function isListenCallback(obj: any): obj is ReturnType<typeof funcListenCallbackBase>;
+export {};

package/lib/Common/events/Listen.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.funcListenCallbackBase = funcListenCallbackBase;
+exports.funcListenCallbackFast = funcListenCallbackFast;
+exports.funcListenCallback = funcListenCallback;
+exports.UseListen = UseListen;
+exports.isListenCallback = isListenCallback;
+function funcListenCallbackBase(b, data) {
+    const { fast = true, event } = data ?? {};
+    const obj = new Map();
+    const evClose = new Map();
+    const sinh = new Map();
+    let a = (...e) => { obj.forEach(z => z(...e)); };
+    let close = null;
+    let cached = null;
+    const getArr = () => cached ?? (cached = Array.from(obj.values()));
+    const rebuild = () => {
+        cached = null;
+        const size = obj.size;
+        if (size === 0) {
+            a = null;
+            return;
+        }
+        if (size === 1) {
+            a = obj.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);
+        });
+    };
+    const func = (...e) => { a?.(...e); };
+    const run = () => { close = (b(func) ?? (() => { })); };
+    const api = {
+        func,
+        isRun: () => close !== null,
+        run,
+        close: () => {
+            close?.();
+            close = null;
+            obj.clear();
+            if (fast)
+                rebuild();
+            sinh.clear();
+            evClose.forEach(cb => cb());
+            evClose.clear();
+        },
+        eventClose: (cb) => {
+            evClose.set(cb, cb);
+            return () => { evClose.delete(cb); };
+        },
+        removeEventClose: (cb) => {
+            const e = sinh.get(cb);
+            if (e)
+                evClose.delete(e);
+            sinh.delete(cb);
+            evClose.delete(cb);
+        },
+        addListen: (cb, cbClose) => {
+            obj.set(cb, cb);
+            if (cbClose) {
+                if (evClose.has(cb)) {
+                    const r = evClose.get(cb);
+                    if (r !== cbClose) {
+                        evClose.delete(r);
+                        evClose.delete(cb);
+                        sinh.delete(r);
+                    }
+                }
+                evClose.set(cb, cbClose);
+                sinh.set(cbClose, cb);
+            }
+            if (fast)
+                rebuild();
+            event?.("add", obj.size, api);
+            return () => api.removeListen(cb);
+        },
+        removeListen: (cb) => {
+            obj.delete(cb);
+            const e = evClose.get(cb);
+            if (fast)
+                rebuild();
+            evClose.delete(cb);
+            if (e) {
+                evClose.delete(e);
+                sinh.delete(e);
+            }
+            event?.("remove", obj.size, api);
+        },
+        count: () => obj.size,
+        get getAllKeys() { return [...obj.keys()]; }
+    };
+    return api;
+}
+function funcListenCallbackFast(a) {
+    return funcListenCallbackBase(a, { fast: true });
+}
+function funcListenCallback(a, event, fast = true) {
+    return funcListenCallbackBase(a, { event, fast });
+}
+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 isListenCallback(obj) {
+    if (obj == null || typeof obj !== "object")
+        return false;
+    const obj2 = obj;
+    return (typeof obj2.addListen === "function" &&
+        typeof obj2.removeListen === "function" &&
+        typeof obj2.eventClose === "function" &&
+        typeof obj2.func === "function" &&
+        typeof obj2.count === "function");
+}

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

@@ -0,0 +1,41 @@
+export type realSocket2<T extends any> = (data: {
+    callback: (data: T) => void;
+    [key: string]: any;
+}, ...b: any[]) => (any | (() => any));
+export type getTypeCallback<T extends realSocket2<any>> = T extends realSocket2<infer R> ? R : never;
+type ParametersOther<T extends (forget: any, ...args: any) => any> = T extends (forget: any, ...args: infer P) => any ? P : never;
+type tr22<T> = T extends undefined ? never : T;
+export declare function socketBuffer3<T extends realSocket2<any | any[]>, T2 extends (readonly unknown[]) | undefined, T3 extends {
+    [key: string]: unknown;
+}, T4 extends T3 | (() => T3)>(func: T, callbackMain: (data: getTypeCallback<T>, memo: T3 | T4) => T2, memo?: T3 | T4): (a: Omit<Parameters<T>[0], "callback"> & {
+    callback: (...data: tr22<T2>) => any;
+}, ...b: ParametersOther<T>) => ReturnType<T>;
+export declare function funcListenCallbackSnapshot<T extends realSocket2<any | any[]>, T2 extends (readonly unknown[]) | undefined, T3 extends {
+    [key: string]: unknown;
+}, T4 extends T3 | (() => T3)>({ func, memo, callbackSave, snapshot }: {
+    func: () => T;
+    callbackSave: (data: getTypeCallback<T>, memo: T3) => T2;
+    memo: T4;
+    snapshot?: (memo: T4) => T3;
+}): {
+    run: (cb: import("./Listen").Listener<[data: getTypeCallback<T>, memo: T3]>, cbClose?: (() => void) | undefined) => () => void;
+    snapshot: () => T3 | undefined;
+    memo: T4;
+    listenA: {
+        func: import("./Listen").Listener<[data: getTypeCallback<T>, memo: T3]>;
+        isRun: () => boolean;
+        run: () => void;
+        close: () => void;
+        eventClose: (cb: () => void) => () => void;
+        removeEventClose: (cb: () => void) => void;
+        addListen: (cb: import("./Listen").Listener<[data: getTypeCallback<T>, memo: T3]>, cbClose?: (() => void) | undefined) => () => void;
+        removeListen: (cb: import("./Listen").Listener<[data: getTypeCallback<T>, memo: T3]> | null) => void;
+        count: () => number;
+        readonly getAllKeys: import("./Listen").Listener<T_1 extends any[] ? T_1 : [T_1]>[];
+    };
+    connect: () => void;
+    readonly disconnect: ((a: Omit<Parameters<T>[0], "callback"> & {
+        callback: (...data: tr22<T2>) => any;
+    }, ...b: ParametersOther<T>) => ReturnType<T>) | null;
+};
+export {};

package/lib/Common/events/SocketBuffer.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.socketBuffer3 = socketBuffer3;
+exports.funcListenCallbackSnapshot = funcListenCallbackSnapshot;
+const Listen_1 = require("./Listen");
+function socketBuffer3(func, callbackMain, memo = {}) {
+    return (a, ...b) => func({
+        ...a, callback: (v) => {
+            const z = callbackMain(v, memo);
+            if (z)
+                a.callback(...z);
+        }
+    }, ...b);
+}
+function funcListenCallbackSnapshot({ func, memo = {}, callbackSave, snapshot }) {
+    let d = null;
+    const [callback, listenA] = (0, Listen_1.UseListen)({
+        event: (type, count, api) => {
+            if (type == "remove" && count == 0) {
+                api.close();
+                d?.();
+            }
+            if (type == "add" && count == 1)
+                api.run();
+        }
+    });
+    const connect = () => {
+        if (d == null)
+            d = socketBuffer3(func(), callbackSave, memo)({ callback });
+    };
+    const run = (...params) => {
+        if (!listenA.isRun()) {
+            snapshot?.(memo);
+            connect();
+        }
+        return listenA.addListen(...params);
+    };
+    return {
+        run, snapshot: () => snapshot?.(memo), memo, listenA, connect, get disconnect() {
+            return d;
+        }
+    };
+}