wenay-common2 1.0.62 → 1.0.64

package/lib/Common/events/Listen.js

@@ -1,17 +1,245 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./Listen3"), exports);
+exports.getListenByOn = getListenByOn;
+exports.isListenOn = isListenOn;
+exports.registerListenOn = registerListenOn;
+exports.createListenCore = createListenCore;
+exports.createListen = createListen;
+exports.createFastListen = createFastListen;
+exports.listen = listen;
+exports.withStoreListen = withStoreListen;
+exports.createStoreListen = createStoreListen;
+exports.listenStore = listenStore;
+exports.toSlimListen = toSlimListen;
+exports.slimListen = slimListen;
+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 registerListenOn(on, api) { listenByOn.set(on, api); }
+function createListenCore(options = {}) {
+    const { fast = true, onRemove, event } = options;
+    const subs = new Map();
+    let dispatcher = (...args) => { subs.forEach(cb => cb(...args)); };
+    let cached = null;
+    const getArr = () => cached ?? (cached = Array.from(subs.values()));
+    function rebuild() {
+        cached = null;
+        const size = subs.size;
+        if (size == 0) {
+            dispatcher = null;
+            return;
+        }
+        if (size == 1) {
+            dispatcher = subs.values().next().value;
+            return;
+        }
+        if (size == 2) {
+            const [a, b] = getArr();
+            dispatcher = ((...args) => { a(...args); b(...args); });
+            return;
+        }
+        dispatcher = ((...args) => {
+            const arr = getArr();
+            for (let i = 0; i < arr.length; i++)
+                arr[i](...args);
+        });
+    }
+    function removeOne(key) {
+        if (!subs.has(key))
+            return;
+        subs.delete(key);
+        onRemove?.(key);
+        if (fast)
+            rebuild();
+        event?.('remove', subs.size, api);
+    }
+    const api = {
+        emit: ((...args) => { dispatcher?.(...args); }),
+        has: (key) => subs.has(key),
+        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); };
+        }),
+        off: (keyOrCallback) => {
+            if (typeof keyOrCallback == 'function') {
+                for (const [key, cb] of [...subs])
+                    if (cb === keyOrCallback)
+                        removeOne(key);
+                return;
+            }
+            if (keyOrCallback != null)
+                removeOne(keyOrCallback);
+        },
+        once: (cb, opts = {}) => {
+            let off = () => { };
+            off = api.on(((...args) => { off(); cb(...args); }), opts);
+            return off;
+        },
+        close: () => {
+            subs.clear();
+            if (fast)
+                rebuild();
+        },
+        count: () => subs.size,
+        keys: () => [...subs.keys()],
+    };
+    listenByOn.set(api.on, api);
+    return api;
+}
+function createListen(producer, options = {}) {
+    const { fast = true, event, closeOn } = options;
+    let teardown = null;
+    let closeSignalOff = null;
+    let closeHooks = null;
+    function forgetKey(key) {
+        closeHooks?.delete(key);
+    }
+    const core = createListenCore({
+        fast,
+        onRemove: forgetKey,
+        event: event && ((type, count) => {
+            if (type == 'remove')
+                event(type, count, api);
+        }),
+    });
+    const api = {
+        emit: core.emit,
+        has: core.has,
+        isRunning: () => teardown !== null,
+        run: () => {
+            if (teardown)
+                return;
+            teardown = (producer(core.emit) ?? (() => { }));
+            if (closeOn && !closeSignalOff)
+                closeSignalOff = closeOn.on(() => api.close());
+        },
+        close: () => {
+            const stop = teardown;
+            teardown = null;
+            stop?.();
+            core.close();
+            if (closeHooks) {
+                const hooks = closeHooks;
+                closeHooks = null;
+                hooks.forEach(cb => cb());
+            }
+            closeSignalOff?.();
+            closeSignalOff = null;
+        },
+        onClose: (cb) => {
+            closeHooks = closeHooks ?? new Map();
+            closeHooks.set(cb, cb);
+            return function offClose() { 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;
+        }),
+        off: core.off,
+        once: (cb, opts = {}) => {
+            let off = () => { };
+            off = api.on(((...args) => { off(); cb(...args); }), opts);
+            return off;
+        },
+        count: core.count,
+        keys: core.keys,
+    };
+    listenByOn.set(api.on, api);
+    return api;
+}
+function createFastListen(producer) {
+    return createListen(producer, { fast: true });
+}
+function listen(options = { fast: true }) {
+    let emit;
+    const api = createListen((next) => { emit = next; }, { fast: true, ...options });
+    api.run();
+    emit = api.emit;
+    return [emit, api];
+}
+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 value = currentValue(current);
+                if (value)
+                    cb(...value);
+            }
+            return off;
+        }),
+        once: (cb, opts = {}) => {
+            if (opts.current) {
+                const value = currentValue(opts.current);
+                if (value) {
+                    cb(...value);
+                    return () => { };
+                }
+            }
+            let off = () => { };
+            off = base.on(((...args) => { off(); cb(...args); }), { key: opts.key });
+            return off;
+        },
+    };
+    listenByOn.set(api.on, api);
+    return api;
+}
+function createStoreListen(producer, options) {
+    const { current, ...listenOptions } = options;
+    return withStoreListen(createListen(producer, listenOptions), current);
+}
+function listenStore(options) {
+    const { current, ...listenOptions } = options;
+    let emit;
+    const base = createListen((next) => { emit = next; }, { fast: true, ...listenOptions });
+    const api = withStoreListen(base, current);
+    base.run();
+    emit = base.emit;
+    return [emit, api];
+}
+function toSlimListen(full) {
+    return {
+        on: (cb, opts) => full.on(cb, opts),
+        off: (keyOrCallback) => full.off(keyOrCallback),
+        close: () => full.close(),
+        count: () => full.count(),
+    };
+}
+function slimListen(options = { fast: true }) {
+    const [emit, full] = listen(options);
+    return [emit, toSlimListen(full)];
+}
+const LISTEN_CORE = ['emit', 'on', 'off', 'onClose', 'run', 'isRunning', 'close', 'count'];
+function isListenCallback(obj) {
+    if (obj == null || typeof obj != 'object')
+        return false;
+    const keys = new Set(Object.keys(obj));
+    for (const key of LISTEN_CORE)
+        if (!keys.has(key))
+            return false;
+    for (const key of LISTEN_CORE)
+        if (typeof obj[key] != 'function')
+            return false;
+    return true;
+}

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

@@ -1,129 +1 @@
-export type Listener<T extends any[]> = (...args: T) => void;
-export type NormalizeTuple<T> = T extends any[] ? T : [T];
-export type ListenKey = string | symbol;
-export type ListenOff = () => void;
-type CloseCallback = () => void;
-declare const LISTEN_ON_BRAND: unique symbol;
-export type ListenOn<Z extends any[] = any[]> = ((cb: Listener<Z>, opts?: {
-    cbClose?: CloseCallback;
-    key?: ListenKey;
-}) => ListenOff) & {
-    readonly [LISTEN_ON_BRAND]: Z;
-};
-export type ListenOnCurrent<Z extends any[] = any[]> = ((cb: Listener<Z>, opts?: {
-    cbClose?: CloseCallback;
-    key?: ListenKey;
-    current?: ListenCurrent<Z>;
-}) => ListenOff) & {
-    readonly [LISTEN_ON_BRAND]: Z;
-};
-export type ListenCurrentProvider<Z extends any[]> = () => Z | undefined;
-export type ListenCurrent<Z extends any[]> = boolean | ListenCurrentProvider<Z>;
-export type ListenCoreApi<T = any> = {
-    emit: Listener<NormalizeTuple<T>>;
-    has(key: ListenKey): boolean;
-    on: ListenOn<NormalizeTuple<T>>;
-    off(keyOrCallback: Listener<NormalizeTuple<T>> | null | ListenKey): void;
-    once(cb: Listener<NormalizeTuple<T>>, opts?: {
-        key?: ListenKey;
-    }): ListenOff;
-    close(): void;
-    count(): number;
-    keys(): ListenKey[];
-};
-export type ListenApi<T = any> = ListenCoreApi<T> & {
-    isRunning(): boolean;
-    run(): void;
-    onClose(cb: CloseCallback): ListenOff;
-};
-export type ListenCoreOptions<T = any> = {
-    fast?: boolean;
-    onRemove?: (key: ListenKey) => void;
-    event?: (type: 'add' | 'remove', count: number, api: ListenCoreApi<T>) => void;
-};
-export type ListenOptions<T = any> = {
-    event?: (type: 'add' | 'remove', count: number, api: ListenApi<T>) => void;
-    fast?: boolean;
-    closeOn?: ListenApi<any>;
-};
-export type ListenStoreOptions<T> = ListenOptions<T> & {
-    current: ListenCurrentProvider<NormalizeTuple<T>>;
-};
-export type ListenOnBrand<Z extends any[] = any[]> = {
-    readonly [LISTEN_ON_BRAND]: Z;
-};
-export declare function getListenByOn(fn: any): any;
-export declare function isListenOn(fn: any): boolean;
-export declare function registerListenOn(on: Function, api: any): void;
-export declare function createListenCore<T>(options?: ListenCoreOptions<T>): ListenCoreApi<T>;
-export declare function createListen<T>(producer: (emit: Listener<NormalizeTuple<T>>) => (void | ListenOff), options?: ListenOptions<T>): ListenApi<T>;
-export declare function createFastListen<T>(producer: (emit: Listener<NormalizeTuple<T>>) => (void | ListenOff)): ListenApi<T>;
-export declare function listen<T>(options?: ListenOptions<T>): readonly [Listener<NormalizeTuple<T>>, ListenApi<T>];
-export declare function withStoreListen<T>(base: ListenApi<T>, currentProvider: ListenCurrentProvider<NormalizeTuple<T>>): {
-    on: ListenOnCurrent<NormalizeTuple<T>>;
-    once: (cb: Listener<NormalizeTuple<T>>, opts?: {
-        key?: ListenKey;
-        current?: ListenCurrent<NormalizeTuple<T>>;
-    }) => ListenOff;
-    emit: Listener<NormalizeTuple<T>>;
-    has(key: ListenKey): boolean;
-    off(keyOrCallback: ListenKey | Listener<NormalizeTuple<T>> | null): void;
-    close(): void;
-    count(): number;
-    keys(): ListenKey[];
-    isRunning(): boolean;
-    run(): void;
-    onClose(cb: CloseCallback): ListenOff;
-};
-export type ListenStoreApi<T> = ReturnType<typeof withStoreListen<T>>;
-export declare function createStoreListen<T>(producer: (emit: Listener<NormalizeTuple<T>>) => (void | ListenOff), options: ListenStoreOptions<T>): {
-    on: ListenOnCurrent<NormalizeTuple<T>>;
-    once: (cb: Listener<NormalizeTuple<T>>, opts?: {
-        key?: ListenKey;
-        current?: ListenCurrent<NormalizeTuple<T>> | undefined;
-    }) => ListenOff;
-    emit: Listener<NormalizeTuple<T>>;
-    has(key: ListenKey): boolean;
-    off(keyOrCallback: ListenKey | Listener<NormalizeTuple<T>> | null): void;
-    close(): void;
-    count(): number;
-    keys(): ListenKey[];
-    isRunning(): boolean;
-    run(): void;
-    onClose(cb: CloseCallback): ListenOff;
-};
-export declare function listenStore<T>(options: ListenStoreOptions<T>): readonly [Listener<NormalizeTuple<T>>, {
-    on: ListenOnCurrent<NormalizeTuple<T>>;
-    once: (cb: Listener<NormalizeTuple<T>>, opts?: {
-        key?: ListenKey;
-        current?: ListenCurrent<NormalizeTuple<T>> | undefined;
-    }) => ListenOff;
-    emit: Listener<NormalizeTuple<T>>;
-    has(key: ListenKey): boolean;
-    off(keyOrCallback: ListenKey | Listener<NormalizeTuple<T>> | null): void;
-    close(): void;
-    count(): number;
-    keys(): ListenKey[];
-    isRunning(): boolean;
-    run(): void;
-    onClose(cb: CloseCallback): ListenOff;
-}];
-export declare function toSlimListen<T>(full: ListenApi<T>): {
-    on: (cb: Listener<NormalizeTuple<T>>, opts?: {
-        key?: ListenKey;
-    }) => ListenOff;
-    off: (keyOrCallback: Listener<NormalizeTuple<T>> | null | ListenKey) => void;
-    close: () => void;
-    count: () => number;
-};
-export type SlimListen<T> = ReturnType<typeof toSlimListen<T>>;
-export declare function slimListen<T>(options?: ListenOptions<T>): readonly [Listener<NormalizeTuple<T>>, {
-    on: (cb: Listener<NormalizeTuple<T>>, opts?: {
-        key?: ListenKey;
-    } | undefined) => ListenOff;
-    off: (keyOrCallback: ListenKey | Listener<NormalizeTuple<T>> | null) => void;
-    close: () => void;
-    count: () => number;
-}];
-export declare function isListenCallback(obj: any): obj is ListenApi;
-export {};
+export * from './Listen';

package/lib/Common/events/Listen3.js

@@ -1,245 +1,17 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getListenByOn = getListenByOn;
-exports.isListenOn = isListenOn;
-exports.registerListenOn = registerListenOn;
-exports.createListenCore = createListenCore;
-exports.createListen = createListen;
-exports.createFastListen = createFastListen;
-exports.listen = listen;
-exports.withStoreListen = withStoreListen;
-exports.createStoreListen = createStoreListen;
-exports.listenStore = listenStore;
-exports.toSlimListen = toSlimListen;
-exports.slimListen = slimListen;
-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 registerListenOn(on, api) { listenByOn.set(on, api); }
-function createListenCore(options = {}) {
-    const { fast = true, onRemove, event } = options;
-    const subs = new Map();
-    let dispatcher = (...args) => { subs.forEach(cb => cb(...args)); };
-    let cached = null;
-    const getArr = () => cached ?? (cached = Array.from(subs.values()));
-    function rebuild() {
-        cached = null;
-        const size = subs.size;
-        if (size == 0) {
-            dispatcher = null;
-            return;
-        }
-        if (size == 1) {
-            dispatcher = subs.values().next().value;
-            return;
-        }
-        if (size == 2) {
-            const [a, b] = getArr();
-            dispatcher = ((...args) => { a(...args); b(...args); });
-            return;
-        }
-        dispatcher = ((...args) => {
-            const arr = getArr();
-            for (let i = 0; i < arr.length; i++)
-                arr[i](...args);
-        });
-    }
-    function removeOne(key) {
-        if (!subs.has(key))
-            return;
-        subs.delete(key);
-        onRemove?.(key);
-        if (fast)
-            rebuild();
-        event?.('remove', subs.size, api);
-    }
-    const api = {
-        emit: ((...args) => { dispatcher?.(...args); }),
-        has: (key) => subs.has(key),
-        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); };
-        }),
-        off: (keyOrCallback) => {
-            if (typeof keyOrCallback == 'function') {
-                for (const [key, cb] of [...subs])
-                    if (cb === keyOrCallback)
-                        removeOne(key);
-                return;
-            }
-            if (keyOrCallback != null)
-                removeOne(keyOrCallback);
-        },
-        once: (cb, opts = {}) => {
-            let off = () => { };
-            off = api.on(((...args) => { off(); cb(...args); }), opts);
-            return off;
-        },
-        close: () => {
-            subs.clear();
-            if (fast)
-                rebuild();
-        },
-        count: () => subs.size,
-        keys: () => [...subs.keys()],
-    };
-    listenByOn.set(api.on, api);
-    return api;
-}
-function createListen(producer, options = {}) {
-    const { fast = true, event, closeOn } = options;
-    let teardown = null;
-    let closeSignalOff = null;
-    let closeHooks = null;
-    function forgetKey(key) {
-        closeHooks?.delete(key);
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
     }
-    const core = createListenCore({
-        fast,
-        onRemove: forgetKey,
-        event: event && ((type, count) => {
-            if (type == 'remove')
-                event(type, count, api);
-        }),
-    });
-    const api = {
-        emit: core.emit,
-        has: core.has,
-        isRunning: () => teardown !== null,
-        run: () => {
-            if (teardown)
-                return;
-            teardown = (producer(core.emit) ?? (() => { }));
-            if (closeOn && !closeSignalOff)
-                closeSignalOff = closeOn.on(() => api.close());
-        },
-        close: () => {
-            const stop = teardown;
-            teardown = null;
-            stop?.();
-            core.close();
-            if (closeHooks) {
-                const hooks = closeHooks;
-                closeHooks = null;
-                hooks.forEach(cb => cb());
-            }
-            closeSignalOff?.();
-            closeSignalOff = null;
-        },
-        onClose: (cb) => {
-            closeHooks = closeHooks ?? new Map();
-            closeHooks.set(cb, cb);
-            return function offClose() { 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;
-        }),
-        off: core.off,
-        once: (cb, opts = {}) => {
-            let off = () => { };
-            off = api.on(((...args) => { off(); cb(...args); }), opts);
-            return off;
-        },
-        count: core.count,
-        keys: core.keys,
-    };
-    listenByOn.set(api.on, api);
-    return api;
-}
-function createFastListen(producer) {
-    return createListen(producer, { fast: true });
-}
-function listen(options = { fast: true }) {
-    let emit;
-    const api = createListen((next) => { emit = next; }, { fast: true, ...options });
-    api.run();
-    emit = api.emit;
-    return [emit, api];
-}
-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 value = currentValue(current);
-                if (value)
-                    cb(...value);
-            }
-            return off;
-        }),
-        once: (cb, opts = {}) => {
-            if (opts.current) {
-                const value = currentValue(opts.current);
-                if (value) {
-                    cb(...value);
-                    return () => { };
-                }
-            }
-            let off = () => { };
-            off = base.on(((...args) => { off(); cb(...args); }), { key: opts.key });
-            return off;
-        },
-    };
-    listenByOn.set(api.on, api);
-    return api;
-}
-function createStoreListen(producer, options) {
-    const { current, ...listenOptions } = options;
-    return withStoreListen(createListen(producer, listenOptions), current);
-}
-function listenStore(options) {
-    const { current, ...listenOptions } = options;
-    let emit;
-    const base = createListen((next) => { emit = next; }, { fast: true, ...listenOptions });
-    const api = withStoreListen(base, current);
-    base.run();
-    emit = base.emit;
-    return [emit, api];
-}
-function toSlimListen(full) {
-    return {
-        on: (cb, opts) => full.on(cb, opts),
-        off: (keyOrCallback) => full.off(keyOrCallback),
-        close: () => full.close(),
-        count: () => full.count(),
-    };
-}
-function slimListen(options = { fast: true }) {
-    const [emit, full] = listen(options);
-    return [emit, toSlimListen(full)];
-}
-const LISTEN_CORE = ['emit', 'on', 'off', 'onClose', 'run', 'isRunning', 'close', 'count'];
-function isListenCallback(obj) {
-    if (obj == null || typeof obj != 'object')
-        return false;
-    const keys = new Set(Object.keys(obj));
-    for (const key of LISTEN_CORE)
-        if (!keys.has(key))
-            return false;
-    for (const key of LISTEN_CORE)
-        if (typeof obj[key] != 'function')
-            return false;
-    return true;
-}
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Listen"), exports);

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

@@ -18,13 +18,13 @@ export declare function listenSnapshot<T extends SocketSource<any | any[]>, T2 e
     memo: T4;
     snapshot?: (memo: T4) => T3;
 }): {
-    run: (cb: import("./Listen3").Listener<[data: SocketPayload<T>, memo: T3]>, opts?: {
+    run: (cb: import("./Listen").Listener<[data: SocketPayload<T>, memo: T3]>, opts?: {
         cbClose?: () => void;
-        key?: import("./Listen3").ListenKey;
-    } | undefined) => import("./Listen3").ListenOff;
+        key?: import("./Listen").ListenKey;
+    } | undefined) => import("./Listen").ListenOff;
     snapshot: () => T3 | undefined;
     memo: T4;
-    listenA: import("./Listen3").ListenApi<[data: SocketPayload<T>, memo: T3]>;
+    listenA: import("./Listen").ListenApi<[data: SocketPayload<T>, memo: T3]>;
     connect: () => void;
     readonly disconnect: ((a: Omit<Parameters<T>[0], "callback"> & {
         callback: (...data: NonUndefined<T2>) => any;

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

@@ -4,9 +4,9 @@ export declare function SocketServerHook(opt?: {
     transformer?: transformer;
 }): {
     obj: {
-        [k: string]: readonly [import("./Listen3").Listener<[unknown]>, import("./Listen3").ListenApi<unknown>];
+        [k: string]: readonly [import("./Listen").Listener<[unknown]>, import("./Listen").ListenApi<unknown>];
     };
-    get(tag: string): readonly [import("./Listen3").Listener<[unknown]>, import("./Listen3").ListenApi<unknown>];
+    get(tag: string): readonly [import("./Listen").Listener<[unknown]>, import("./Listen").ListenApi<unknown>];
     provider: (tag: string, data: any) => void;
 };
 export declare function WebSocketServerHook(s: ReturnType<typeof SocketServerHook>, paramsSoc?: Parameters<typeof soc>[1], disconnect?: () => any): {