wenay-common2 1.0.61 → 1.0.63

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

@@ -1 +1,129 @@
-export * from "./Listen3";
+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 {};

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,210 +1 @@
-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 registerListenOn(on: Function, api: any): void;
-export type ListenOnBrand<Z extends any[] = any[]> = {
-    readonly [LISTEN_ON_BRAND]: Z;
-};
-export declare function funcListenCore<T>(options?: ListenCoreOptions<T>): {
-    func: Listener<NormalizeTuple<T>>;
-    has: (k: key) => boolean;
-    on: ListenOn<NormalizeTuple<T>>;
-    off: (k: Listener<NormalizeTuple<T>> | null | key) => void;
-    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>>;
-    off: (k: key | Listener<NormalizeTuple<T>> | null) => void;
-    addListen: (cb: Listener<NormalizeTuple<T>>, opts?: {
-        cbClose?: cbClose;
-        key?: key;
-    }) => () => void;
-    removeListen: (k: Listener<NormalizeTuple<T>> | null | key) => 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>>;
-    off: (k: key | Listener<NormalizeTuple<T>> | null) => void;
-    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>>;
-    off: (k: key | Listener<NormalizeTuple<T>> | null) => void;
-    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;
-    removeListen: (k: Listener<NormalizeTuple<T>> | null | key) => 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;
-    off: (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;
-    removeListen: (k: key | Listener<NormalizeTuple<T>> | null) => 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;
-    off: (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;
-    removeListen: (k: key | Listener<NormalizeTuple<T>> | null) => 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;
-    off: (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;
-    off: (k: Listener<NormalizeTuple<T>> | null | 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;
-    off: (k: key | Listener<NormalizeTuple<T>> | null) => void;
-    close: () => void;
-    count: () => number;
-}];
-export declare function isListenCallback(obj: any): obj is ListenApi;
-export {};
+export * from './Listen';