wenay-common2 1.0.61 → 1.0.63

package/lib/Common/Observe/store-offline.js

@@ -0,0 +1,278 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMemoryOfflineStorage = createMemoryOfflineStorage;
+exports.persistStore = persistStore;
+exports.createOfflineStore = createOfflineStore;
+const common_1 = require("../core/common");
+const Listen_1 = require("../events/Listen");
+const store_1 = require("./store");
+const store_replay_1 = require("./store-replay");
+function isRecord(v) {
+    return !!v && typeof v == 'object' && typeof v.version == 'number'
+        && typeof v.seq == 'number' && 'snapshot' in v;
+}
+function cloneValue(value) {
+    return (0, common_1.clone)(value);
+}
+function createMemoryOfflineStorage(initial) {
+    const data = new Map();
+    for (const [k, v] of Object.entries(initial ?? {}))
+        data.set(k, cloneValue(v));
+    const api = {
+        async read(key) {
+            return data.has(key) ? cloneValue(data.get(key)) : undefined;
+        },
+        async write(key, value) {
+            data.set(key, cloneValue(value));
+        },
+        async remove(key) {
+            data.delete(key);
+        },
+        async transaction(fn) {
+            return fn(api);
+        },
+        dump() {
+            const out = {};
+            for (const [k, v] of data)
+                out[k] = cloneValue(v);
+            return out;
+        },
+    };
+    return api;
+}
+function emitError(opts, error) {
+    if (opts.onError)
+        opts.onError(error);
+    else
+        setTimeout(function rethrowOfflineStoreError() { throw error; }, 0);
+}
+function copyStatus(status) {
+    return { ...status };
+}
+function persistStore(store, opts) {
+    const { key, storage, version = 1, debounceMs = 250, now = Date.now, onStatus } = opts;
+    let seq = opts.seq ?? -1;
+    let savedAt = opts.savedAt;
+    let closed = false;
+    let dirty = false;
+    let timer = null;
+    let chain = Promise.resolve();
+    const status = {
+        ready: true,
+        syncing: false,
+        offline: false,
+        stale: false,
+        saving: false,
+        seq,
+        savedAt,
+    };
+    const [emitStatus, statusListen] = (0, Listen_1.listenStore)({
+        current: () => [copyStatus(status)],
+    });
+    function updateStatus(patch = {}) {
+        Object.assign(status, patch, { seq, savedAt });
+        const snap = copyStatus(status);
+        emitStatus(snap);
+        onStatus?.(snap);
+    }
+    function clearTimer() {
+        if (timer)
+            clearTimeout(timer);
+        timer = null;
+    }
+    function scheduleSave() {
+        if (closed)
+            return;
+        dirty = true;
+        clearTimer();
+        timer = setTimeout(function flushOfflineStoreTimer() {
+            timer = null;
+            flush().catch(e => emitError(opts, e));
+        }, Math.max(0, debounceMs));
+        timer.unref?.();
+    }
+    async function writeRecord(record) {
+        if (storage.transaction) {
+            await storage.transaction(async function writeOfflineStoreTx(tx) {
+                await tx.write(key, record);
+            });
+        }
+        else {
+            await storage.write(key, record);
+        }
+    }
+    async function runFlush(force = false) {
+        if (closed)
+            return;
+        if (!dirty && !force)
+            return;
+        dirty = false;
+        updateStatus({ saving: true, error: undefined });
+        const nextSavedAt = now();
+        const record = {
+            version,
+            seq,
+            snapshot: store.snapshot(),
+            savedAt: nextSavedAt,
+        };
+        try {
+            await writeRecord(record);
+            savedAt = nextSavedAt;
+            updateStatus({ saving: false, error: undefined });
+        }
+        catch (e) {
+            updateStatus({ saving: false, error: e });
+            throw e;
+        }
+        finally {
+            if (dirty && !closed)
+                scheduleSave();
+        }
+    }
+    function flush() {
+        clearTimer();
+        const task = chain.catch(() => { }).then(function flushOfflineStore() { return runFlush(false); });
+        chain = task.catch(() => { });
+        return task;
+    }
+    function forceFlush() {
+        clearTimer();
+        dirty = true;
+        const task = chain.catch(() => { }).then(function forceFlushOfflineStore() { return runFlush(true); });
+        chain = task.catch(() => { });
+        return task;
+    }
+    function setSeq(nextSeq) {
+        if (nextSeq == seq)
+            return;
+        seq = nextSeq;
+        updateStatus();
+        scheduleSave();
+    }
+    const offStore = store.listenPaths().on(function persistStoreChange() {
+        scheduleSave();
+    });
+    function close() {
+        if (closed)
+            return;
+        closed = true;
+        clearTimer();
+        offStore();
+        statusListen.close();
+    }
+    function setSyncStatus(patch) {
+        updateStatus(patch);
+    }
+    return {
+        flush,
+        forceFlush,
+        close,
+        setSeq,
+        seq: () => seq,
+        status: () => copyStatus(status),
+        statusListen,
+        setSyncStatus,
+    };
+}
+async function loadSnapshot(opts) {
+    const { key, storage, initial, version = 1, migrate } = opts;
+    const raw = await storage.read(key);
+    if (raw == null)
+        return { snapshot: initial, seq: -1 };
+    if (isRecord(raw)) {
+        if (raw.version == version)
+            return { snapshot: raw.snapshot, seq: raw.seq, savedAt: raw.savedAt };
+        if (migrate)
+            return {
+                snapshot: await migrate(raw.snapshot, raw.version, version),
+                seq: raw.seq,
+                savedAt: raw.savedAt,
+            };
+        return { snapshot: initial, seq: -1 };
+    }
+    if (migrate)
+        return { snapshot: await migrate(raw, 0, version), seq: -1 };
+    return { snapshot: initial, seq: -1 };
+}
+async function createOfflineStore(opts) {
+    const { remote, storeOpts, syncOpts = {}, onStatus } = opts;
+    if (opts.mode && opts.mode != 'snapshot')
+        throw new Error('createOfflineStore: only snapshot mode is implemented');
+    let loaded;
+    try {
+        loaded = await loadSnapshot(opts);
+    }
+    catch (e) {
+        emitError(opts, e);
+        loaded = { snapshot: opts.initial, seq: -1 };
+    }
+    const store = (0, store_1.createStore)(loaded.snapshot, storeOpts);
+    const persist = persistStore(store, {
+        key: opts.key,
+        storage: opts.storage,
+        version: opts.version,
+        seq: loaded.seq,
+        savedAt: loaded.savedAt,
+        debounceMs: opts.debounceMs,
+        now: opts.now,
+        onError: opts.onError,
+        onStatus,
+    });
+    let sub = null;
+    let ready = Promise.resolve();
+    async function reconnect(nextRemote, nextSyncOpts = syncOpts) {
+        sub?.();
+        persist.setSyncStatus({ syncing: true, offline: false, ready: false, error: undefined });
+        const { onSeq, onError, onStale, since, ...rest } = nextSyncOpts;
+        const effectiveSince = since ?? (persist.seq() >= 0 ? persist.seq() : undefined);
+        try {
+            sub = (0, store_replay_1.syncStoreReplay)(store, nextRemote, {
+                ...rest,
+                since: effectiveSince,
+                onSeq: function offlineStoreOnSeq(seq) {
+                    persist.setSeq(seq);
+                    onSeq?.(seq);
+                },
+                onError: function offlineStoreOnError(error) {
+                    persist.setSyncStatus({ offline: true, syncing: false, error });
+                    onError?.(error);
+                    if (!onError)
+                        opts.onError?.(error);
+                },
+                onStale: onStale && function offlineStoreOnStale(info) {
+                    persist.setSyncStatus({ stale: info.stale });
+                    onStale(info);
+                },
+            });
+            ready = sub.ready.then(function offlineStoreReady() {
+                persist.setSyncStatus({ ready: true, syncing: false });
+            });
+            await ready;
+        }
+        catch (e) {
+            persist.setSyncStatus({ ready: true, syncing: false, offline: true, error: e });
+            emitError(opts, e);
+        }
+    }
+    if (remote) {
+        ready = reconnect(remote);
+    }
+    else {
+        persist.setSyncStatus({ ready: true, syncing: false, offline: true });
+    }
+    function close() {
+        sub?.();
+        persist.close();
+    }
+    function flush() {
+        return persist.flush();
+    }
+    return Object.assign(store, {
+        get ready() { return ready; },
+        close,
+        flush,
+        status: persist.status,
+        statusListen: persist.statusListen,
+        reconnect,
+    });
+}

package/lib/Common/{ObserveAll2 → Observe}/store-replay.d.ts

@@ -17,57 +17,28 @@ export declare function exposeStoreReplay<T extends object>(store: Store<T>, opt
         changedData?: any;
     };
     replay: {
-        func: import("../..").Listener<[StorePatch]>;
+        emit: import("../..").Listener<[StorePatch]>;
         head: () => number;
         isStale: () => boolean;
         lastTs: () => number;
         close: () => void;
         getSince: (seq: number) => ReplayEvent<[StorePatch]>[] | undefined;
-        line: {
-            func: import("../..").Listener<[ReplayEvent<[StorePatch]>]>;
-            isRun: () => boolean;
-            run: () => void;
-            close: () => void;
-            eventClose: (cb: () => void) => () => void;
-            onClose: (cb: () => void) => () => void;
-            removeEventClose: (cb: () => void) => void;
-            on: import("../..").ListenOn<[ReplayEvent<[StorePatch]>]>;
-            off: (k: (string | symbol) | import("../..").Listener<[ReplayEvent<[StorePatch]>]> | null) => void;
-            addListen: (cb: import("../..").Listener<[ReplayEvent<[StorePatch]>]>, opts?: {
-                cbClose?: () => void;
-                key?: string | symbol;
-            }) => () => void;
-            removeListen: (k: (string | symbol) | import("../..").Listener<[ReplayEvent<[StorePatch]>]> | null) => void;
-            once: (cb: import("../..").Listener<[ReplayEvent<[StorePatch]>]>, opts?: {
-                key?: string | symbol;
-            }) => () => void;
-            count: () => number;
-            readonly getAllKeys: (string | symbol)[];
-        };
+        line: import("../..").ListenApi<[ReplayEvent<[StorePatch]>]>;
         hasKeyframe: boolean;
         keyframe: () => ReplayEvent<[StorePatch]> | undefined;
         frame: (sinceSeq: number, hint?: unknown) => ReplayEvent<[StorePatch]>[];
         on: import("../events/replay-listen").ListenOnReplay<[StorePatch]>;
-        addListen: (cb: import("../..").Listener<[StorePatch]>, opts?: {
-            cbClose?: () => void;
-            key?: string | symbol;
-            current?: import("../..").ListenCurrent<[StorePatch]> | undefined;
-            since?: number;
-            onSeq?: (seq: number) => void;
-        }) => () => void;
-        removeListen: (k: (string | symbol) | import("../..").Listener<[StorePatch]> | null) => void;
         once: (cb: import("../..").Listener<[StorePatch]>, opts?: {
             key?: string | symbol;
             current?: import("../..").ListenCurrent<[StorePatch]> | undefined;
         }) => () => void;
-        getAllKeys: (string | symbol)[];
-        isRun: () => boolean;
-        run: () => void;
-        eventClose: (cb: () => void) => () => void;
-        onClose: (cb: () => void) => () => void;
-        removeEventClose: (cb: () => void) => void;
-        off: (k: (string | symbol) | import("../..").Listener<[StorePatch]> | null) => void;
-        count: () => number;
+        has(key: import("../..").ListenKey): boolean;
+        off(keyOrCallback: import("../..").ListenKey | import("../..").Listener<[StorePatch]> | null): void;
+        count(): number;
+        keys(): import("../..").ListenKey[];
+        isRunning(): boolean;
+        run(): void;
+        onClose(cb: () => void): import("../..").ListenOff;
     };
     close: () => void;
 };

package/lib/Common/{ObserveAll2 → Observe}/store-replay.js

@@ -34,7 +34,7 @@ function condensePatchTail(tail) {
     return [...held.values()];
 }
 function exposeStoreReplay(store, opts = {}) {
-    const [emitPatch, lineApi] = (0, replay_listen_1.UseReplayListen)({
+    const [emitPatch, lineApi] = (0, replay_listen_1.replayListen)({
         current: () => [{ path: [], exists: true, value: store.snapshot() }],
         frame: condensePatchTail,
         history: opts.getSince ? undefined : (opts.history ?? 1024),

package/lib/Common/{ObserveAll2 → Observe}/store.d.ts

@@ -1,5 +1,5 @@
-import { funcListenCallbackBase } from "../events/Listen";
-import { listenUpdate, listenUpdatePaths, reactive, ReactiveChange } from "./reactive2";
+import { createListen } from "../events/Listen";
+import { listenUpdate, listenUpdatePaths, reactive, ReactiveChange } from "./reactive";
 export type StorePath = readonly PropertyKey[];
 export type StoreDrain = "micro" | "immediate" | number | ((flush: () => void) => void);
 export type StoreSubOpts = {
@@ -83,7 +83,7 @@ export type Store<T extends object> = {
     on(cb: (value: T, ctx: StoreCtx<T>) => void, opts?: StoreSubOpts): () => void;
     once(cb: (value: T, ctx: StoreCtx<T>) => void, opts?: StoreSubOpts): () => void;
     update<M extends StoreMask<T>>(mask: M, opts?: StoreSubOpts): StoreSelection<T, M>;
-    each(opts?: StoreEachOpts): ReturnType<typeof funcListenCallbackBase<[key: string, value: T[keyof T] | undefined, ctx: StoreEachCtx]>>;
+    each(opts?: StoreEachOpts): ReturnType<typeof createListen<[key: string, value: T[keyof T] | undefined, ctx: StoreEachCtx]>>;
     listen(): ReturnType<typeof listenUpdate>;
     listenPaths(): ReturnType<typeof listenUpdatePaths>;
     count(): number;

package/lib/Common/{ObserveAll2 → Observe}/store.js

@@ -7,7 +7,7 @@ exports.createStore = createStore;
 exports.exposeStore = exposeStore;
 exports.createStoreMirror = createStoreMirror;
 const Listen_1 = require("../events/Listen");
-const reactive2_1 = require("./reactive2");
+const reactive_1 = require("./reactive");
 const hasSetImmediate = typeof setImmediate == "function";
 function pathText(path) {
     return path.map(String).join(".");
@@ -119,7 +119,7 @@ function setAt(root, path, value) {
     p[path[path.length - 1]] = value;
 }
 function snapshotValue(value, seen = new WeakMap()) {
-    value = (0, reactive2_1.toRaw)(value);
+    value = (0, reactive_1.toRaw)(value);
     if (!isObj(value))
         return value;
     const old = seen.get(value);
@@ -158,7 +158,7 @@ function maskPaths(mask, base = []) {
     return out;
 }
 function pickSnapshot(root, mask, base = []) {
-    root = (0, reactive2_1.toRaw)(root);
+    root = (0, reactive_1.toRaw)(root);
     if (mask === true || mask == null)
         return snapshotValue(getAt(root, base));
     const out = {};
@@ -259,7 +259,7 @@ function maskFromPaths(paths) {
     return out ?? true;
 }
 function makePatch(root, path) {
-    root = (0, reactive2_1.toRaw)(root);
+    root = (0, reactive_1.toRaw)(root);
     const exists = hasAt(root, path);
     return {
         path: [...path],
@@ -292,7 +292,7 @@ function patchesForMask(patch, mask) {
     return out;
 }
 function createPatchesListen(store) {
-    return (0, Listen_1.funcListenCallbackBase)((emit) => {
+    return (0, Listen_1.createListen)((emit) => {
         const off = store.listenPaths().on((change) => {
             for (const path of change.paths)
                 emit(makePatch(store.state, path));
@@ -300,9 +300,9 @@ function createPatchesListen(store) {
         return off;
     }, {
         event: (type, count, api) => {
-            if (type == "add" && count == 1 && !api.isRun())
+            if (type == "add" && count == 1 && !api.isRunning())
                 api.run();
-            if (type == "remove" && count == 0 && api.isRun())
+            if (type == "remove" && count == 0 && api.isRunning())
                 api.close();
         },
     });
@@ -310,10 +310,10 @@ function createPatchesListen(store) {
 function createEachListen(store, opts = {}) {
     if (opts.depth != null && opts.depth != 1)
         throw new Error("store.each: only depth 1 is supported (reserved option)");
-    return (0, Listen_1.funcListenCallbackBase)((emit) => {
-        const known = new Set(Reflect.ownKeys((0, reactive2_1.toRaw)(store.state)));
+    return (0, Listen_1.createListen)((emit) => {
+        const known = new Set(Reflect.ownKeys((0, reactive_1.toRaw)(store.state)));
         function emitKey(key) {
-            const raw = (0, reactive2_1.toRaw)(store.state);
+            const raw = (0, reactive_1.toRaw)(store.state);
             const exists = isObj(raw) && key in raw;
             if (exists)
                 known.add(key);
@@ -331,7 +331,7 @@ function createEachListen(store, opts = {}) {
                     keys.add(path[0]);
             }
             if (root) {
-                for (const key of Reflect.ownKeys((0, reactive2_1.toRaw)(store.state)))
+                for (const key of Reflect.ownKeys((0, reactive_1.toRaw)(store.state)))
                     keys.add(key);
                 for (const key of known)
                     keys.add(key);
@@ -342,15 +342,15 @@ function createEachListen(store, opts = {}) {
         return off;
     }, {
         event: (type, count, api) => {
-            if (type == "add" && count == 1 && !api.isRun())
+            if (type == "add" && count == 1 && !api.isRunning())
                 api.run();
-            if (type == "remove" && count == 0 && api.isRun())
+            if (type == "remove" && count == 0 && api.isRunning())
                 api.close();
         },
     });
 }
 function createChangedDataListen(store) {
-    return (0, Listen_1.funcListenCallbackBase)((emit) => {
+    return (0, Listen_1.createListen)((emit) => {
         const off = store.listenPaths().on((change) => {
             const mask = maskFromPaths(change.paths);
             emit({ mask, data: pickSnapshot(store.state, mask) });
@@ -358,9 +358,9 @@ function createChangedDataListen(store) {
         return off;
     }, {
         event: (type, count, api) => {
-            if (type == "add" && count == 1 && !api.isRun())
+            if (type == "add" && count == 1 && !api.isRunning())
                 api.run();
-            if (type == "remove" && count == 0 && api.isRun())
+            if (type == "remove" && count == 0 && api.isRunning())
                 api.close();
         },
     });
@@ -372,7 +372,7 @@ function watchTarget(root, path) {
         if (!isObj(cur) || !(k in cur))
             return lastReactive;
         const next = cur[k];
-        if ((0, reactive2_1.isReactive)(next)) {
+        if ((0, reactive_1.isReactive)(next)) {
             cur = next;
             lastReactive = next;
         }
@@ -427,10 +427,10 @@ function subscribePath(store, path, cb, opts = {}, once = false) {
     function attach() {
         offUpdate?.();
         const target = watchTarget(store._state, path);
-        offUpdate = (0, reactive2_1.onUpdate)(target, () => {
+        offUpdate = (0, reactive_1.onUpdate)(target, () => {
             const exists = hasAt(store._state, path);
             const value = getAt(store._state, path);
-            const valueIsObject = (0, reactive2_1.isReactive)(value);
+            const valueIsObject = (0, reactive_1.isReactive)(value);
             const watchedSelf = target === value;
             if (!valueIsObject && !watchedSelf && sameLeaf(lastValue, value, lastExists, exists))
                 return;
@@ -541,7 +541,7 @@ function createSelection(store, base, mask, defaults = {}) {
     };
 }
 function createStore(initial, opts = {}) {
-    const state = (0, reactive2_1.reactive)(initial, opts);
+    const state = (0, reactive_1.reactive)(initial, opts);
     let store;
     store = {
         _state: state,
@@ -556,8 +556,8 @@ function createStore(initial, opts = {}) {
         once: (cb, opts) => getNode(store, []).once(cb, opts),
         update: (mask, opts) => createSelection(store, [], mask, opts),
         each: (opts) => createEachListen(store, opts),
-        listen: () => (0, reactive2_1.listenUpdate)(state),
-        listenPaths: () => (0, reactive2_1.listenUpdatePaths)(state),
+        listen: () => (0, reactive_1.listenUpdate)(state),
+        listenPaths: () => (0, reactive_1.listenUpdatePaths)(state),
         count: () => Array.from(store._counts.values()).reduce((a, b) => a + b, 0),
     };
     return store;
@@ -588,16 +588,12 @@ function exposeStore(store, opts = {}) {
     return api;
 }
 function isRemoteListen(listen) {
-    return typeof listen?.on == "function" || typeof listen?.addListen == "function";
+    return typeof listen?.on == "function";
 }
 function subscribeRemote(listen, cb) {
-    let handle;
-    if (typeof listen?.on == "function")
-        handle = listen.on(cb);
-    else if (typeof listen?.addListen == "function")
-        handle = listen.addListen(cb);
-    else
+    if (typeof listen?.on != "function")
         return () => { };
+    const handle = listen.on(cb);
     return () => {
         if (typeof handle == "function")
             handle();
@@ -605,8 +601,6 @@ function subscribeRemote(listen, cb) {
             handle.off();
         else if (typeof listen?.off == "function")
             listen.off(cb);
-        else if (typeof listen?.removeListen == "function")
-            listen.removeListen(cb);
     };
 }
 function createStoreMirror(remote, initial = {}, opts = {}) {

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

@@ -0,0 +1,12 @@
+export declare function promiseProgress<T extends any = unknown>(array: ((() => Promise<T>) | (() => any) | Promise<T>)[]): {
+    onOk: (cb: (...data: [data: T, i: number, countOk: number, countError: number, count: number]) => any) => import("../events/Listen").ListenOff;
+    onError: (cb: (...data: [error: any, i: number, countOk: number, countError: number, count: number]) => any) => import("../events/Listen").ListenOff;
+    all: () => Promise<any[]>;
+    allSettled: () => Promise<PromiseSettledResult<any>[]>;
+    items: () => Promise<any>[];
+    stats: () => {
+        ok: number;
+        error: number;
+        count: number;
+    };
+};

package/lib/Common/async/promiseProgress.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promiseProgress = promiseProgress;
+const Listen_1 = require("../events/Listen");
+function promiseProgress(array) {
+    let ok = 0, errorCount = 0;
+    const count = array.length;
+    const okEvents = (0, Listen_1.listen)();
+    const errorEvents = (0, Listen_1.listen)();
+    const emitOk = (data, i) => {
+        ++ok;
+        okEvents[0](data, i, ok, errorCount, count);
+    };
+    const emitError = (error, i) => {
+        ++errorCount;
+        errorEvents[0](error, i, ok, errorCount, count);
+    };
+    const wrap = (promise, i) => promise.then(r => { emitOk(r, i); return r; }).catch((er) => { emitError(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));
+    const onOk = (cb) => okEvents[1].on(cb);
+    const onError = (cb) => errorEvents[1].on(cb);
+    const all = () => Promise.all(startAll());
+    const allSettled = () => Promise.allSettled(startAll());
+    const items = () => startAll();
+    const stats = () => ({ ok, error: errorCount, count });
+    return { onOk, onError, all, allSettled, items, stats };
+}