wenay-common2 1.0.61 → 1.0.63

package/lib/Common/events/Listen3.js

@@ -1,255 +1,17 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.funcListenCallback = void 0;
-exports.getListenByOn = getListenByOn;
-exports.isListenOn = isListenOn;
-exports.registerListenOn = registerListenOn;
-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 registerListenOn(on, api) { listenByOn.set(on, api); }
-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); };
-        }),
-        off: (k) => {
-            if (typeof k == 'function') {
-                for (const [kk, cb] of [...subs])
-                    if (cb === k)
-                        removeOne(kk);
-                return;
-            }
-            if (k != null)
-                removeOne(k);
-        },
-        addListen: (cb, opts = {}) => api.on(cb, opts),
-        removeListen: (k) => api.off(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);
+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 = 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;
-        }),
-        off: core.off,
-        addListen: (cb, opts = {}) => api.on(cb, opts),
-        removeListen: (k) => api.off(k),
-        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),
-        removeListen: (k) => api.off(k),
-        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),
-        off: (k) => full.off(k),
-        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;
-}
+    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

@@ -1,53 +1,33 @@
-export type realSocket2<T extends any> = (data: {
+export type SocketSource<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;
+export type SocketPayload<T extends SocketSource<any>> = T extends SocketSource<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 {
+type NonUndefined<T> = T extends undefined ? never : T;
+export declare function socketBuffer<T extends SocketSource<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;
+}, T4 extends T3 | (() => T3)>(func: T, callbackMain: (data: SocketPayload<T>, memo: T3 | T4) => T2, memo?: T3 | T4): (a: Omit<Parameters<T>[0], "callback"> & {
+    callback: (...data: NonUndefined<T2>) => any;
 }, ...b: ParametersOther<T>) => ReturnType<T>;
-export declare function funcListenCallbackSnapshot<T extends realSocket2<any | any[]>, T2 extends (readonly unknown[]) | undefined, T3 extends {
+export declare function listenSnapshot<T extends SocketSource<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;
+    callbackSave: (data: SocketPayload<T>, memo: T3) => T2;
     memo: T4;
     snapshot?: (memo: T4) => T3;
 }): {
-    run: (cb: import("./Listen3").Listener<[data: getTypeCallback<T>, memo: T3]>, opts?: {
+    run: (cb: import("./Listen").Listener<[data: SocketPayload<T>, memo: T3]>, opts?: {
         cbClose?: () => void;
-        key?: string | symbol;
-    } | undefined) => () => void;
+        key?: import("./Listen").ListenKey;
+    } | undefined) => import("./Listen").ListenOff;
     snapshot: () => T3 | undefined;
     memo: T4;
-    listenA: {
-        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;
-        on: import("./Listen3").ListenOn<[data: getTypeCallback<T>, memo: T3]>;
-        off: (k: (string | symbol) | import("./Listen3").Listener<[data: getTypeCallback<T>, memo: T3]> | null) => void;
-        addListen: (cb: import("./Listen3").Listener<[data: getTypeCallback<T>, memo: T3]>, opts?: {
-            cbClose?: () => void;
-            key?: string | symbol;
-        }) => () => void;
-        removeListen: (k: (string | symbol) | import("./Listen3").Listener<[data: getTypeCallback<T>, memo: T3]> | null) => void;
-        once: (cb: import("./Listen3").Listener<[data: getTypeCallback<T>, memo: T3]>, opts?: {
-            key?: string | symbol;
-        }) => () => void;
-        count: () => number;
-        readonly getAllKeys: (string | symbol)[];
-    };
+    listenA: import("./Listen").ListenApi<[data: SocketPayload<T>, memo: T3]>;
     connect: () => void;
     readonly disconnect: ((a: Omit<Parameters<T>[0], "callback"> & {
-        callback: (...data: tr22<T2>) => any;
+        callback: (...data: NonUndefined<T2>) => any;
     }, ...b: ParametersOther<T>) => ReturnType<T>) | null;
 };
 export {};

package/lib/Common/events/SocketBuffer.js

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

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

@@ -4,58 +4,18 @@ export declare function SocketServerHook(opt?: {
     transformer?: transformer;
 }): {
     obj: {
-        [k: string]: readonly [(a_0: unknown) => void, {
-            func: import("./Listen3").Listener<[unknown]>;
-            isRun: () => boolean;
-            run: () => void;
-            close: () => void;
-            eventClose: (cb: () => void) => () => void;
-            onClose: (cb: () => void) => () => void;
-            removeEventClose: (cb: () => void) => void;
-            on: import("./Listen3").ListenOn<[unknown]>;
-            off: (k: (string | symbol) | import("./Listen3").Listener<[unknown]> | null) => void;
-            addListen: (cb: import("./Listen3").Listener<[unknown]>, opts?: {
-                cbClose?: () => void;
-                key?: string | symbol;
-            }) => () => void;
-            removeListen: (k: (string | symbol) | import("./Listen3").Listener<[unknown]> | null) => void;
-            once: (cb: import("./Listen3").Listener<[unknown]>, opts?: {
-                key?: string | symbol;
-            }) => () => void;
-            count: () => number;
-            readonly getAllKeys: (string | symbol)[];
-        }];
+        [k: string]: readonly [import("./Listen").Listener<[unknown]>, import("./Listen").ListenApi<unknown>];
     };
-    get(tag: string): readonly [(a_0: unknown) => void, {
-        func: import("./Listen3").Listener<[unknown]>;
-        isRun: () => boolean;
-        run: () => void;
-        close: () => void;
-        eventClose: (cb: () => void) => () => void;
-        onClose: (cb: () => void) => () => void;
-        removeEventClose: (cb: () => void) => void;
-        on: import("./Listen3").ListenOn<[unknown]>;
-        off: (k: (string | symbol) | import("./Listen3").Listener<[unknown]> | null) => void;
-        addListen: (cb: import("./Listen3").Listener<[unknown]>, opts?: {
-            cbClose?: () => void;
-            key?: string | symbol;
-        }) => () => void;
-        removeListen: (k: (string | symbol) | import("./Listen3").Listener<[unknown]> | null) => void;
-        once: (cb: import("./Listen3").Listener<[unknown]>, opts?: {
-            key?: string | symbol;
-        }) => () => void;
-        count: () => number;
-        readonly getAllKeys: (string | symbol)[];
-    }];
+    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): {
     disconnect(): void;
     get: {
         [k: string]: {
-            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;
+            callback: (z: (...args: any[]) => void) => import("../rcp/listen-socket").SubscriptionHandle;
+            on: (z: (...args: any[]) => void) => import("../rcp/listen-socket").SubscriptionHandle;
+            once: (z: (...args: any[]) => void) => import("../rcp/listen-socket").SubscriptionHandle;
             close: () => void;
             off: () => boolean;
             removeCallback: () => boolean;

package/lib/Common/events/SocketServerHook.js

@@ -10,7 +10,7 @@ function SocketServerHook(opt) {
     const r = {
         obj,
         get(tag) {
-            return obj[tag] ??= (0, Listen_1.UseListen)();
+            return obj[tag] ??= (0, Listen_1.listen)();
         },
         provider: (tag, data) => {
             const t = r.get(tag)[0];

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

@@ -1,20 +1,19 @@
-import { UseListen } from "./Listen";
-export type listen<T extends any[] = any[]> = ReturnType<typeof UseListen<T>>;
+import { listen as createListenPair } from "./Listen";
+export type ListenPair<T extends any[] = any[]> = ReturnType<typeof createListenPair<T>>;
 type KeyExtractor<D> = (data: D) => string | undefined;
 export type ListenMap<T extends Record<string, any>> = {
-    [K in keyof T]: listen<T[K]>[1];
+    [K in keyof T]: ListenPair<T[K]>[1];
 };
 type CollectedResult<T extends Record<string, any>> = {
     [K in keyof T]: T[K];
 };
 type JoinResult<R> = {
-    listen: listen<[R, string]>[1];
+    listen: ListenPair<[R, string]>[1];
     pending: Map<string, Map<string, any>>;
     clear: (tid?: string) => void;
     destroy: () => void;
-    add: (port: listen<any>[1], key?: string) => void;
-    addListen: (listener: listen<any>[1], key?: string) => void;
+    add: (port: ListenPair<any>[1], key?: string) => void;
 };
 export declare function joinListens<T extends Record<string, any[]>>(listens: ListenMap<T>, keyExtractor?: KeyExtractor<any>): JoinResult<CollectedResult<T>>;
-export declare function joinListens<D extends any[] = any[]>(listens: listen<D>[1][], keyExtractor?: KeyExtractor<any>): JoinResult<D[][]>;
+export declare function joinListens<D extends any[] = any[]>(listens: ListenPair<D>[1][], keyExtractor?: KeyExtractor<any>): JoinResult<D[][]>;
 export {};

package/lib/Common/events/joinListens.js

@@ -7,7 +7,7 @@ function joinListens(listens, keyExtractor) {
     const map = isArray
         ? Object.fromEntries(listens.map((l, i) => [String(i), l]))
         : listens;
-    const [set, out] = (0, Listen_1.UseListen)();
+    const [set, out] = (0, Listen_1.listen)();
     const keys = Object.keys(map);
     const buckets = new Map();
     const getKey = (data) => keyExtractor?.(data) ?? "_";
@@ -30,7 +30,7 @@ function joinListens(listens, keyExtractor) {
             buckets.get(tid).set(portId, data.length <= 1 ? data[0] : data);
             tryFire(tid);
         };
-        unsubs.push(listener.addListen(cb));
+        unsubs.push(listener.on(cb));
     };
     for (const portId of keys) {
         bindPort(portId, map[portId]);
@@ -55,7 +55,6 @@ function joinListens(listens, keyExtractor) {
             unsubs.length = 0;
             buckets.clear();
         },
-        add,
-        addListen: (listener, key) => add(listener, key)
+        add
     };
 }

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

@@ -0,0 +1,4 @@
+import { Listener, NormalizeTuple, ListenApi } from "./Listen";
+export declare function mapListen<TSource extends any[], TTarget extends any[]>(sourceListen: ListenApi<TSource>, transform: (...args: NormalizeTuple<TSource>) => TTarget | null, options?: {
+    closeOn?: ListenApi<any>;
+}): readonly [Listener<NormalizeTuple<TTarget>>, ListenApi<TTarget>];

package/lib/Common/events/mapListen.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapListen = mapListen;
+const Listen_1 = require("./Listen");
+function mapListen(sourceListen, transform, options) {
+    let unsubscribeFromSource = null;
+    const [emit, targetListen] = (0, Listen_1.listen)({
+        event: (type, count) => {
+            if (type == "add" && count == 1) {
+                const sourceCallback = (...args) => {
+                    const result = transform(...args);
+                    if (result !== null)
+                        emit(...result);
+                };
+                unsubscribeFromSource = sourceListen.on(sourceCallback);
+            }
+            if (type == "remove" && count == 0 && unsubscribeFromSource) {
+                unsubscribeFromSource();
+                unsubscribeFromSource = null;
+            }
+        },
+        closeOn: options?.closeOn,
+    });
+    return [emit, targetListen];
+}

package/lib/Common/events/replay-conflate.d.ts

@@ -1,4 +1,4 @@
-import { NormalizeTuple } from './Listen3';
+import { NormalizeTuple } from './Listen';
 import { ListenReplayApi, ReplayEvent } from './replay-listen';
 export type ConflateOpts<Z extends any[] = any[]> = {
     pending: () => number;
@@ -10,27 +10,7 @@ export type ConflateOpts<Z extends any[] = any[]> = {
 };
 export declare function conflateReplay<T>(replay: ListenReplayApi<T>, opts: ConflateOpts<NormalizeTuple<T>>): {
     api: {
-        line: {
-            func: import("./Listen3").Listener<[ReplayEvent<NormalizeTuple<T>>]>;
-            isRun: () => boolean;
-            run: () => void;
-            close: () => void;
-            eventClose: (cb: () => void) => () => void;
-            onClose: (cb: () => void) => () => void;
-            removeEventClose: (cb: () => void) => void;
-            on: import("./Listen3").ListenOn<[ReplayEvent<NormalizeTuple<T>>]>;
-            off: (k: (string | symbol) | import("./Listen3").Listener<[ReplayEvent<NormalizeTuple<T>>]> | null) => void;
-            addListen: (cb: import("./Listen3").Listener<[ReplayEvent<NormalizeTuple<T>>]>, opts?: {
-                cbClose?: () => void;
-                key?: string | symbol;
-            }) => () => void;
-            removeListen: (k: (string | symbol) | import("./Listen3").Listener<[ReplayEvent<NormalizeTuple<T>>]> | null) => void;
-            once: (cb: import("./Listen3").Listener<[ReplayEvent<NormalizeTuple<T>>]>, opts?: {
-                key?: string | symbol;
-            }) => () => void;
-            count: () => number;
-            readonly getAllKeys: (string | symbol)[];
-        };
+        line: import("./Listen").ListenApi<[ReplayEvent<NormalizeTuple<T>>]>;
         since: (seq: number) => ReplayEvent<NormalizeTuple<T>>[] | null;
         keyframe: () => ReplayEvent<NormalizeTuple<T>> | null;
         frame: (seq: number, hint?: unknown) => ReplayEvent<NormalizeTuple<T>>[];

package/lib/Common/events/replay-conflate.js

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.conflateReplay = conflateReplay;
-const Listen3_1 = require("./Listen3");
+const Listen_1 = require("./Listen");
 function conflateReplay(replay, opts) {
     const { pending, highWater, lowWater = 0, pollMs = 25, keyOf, maxKeys = 1024 } = opts;
     if (!replay.hasKeyframe)
         throw new TypeError('conflateReplay: нужен current-провайдер (keyframe recovery)');
-    const gate = (0, Listen3_1.funcListenCallbackBase)(() => { });
+    const gate = (0, Listen_1.createListen)(() => { });
     gate.run();
     let conflating = false;
     let closed = false;
@@ -40,13 +40,13 @@ function conflateReplay(replay, opts) {
             held = null;
             flushes++;
             for (const ev of tail)
-                gate.func(ev);
+                gate.emit(ev);
             return;
         }
         const kf = replay.keyframe();
         if (kf) {
             keyframes++;
-            gate.func(kf);
+            gate.emit(kf);
         }
     }
     function absorb(ev) {
@@ -79,7 +79,7 @@ function conflateReplay(replay, opts) {
                 dropped++;
             return;
         }
-        gate.func(ev);
+        gate.emit(ev);
     });
     function close() {
         if (closed)

package/lib/Common/events/replay-history.d.ts

@@ -1,4 +1,4 @@
-import { Listener, NormalizeTuple } from './Listen3';
+import { Listener, NormalizeTuple } from './Listen';
 import { ListenOnReplay, ListenReplayApi, ReplayEvent } from './replay-listen';
 export type ReplayStorage<Z extends any[] = any[]> = {
     putEvent: (ev: ReplayEvent<Z>) => void;