wenay-common2 1.0.46 → 1.0.48

package/lib/Common/data/ByteStream.js

@@ -4,7 +4,10 @@ exports.ByteStreamR = exports.ByteStreamW = exports.Nullable = void 0;
 exports.nullable = nullable;
 function createCopyOfBuffer(src, length = src.byteLength) {
     let dst = new ArrayBuffer(length);
-    new Uint8Array(dst).set(new Uint8Array(src));
+    const bytes = src instanceof DataView
+        ? new Uint8Array(src.buffer, src.byteOffset, Math.min(src.byteLength, length))
+        : new Uint8Array(src, 0, Math.min(src.byteLength, length));
+    new Uint8Array(dst).set(bytes);
     return dst;
 }
 class Nullable {
@@ -45,7 +48,7 @@ class ByteStreamW {
     _isThrowable = true;
     _buffer() { return this._view?.buffer; }
     resize(size) {
-        let buf = createCopyOfBuffer(this._buffer(), size);
+        let buf = createCopyOfBuffer(this._view, size);
         this._view = new DataView(buf);
     }
     constructor(view) {
@@ -57,7 +60,7 @@ class ByteStreamW {
         }
     }
     get length() { return this._pos; }
-    get data() { return new DataView(this._buffer(), 0, this._pos); }
+    get data() { return new DataView(this._buffer(), this._view.byteOffset, this._pos); }
     noThrow() { let other = new ByteStreamW(this._view); other._pos = this._pos; other._isThrowable = false; return other; }
     _ensureAllocation(bytes) {
         let minSize = this._pos + bytes;
@@ -166,7 +169,15 @@ class ByteStreamW {
         let typeInfo = getNumericTypeInfo(type);
         if (!typeInfo)
             throw ("Wrong type: " + type);
-        return (stream, value) => { return (isNullable ? stream.pushBool(value != null) : stream)?._push(value, typeInfo.size, typeInfo.integer) != null; };
+        return (stream, value) => {
+            if (isNullable) {
+                if (stream.pushBool(value != null) == null)
+                    return false;
+                if (value == null)
+                    return true;
+            }
+            return stream._push(value, typeInfo.size, typeInfo.integer) != null;
+        };
     }
     pushArrayNumeric(array, type, maxlength) {
         return this.pushArrayByFunc(array, this._getWriteFuncForNumeric(type), maxlength);
@@ -177,10 +188,7 @@ class ByteStreamW {
             this._ensureAllocation(length + 4);
             this.pushInt32(length);
             let arrayClass = (array instanceof Int8Array) ? Int8Array : Uint8Array;
-            if (length != array.length) {
-                array = new arrayClass(array.buffer, 0, length);
-            }
-            new arrayClass(this._buffer()).set(array, this._pos);
+            new arrayClass(this._buffer(), this._view.byteOffset + this._pos, length).set(array.subarray(0, length));
             this._pos += length;
             return this;
         }
@@ -341,6 +349,11 @@ class ByteStreamR_ {
             let size = this.readUint32();
             if (size == null)
                 return null;
+            if (this._pos + size > this._view.byteLength)
+                if (this.isThrowable)
+                    throw ("Array read out of range");
+                else
+                    return null;
             let bufpos = this._view.byteOffset + this._pos;
             const out = new arrayClass(this._view.buffer.slice(bufpos, bufpos + size));
             this._pos += size;

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

@@ -24,6 +24,7 @@ export declare class CList<T, TNode extends ListNode<T> = ListNode<T>> implement
     get last(): CListNode<T> | undefined;
     get count(): number;
     get length(): number;
+    get size(): number;
     readonly [Symbol.iterator]: () => Generator<TNode, void, unknown>;
     constructor(values?: Iterable<T>);
     nodes(): Generator<TNode, void, unknown>;
@@ -53,6 +54,10 @@ export declare class CList<T, TNode extends ListNode<T> = ListNode<T>> implement
     delete(node: ListNode<T>): void;
     deleteFirst(): void;
     deleteLast(): void;
+    push(value: T): ListNode<T>;
+    unshift(value: T): ListNode<T>;
+    pop(): T | undefined;
+    shift(): T | undefined;
     clear(): void;
     private validateNode;
     private newNode;

package/lib/Common/data/List.js

@@ -18,15 +18,20 @@ class CList {
     get last() { return this._last; }
     get count() { return this._count; }
     get length() { return this._count; }
+    get size() { 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; }
+    *nodes() { for (let node = this._first; node != null;) {
+        yield node;
+        node = node.next;
+    } }
     *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; }
+    *reversedNodes() { for (let node = this._last; node != null;) {
+        yield node;
+        node = node.prev;
+    } }
     *reversedValues() { for (let node of this.reversedNodes())
         yield node.value; }
     *entries() { let i = 0; for (let node of this.nodes())
@@ -143,6 +148,10 @@ class CList {
         this.delete(this._first); }
     deleteLast() { if (this._last)
         this.delete(this._last); }
+    push(value) { return this.addLast(value); }
+    unshift(value) { return this.addFirst(value); }
+    pop() { let value = this._last?.value; this.deleteLast(); return value; }
+    shift() { let value = this._first?.value; this.deleteFirst(); return value; }
     clear() {
         for (let node = this._first; node != null; node = node.next)
             node.list = undefined;

package/lib/Common/data/ListNodeAnd.js

@@ -68,8 +68,8 @@ class CListNodeAnd extends CBaseList {
     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); }
+    AddNext(a) { return a instanceof CListNodeAnd ? a._Init(this, this._next, this) : arguments.length ? 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) : arguments.length ? 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) {

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

@@ -2,10 +2,14 @@ export type ObjectKeyPath<TObject extends object = object, TValue = unknown> = r
 export declare function objectSetValueByPath<TObj extends {
     [key: string]: any;
 }, TVal>(obj: TObj, path: ObjectKeyPath<TObj, TVal>, value: TVal): void;
+export declare const objectSet: typeof objectSetValueByPath;
 export declare function objectGetValueByPath<TObj extends {
     readonly [key: string]: any;
 }, TVal>(object: TObj, path: ObjectKeyPath<TObj, TVal>): TVal;
+export declare const objectGet: typeof objectGetValueByPath;
 export declare function objectDeleteValueByPath<TObj extends {
     readonly [key: string]: any;
 }, TVal>(object: TObj, path: ObjectKeyPath<TObj, TVal>): boolean;
+export declare const objectUnset: typeof objectDeleteValueByPath;
 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>]>;
+export declare const deepEntries: typeof iterateDeepObjectEntries;

package/lib/Common/data/objectPath.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.deepEntries = exports.objectUnset = exports.objectGet = exports.objectSet = void 0;
 exports.objectSetValueByPath = objectSetValueByPath;
 exports.objectGetValueByPath = objectGetValueByPath;
 exports.objectDeleteValueByPath = objectDeleteValueByPath;
@@ -13,10 +14,11 @@ function objectSetValueByPath(obj, path, value) {
         return;
     }
     let val = obj[key];
-    if (typeof val != "object")
+    if (val == null || typeof val != "object")
         throw "value is not an object: " + val;
     return objectSetValueByPath(val, path.slice(1), value);
 }
+exports.objectSet = objectSetValueByPath;
 function objectGetValueByPath(object, path) {
     if (path.length == 0)
         throw "empty path!";
@@ -26,10 +28,11 @@ function objectGetValueByPath(object, path) {
     let val = object[key];
     if (path.length == 1)
         return val;
-    if (typeof val != "object")
+    if (val == null || typeof val != "object")
         throw "value is not an object: " + val;
     return objectGetValueByPath(val, path.slice(1));
 }
+exports.objectGet = objectGetValueByPath;
 function objectDeleteValueByPath(object, path) {
     if (path.length == 0)
         throw "empty path!";
@@ -42,10 +45,11 @@ function objectDeleteValueByPath(object, path) {
             return true;
         }
     let val = object[key];
-    if (typeof val != "object")
+    if (val == null || typeof val != "object")
         throw "value is not an object: " + val;
     return objectDeleteValueByPath(val, path.slice(1));
 }
+exports.objectUnset = objectDeleteValueByPath;
 function* iterateDeepObjectEntries(obj, filter, currentPath = []) {
     if (obj)
         for (let [key, val] of Object.entries(obj)) {
@@ -57,3 +61,4 @@ function* iterateDeepObjectEntries(obj, filter, currentPath = []) {
                 yield* iterateDeepObjectEntries(val, filter, keyPath);
         }
 }
+exports.deepEntries = iterateDeepObjectEntries;

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/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;
 }