wenay-common2 1.0.46 → 1.0.48

package/lib/Common/Color.d.ts

@@ -24,8 +24,11 @@ export declare function colorGenerator2(data?: {
 }): Generator<[number, number, number]>;
 export declare function colorGeneratorByCount2(value?: number, count?: number, index?: number): [number, number, number];
 export declare function colorGeneratorByCount(value?: number, count?: number, index?: number): ColorString;
+export declare const hue: typeof colorGeneratorByCount;
+export declare const hueRGB: typeof colorGeneratorByCount2;
 export declare function colorStringToRGBA(str: ColorString): [number, number, number, number];
 export declare function colorStringToRGBA(str: string): [number, number, number, number] | undefined;
+export declare const toRGBA: typeof colorStringToRGBA;
 export declare function toColorString(str: string): ColorString;
 export declare function isSimilarColors(color1: ColorString | readonly [number, number, number], color2: ColorString | readonly [number, number, number], maxDelta?: number): boolean;
 export {};

package/lib/Common/Color.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.toRGBA = exports.hueRGB = exports.hue = void 0;
 exports.rgb = rgb;
 exports.colorGenerator = colorGenerator;
 exports.colorGenerator2 = colorGenerator2;
@@ -80,6 +81,8 @@ function colorGeneratorByCount(value = 180, count = 100, index = 1) {
     const [r, g, b] = colorGeneratorByCount2(value, count, index);
     return `rgb(${r},${g},${b})`;
 }
+exports.hue = colorGeneratorByCount;
+exports.hueRGB = colorGeneratorByCount2;
 function colorStringToRGBA(str) {
     const rgbRegex = /^rgb\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)$/i;
     const rgbaRegex = /^rgba\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d*\.?\d+)\s*\)$/i;
@@ -99,6 +102,7 @@ function colorStringToRGBA(str) {
     }
     return undefined;
 }
+exports.toRGBA = colorStringToRGBA;
 function isValidRGBValue(value) {
     return value >= 0 && value <= 255;
 }

package/lib/Common/ObserveAll2/reactive2.d.ts

@@ -0,0 +1,32 @@
+type Fn = () => void;
+type Drain = 'micro' | 'immediate' | number | ((flush: Fn) => void);
+export type Opts = {
+    drain?: Drain;
+    depth?: number;
+    eager?: boolean;
+};
+export declare function reactive<T extends object>(root: T, opts?: Opts): T;
+export declare function onUpdate(p: any, cb: Fn): () => void;
+export declare function flushReactive(p: any): Promise<void>;
+export declare function listenUpdate(p: any): {
+    func: import("../events/Listen").Listener<[]>;
+    isRun: () => boolean;
+    run: () => void;
+    close: () => void;
+    eventClose: (cb: () => void) => () => void;
+    onClose: (cb: () => void) => () => void;
+    removeEventClose: (cb: () => void) => void;
+    addListen: (cb: import("../events/Listen").Listener<[]>, { cbClose, key }?: {
+        cbClose?: (() => void) | undefined;
+        key?: string | symbol;
+    }) => () => void;
+    removeListen: (k: (string | symbol) | import("../events/Listen").Listener<[]> | null) => void;
+    on: import("../events/Listen").ListenOn<[]>;
+    once: (cb: import("../events/Listen").Listener<[]>, opts?: {
+        key?: string | symbol;
+    }) => () => void;
+    count: () => number;
+    readonly getAllKeys: ((string | symbol) | import("../events/Listen").Listener<[]>)[];
+};
+export type Reactive<T extends object> = T;
+export {};

package/lib/Common/ObserveAll2/reactive2.js

@@ -0,0 +1,249 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reactive = reactive;
+exports.onUpdate = onUpdate;
+exports.flushReactive = flushReactive;
+exports.listenUpdate = listenUpdate;
+const Listen_1 = require("../events/Listen");
+const NODE = Symbol('reactive2.node');
+const isObj = (v) => v != null && typeof v == 'object';
+const isReactiveObj = (v) => {
+    if (!isObj(v))
+        return false;
+    if (Array.isArray(v))
+        return true;
+    const p = Object.getPrototypeOf(v);
+    return p == Object.prototype || p == null;
+};
+const hasSetImmediate = typeof setImmediate == 'function';
+function scheduler(drain) {
+    if (drain == 'micro')
+        return f => queueMicrotask(f);
+    if (typeof drain == 'number')
+        return f => { setTimeout(f, drain); };
+    if (typeof drain == 'function')
+        return f => drain(f);
+    return hasSetImmediate ? f => { setImmediate(f); } : f => { setTimeout(f, 0); };
+}
+function reactive(root, opts = {}) {
+    const { drain = 'immediate', depth = Infinity, eager = false } = opts;
+    const fire = scheduler(drain);
+    const eng = {
+        live: 0, dirty: new Set(), scheduled: false, waiters: new Set(), depth,
+        schedule() {
+            if (eng.scheduled)
+                return;
+            eng.scheduled = true;
+            fire(function flush() {
+                eng.scheduled = false;
+                const batch = [...eng.dirty];
+                eng.dirty.clear();
+                let err;
+                for (const n of batch)
+                    for (const cb of [...n.subs]) {
+                        try {
+                            cb();
+                        }
+                        catch (e) {
+                            err ??= e;
+                        }
+                    }
+                if (!eng.scheduled && eng.dirty.size == 0) {
+                    const waiters = [...eng.waiters];
+                    eng.waiters.clear();
+                    for (const w of waiters)
+                        w();
+                }
+                if (err !== undefined)
+                    setTimeout(() => { throw err; }, 0);
+            });
+        },
+    };
+    const rootNode = makeNode(root, null, 0, eng);
+    if (eager)
+        prewalk(rootNode);
+    return rootNode.proxy;
+}
+function makeNode(target, parent, level, eng) {
+    const node = { target, parent, active: true, level, subs: new Set(), kids: new Map(), proxy: null, eng };
+    const proxyTarget = (Array.isArray(target) ? [] : {});
+    node.proxy = new Proxy(proxyTarget, {
+        get(_, k) {
+            if (k == NODE)
+                return node;
+            if (k == 'toJSON' && Array.isArray(proxyTarget) && !Array.isArray(node.target) && node.target?.toJSON === undefined)
+                return () => node.target;
+            const v = node.target[k];
+            if (isReactiveObj(v) && level < eng.depth) {
+                let kid = node.kids.get(k);
+                if (!kid) {
+                    kid = makeNode(v, node, level + 1, eng);
+                    node.kids.set(k, kid);
+                }
+                else if (kid.target !== v)
+                    kid.target = v;
+                return kid.proxy;
+            }
+            return v;
+        },
+        set(_, k, v) {
+            if (Object.is(node.target[k], v))
+                return true;
+            node.target[k] = v;
+            if (Array.isArray(proxyTarget) && k == "length")
+                proxyTarget.length = v;
+            const kid = node.kids.get(k);
+            if (kid)
+                rebind(kid, v);
+            if (eng.live > 0)
+                bubble(node);
+            return true;
+        },
+        defineProperty(_, k, d) {
+            const old = node.target[k];
+            const ok = Reflect.defineProperty(node.target, k, d);
+            if (!ok)
+                return false;
+            if (d.configurable === false) {
+                const mirror = Reflect.defineProperty(proxyTarget, k, d);
+                if (!mirror)
+                    return false;
+            }
+            const v = node.target[k];
+            if (!Object.is(old, v)) {
+                const kid = node.kids.get(k);
+                if (kid) {
+                    if (isReactiveObj(v))
+                        rebind(kid, v);
+                    else {
+                        node.kids.delete(k);
+                        markChanged(kid);
+                        detachTree(kid);
+                    }
+                }
+                if (eng.live > 0)
+                    bubble(node);
+            }
+            return true;
+        },
+        deleteProperty(_, k) {
+            if (!(k in node.target))
+                return true;
+            delete node.target[k];
+            const kid = node.kids.get(k);
+            if (kid) {
+                node.kids.delete(k);
+                markChanged(kid);
+                detachTree(kid);
+            }
+            if (eng.live > 0)
+                bubble(node);
+            return true;
+        },
+        has(_, k) { return k in node.target; },
+        ownKeys() {
+            const keys = Reflect.ownKeys(node.target);
+            for (const k of Reflect.ownKeys(proxyTarget)) {
+                const d = Reflect.getOwnPropertyDescriptor(proxyTarget, k);
+                if (d?.configurable === false && !keys.includes(k))
+                    keys.push(k);
+            }
+            return keys;
+        },
+        getOwnPropertyDescriptor(_, k) {
+            if (Array.isArray(proxyTarget) && k == "length")
+                return Reflect.getOwnPropertyDescriptor(proxyTarget, k);
+            const pd = Reflect.getOwnPropertyDescriptor(proxyTarget, k);
+            if (pd && pd.configurable === false)
+                return pd;
+            const d = Reflect.getOwnPropertyDescriptor(node.target, k);
+            if (d)
+                d.configurable = true;
+            return d;
+        },
+    });
+    return node;
+}
+function bubble(from) {
+    const eng = from.eng;
+    for (let n = from; n && n.active; n = n.parent)
+        if (n.subs.size)
+            eng.dirty.add(n);
+    eng.schedule();
+}
+function rebind(node, next) {
+    node.target = next;
+    if (node.subs.size)
+        node.eng.dirty.add(node);
+    for (const [k, kid] of [...node.kids]) {
+        const cv = isReactiveObj(next) ? next[k] : undefined;
+        if (isReactiveObj(cv))
+            rebind(kid, cv);
+        else {
+            node.kids.delete(k);
+            markChanged(kid);
+            detachTree(kid);
+        }
+    }
+}
+function markChanged(node) {
+    if (node.subs.size)
+        node.eng.dirty.add(node);
+    for (const kid of node.kids.values())
+        markChanged(kid);
+}
+function detachTree(node) {
+    if (!node.active)
+        return;
+    node.active = false;
+    node.parent = null;
+    for (const kid of node.kids.values())
+        detachTree(kid);
+    node.kids.clear();
+}
+function prewalk(node) {
+    if (node.level >= node.eng.depth)
+        return;
+    for (const k of Reflect.ownKeys(node.target)) {
+        if (isReactiveObj(node.target[k])) {
+            node.proxy[k];
+            const kid = node.kids.get(k);
+            if (kid)
+                prewalk(kid);
+        }
+    }
+}
+function onUpdate(p, cb) {
+    const node = p && p[NODE];
+    if (!node)
+        throw new Error('onUpdate: not a reactive object');
+    if (!node.active)
+        throw new Error('onUpdate: reactive object is detached');
+    const sub = () => cb();
+    node.subs.add(sub);
+    node.eng.live++;
+    let done = false;
+    return () => { if (done)
+        return; done = true; if (node.subs.delete(sub))
+        node.eng.live--; };
+}
+function flushReactive(p) {
+    const node = p && p[NODE];
+    if (!node)
+        throw new Error('flushReactive: not a reactive object');
+    const eng = node.eng;
+    if (!eng.scheduled && eng.dirty.size == 0)
+        return Promise.resolve();
+    return new Promise(resolve => { eng.waiters.add(resolve); });
+}
+function listenUpdate(p) {
+    const listen = (0, Listen_1.funcListenCallbackBase)((emit) => onUpdate(p, () => emit()), {
+        event: (type, count, api) => {
+            if (type == "add" && count == 1 && !api.isRun())
+                api.run();
+            if (type == "remove" && count == 0 && api.isRun())
+                api.close();
+        },
+    });
+    return listen;
+}

package/lib/Common/Time.d.ts

@@ -191,12 +191,18 @@ export declare function timeLocalToStr_yyyymmdd_hhmmss(date: const_Date, dateDel
 export declare function timeLocalToStr_yyyymmdd_hhmmss_ms(date: const_Date, dateDelim?: string): string;
 export declare function timeToString_yyyymmdd_hhmm_offset(date: const_Date): string;
 export declare function timeToString_yyyymmdd_hhmmss_offset(date: const_Date): string;
+export type tTimeFormatPattern = 'HH:mm:ss' | 'HH:mm:ss.SSS' | 'yyyy-MM-dd' | 'yyyy-MM-dd HH:mm' | 'yyyy-MM-dd HH:mm:ss' | 'yyyy-MM-dd HH:mm:ss.SSS' | 'yyyy-MM-dd HH:mm O' | 'yyyy-MM-dd HH:mm:ss O';
+export declare function format(date: const_Date, pattern: tTimeFormatPattern, opts?: {
+    utc?: boolean;
+}): string;
 export declare function convertDatesToStrings(arg: any): any;
 export declare function toPrintObject(arg: any): any;
 export declare function durationToStr(duration_ms: number): string;
 export declare function durationToStrNullable(duration_ms: number | null | undefined): string | null;
 export declare function durationToStr_h_mm_ss(duration_ms: number): string;
 export declare function durationToStr_h_mm_ss_ms(duration_ms: number): string;
+export type tDurationFormatPattern = 'H:mm:ss' | 'H:mm:ss.SSS';
+export declare function formatDuration(duration_ms: number, pattern?: tDurationFormatPattern): string;
 export declare class CDelayer {
     protected remainPause: number;
     sleepAsync(pause_ms_getter: () => number | null): Promise<void>;
@@ -204,3 +210,5 @@ export declare class CDelayer {
 type NullableTime = const_Date | undefined | null;
 export declare function MinTime<T1 extends NullableTime, T2 extends NullableTime>(time1: T1, time2: T2): T1 | NonNullable<T2>;
 export declare function MaxTime<T1 extends NullableTime, T2 extends NullableTime>(time1: T1, time2: T2): T1 | NonNullable<T2>;
+export declare const minDate: typeof MinTime;
+export declare const maxDate: typeof MaxTime;

package/lib/Common/Time.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CDelayer = exports.Period = exports.PeriodSpan = exports.TF = exports.TIME_UNIT = exports.M1_MS = exports.H1_MS = exports.D1_MS = exports.W1_MS = exports.W1_S = exports.D1_S = exports.H1_S = void 0;
+exports.maxDate = exports.minDate = exports.CDelayer = exports.Period = exports.PeriodSpan = exports.TF = exports.TIME_UNIT = exports.M1_MS = exports.H1_MS = exports.D1_MS = exports.W1_MS = exports.W1_S = exports.D1_S = exports.H1_S = void 0;
 exports.timeToStr_hhmmss_ms = timeToStr_hhmmss_ms;
 exports.timeToStr_hhmmss = timeToStr_hhmmss;
 exports.timeToStr_yyyymmdd_hhmm = timeToStr_yyyymmdd_hhmm;
@@ -14,12 +14,14 @@ exports.timeLocalToStr_yyyymmdd_hhmmss = timeLocalToStr_yyyymmdd_hhmmss;
 exports.timeLocalToStr_yyyymmdd_hhmmss_ms = timeLocalToStr_yyyymmdd_hhmmss_ms;
 exports.timeToString_yyyymmdd_hhmm_offset = timeToString_yyyymmdd_hhmm_offset;
 exports.timeToString_yyyymmdd_hhmmss_offset = timeToString_yyyymmdd_hhmmss_offset;
+exports.format = format;
 exports.convertDatesToStrings = convertDatesToStrings;
 exports.toPrintObject = toPrintObject;
 exports.durationToStr = durationToStr;
 exports.durationToStrNullable = durationToStrNullable;
 exports.durationToStr_h_mm_ss = durationToStr_h_mm_ss;
 exports.durationToStr_h_mm_ss_ms = durationToStr_h_mm_ss_ms;
+exports.formatDuration = formatDuration;
 exports.MinTime = MinTime;
 exports.MaxTime = MaxTime;
 const common_1 = require("./core/common");
@@ -293,6 +295,19 @@ function timeLocalToStr_yyyymmdd_hhmmss(date, dateDelim = "-") { return timeLoca
 function timeLocalToStr_yyyymmdd_hhmmss_ms(date, dateDelim = "-") { return timeLocalToStr_yyyymmdd_hhmmss(date, dateDelim) + "." + str3(date.getMilliseconds()); }
 function timeToString_yyyymmdd_hhmm_offset(date) { let offset = date.getTimezoneOffset(); return timeLocalToStr_yyyymmdd_hhmm(date) + " GMT" + (offset < 0 ? '+' : '') + (-offset / 60); }
 function timeToString_yyyymmdd_hhmmss_offset(date) { let offset = date.getTimezoneOffset(); return timeLocalToStr_yyyymmdd_hhmmss(date) + " GMT" + (offset < 0 ? '+' : '') + (-offset / 60); }
+function format(date, pattern, opts) {
+    let utc = opts?.utc ?? true;
+    switch (pattern) {
+        case 'HH:mm:ss': return utc ? timeToStr_hhmmss(date) : timeLocalToStr_hhmmss(date);
+        case 'HH:mm:ss.SSS': return utc ? timeToStr_hhmmss_ms(date) : (timeLocalToStr_hhmmss(date) + '.' + str3(date.getMilliseconds()));
+        case 'yyyy-MM-dd': return utc ? timeToStr_yyyymmdd_hhmm(date).slice(0, 10) : timeLocalToStr_yyyymmdd(date);
+        case 'yyyy-MM-dd HH:mm': return utc ? timeToStr_yyyymmdd_hhmm(date) : timeLocalToStr_yyyymmdd_hhmm(date);
+        case 'yyyy-MM-dd HH:mm:ss': return utc ? timeToStr_yyyymmdd_hhmmss(date) : timeLocalToStr_yyyymmdd_hhmmss(date);
+        case 'yyyy-MM-dd HH:mm:ss.SSS': return utc ? timeToStr_yyyymmdd_hhmmss_ms(date) : timeLocalToStr_yyyymmdd_hhmmss_ms(date);
+        case 'yyyy-MM-dd HH:mm O': return timeToString_yyyymmdd_hhmm_offset(date);
+        case 'yyyy-MM-dd HH:mm:ss O': return timeToString_yyyymmdd_hhmmss_offset(date);
+    }
+}
 Date.prototype.toString = function () { return timeToString_yyyymmdd_hhmmss_offset(this); };
 Date.prototype.toDateString = function () { return timeLocalToStr_yyyymmdd(this); };
 Date.prototype.toTimeString = function () { let offset = this.getTimezoneOffset(); return timeLocalToStr_hhmmss(this) + " GMT" + (offset < 0 ? '+' : '') + (-offset / 60); };
@@ -331,25 +346,32 @@ function replaceConsoleCommands() {
 }
 function durationToStr(duration_ms) {
     let units = [[exports.D1_MS, "д"], [exports.H1_MS, "ч"], [exports.M1_MS, "м"], [1000, "c"], [1, "мс"]];
-    let lastUnit = null;
+    let firstUnit = null;
+    let firstCount = 0;
     let str = "";
     for (let unit of units) {
         let unitCountFloat = duration_ms / unit[0];
-        if (unitCountFloat < 1.1 && lastUnit == null)
+        if (unitCountFloat < 1.1 && firstUnit == null)
+            continue;
+        if (firstUnit == null && unitCountFloat <= 10) {
+            firstUnit = unit;
+            firstCount = Math.floor(unitCountFloat);
+            duration_ms %= unit[0];
             continue;
-        let unitCount;
-        if (lastUnit || unitCountFloat > 10) {
-            unitCount = Math.round(unitCountFloat);
-            lastUnit = unit;
         }
-        else
-            unitCount = Math.floor(unitCountFloat);
-        str += unitCount + unit[1] + " ";
-        if (lastUnit)
-            break;
-        duration_ms %= unit[0];
-        lastUnit = unit;
+        let unitCount = Math.round(unitCountFloat);
+        if (firstUnit && unitCount * unit[0] >= firstUnit[0]) {
+            firstCount++;
+            unitCount = 0;
+        }
+        if (firstUnit)
+            str += firstCount + firstUnit[1] + " ";
+        if (unitCount > 0 || firstUnit == null)
+            str += unitCount + unit[1] + " ";
+        return str;
     }
+    if (firstUnit)
+        str += firstCount + firstUnit[1] + " ";
     return str;
 }
 function durationToStrNullable(duration_ms) { return duration_ms == null ? null : durationToStr(duration_ms); }
@@ -358,6 +380,9 @@ function durationToStr_h_mm_ss(duration_ms) {
     return Math.trunc(duration_ms / exports.H1_MS) + ":" + str2(time.getUTCMinutes()) + ":" + str2(time.getUTCSeconds());
 }
 function durationToStr_h_mm_ss_ms(duration_ms) { return durationToStr_h_mm_ss(duration_ms) + "." + str3(Math.trunc(duration_ms % 1000)); }
+function formatDuration(duration_ms, pattern = 'H:mm:ss') {
+    return pattern == 'H:mm:ss.SSS' ? durationToStr_h_mm_ss_ms(duration_ms) : durationToStr_h_mm_ss(duration_ms);
+}
 async function sleepAsync(msec) {
     return new Promise((resolve, reject) => { setTimeout(resolve, msec); });
 }
@@ -391,3 +416,5 @@ function MinTime(time1, time2) {
 function MaxTime(time1, time2) {
     return time1 && time2 && time1.valueOf() >= time2.valueOf() ? time1 : time2 ?? time1;
 }
+exports.minDate = MinTime;
+exports.maxDate = MaxTime;

package/lib/Common/async/PromiseArrayListen.d.ts

@@ -2,10 +2,10 @@ export declare function PromiseArrayListen<T extends any = unknown>(array: ((()
     listenOk: (a: (...d: [data: T, i: number, countOk: number, countError: number, count: number]) => any) => () => void;
     listenError: (a: (...d: [error: any, i: number, countOk: number, countError: number, count: number]) => any) => () => void;
     promise: {
-        all: () => Promise<(void | (() => Promise<void>))[]>;
-        allSettled: () => Promise<PromiseSettledResult<void | (() => Promise<void>)>[]>;
+        all: () => Promise<any[]>;
+        allSettled: () => Promise<PromiseSettledResult<any>[]>;
     };
-    getData(): (Promise<void> | (() => Promise<void>))[];
+    getData(): Promise<any>[];
     status(): {
         ok: number;
         error: number;

package/lib/Common/async/PromiseArrayListen.js

@@ -15,23 +15,20 @@ function PromiseArrayListen(array) {
         ++errorCount;
         c[0](error, i, ok, errorCount, count);
     };
-    const arr = array.map((e, i) => e instanceof Promise ? e.then(r => a(r, i)).catch((er) => b(er, i))
-        : () => (async () => e())().then(r => a(r, i)).catch((er) => b(er, i)));
+    const wrap = (promise, i) => promise.then(r => { a(r, i); return r; }).catch((er) => { b(er, i); throw er; });
+    const arr = array.map((e, i) => e instanceof Promise ? wrap(e, i)
+        : () => wrap((async () => e())(), i));
+    const started = [];
+    const startAll = () => arr.map((x, i) => started[i] ??= (typeof x === 'function' ? x() : x));
     return {
-        listenOk: (a) => {
-            t[1].addListen(a);
-            return () => t[1].removeListen(a);
-        },
-        listenError: (a) => {
-            c[1].addListen(a);
-            return () => c[1].removeListen(a);
-        },
+        listenOk: (a) => t[1].addListen(a),
+        listenError: (a) => c[1].addListen(a),
         promise: {
-            all: () => Promise.all(arr),
-            allSettled: () => Promise.allSettled(arr),
+            all: () => Promise.all(startAll()),
+            allSettled: () => Promise.allSettled(startAll()),
         },
         getData() {
-            return arr;
+            return startAll();
         },
         status() {
             return { ok, error: errorCount, count };

package/lib/Common/async/createIterableObject.js

@@ -18,7 +18,7 @@ function createIterableObject(options) {
         },
         deleteProperty(_, key) {
             if (!onChange || typeof key !== "string")
-                return false;
+                return true;
             onChange("delete", key);
             return true;
         },

package/lib/Common/async/waitRun.d.ts

@@ -1,10 +1,15 @@
-export declare function enhancedWaitRun(): {
+export declare function createThrottle(): {
+    throttle: (ms: number, func: () => any) => void;
+    debounce: (ms: number, func: () => any) => Promise<void>;
     throttleAsync: (ms: number, func: () => any) => void;
     debounceAsync: (ms: number, func: () => any) => Promise<void>;
 };
+export declare const enhancedWaitRun: typeof createThrottle;
 export declare function createAsyncQueue(concurrency?: number): {
-    enqueue: <T>(task: () => Promise<T>) => Promise<T>;
+    add: <T>(task: () => Promise<T>) => Promise<T>;
     onIdle: () => Promise<void>;
+    readonly size: number;
+    enqueue: <T>(task: () => Promise<T>) => Promise<T>;
     getQueueSize: () => number;
 };
 export declare function enhancedQueueRun(maxParallelTasks?: number): {
@@ -23,9 +28,11 @@ export declare function queueRun(n?: number): {
     nextRun: () => Promise<any>;
     run: () => Promise<void>;
 };
-export declare function createTaskQueue(): {
+export declare function createReadyGate(): {
     add: (fn: () => any) => number | undefined;
-    setReady: () => Promise<void>;
+    ready: () => Promise<void>;
     isReady: () => boolean;
     tasks: () => (() => any)[];
+    setReady: () => Promise<void>;
 };
+export declare const createTaskQueue: typeof createReadyGate;