wenay-common2 1.0.46 → 1.0.49

package/lib/Common/data/ByteStream.js

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

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

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

package/lib/Common/data/List.js

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

package/lib/Common/data/ListNodeAnd.js

@@ -68,8 +68,8 @@ class CListNodeAnd extends CBaseList {
     isForbidden() { return this._stop; }
     isExists() { return this.isForbidden() || this._prev._stop || this._next._stop; }
     static _Add(prev, next, home, a) { let buf = new CListNodeAnd(prev, next, home); buf.data = a; return buf; }
-    AddNext(a) { return a instanceof CListNodeAnd ? a._Init(this, this._next, this) : a ? CListNodeAnd._Add(this, this._next, this._home, a) : new CListNodeAnd(this, this._next); }
-    AddPrev(a) { return a instanceof CListNodeAnd ? a._Init(this._prev, this, this) : a ? CListNodeAnd._Add(this._prev, this, this._home, a) : new CListNodeAnd(this._prev, this); }
+    AddNext(a) { return a instanceof CListNodeAnd ? a._Init(this, this._next, this) : arguments.length ? CListNodeAnd._Add(this, this._next, this._home, a) : new CListNodeAnd(this, this._next); }
+    AddPrev(a) { return a instanceof CListNodeAnd ? a._Init(this._prev, this, this) : arguments.length ? CListNodeAnd._Add(this._prev, this, this._home, a) : new CListNodeAnd(this._prev, this); }
     AddEnd(a) { return this._stop ? this.AddPrev(a) : this._End().AddNext(a); }
     AddStart(a) { return this._stop ? this.AddNext(a) : this._First().AddPrev(a); }
     forEach(el) {

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

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

package/lib/Common/data/objectPath.js

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

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

@@ -1,55 +1 @@
-export type Listener<T extends any[]> = (...r: T) => void;
-export type NormalizeTuple<T> = T extends any[] ? T : [T];
-type key = string;
-export declare function funcListenCallbackBase<T>(b: (e: Listener<NormalizeTuple<T>>) => (void | (() => void)), { fast, event, addListenClose }?: {
-    event?: (type: "add" | "remove", count: number, api: ReturnType<typeof funcListenCallbackBase<T>>) => void;
-    fast?: boolean;
-    addListenClose?: ReturnType<typeof funcListenCallbackBase<any>>;
-}): {
-    func: Listener<NormalizeTuple<T>>;
-    isRun: () => boolean;
-    run: () => void;
-    close: () => void;
-    eventClose: (cb: () => void) => () => void;
-    removeEventClose: (cb: (() => void)) => void;
-    addListen: (cb: Listener<NormalizeTuple<T>>, { cbClose, key }?: {
-        cbClose?: () => void;
-        key?: key;
-    }) => () => void;
-    removeListen: (k: Listener<NormalizeTuple<T>> | null | key) => void;
-    count: () => number;
-    readonly getAllKeys: (Listener<NormalizeTuple<T>> | key)[];
-};
-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: () => void) => () => void;
-    removeEventClose: (cb: () => void) => void;
-    addListen: (cb: Listener<NormalizeTuple<T>>, { cbClose, key }?: {
-        cbClose?: (() => void) | undefined;
-        key?: key;
-    }) => () => void;
-    removeListen: (k: string | Listener<NormalizeTuple<T>> | null) => void;
-    count: () => number;
-    readonly getAllKeys: (string | Listener<NormalizeTuple<T>>)[];
-};
-export declare const funcListenCallback: typeof funcListenCallbackBase;
-export declare function UseListen<T>(data?: Parameters<typeof funcListenCallbackBase<T>>[1]): readonly [(...a: NormalizeTuple<T>) => void, {
-    func: Listener<NormalizeTuple<T>>;
-    isRun: () => boolean;
-    run: () => void;
-    close: () => void;
-    eventClose: (cb: () => void) => () => void;
-    removeEventClose: (cb: () => void) => void;
-    addListen: (cb: Listener<NormalizeTuple<T>>, { cbClose, key }?: {
-        cbClose?: (() => void) | undefined;
-        key?: key;
-    }) => () => void;
-    removeListen: (k: string | Listener<NormalizeTuple<T>> | null) => void;
-    count: () => number;
-    readonly getAllKeys: (string | Listener<NormalizeTuple<T>>)[];
-}];
-export declare function isListenCallback(obj: any): obj is ReturnType<typeof funcListenCallbackBase>;
-export {};
+export * from "./Listen3";

package/lib/Common/events/Listen.js

@@ -1,156 +1,17 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.funcListenCallback = void 0;
-exports.funcListenCallbackBase = funcListenCallbackBase;
-exports.funcListenCallbackFast = funcListenCallbackFast;
-exports.UseListen = UseListen;
-exports.isListenCallback = isListenCallback;
-function funcListenCallbackBase(b, { fast = true, event, addListenClose } = {}) {
-    const obj = new Map();
-    const evClose = new Map();
-    const sinh = new Map();
-    let a = (...e) => { obj.forEach(z => z(...e)); };
-    let close = null;
-    let cached = null;
-    let closeUnsubscribe = null;
-    const getArr = () => cached ?? (cached = Array.from(obj.values()));
-    const rebuild = () => {
-        cached = null;
-        const size = obj.size;
-        if (size === 0) {
-            a = null;
-            return;
-        }
-        if (size === 1) {
-            a = obj.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);
-        });
-    };
-    const func = (...e) => { a?.(...e); };
-    const run = () => {
-        close = (b(func) ?? (() => { }));
-        if (addListenClose && !closeUnsubscribe) {
-            closeUnsubscribe = addListenClose.addListen(() => {
-                api.close();
-            });
-        }
-    };
-    const api = {
-        func,
-        isRun: () => close !== null,
-        run,
-        close: () => {
-            close?.();
-            close = null;
-            obj.clear();
-            if (fast)
-                rebuild();
-            sinh.clear();
-            evClose.forEach(cb => cb());
-            evClose.clear();
-            if (closeUnsubscribe) {
-                closeUnsubscribe();
-                closeUnsubscribe = null;
-            }
-        },
-        eventClose: (cb) => {
-            evClose.set(cb, cb);
-            return () => { evClose.delete(cb); };
-        },
-        removeEventClose: (cb) => {
-            const e = sinh.get(cb);
-            if (e)
-                evClose.delete(e);
-            sinh.delete(cb);
-            evClose.delete(cb);
-        },
-        addListen: (cb, { cbClose, key } = {}) => {
-            const k = key ?? cb;
-            obj.set(k, cb);
-            if (cbClose) {
-                if (evClose.has(k)) {
-                    const r = evClose.get(k);
-                    if (r !== cbClose) {
-                        evClose.delete(r);
-                        evClose.delete(k);
-                        sinh.delete(r);
-                    }
-                }
-                evClose.set(k, cbClose);
-                sinh.set(cbClose, cb);
-            }
-            if (fast)
-                rebuild();
-            event?.("add", obj.size, api);
-            return () => api.removeListen(k);
-        },
-        removeListen: (k) => {
-            obj.delete(k);
-            const e = evClose.get(k);
-            if (fast)
-                rebuild();
-            evClose.delete(k);
-            if (e) {
-                evClose.delete(e);
-                sinh.delete(e);
-            }
-            event?.("remove", obj.size, api);
-        },
-        count: () => obj.size,
-        get getAllKeys() { return [...obj.keys()]; }
-    };
-    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];
-}
-let referenceKeys = null;
-let referenceTypes = null;
-function getReferenceData() {
-    if (!referenceKeys || !referenceTypes) {
-        const demo = funcListenCallbackBase(() => { });
-        referenceKeys = Object.keys(demo).sort();
-        referenceTypes = new Map();
-        for (const key of referenceKeys) {
-            referenceTypes.set(key, typeof demo[key]);
-        }
-    }
-    return { keys: referenceKeys, types: referenceTypes };
-}
-function isListenCallback(obj) {
-    if (obj == null || typeof obj !== "object")
-        return false;
-    const objKeys = Object.keys(obj).sort();
-    const { keys: refKeys, types: refTypes } = getReferenceData();
-    if (objKeys.length !== refKeys.length)
-        return false;
-    for (let i = 0; i < refKeys.length; i++) {
-        if (objKeys[i] !== refKeys[i])
-            return false;
+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]; } };
     }
-    for (const key of refKeys) {
-        const expectedType = refTypes.get(key);
-        const actualType = typeof obj[key];
-        if (actualType !== expectedType)
-            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("./Listen3"), exports);

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

@@ -0,0 +1 @@
+export * from "./Listen3";

package/lib/Common/events/Listen2.js

@@ -0,0 +1,17 @@
+"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);

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