wenay-common2 1.0.55 → 1.0.57

package/lib/Common/ObserveAll2/reactive2.js

@@ -33,7 +33,9 @@ function reactive(root, opts = {}) {
     const { drain = 'immediate', depth = Infinity, eager = false } = opts;
     const fire = scheduler(drain);
     const eng = {
-        live: 0, pathLive: 0, dirty: new Set(), dirtyPaths: [], scheduled: false, waiters: new Set(), depth,
+        live: 0, pathLive: 0, dirty: new Set(), dirtyPaths: [],
+        dirtyPathKeys: new Set(), pathKey: createPathKeyer(),
+        scheduled: false, waiters: new Set(), depth,
         schedule() {
             if (eng.scheduled)
                 return;
@@ -44,6 +46,8 @@ function reactive(root, opts = {}) {
                 eng.dirty.clear();
                 const dirtyPaths = eng.dirtyPaths;
                 eng.dirtyPaths = [];
+                eng.dirtyPathKeys = new Set();
+                eng.pathKey = createPathKeyer();
                 let err;
                 for (const n of batch) {
                     for (const cb of [...n.subs]) {
@@ -112,7 +116,6 @@ function makeNode(target, parent, path, level, eng) {
             v = toRaw(v);
             if (Object.is(node.target[k], v))
                 return true;
-            const dirtyPath = dirtyPathFor(node, k);
             node.target[k] = v;
             if (Array.isArray(proxyTarget) && k == "length")
                 proxyTarget.length = v;
@@ -120,7 +123,7 @@ function makeNode(target, parent, path, level, eng) {
             if (kid)
                 rebind(kid, v);
             if (eng.live > 0)
-                bubble(node, dirtyPath);
+                bubble(node, k);
             return true;
         },
         defineProperty(_, k, d) {
@@ -136,7 +139,6 @@ function makeNode(target, parent, path, level, eng) {
             }
             const v = node.target[k];
             if (!Object.is(old, v)) {
-                const dirtyPath = dirtyPathFor(node, k);
                 const kid = node.kids.get(k);
                 if (kid) {
                     if (isReactiveObj(v))
@@ -148,14 +150,13 @@ function makeNode(target, parent, path, level, eng) {
                     }
                 }
                 if (eng.live > 0)
-                    bubble(node, dirtyPath);
+                    bubble(node, k);
             }
             return true;
         },
         deleteProperty(_, k) {
             if (!(k in node.target))
                 return true;
-            const dirtyPath = dirtyPathFor(node, k);
             delete node.target[k];
             const kid = node.kids.get(k);
             if (kid) {
@@ -164,7 +165,7 @@ function makeNode(target, parent, path, level, eng) {
                 detachTree(kid);
             }
             if (eng.live > 0)
-                bubble(node, dirtyPath);
+                bubble(node, k);
             return true;
         },
         has(_, k) { return k in node.target; },
@@ -191,10 +192,10 @@ function makeNode(target, parent, path, level, eng) {
     });
     return node;
 }
-function bubble(from, dirtyPath) {
+function bubble(from, key) {
     const eng = from.eng;
-    if (eng.pathLive > 0 && dirtyPath)
-        addDirtyPath(eng, dirtyPath);
+    if (eng.pathLive > 0)
+        addDirtyPath(eng, dirtyPathFor(from, key));
     for (let n = from; n && n.active; n = n.parent)
         if (n.subs.size || n.pathSubs.size)
             eng.dirty.add(n);
@@ -224,26 +225,55 @@ function markChanged(node) {
 function dirtyPathFor(node, key) {
     return Array.isArray(node.target) ? [...node.path] : [...node.path, key];
 }
-function addDirtyPath(eng, path) {
-    if (!eng.dirtyPaths.some(p => samePath(p, path)))
-        eng.dirtyPaths.push([...path]);
+function createPathKeyer() {
+    let symIds = null;
+    return function pathKey(path) {
+        let out = '';
+        for (const p of path) {
+            if (typeof p == 'symbol') {
+                symIds ??= new Map();
+                let id = symIds.get(p);
+                if (id == null) {
+                    id = symIds.size;
+                    symIds.set(p, id);
+                }
+                out += 'y' + id + '|';
+            }
+            else {
+                const s = String(p);
+                out += (typeof p)[0] + s.length + ':' + s + '|';
+            }
+        }
+        return out;
+    };
 }
-function samePath(a, b) {
-    return a.length == b.length && a.every((k, i) => Object.is(k, b[i]));
+function addDirtyPath(eng, path) {
+    const k = eng.pathKey(path);
+    if (eng.dirtyPathKeys.has(k))
+        return;
+    eng.dirtyPathKeys.add(k);
+    eng.dirtyPaths.push(path);
 }
 function startsWithPath(path, prefix) {
     return prefix.length <= path.length && prefix.every((k, i) => Object.is(k, path[i]));
 }
 function pathsForNode(node, dirtyPaths) {
     const out = [];
+    const seen = new Set();
+    const pathKey = createPathKeyer();
     for (const path of dirtyPaths) {
         let next = null;
         if (startsWithPath(path, node.path))
             next = path.slice(node.path.length);
         else if (startsWithPath(node.path, path))
             next = [];
-        if (next && !out.some(p => samePath(p, next)))
-            out.push(next);
+        if (next == null)
+            continue;
+        const k = pathKey(next);
+        if (seen.has(k))
+            continue;
+        seen.add(k);
+        out.push(next);
     }
     return out;
 }

package/lib/Common/ObserveAll2/store-replay.d.ts

@@ -6,31 +6,7 @@ export type StoreReplayOpts = Pick<ReplayListenOptions<[StorePatch]>, 'history'
 export declare function storePatchKey(patch: StorePatch): string | null;
 export declare function exposeStoreReplay<T extends object>(store: Store<T>, opts?: StoreReplayOpts): {
     api: {
-        replay: {
-            line: {
-                func: import("../..").Listener<[import("../events/replay-listen").ReplayEvent<[StorePatch]>]>;
-                isRun: () => boolean;
-                run: () => void;
-                close: () => void;
-                eventClose: (cb: () => void) => () => void;
-                onClose: (cb: () => void) => () => void;
-                removeEventClose: (cb: () => void) => void;
-                on: import("../..").ListenOn<[import("../events/replay-listen").ReplayEvent<[StorePatch]>]>;
-                off: (k: (string | symbol) | import("../..").Listener<[import("../events/replay-listen").ReplayEvent<[StorePatch]>]> | null) => void;
-                addListen: (cb: import("../..").Listener<[import("../events/replay-listen").ReplayEvent<[StorePatch]>]>, opts?: {
-                    cbClose?: () => void;
-                    key?: string | symbol;
-                }) => () => void;
-                removeListen: (k: (string | symbol) | import("../..").Listener<[import("../events/replay-listen").ReplayEvent<[StorePatch]>]> | null) => void;
-                once: (cb: import("../..").Listener<[import("../events/replay-listen").ReplayEvent<[StorePatch]>]>, opts?: {
-                    key?: string | symbol;
-                }) => () => void;
-                count: () => number;
-                readonly getAllKeys: (string | symbol)[];
-            };
-            since: (seq: number) => import("../events/replay-listen").ReplayEvent<[StorePatch]>[] | null;
-            keyframe: () => import("../events/replay-listen").ReplayEvent<[StorePatch]> | null;
-        };
+        replay: import("../events/replay-wire").ReplayExpose<[StorePatch]>;
         get(): T;
         get<M extends import("./store").StoreMask<T>>(mask: M): import("./store").StorePick<T, M>;
         set(path: import("./store").StorePath, value: any): void;
@@ -43,6 +19,9 @@ export declare function exposeStoreReplay<T extends object>(store: Store<T>, opt
     replay: {
         func: import("../..").Listener<[StorePatch]>;
         head: () => number;
+        isStale: () => boolean;
+        lastTs: () => number;
+        close: () => void;
         getSince: (seq: number) => import("../events/replay-listen").ReplayEvent<[StorePatch]>[] | undefined;
         line: {
             func: import("../..").Listener<[import("../events/replay-listen").ReplayEvent<[StorePatch]>]>;
@@ -83,7 +62,6 @@ export declare function exposeStoreReplay<T extends object>(store: Store<T>, opt
         getAllKeys: (string | symbol)[];
         isRun: () => boolean;
         run: () => void;
-        close: () => void;
         eventClose: (cb: () => void) => () => void;
         onClose: (cb: () => void) => () => void;
         removeEventClose: (cb: () => void) => void;
@@ -95,6 +73,8 @@ export declare function exposeStoreReplay<T extends object>(store: Store<T>, opt
 export declare function syncStoreReplay<T extends object>(store: Store<T>, remote: ReplayRemote<[StorePatch]>, opts?: ReplaySubscribeOpts): (() => void) & {
     ready: Promise<void>;
     seq: () => number;
+    isStale: () => boolean;
+    lastTs: () => number;
 };
 export declare function storeReplayAt<T extends object>(storage: ReplayStorage<[StorePatch]>, at?: {
     seq?: number;

package/lib/Common/ObserveAll2/store.js

@@ -122,6 +122,9 @@ function snapshotValue(value, seen = new WeakMap()) {
     value = (0, reactive2_1.toRaw)(value);
     if (!isObj(value))
         return value;
+    const old = seen.get(value);
+    if (old)
+        return old;
     if (value instanceof Date)
         return new Date(value.valueOf());
     if (value instanceof RegExp)
@@ -138,9 +141,6 @@ function snapshotValue(value, seen = new WeakMap()) {
         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))

package/lib/Common/events/replay-conflate.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.conflateReplay = conflateReplay;
 const Listen3_1 = require("./Listen3");
-const replay_wire_1 = require("./replay-wire");
 function conflateReplay(replay, opts) {
     const { pending, highWater, lowWater = 0, pollMs = 25, keyOf, maxKeys = 1024 } = opts;
     if (!replay.hasKeyframe)
@@ -92,7 +91,11 @@ function conflateReplay(replay, opts) {
         gate.close();
     }
     return {
-        api: { ...(0, replay_wire_1.exposeReplay)(replay), line: gate },
+        api: {
+            line: gate,
+            since: (seq) => replay.getSince(seq) ?? null,
+            keyframe: () => replay.keyframe() ?? null,
+        },
         close,
         stats: () => ({ conflating, dropped, keyframes, coalesced, flushes }),
     };

package/lib/Common/events/replay-listen.d.ts

@@ -6,12 +6,19 @@ export type ReplayEvent<Z extends any[] = any[]> = {
     ts: number;
     event: Z;
 };
+export type StaleInfo = {
+    stale: boolean;
+    lastTs: number;
+    age: number;
+};
 export type ReplayListenOptions<Z extends any[]> = {
     current?: ListenCurrentProvider<Z>;
     history?: number;
     getSince?: (seq: number) => ReplayEvent<Z>[] | undefined;
     onJournal?: (ev: ReplayEvent<Z>) => void;
     now?: () => number;
+    staleMs?: number;
+    onStale?: (info: StaleInfo) => void;
 };
 type ReplayOnOptions<Z extends any[]> = {
     cbClose?: cbClose;
@@ -24,6 +31,9 @@ export type ListenOnReplay<Z extends any[] = any[]> = ((cb: Listener<Z>, opts?:
 export declare function withReplayListen<T>(base: ListenApi<T>, options?: ReplayListenOptions<NormalizeTuple<T>>): {
     func: Listener<NormalizeTuple<T>>;
     head: () => number;
+    isStale: () => boolean;
+    lastTs: () => number;
+    close: () => void;
     getSince: (seq: number) => ReplayEvent<NormalizeTuple<T>>[] | undefined;
     line: {
         func: Listener<[ReplayEvent<NormalizeTuple<T>>]>;
@@ -58,7 +68,6 @@ export declare function withReplayListen<T>(base: ListenApi<T>, options?: Replay
     getAllKeys: key[];
     isRun: () => boolean;
     run: () => void;
-    close: () => void;
     eventClose: (cb: () => void) => () => void;
     onClose: (cb: () => void) => () => void;
     removeEventClose: (cb: () => void) => void;
@@ -70,6 +79,9 @@ export type ReplayListenUseOptions<T> = ListenOptions<T> & ReplayListenOptions<N
 export declare function UseReplayListen<T>(options?: ReplayListenUseOptions<T>): readonly [(...a: NormalizeTuple<T>) => void, {
     func: Listener<NormalizeTuple<T>>;
     head: () => number;
+    isStale: () => boolean;
+    lastTs: () => number;
+    close: () => void;
     getSince: (seq: number) => ReplayEvent<NormalizeTuple<T>>[] | undefined;
     line: {
         func: Listener<[ReplayEvent<NormalizeTuple<T>>]>;
@@ -104,7 +116,6 @@ export declare function UseReplayListen<T>(options?: ReplayListenUseOptions<T>):
     getAllKeys: key[];
     isRun: () => boolean;
     run: () => void;
-    close: () => void;
     eventClose: (cb: () => void) => () => void;
     onClose: (cb: () => void) => () => void;
     removeEventClose: (cb: () => void) => void;

package/lib/Common/events/replay-listen.js

@@ -4,7 +4,7 @@ exports.withReplayListen = withReplayListen;
 exports.UseReplayListen = UseReplayListen;
 const Listen3_1 = require("./Listen3");
 function withReplayListen(base, options = {}) {
-    const { current, history = 0, getSince, onJournal, now = Date.now } = options;
+    const { current, history = 0, getSince, onJournal, now = Date.now, staleMs, onStale } = options;
     let head = 0;
     const ring = [];
     let emitting = null;
@@ -30,6 +30,44 @@ function withReplayListen(base, options = {}) {
             return c();
         return c ? current?.() : undefined;
     }
+    let lastTs = 0;
+    let staleFlag = false;
+    let staleTimer = null;
+    function stopStaleTimer() {
+        if (staleTimer) {
+            clearTimeout(staleTimer);
+            staleTimer = null;
+        }
+    }
+    function reportStale(stale) {
+        staleFlag = stale;
+        try {
+            onStale({ stale, lastTs, age: now() - lastTs });
+        }
+        catch (e) {
+            setTimeout(function rethrowOnStale() { throw e; }, 0);
+        }
+    }
+    function checkStale() {
+        staleTimer = null;
+        const age = now() - lastTs;
+        if (age >= staleMs)
+            reportStale(true);
+        else
+            armStaleTimer(staleMs - age);
+    }
+    function armStaleTimer(delay) {
+        if (staleTimer || !onStale || staleMs == null)
+            return;
+        staleTimer = setTimeout(checkStale, delay);
+        staleTimer.unref?.();
+    }
+    function touchStale(ts) {
+        lastTs = ts;
+        if (staleFlag)
+            reportStale(false);
+        armStaleTimer(staleMs);
+    }
     const api = {
         ...base,
         func: function emitJournaled(...e) {
@@ -37,6 +75,7 @@ function withReplayListen(base, options = {}) {
             if (history > 0)
                 ring[(ev.seq - 1) % history] = ev;
             onJournal?.(ev);
+            touchStale(ev.ts);
             line.func(ev);
             const prev = emitting;
             emitting = ev;
@@ -48,6 +87,9 @@ function withReplayListen(base, options = {}) {
             }
         },
         head: () => head,
+        isStale: () => staleMs != null && head > 0 && now() - lastTs >= staleMs,
+        lastTs: () => lastTs,
+        close: function closeReplay() { stopStaleTimer(); base.close(); },
         getSince: journalSince,
         line,
         hasKeyframe: current != null,
@@ -124,10 +166,10 @@ function withReplayListen(base, options = {}) {
     return api;
 }
 function UseReplayListen(options = {}) {
-    const { current, history, getSince, onJournal, now, ...listenOptions } = options;
+    const { current, history, getSince, onJournal, now, staleMs, onStale, ...listenOptions } = options;
     let t;
     const base = (0, Listen3_1.funcListenCallbackBase)((e) => { t = e; }, { fast: true, ...listenOptions });
-    const listen = withReplayListen(base, { current, history, getSince, onJournal, now });
+    const listen = withReplayListen(base, { current, history, getSince, onJournal, now, staleMs, onStale });
     base.run();
     t = listen.func;
     return [t, listen];

package/lib/Common/events/replay-wire.d.ts

@@ -1,29 +1,17 @@
-import { Listener } from './Listen3';
-import { ListenReplayApi, ReplayEvent } from './replay-listen';
-export declare function exposeReplay<T>(replay: ListenReplayApi<T>): {
-    line: {
-        func: Listener<[ReplayEvent<import("./Listen3").NormalizeTuple<T>>]>;
-        isRun: () => boolean;
-        run: () => void;
-        close: () => void;
-        eventClose: (cb: () => void) => () => void;
-        onClose: (cb: () => void) => () => void;
-        removeEventClose: (cb: () => void) => void;
-        on: import("./Listen3").ListenOn<[ReplayEvent<import("./Listen3").NormalizeTuple<T>>]>;
-        off: (k: (string | symbol) | Listener<[ReplayEvent<import("./Listen3").NormalizeTuple<T>>]> | null) => void;
-        addListen: (cb: Listener<[ReplayEvent<import("./Listen3").NormalizeTuple<T>>]>, opts?: {
-            cbClose?: () => void;
-            key?: string | symbol;
-        }) => () => void;
-        removeListen: (k: (string | symbol) | Listener<[ReplayEvent<import("./Listen3").NormalizeTuple<T>>]> | null) => void;
-        once: (cb: Listener<[ReplayEvent<import("./Listen3").NormalizeTuple<T>>]>, opts?: {
-            key?: string | symbol;
-        }) => () => void;
-        count: () => number;
-        readonly getAllKeys: (string | symbol)[];
-    };
-    since: (seq: number) => ReplayEvent<import("./Listen3").NormalizeTuple<T>>[] | null;
-    keyframe: () => ReplayEvent<import("./Listen3").NormalizeTuple<T>> | null;
+import { Listener, NormalizeTuple } from './Listen3';
+import { ListenReplayApi, ReplayEvent, StaleInfo } from './replay-listen';
+import { conflateReplay, ConflateOpts } from './replay-conflate';
+export type ReplayExpose<T> = {
+    line: ListenReplayApi<T>['line'];
+    since: (seq: number) => ReplayEvent<NormalizeTuple<T>>[] | null;
+    keyframe: () => ReplayEvent<NormalizeTuple<T>> | null;
+};
+export declare function exposeReplay<T>(replay: ListenReplayApi<T>): ReplayExpose<T>;
+export declare function exposeReplay<T>(replay: ListenReplayApi<T>, opts: {
+    conflate: ConflateOpts<NormalizeTuple<T>>;
+}): ReplayExpose<T> & {
+    close: () => void;
+    stats: ReturnType<typeof conflateReplay<T>>['stats'];
 };
 export type ReplayRemote<Z extends any[] = any[]> = {
     line: {
@@ -36,8 +24,14 @@ export type ReplaySubscribeOpts = {
     since?: number;
     onSeq?: (seq: number) => void;
     onError?: (e: any) => void;
+    staleMs?: number;
+    onStale?: (info: StaleInfo) => void;
+    skewMs?: number;
+    now?: () => number;
 };
 export declare function replaySubscribe<Z extends any[]>(remote: ReplayRemote<Z>, cb: Listener<Z>, opts?: ReplaySubscribeOpts): (() => void) & {
     ready: Promise<void>;
     seq: () => number;
+    isStale: () => boolean;
+    lastTs: () => number;
 };

package/lib/Common/events/replay-wire.js

@@ -2,13 +2,20 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.exposeReplay = exposeReplay;
 exports.replaySubscribe = replaySubscribe;
-function exposeReplay(replay) {
+const replay_conflate_1 = require("./replay-conflate");
+function exposeReplayPlain(replay) {
     return {
         line: replay.line,
         since: (seq) => replay.getSince(seq) ?? null,
         keyframe: () => replay.keyframe() ?? null,
     };
 }
+function exposeReplay(replay, opts) {
+    if (!opts?.conflate)
+        return exposeReplayPlain(replay);
+    const gated = (0, replay_conflate_1.conflateReplay)(replay, opts.conflate);
+    return { ...gated.api, close: gated.close, stats: gated.stats };
+}
 function unsubscribeHandle(handle) {
     if (typeof handle == 'function') {
         handle();
@@ -20,19 +27,75 @@ function unsubscribeHandle(handle) {
         handle.unsubscribe();
 }
 function replaySubscribe(remote, cb, opts = {}) {
-    const { since = -1, onSeq, onError } = opts;
+    const { since = -1, onSeq, onError, staleMs, onStale, skewMs = 0, now = Date.now } = opts;
     let lastDelivered = since;
     let replaying = true;
     let closed = false;
     const queue = [];
+    let lastTs = 0;
+    let lastArrival = now();
+    let staleFlag = false;
+    let staleTimer = null;
+    function stopStaleTimer() {
+        if (staleTimer) {
+            clearTimeout(staleTimer);
+            staleTimer = null;
+        }
+    }
+    function reportStale(stale) {
+        staleFlag = stale;
+        if (!onStale)
+            return;
+        try {
+            onStale({ stale, lastTs, age: now() - (lastTs || lastArrival) });
+        }
+        catch (e) {
+            setTimeout(function rethrowOnStale() { throw e; }, 0);
+        }
+    }
+    function checkArrivalGap() {
+        staleTimer = null;
+        if (closed)
+            return;
+        const gap = now() - lastArrival;
+        if (gap >= staleMs) {
+            if (!staleFlag)
+                reportStale(true);
+        }
+        else
+            armStaleTimer(staleMs - gap);
+    }
+    function armStaleTimer(delay) {
+        if (staleTimer || !onStale || staleMs == null || closed)
+            return;
+        staleTimer = setTimeout(checkArrivalGap, delay);
+        staleTimer.unref?.();
+    }
+    function assessStale() {
+        if (staleMs == null || closed)
+            return;
+        const tsStale = lastTs > 0 && now() - lastTs > staleMs + skewMs;
+        if (tsStale != staleFlag)
+            reportStale(tsStale);
+        if (tsStale)
+            stopStaleTimer();
+        else
+            armStaleTimer(staleMs);
+    }
+    armStaleTimer(staleMs);
     function deliver(ev) {
         if (closed || ev.seq <= lastDelivered)
             return;
         lastDelivered = ev.seq;
+        lastTs = ev.ts;
+        lastArrival = now();
         cb(...ev.event);
         onSeq?.(ev.seq);
+        if (!replaying)
+            assessStale();
     }
     const handle = remote.line.on(function liveTap(ev) {
+        lastArrival = now();
         if (replaying)
             queue.push(ev);
         else
@@ -53,6 +116,8 @@ function replaySubscribe(remote, cb, opts = {}) {
                     return;
                 if (kf) {
                     lastDelivered = kf.seq;
+                    lastTs = kf.ts;
+                    lastArrival = now();
                     cb(...kf.event);
                     onSeq?.(kf.seq);
                 }
@@ -68,6 +133,7 @@ function replaySubscribe(remote, cb, opts = {}) {
             while (queue.length)
                 deliver(queue.shift());
             replaying = false;
+            assessStale();
         }
     }
     const ready = catchUp();
@@ -75,10 +141,13 @@ function replaySubscribe(remote, cb, opts = {}) {
         if (closed)
             return;
         closed = true;
+        stopStaleTimer();
         unsubscribeHandle(handle);
     }
     return Object.assign(off, {
         ready,
         seq: () => lastDelivered,
+        isStale: () => staleFlag || (staleMs != null && now() - lastArrival >= staleMs),
+        lastTs: () => lastTs,
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wenay-common2",
-  "version": "1.0.55",
+  "version": "1.0.57",
   "description": "Common library",
   "strict": true,
   "main": "lib/index.js",