wenay-common2 1.0.46 → 1.0.49

package/lib/Common/ObserveAll2/store.js

@@ -0,0 +1,381 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStore = createStore;
+exports.exposeStore = exposeStore;
+exports.createStoreMirror = createStoreMirror;
+const reactive2_1 = require("./reactive2");
+const hasSetImmediate = typeof setImmediate == "function";
+function pathKey(path) {
+    return path.map(String).join(".");
+}
+function schedule(drain, flush) {
+    if (drain == null) {
+        flush();
+        return;
+    }
+    if (drain == "micro") {
+        queueMicrotask(flush);
+        return;
+    }
+    if (drain == "immediate") {
+        (hasSetImmediate ? setImmediate : setTimeout)(flush, 0);
+        return;
+    }
+    if (typeof drain == "number") {
+        setTimeout(flush, drain);
+        return;
+    }
+    drain(flush);
+}
+function createDrained(fn, drain) {
+    let scheduled = false;
+    let latest = null;
+    let closed = false;
+    return {
+        push(...a) {
+            if (closed)
+                return;
+            if (drain == null) {
+                fn(...a);
+                return;
+            }
+            latest = a;
+            if (scheduled)
+                return;
+            scheduled = true;
+            schedule(drain, () => {
+                scheduled = false;
+                const x = latest;
+                latest = null;
+                if (!closed && x)
+                    fn(...x);
+            });
+        },
+        close() { closed = true; latest = null; },
+    };
+}
+function isObj(v) {
+    return v != null && typeof v == "object";
+}
+function getAt(root, path) {
+    let cur = root;
+    for (const k of path) {
+        if (!isObj(cur))
+            return undefined;
+        cur = cur[k];
+    }
+    return cur;
+}
+function hasAt(root, path) {
+    let cur = root;
+    for (const k of path) {
+        if (!isObj(cur) || !(k in cur))
+            return false;
+        cur = cur[k];
+    }
+    return true;
+}
+function ensureParent(root, path) {
+    let cur = root;
+    for (let i = 0; i < path.length - 1; i++) {
+        const k = path[i];
+        if (!isObj(cur[k]))
+            cur[k] = {};
+        cur = cur[k];
+    }
+    return cur;
+}
+function replaceRoot(root, value) {
+    for (const k of Reflect.ownKeys(root))
+        if (!isObj(value) || !(k in value))
+            delete root[k];
+    if (isObj(value))
+        for (const k of Reflect.ownKeys(value))
+            root[k] = value[k];
+}
+function setAt(root, path, value) {
+    if (path.length == 0) {
+        replaceRoot(root, value);
+        return;
+    }
+    const p = ensureParent(root, path);
+    p[path[path.length - 1]] = value;
+}
+function snapshotValue(value, seen = new WeakMap()) {
+    if (!isObj(value))
+        return value;
+    if (value instanceof Date)
+        return new Date(value.valueOf());
+    if (value instanceof RegExp)
+        return new RegExp(value.source, value.flags);
+    if (value instanceof Map) {
+        const out = new Map();
+        seen.set(value, out);
+        value.forEach((v, k) => out.set(snapshotValue(k, seen), snapshotValue(v, seen)));
+        return out;
+    }
+    if (value instanceof Set) {
+        const out = new Set();
+        seen.set(value, out);
+        value.forEach(v => out.add(snapshotValue(v, seen)));
+        return out;
+    }
+    const old = seen.get(value);
+    if (old)
+        return old;
+    const out = Array.isArray(value) ? [] : {};
+    seen.set(value, out);
+    for (const k of Reflect.ownKeys(value))
+        out[k] = snapshotValue(value[k], seen);
+    return out;
+}
+function maskPaths(mask, base = []) {
+    if (mask === true || mask == null)
+        return [base];
+    if (!isObj(mask))
+        return [base];
+    const out = [];
+    for (const k of Object.keys(mask))
+        out.push(...maskPaths(mask[k], [...base, k]));
+    return out;
+}
+function pickSnapshot(root, mask, base = []) {
+    if (mask === true || mask == null)
+        return snapshotValue(getAt(root, base));
+    const out = {};
+    for (const k of Object.keys(mask))
+        out[k] = pickSnapshot(root, mask[k], [...base, k]);
+    return out;
+}
+function applyMask(root, mask, data, base = []) {
+    if (mask === true || mask == null) {
+        setAt(root, base, snapshotValue(data));
+        return;
+    }
+    for (const k of Object.keys(mask))
+        applyMask(root, mask[k], data?.[k], [...base, k]);
+}
+function watchTarget(root, path) {
+    let cur = root;
+    let lastReactive = root;
+    for (const k of path) {
+        if (!isObj(cur) || !(k in cur))
+            return lastReactive;
+        const next = cur[k];
+        if ((0, reactive2_1.isReactive)(next)) {
+            cur = next;
+            lastReactive = next;
+        }
+        else
+            return lastReactive;
+    }
+    return lastReactive;
+}
+function sameLeaf(a, b, ae, be) {
+    if (ae !== be)
+        return false;
+    if (!ae && !be)
+        return true;
+    return Object.is(a, b);
+}
+function makeCtx(store, path) {
+    return {
+        store,
+        node: getNode(store, path),
+        path: [...path],
+        pathString: pathKey(path),
+        exists: hasAt(store._state, path),
+    };
+}
+function incCount(store, path) {
+    const k = pathKey(path);
+    store._counts.set(k, (store._counts.get(k) ?? 0) + 1);
+}
+function decCount(store, path) {
+    const k = pathKey(path);
+    const n = (store._counts.get(k) ?? 0) - 1;
+    if (n > 0)
+        store._counts.set(k, n);
+    else
+        store._counts.delete(k);
+}
+function subscribePath(store, path, cb, opts = {}, once = false) {
+    let done = false;
+    let offUpdate = null;
+    let lastExists = hasAt(store._state, path);
+    let lastValue = getAt(store._state, path);
+    const drained = createDrained((value, ctx) => {
+        if (done)
+            return;
+        cb(value, ctx);
+        if (once)
+            off();
+    }, opts.drain);
+    function emitNow() {
+        drained.push(getAt(store._state, path), makeCtx(store, path));
+    }
+    function attach() {
+        offUpdate?.();
+        const target = watchTarget(store._state, path);
+        offUpdate = (0, reactive2_1.onUpdate)(target, () => {
+            const exists = hasAt(store._state, path);
+            const value = getAt(store._state, path);
+            const valueIsObject = (0, reactive2_1.isReactive)(value);
+            const watchedSelf = target === value;
+            if (!valueIsObject && !watchedSelf && sameLeaf(lastValue, value, lastExists, exists))
+                return;
+            lastExists = exists;
+            lastValue = value;
+            const nextTarget = watchTarget(store._state, path);
+            if (nextTarget !== target && !done)
+                attach();
+            emitNow();
+        });
+    }
+    function off() {
+        if (done)
+            return;
+        done = true;
+        drained.close();
+        offUpdate?.();
+        offUpdate = null;
+        decCount(store, path);
+    }
+    incCount(store, path);
+    if (opts.current && lastExists) {
+        cb(lastValue, makeCtx(store, path));
+        if (once) {
+            off();
+            return off;
+        }
+    }
+    attach();
+    return off;
+}
+function getNode(store, path) {
+    const k = pathKey(path);
+    const cached = store._nodeCache.get(k);
+    if (cached)
+        return cached;
+    const api = {
+        get path() { return [...path]; },
+        get pathString() { return pathKey(path); },
+        get: () => getAt(store._state, path),
+        has: () => hasAt(store._state, path),
+        snapshot: () => snapshotValue(getAt(store._state, path)),
+        set: (value) => setAt(store._state, path, value),
+        replace: (value) => setAt(store._state, path, value),
+        on: (cb, opts) => subscribePath(store, path, cb, opts, false),
+        once: (cb, opts) => subscribePath(store, path, cb, opts, true),
+        update: (mask, opts) => createSelection(store, path, mask, opts),
+        at: (key) => getNode(store, [...path, key]),
+        count: () => store._counts.get(pathKey(path)) ?? 0,
+    };
+    const proxy = new Proxy(api, {
+        get(target, p) {
+            if (p === "then")
+                return undefined;
+            if (p in target)
+                return target[p];
+            if (typeof p == "symbol")
+                return undefined;
+            return getNode(store, [...path, p]);
+        },
+        ownKeys() {
+            const v = getAt(store._state, path);
+            return isObj(v) ? Reflect.ownKeys(v) : [];
+        },
+        getOwnPropertyDescriptor() { return { enumerable: true, configurable: true }; },
+    });
+    store._nodeCache.set(k, proxy);
+    return proxy;
+}
+function createSelection(store, base, mask, defaults = {}) {
+    const fullPaths = maskPaths(mask, base);
+    const rootNode = getNode(store, base);
+    const ctx = () => ({ store, node: rootNode, mask, paths: fullPaths.map(p => [...p]) });
+    const get = () => pickSnapshot(store._state, mask, base);
+    return {
+        mask,
+        paths: fullPaths.map(p => [...p]),
+        get,
+        on(cb, opts = {}) {
+            const o = { ...defaults, ...opts, current: false };
+            const drained = createDrained(() => cb(get(), ctx()), opts.drain ?? defaults.drain ?? "micro");
+            const offs = fullPaths.map(p => subscribePath(store, p, () => drained.push(), o, false));
+            if ((opts.current ?? defaults.current))
+                cb(get(), ctx());
+            return () => { drained.close(); for (const off of offs)
+                off(); };
+        },
+        once(cb, opts = {}) {
+            let off = () => { };
+            off = this.on((v, c) => { off(); cb(v, c); }, { ...opts, current: opts.current ?? defaults.current });
+            return off;
+        },
+        onEach(cb, opts = {}) {
+            const o = { ...defaults, ...opts };
+            const offs = fullPaths.map(p => subscribePath(store, p, cb, o, false));
+            return () => { for (const off of offs)
+                off(); };
+        },
+    };
+}
+function createStore(initial, opts = {}) {
+    const state = (0, reactive2_1.reactive)(initial, opts);
+    let store;
+    store = {
+        _state: state,
+        _nodeCache: new Map(),
+        _counts: new Map(),
+        state,
+        get node() { return getNode(store, []); },
+        get: () => state,
+        snapshot: () => snapshotValue(state),
+        replace: (value) => replaceRoot(state, value),
+        on: (cb, opts) => getNode(store, []).on(cb, opts),
+        once: (cb, opts) => getNode(store, []).once(cb, opts),
+        update: (mask, opts) => createSelection(store, [], mask, opts),
+        listen: () => (0, reactive2_1.listenUpdate)(state),
+        count: () => Array.from(store._counts.values()).reduce((a, b) => a + b, 0),
+    };
+    return store;
+}
+function exposeStore(store) {
+    return {
+        get: (mask) => mask ? store.update(mask).get() : store.snapshot(),
+        set: (path, value) => {
+            let node = store.node;
+            for (const k of path)
+                node = node.at(k);
+            node.replace(value);
+        },
+        replace: (path, value) => {
+            let node = store.node;
+            for (const k of path)
+                node = node.at(k);
+            node.replace(value);
+        },
+        changed: store.listen(),
+    };
+}
+function createStoreMirror(remote, initial = {}, opts = {}) {
+    const store = createStore(initial, opts);
+    async function sync(mask, subOpts = { current: true }) {
+        async function pull() {
+            const snap = await remote.get(mask);
+            applyMask(store.state, mask, snap);
+        }
+        if (subOpts.current !== false)
+            await pull();
+        const drained = createDrained(() => { void pull(); }, subOpts.drain);
+        const changed = remote.changed;
+        const off = typeof changed?.on == "function"
+            ? changed.on(() => drained.push())
+            : typeof changed?.addListen == "function"
+                ? changed.addListen(() => drained.push())
+                : (() => { });
+        return () => { drained.close(); off?.(); };
+    }
+    return Object.assign(store, { sync });
+}

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;