wenay-common2 1.0.48 → 1.0.49

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

@@ -0,0 +1,197 @@
+export type Listener<T extends any[]> = (...r: T) => void;
+export type NormalizeTuple<T> = T extends any[] ? T : [T];
+type key = string | symbol;
+type cbClose = () => void;
+declare const LISTEN_ON_BRAND: unique symbol;
+export type ListenOn<Z extends any[] = any[]> = ((cb: Listener<Z>, opts?: {
+    cbClose?: cbClose;
+    key?: key;
+}) => (() => void)) & {
+    readonly [LISTEN_ON_BRAND]: Z;
+};
+export type ListenOnCurrent<Z extends any[] = any[]> = ((cb: Listener<Z>, opts?: {
+    cbClose?: cbClose;
+    key?: key;
+    current?: ListenCurrent<Z>;
+}) => (() => void)) & {
+    readonly [LISTEN_ON_BRAND]: Z;
+};
+export type ListenCurrentProvider<Z extends any[]> = () => Z | undefined;
+export type ListenCurrent<Z extends any[]> = boolean | ListenCurrentProvider<Z>;
+export type ListenCoreOptions<T = any> = {
+    fast?: boolean;
+    onRemove?: (k: key) => void;
+    event?: (type: 'add' | 'remove', count: number, api: ListenCoreApi<T>) => void;
+};
+export type ListenOptions<T> = {
+    event?: (type: 'add' | 'remove', count: number, api: ListenApi<T>) => void;
+    fast?: boolean;
+    addListenClose?: ListenApi<any>;
+};
+export type ListenStoreOptions<T> = ListenOptions<T> & {
+    current: ListenCurrentProvider<NormalizeTuple<T>>;
+};
+export declare function getListenByOn(fn: any): any;
+export declare function isListenOn(fn: any): boolean;
+export declare function funcListenCore<T>(options?: ListenCoreOptions<T>): {
+    func: Listener<NormalizeTuple<T>>;
+    has: (k: key) => boolean;
+    on: ListenOn<NormalizeTuple<T>>;
+    addListen: (cb: Listener<NormalizeTuple<T>>, opts?: {
+        key?: key;
+    }) => () => void;
+    removeListen: (k: Listener<NormalizeTuple<T>> | null | key) => void;
+    once: (cb: Listener<NormalizeTuple<T>>, opts?: {
+        key?: key;
+    }) => () => void;
+    close: () => void;
+    count: () => number;
+    readonly getAllKeys: key[];
+};
+export type ListenCoreApi<T = any> = ReturnType<typeof funcListenCore<T>>;
+export declare function funcListenCallbackBase<T>(b: (e: Listener<NormalizeTuple<T>>) => (void | (() => void)), options?: ListenOptions<T>): {
+    func: Listener<NormalizeTuple<T>>;
+    isRun: () => boolean;
+    run: () => void;
+    close: () => void;
+    eventClose: (cb: cbClose) => () => void;
+    onClose: (cb: cbClose) => () => void;
+    removeEventClose: (cb: cbClose) => void;
+    on: ListenOn<NormalizeTuple<T>>;
+    addListen: (cb: Listener<NormalizeTuple<T>>, opts?: {
+        cbClose?: cbClose;
+        key?: key;
+    }) => () => void;
+    removeListen: (k: key | Listener<NormalizeTuple<T>> | null) => void;
+    once: (cb: Listener<NormalizeTuple<T>>, opts?: {
+        key?: key;
+    }) => () => void;
+    count: () => number;
+    readonly getAllKeys: key[];
+};
+export type ListenApi<T = any> = ReturnType<typeof funcListenCallbackBase<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: cbClose) => () => void;
+    onClose: (cb: cbClose) => () => void;
+    removeEventClose: (cb: cbClose) => void;
+    on: ListenOn<NormalizeTuple<T>>;
+    addListen: (cb: Listener<NormalizeTuple<T>>, opts?: {
+        cbClose?: cbClose;
+        key?: key;
+    }) => () => void;
+    removeListen: (k: key | Listener<NormalizeTuple<T>> | null) => void;
+    once: (cb: Listener<NormalizeTuple<T>>, opts?: {
+        key?: key;
+    }) => () => void;
+    count: () => number;
+    readonly getAllKeys: key[];
+};
+export declare const funcListenCallback: typeof funcListenCallbackBase;
+export declare function UseListen<T>(data?: ListenOptions<T>): readonly [(...a: NormalizeTuple<T>) => void, {
+    func: Listener<NormalizeTuple<T>>;
+    isRun: () => boolean;
+    run: () => void;
+    close: () => void;
+    eventClose: (cb: cbClose) => () => void;
+    onClose: (cb: cbClose) => () => void;
+    removeEventClose: (cb: cbClose) => void;
+    on: ListenOn<NormalizeTuple<T>>;
+    addListen: (cb: Listener<NormalizeTuple<T>>, opts?: {
+        cbClose?: cbClose;
+        key?: key;
+    }) => () => void;
+    removeListen: (k: key | Listener<NormalizeTuple<T>> | null) => void;
+    once: (cb: Listener<NormalizeTuple<T>>, opts?: {
+        key?: key;
+    }) => () => void;
+    count: () => number;
+    readonly getAllKeys: key[];
+}];
+export declare function withStoreListen<T>(base: ListenApi<T>, currentProvider: ListenCurrentProvider<NormalizeTuple<T>>): {
+    on: ListenOnCurrent<NormalizeTuple<T>>;
+    addListen: (cb: Listener<NormalizeTuple<T>>, opts?: {
+        cbClose?: cbClose;
+        key?: key;
+        current?: ListenCurrent<NormalizeTuple<T>>;
+    }) => () => void;
+    once: (cb: Listener<NormalizeTuple<T>>, opts?: {
+        key?: key;
+        current?: ListenCurrent<NormalizeTuple<T>>;
+    }) => () => void;
+    getAllKeys: key[];
+    func: Listener<NormalizeTuple<T>>;
+    isRun: () => boolean;
+    run: () => void;
+    close: () => void;
+    eventClose: (cb: cbClose) => () => void;
+    onClose: (cb: cbClose) => () => void;
+    removeEventClose: (cb: cbClose) => void;
+    removeListen: (k: key | Listener<NormalizeTuple<T>> | null) => void;
+    count: () => number;
+};
+export type ListenStoreApi<T> = ReturnType<typeof withStoreListen<T>>;
+export declare function funcListenCallbackStore<T>(b: (e: Listener<NormalizeTuple<T>>) => (void | (() => void)), options: ListenStoreOptions<T>): {
+    on: ListenOnCurrent<NormalizeTuple<T>>;
+    addListen: (cb: Listener<NormalizeTuple<T>>, opts?: {
+        cbClose?: cbClose;
+        key?: key;
+        current?: ListenCurrent<NormalizeTuple<T>> | undefined;
+    }) => () => void;
+    once: (cb: Listener<NormalizeTuple<T>>, opts?: {
+        key?: key;
+        current?: ListenCurrent<NormalizeTuple<T>> | undefined;
+    }) => () => void;
+    getAllKeys: key[];
+    func: Listener<NormalizeTuple<T>>;
+    isRun: () => boolean;
+    run: () => void;
+    close: () => void;
+    eventClose: (cb: cbClose) => () => void;
+    onClose: (cb: cbClose) => () => void;
+    removeEventClose: (cb: cbClose) => void;
+    removeListen: (k: key | Listener<NormalizeTuple<T>> | null) => void;
+    count: () => number;
+};
+export declare function UseListenStore<T>(data: ListenStoreOptions<T>): readonly [(...a: NormalizeTuple<T>) => void, {
+    on: ListenOnCurrent<NormalizeTuple<T>>;
+    addListen: (cb: Listener<NormalizeTuple<T>>, opts?: {
+        cbClose?: cbClose;
+        key?: key;
+        current?: ListenCurrent<NormalizeTuple<T>> | undefined;
+    }) => () => void;
+    once: (cb: Listener<NormalizeTuple<T>>, opts?: {
+        key?: key;
+        current?: ListenCurrent<NormalizeTuple<T>> | undefined;
+    }) => () => void;
+    getAllKeys: key[];
+    func: Listener<NormalizeTuple<T>>;
+    isRun: () => boolean;
+    run: () => void;
+    close: () => void;
+    eventClose: (cb: cbClose) => () => void;
+    onClose: (cb: cbClose) => () => void;
+    removeEventClose: (cb: cbClose) => void;
+    removeListen: (k: key | Listener<NormalizeTuple<T>> | null) => void;
+    count: () => number;
+}];
+export declare function toListen2<T>(full: ListenApi<T>): {
+    on: (cb: Listener<NormalizeTuple<T>>, opts?: {
+        key?: key;
+    }) => () => void;
+    close: () => void;
+    count: () => number;
+};
+export type Listen2<T> = ReturnType<typeof toListen2<T>>;
+export declare function UseListen2<T>(data?: ListenOptions<T>): readonly [(...a: NormalizeTuple<T>) => void, {
+    on: (cb: Listener<NormalizeTuple<T>>, opts?: {
+        key?: key;
+    } | undefined) => () => void;
+    close: () => void;
+    count: () => number;
+}];
+export declare function isListenCallback(obj: any): obj is ListenApi;
+export {};

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,31 +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;
+    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;
+        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("./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?: {
+        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;
         count: () => number;
-        readonly getAllKeys: ((string | symbol) | 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,45 +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;
+            on: import("./Listen3").ListenOn<[unknown]>;
+            addListen: (cb: import("./Listen3").Listener<[unknown]>, opts?: {
+                cbClose?: () => void;
                 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?: {
+            removeListen: (k: (string | symbol) | import("./Listen3").Listener<[unknown]> | null) => void;
+            once: (cb: import("./Listen3").Listener<[unknown]>, opts?: {
                 key?: string | symbol;
             }) => () => void;
             count: () => number;
-            readonly getAllKeys: ((string | symbol) | 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;
+        on: import("./Listen3").ListenOn<[unknown]>;
+        addListen: (cb: import("./Listen3").Listener<[unknown]>, opts?: {
+            cbClose?: () => void;
             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?: {
+        removeListen: (k: (string | symbol) | import("./Listen3").Listener<[unknown]> | null) => void;
+        once: (cb: import("./Listen3").Listener<[unknown]>, opts?: {
             key?: string | symbol;
         }) => () => void;
         count: () => number;
-        readonly getAllKeys: ((string | symbol) | import("./Listen").Listener<[unknown]>)[];
+        readonly getAllKeys: (string | symbol)[];
     }];
     provider: (tag: string, data: any) => void;
 };

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

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

package/lib/Common/rcp/listen-socket.js

@@ -44,9 +44,12 @@ function createThrottleLatest(ms, sink) {
 }
 function listenSocket(e, d) {
     const { stop, addListenClose, status, paramsModify, throttle } = d ?? {};
-    const { addListen, removeListen, eventClose, removeEventClose } = e;
+    const subscribe = (cb, opts) => typeof e.on == "function" ? e.on(cb, opts) : e.addListen(cb, opts);
+    const subscribeClose = addListenClose && ((cb) => typeof addListenClose.on == "function" ? addListenClose.on(cb) : addListenClose.addListen(cb));
     let last = null;
     let active = null;
+    let activeOff = null;
+    let closeSignalOff = null;
     let resolveWait = null;
     let throttleCh = null;
     function finish() {
@@ -64,11 +67,15 @@ function listenSocket(e, d) {
             stop?.(last);
             last = null;
         }
-        if (active) {
-            removeListen(active);
+        if (activeOff) {
+            activeOff();
+            activeOff = null;
             active = null;
         }
-        addListenClose?.removeListen(removeCallback);
+        if (closeSignalOff) {
+            closeSignalOff();
+            closeSignalOff = null;
+        }
         finish();
         return true;
     }
@@ -78,8 +85,15 @@ function listenSocket(e, d) {
         }
         if (last)
             stop?.(last);
-        if (active)
-            removeListen(active);
+        if (activeOff) {
+            activeOff();
+            activeOff = null;
+            active = null;
+        }
+        if (closeSignalOff) {
+            closeSignalOff();
+            closeSignalOff = null;
+        }
         if (resolveWait) {
             resolveWait();
             resolveWait = null;
@@ -118,18 +132,22 @@ function listenSocket(e, d) {
                     stop?.(last);
                 }
                 last = null;
-                if (active) {
-                    removeListen(active);
+                if (activeOff) {
+                    activeOff();
+                    activeOff = null;
                     active = null;
                 }
-                addListenClose?.removeListen(removeCallback);
+                if (closeSignalOff) {
+                    closeSignalOff();
+                    closeSignalOff = null;
+                }
                 finish();
                 return;
             }
             inner(...a);
         };
-        addListen(active, { cbClose: removeCallback });
-        addListenClose?.addListen(removeCallback);
+        activeOff = subscribe(active, { cbClose: removeCallback });
+        closeSignalOff = subscribeClose?.(removeCallback) ?? null;
         const wait = new Promise((resolve) => {
             resolveWait = () => { resolve(); };
         });

package/lib/index.d.ts

@@ -12,6 +12,7 @@ export * from "./Common/data/List";
 export * from "./Common/data/ListNodeAnd";
 export * from "./Common/data/objectPath";
 export * from "./Common/events/Listen";
+export * as ListenNext from "./Common/events/Listen2";
 export * from "./Common/events/event";
 export * from "./Common/events/SocketBuffer";
 export * from "./Common/events/SocketServerHook";
@@ -31,4 +32,4 @@ export * as Bars from "./Exchange/Bars";
 export * as Params from "./Exchange/CParams";
 export * as Time from "./Common/Time";
 export * as Color from "./Common/Color";
-export * as ObserveAll2 from "./Common/ObserveAll2/reactive2";
+export * as ObserveAll2 from "./Common/ObserveAll2";