wenay-common2 1.0.53 → 1.0.55

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

@@ -1,2 +1,3 @@
 export * from "./reactive2";
 export * from "./store";
+export * from "./store-replay";

package/lib/Common/ObserveAll2/index.js

@@ -16,3 +16,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./reactive2"), exports);
 __exportStar(require("./store"), exports);
+__exportStar(require("./store-replay"), exports);

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

@@ -0,0 +1,102 @@
+import { Store, StorePatch } from './store';
+import { ReplayListenOptions } from '../events/replay-listen';
+import { ReplayRemote, ReplaySubscribeOpts } from '../events/replay-wire';
+import { ReplayStorage } from '../events/replay-history';
+export type StoreReplayOpts = Pick<ReplayListenOptions<[StorePatch]>, 'history' | 'getSince' | 'onJournal' | 'now'>;
+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;
+        };
+        get(): T;
+        get<M extends import("./store").StoreMask<T>>(mask: M): import("./store").StorePick<T, M>;
+        set(path: import("./store").StorePath, value: any): void;
+        replace(path: import("./store").StorePath, value: any): void;
+        changed: any;
+        changedPaths: any;
+        patches?: any;
+        changedData?: any;
+    };
+    replay: {
+        func: import("../..").Listener<[StorePatch]>;
+        head: () => number;
+        getSince: (seq: number) => import("../events/replay-listen").ReplayEvent<[StorePatch]>[] | undefined;
+        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)[];
+        };
+        hasKeyframe: boolean;
+        keyframe: () => import("../events/replay-listen").ReplayEvent<[StorePatch]> | undefined;
+        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: import("../..").Listener<[StorePatch]> | (string | symbol) | null) => void;
+        once: (cb: import("../..").Listener<[StorePatch]>, opts?: {
+            key?: string | symbol;
+            current?: import("../..").ListenCurrent<[StorePatch]> | undefined;
+        }) => () => void;
+        getAllKeys: (string | symbol)[];
+        isRun: () => boolean;
+        run: () => void;
+        close: () => void;
+        eventClose: (cb: () => void) => () => void;
+        onClose: (cb: () => void) => () => void;
+        removeEventClose: (cb: () => void) => void;
+        off: (k: (string | symbol) | import("../..").Listener<[StorePatch]> | null) => void;
+        count: () => number;
+    };
+    close: () => void;
+};
+export declare function syncStoreReplay<T extends object>(store: Store<T>, remote: ReplayRemote<[StorePatch]>, opts?: ReplaySubscribeOpts): (() => void) & {
+    ready: Promise<void>;
+    seq: () => number;
+};
+export declare function storeReplayAt<T extends object>(storage: ReplayStorage<[StorePatch]>, at?: {
+    seq?: number;
+    ts?: number;
+}): T | undefined;

package/lib/Common/ObserveAll2/store-replay.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.storePatchKey = storePatchKey;
+exports.exposeStoreReplay = exposeStoreReplay;
+exports.syncStoreReplay = syncStoreReplay;
+exports.storeReplayAt = storeReplayAt;
+const store_1 = require("./store");
+const replay_listen_1 = require("../events/replay-listen");
+const replay_wire_1 = require("../events/replay-wire");
+const replay_history_1 = require("../events/replay-history");
+function makeStorePatch(store, path) {
+    let node = store.node;
+    for (const k of path)
+        node = node.at(k);
+    const exists = node.has();
+    return { path: [...path], exists, value: exists ? node.snapshot() : undefined };
+}
+function storePatchKey(patch) {
+    for (const k of patch.path)
+        if (typeof k == 'symbol')
+            return null;
+    return JSON.stringify(patch.path);
+}
+function exposeStoreReplay(store, opts = {}) {
+    const [emitPatch, lineApi] = (0, replay_listen_1.UseReplayListen)({
+        current: () => [{ path: [], exists: true, value: store.snapshot() }],
+        history: opts.getSince ? undefined : (opts.history ?? 1024),
+        getSince: opts.getSince,
+        onJournal: opts.onJournal,
+        now: opts.now,
+    });
+    const offStore = store.listenPaths().on(function journalStoreChange(change) {
+        for (const path of change.paths)
+            emitPatch(makeStorePatch(store, path));
+    });
+    return {
+        api: { ...(0, store_1.exposeStore)(store), replay: (0, replay_wire_1.exposeReplay)(lineApi) },
+        replay: lineApi,
+        close: () => { offStore(); },
+    };
+}
+function syncStoreReplay(store, remote, opts = {}) {
+    return (0, replay_wire_1.replaySubscribe)(remote, function applyLine(patch) { (0, store_1.applyStorePatch)(store, patch); }, opts);
+}
+function storeReplayAt(storage, at = {}) {
+    const envelopes = (0, replay_history_1.openHistory)(storage).at(at);
+    if (!envelopes)
+        return undefined;
+    const scratch = (0, store_1.createStore)({});
+    for (const ev of envelopes)
+        (0, store_1.applyStorePatch)(scratch, ev.event[0]);
+    return scratch.snapshot();
+}

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

@@ -7,10 +7,22 @@ export type StoreSubOpts = {
     key?: string;
 };
 export type StoreChange = ReactiveChange;
+export type StorePatch = {
+    path: PropertyKey[];
+    value: any;
+    exists: boolean;
+};
+export type StoreChangedData<M = any> = {
+    mask: M;
+    data: any;
+};
 export type StoreSyncOpts = StoreSubOpts & {
     partial?: boolean;
     onError?: (error: any) => void;
 };
+export type StoreExposeOpts = {
+    push?: boolean;
+};
 export type StoreCtx<T = any> = {
     store: Store<any>;
     node: StoreNode<T>;
@@ -72,56 +84,27 @@ type RemoteStore<T extends object> = {
     get(mask?: any): T | Promise<T>;
     changed: any;
     changedPaths?: any;
+    patches?: any;
+    changedData?: any;
 };
-export declare function createStore<T extends object>(initial: T, opts?: Parameters<typeof reactive<T>>[1]): Store<T>;
-export declare function exposeStore<T extends object>(store: Store<T>): {
-    get: (mask?: StoreMask<T>) => T extends object ? T | { [K in (string | number | symbol) & keyof T]: T[K] | (NonNullable<T[K]> extends object ? T[K] | { [K_2 in (string | number | symbol) & keyof NonNullable<T[K]>]: NonNullable<T[K]>[K_2] | (NonNullable<NonNullable<T[K]>[K_2]> extends object ? NonNullable<T[K]>[K_2] | { [K_3 in (string | number | symbol) & keyof NonNullable<NonNullable<T[K]>[K_2]>]: NonNullable<NonNullable<T[K]>[K_2]>[K_3] | (NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]> extends object ? NonNullable<NonNullable<T[K]>[K_2]>[K_3] | { [K_4 in (string | number | symbol) & keyof NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>]: NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4] | (NonNullable<NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4]> extends object ? NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4] | { [K_5 in (string | number | symbol) & keyof NonNullable<NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4]>]: NonNullable<NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4]>[K_5] | (NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4]>[K_5]> extends object ? NonNullable<NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4]>[K_5] | { [K_6 in (string | number | symbol) & keyof NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4]>[K_5]>]: NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4]>[K_5]>[K_6] | (NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4]>[K_5]>[K_6]> extends object ? NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4]>[K_5]>[K_6] | { [K_7 in (string | number | symbol) & keyof NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4]>[K_5]>[K_6]>]: NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4]>[K_5]>[K_6]>[K_7] | (NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4]>[K_5]>[K_6]>[K_7]> extends object ? NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4]>[K_5]>[K_6]>[K_7] | { [K_8 in (string | number | symbol) & keyof NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4]>[K_5]>[K_6]>[K_7]>]: NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4]>[K_5]>[K_6]>[K_7]>[K_8] | (NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4]>[K_5]>[K_6]>[K_7]>[K_8]> extends object ? NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4]>[K_5]>[K_6]>[K_7]>[K_8] | { [K_9 in (string | number | symbol) & keyof NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4]>[K_5]>[K_6]>[K_7]>[K_8]>]: NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4]>[K_5]>[K_6]>[K_7]>[K_8]>[K_9] | (NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4]>[K_5]>[K_6]>[K_7]>[K_8]>[K_9]> extends object ? NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4]>[K_5]>[K_6]>[K_7]>[K_8]>[K_9] | { [K_10 in (string | number | symbol) & keyof NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4]>[K_5]>[K_6]>[K_7]>[K_8]>[K_9]>]: NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4]>[K_5]>[K_6]>[K_7]>[K_8]>[K_9]>[K_10] | (NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4]>[K_5]>[K_6]>[K_7]>[K_8]>[K_9]>[K_10]> extends object ? NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4]>[K_5]>[K_6]>[K_7]>[K_8]>[K_9]>[K_10] | { [K_11 in (string | number | symbol) & keyof NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4]>[K_5]>[K_6]>[K_7]>[K_8]>[K_9]>[K_10]>]: NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4]>[K_5]>[K_6]>[K_7]>[K_8]>[K_9]>[K_10]>[K_11] | any; } : NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4]>[K_5]>[K_6]>[K_7]>[K_8]>[K_9]>[K_10]); } : NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4]>[K_5]>[K_6]>[K_7]>[K_8]>[K_9]); } : NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4]>[K_5]>[K_6]>[K_7]>[K_8]); } : NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4]>[K_5]>[K_6]>[K_7]); } : NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4]>[K_5]>[K_6]); } : NonNullable<NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4]>[K_5]); } : NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4]); } : NonNullable<NonNullable<T[K]>[K_2]>[K_3]); } : NonNullable<T[K]>[K_2]); } : T[K]); } : T;
-    set: (path: StorePath, value: any) => void;
-    replace: (path: StorePath, value: any) => void;
-    changed: {
-        func: import("../..").Listener<[]>;
-        isRun: () => boolean;
-        run: () => void;
-        close: () => void;
-        eventClose: (cb: () => void) => () => void;
-        onClose: (cb: () => void) => () => void;
-        removeEventClose: (cb: () => void) => void;
-        on: import("../..").ListenOn<[]>;
-        off: (k: (string | symbol) | import("../..").Listener<[]> | null) => void;
-        addListen: (cb: import("../..").Listener<[]>, opts?: {
-            cbClose?: () => void;
-            key?: string | symbol;
-        }) => () => void;
-        removeListen: (k: (string | symbol) | import("../..").Listener<[]> | null) => void;
-        once: (cb: import("../..").Listener<[]>, opts?: {
-            key?: string | symbol;
-        }) => () => void;
-        count: () => number;
-        readonly getAllKeys: (string | symbol)[];
-    };
-    changedPaths: {
-        func: import("../..").Listener<[ReactiveChange]>;
-        isRun: () => boolean;
-        run: () => void;
-        close: () => void;
-        eventClose: (cb: () => void) => () => void;
-        onClose: (cb: () => void) => () => void;
-        removeEventClose: (cb: () => void) => void;
-        on: import("../..").ListenOn<[ReactiveChange]>;
-        off: (k: (string | symbol) | import("../..").Listener<[ReactiveChange]> | null) => void;
-        addListen: (cb: import("../..").Listener<[ReactiveChange]>, opts?: {
-            cbClose?: () => void;
-            key?: string | symbol;
-        }) => () => void;
-        removeListen: (k: (string | symbol) | import("../..").Listener<[ReactiveChange]> | null) => void;
-        once: (cb: import("../..").Listener<[ReactiveChange]>, opts?: {
-            key?: string | symbol;
-        }) => () => void;
-        count: () => number;
-        readonly getAllKeys: (string | symbol)[];
-    };
+export type StoreRemoteApi<T extends object> = {
+    get(): T;
+    get<M extends StoreMask<T>>(mask: M): StorePick<T, M>;
+    set(path: StorePath, value: any): void;
+    replace(path: StorePath, value: any): void;
+    changed: any;
+    changedPaths: any;
+    patches?: any;
+    changedData?: any;
 };
+export declare function applyStoreMask<T extends object>(store: Store<T>, mask: StoreMask<T> | any, data: any): void;
+export declare function applyStorePatch<T extends object>(store: Store<T>, patch: StorePatch): void;
+export declare function applyStorePatches<T extends object>(store: Store<T>, patches: readonly StorePatch[]): void;
+export declare function createStore<T extends object>(initial: T, opts?: Parameters<typeof reactive<T>>[1]): Store<T>;
+export declare function exposeStore<T extends object>(store: Store<T>, opts?: StoreExposeOpts): StoreRemoteApi<T>;
 export declare function createStoreMirror<T extends object>(remote: RemoteStore<T>, initial?: T, opts?: Parameters<typeof createStore<T>>[1]): Store<T> & {
     sync: <M extends StoreMask<T>>(mask: M, subOpts?: StoreSyncOpts) => Promise<() => void>;
+    syncPatches: <M extends StoreMask<T>>(mask: M, subOpts?: StoreSyncOpts) => Promise<() => void>;
+    syncChangedData: <M extends StoreMask<T>>(mask: M, subOpts?: StoreSyncOpts) => Promise<() => void>;
 };
 export {};

package/lib/Common/ObserveAll2/store.js

@@ -1,8 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyStoreMask = applyStoreMask;
+exports.applyStorePatch = applyStorePatch;
+exports.applyStorePatches = applyStorePatches;
 exports.createStore = createStore;
 exports.exposeStore = exposeStore;
 exports.createStoreMirror = createStoreMirror;
+const Listen_1 = require("../events/Listen");
 const reactive2_1 = require("./reactive2");
 const hasSetImmediate = typeof setImmediate == "function";
 function pathText(path) {
@@ -182,6 +186,19 @@ function applyMask(root, mask, data, base = []) {
     for (const k of Reflect.ownKeys(mask))
         applyMask(root, mask[k], data?.[k], [...base, k]);
 }
+function applyStoreMask(store, mask, data) {
+    applyMask(store.state, mask ?? true, data);
+}
+function applyStorePatch(store, patch) {
+    if (patch.exists === false)
+        deleteAt(store.state, patch.path);
+    else
+        setAt(store.state, patch.path, snapshotValue(patch.value));
+}
+function applyStorePatches(store, patches) {
+    for (const patch of patches)
+        applyStorePatch(store, patch);
+}
 function pathToMask(path) {
     let out = true;
     for (let i = path.length - 1; i >= 0; i--)
@@ -235,6 +252,77 @@ function intersectMaskWithPaths(mask, dirtyPaths) {
     }
     return out;
 }
+function maskFromPaths(paths) {
+    let out = undefined;
+    for (const path of paths)
+        out = mergeMasks(out, pathToMask(path));
+    return out ?? true;
+}
+function makePatch(root, path) {
+    root = (0, reactive2_1.toRaw)(root);
+    const exists = hasAt(root, path);
+    return {
+        path: [...path],
+        exists,
+        value: exists ? snapshotValue(getAt(root, path)) : undefined,
+    };
+}
+function patchesForMask(patch, mask) {
+    const selected = maskPaths(mask ?? true);
+    const out = [];
+    let emittedWholePatch = false;
+    for (const selectedPath of selected) {
+        if (startsWithPath(patch.path, selectedPath)) {
+            if (!emittedWholePatch) {
+                out.push(patch);
+                emittedWholePatch = true;
+            }
+            continue;
+        }
+        if (!startsWithPath(selectedPath, patch.path))
+            continue;
+        const rel = selectedPath.slice(patch.path.length);
+        const exists = patch.exists && hasAt(patch.value, rel);
+        out.push({
+            path: [...selectedPath],
+            exists,
+            value: exists ? snapshotValue(getAt(patch.value, rel)) : undefined,
+        });
+    }
+    return out;
+}
+function createPatchesListen(store) {
+    return (0, Listen_1.funcListenCallbackBase)((emit) => {
+        const off = store.listenPaths().on((change) => {
+            for (const path of change.paths)
+                emit(makePatch(store.state, path));
+        });
+        return off;
+    }, {
+        event: (type, count, api) => {
+            if (type == "add" && count == 1 && !api.isRun())
+                api.run();
+            if (type == "remove" && count == 0 && api.isRun())
+                api.close();
+        },
+    });
+}
+function createChangedDataListen(store) {
+    return (0, Listen_1.funcListenCallbackBase)((emit) => {
+        const off = store.listenPaths().on((change) => {
+            const mask = maskFromPaths(change.paths);
+            emit({ mask, data: pickSnapshot(store.state, mask) });
+        });
+        return off;
+    }, {
+        event: (type, count, api) => {
+            if (type == "add" && count == 1 && !api.isRun())
+                api.run();
+            if (type == "remove" && count == 0 && api.isRun())
+                api.close();
+        },
+    });
+}
 function watchTarget(root, path) {
     let cur = root;
     let lastReactive = root;
@@ -426,9 +514,10 @@ function createStore(initial, opts = {}) {
     };
     return store;
 }
-function exposeStore(store) {
-    return {
-        get: (mask) => mask ? store.update(mask).get() : store.snapshot(),
+function exposeStore(store, opts = {}) {
+    const get = ((mask) => mask ? store.update(mask).get() : store.snapshot());
+    const api = {
+        get,
         set: (path, value) => {
             let node = store.node;
             for (const k of path)
@@ -444,6 +533,14 @@ function exposeStore(store) {
         changed: store.listen(),
         changedPaths: store.listenPaths(),
     };
+    if (opts.push) {
+        api.patches = createPatchesListen(store);
+        api.changedData = createChangedDataListen(store);
+    }
+    return api;
+}
+function isRemoteListen(listen) {
+    return typeof listen?.on == "function" || typeof listen?.addListen == "function";
 }
 function subscribeRemote(listen, cb) {
     let handle;
@@ -466,18 +563,19 @@ function subscribeRemote(listen, cb) {
 }
 function createStoreMirror(remote, initial = {}, opts = {}) {
     const store = createStore(initial, opts);
+    const makeReport = (subOpts) => (error) => {
+        if (subOpts.onError)
+            subOpts.onError(error);
+        else
+            setTimeout(() => { throw error; }, 0);
+    };
+    async function pull(mask) {
+        const snap = await remote.get(mask);
+        applyMask(store.state, mask, snap);
+    }
     async function sync(mask, subOpts = { current: true }) {
         const baseMask = mask ?? true;
-        const report = (error) => {
-            if (subOpts.onError)
-                subOpts.onError(error);
-            else
-                setTimeout(() => { throw error; }, 0);
-        };
-        async function pull(nextMask = baseMask) {
-            const snap = await remote.get(nextMask);
-            applyMask(store.state, nextMask, snap);
-        }
+        const report = makeReport(subOpts);
         if (subOpts.current !== false)
             await pull(baseMask);
         let pendingMask = undefined;
@@ -492,7 +590,7 @@ function createStoreMirror(remote, initial = {}, opts = {}) {
             drained.push();
         };
         const changedPaths = remote.changedPaths;
-        const usePaths = subOpts.partial !== false && (typeof changedPaths?.on == "function" || typeof changedPaths?.addListen == "function");
+        const usePaths = subOpts.partial !== false && isRemoteListen(changedPaths);
         const off = usePaths
             ? subscribeRemote(changedPaths, (change) => {
                 const nextMask = intersectMaskWithPaths(baseMask, change?.paths);
@@ -502,5 +600,58 @@ function createStoreMirror(remote, initial = {}, opts = {}) {
             : subscribeRemote(remote.changed, () => queue(baseMask));
         return () => { drained.close(); off(); };
     }
-    return Object.assign(store, { sync });
+    async function syncPatches(mask, subOpts = { current: true }) {
+        if (!isRemoteListen(remote.patches))
+            throw new Error("createStoreMirror.syncPatches: remote.patches is not exposed");
+        const baseMask = mask ?? true;
+        const report = makeReport(subOpts);
+        if (subOpts.current !== false)
+            await pull(baseMask);
+        const pending = [];
+        const drained = createDrained(() => {
+            const batch = pending.splice(0);
+            try {
+                applyStorePatches(store, batch);
+            }
+            catch (e) {
+                report(e);
+            }
+        }, subOpts.drain);
+        const off = subscribeRemote(remote.patches, (patch) => {
+            const next = patchesForMask(patch, baseMask);
+            if (next.length == 0)
+                return;
+            pending.push(...next);
+            drained.push();
+        });
+        return () => { drained.close(); off(); };
+    }
+    async function syncChangedData(mask, subOpts = { current: true }) {
+        if (!isRemoteListen(remote.changedData))
+            throw new Error("createStoreMirror.syncChangedData: remote.changedData is not exposed");
+        const baseMask = mask ?? true;
+        const report = makeReport(subOpts);
+        if (subOpts.current !== false)
+            await pull(baseMask);
+        const pending = [];
+        const drained = createDrained(() => {
+            const batch = pending.splice(0);
+            try {
+                for (const change of batch) {
+                    const nextMask = intersectMaskWithPaths(baseMask, maskPaths(change?.mask ?? true));
+                    if (nextMask !== undefined)
+                        applyMask(store.state, nextMask, change.data);
+                }
+            }
+            catch (e) {
+                report(e);
+            }
+        }, subOpts.drain);
+        const off = subscribeRemote(remote.changedData, (change) => {
+            pending.push(change);
+            drained.push();
+        });
+        return () => { drained.close(); off(); };
+    }
+    return Object.assign(store, { sync, syncPatches, syncChangedData });
 }

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

@@ -33,6 +33,10 @@ export type ListenStoreOptions<T> = ListenOptions<T> & {
 };
 export declare function getListenByOn(fn: any): any;
 export declare function isListenOn(fn: any): boolean;
+export declare function registerListenOn(on: Function, api: any): void;
+export type ListenOnBrand<Z extends any[] = any[]> = {
+    readonly [LISTEN_ON_BRAND]: Z;
+};
 export declare function funcListenCore<T>(options?: ListenCoreOptions<T>): {
     func: Listener<NormalizeTuple<T>>;
     has: (k: key) => boolean;

package/lib/Common/events/Listen3.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.funcListenCallback = void 0;
 exports.getListenByOn = getListenByOn;
 exports.isListenOn = isListenOn;
+exports.registerListenOn = registerListenOn;
 exports.funcListenCore = funcListenCore;
 exports.funcListenCallbackBase = funcListenCallbackBase;
 exports.funcListenCallbackFast = funcListenCallbackFast;
@@ -16,6 +17,7 @@ exports.isListenCallback = isListenCallback;
 const listenByOn = new WeakMap();
 function getListenByOn(fn) { return typeof fn == 'function' ? listenByOn.get(fn) : undefined; }
 function isListenOn(fn) { return typeof fn == 'function' && listenByOn.has(fn); }
+function registerListenOn(on, api) { listenByOn.set(on, api); }
 function funcListenCore(options = {}) {
     const { fast = true, onRemove, event } = options;
     const subs = new Map();

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

@@ -0,0 +1,45 @@
+import { NormalizeTuple } from './Listen3';
+import { ListenReplayApi, ReplayEvent } from './replay-listen';
+export type ConflateOpts<Z extends any[] = any[]> = {
+    pending: () => number;
+    highWater: number;
+    lowWater?: number;
+    pollMs?: number;
+    keyOf?: (...event: Z) => PropertyKey | null | undefined;
+    maxKeys?: number;
+};
+export declare function conflateReplay<T>(replay: ListenReplayApi<T>, opts: ConflateOpts<NormalizeTuple<T>>): {
+    api: {
+        line: {
+            func: import("./Listen3").Listener<[ReplayEvent<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<NormalizeTuple<T>>]>;
+            off: (k: (string | symbol) | import("./Listen3").Listener<[ReplayEvent<NormalizeTuple<T>>]> | null) => void;
+            addListen: (cb: import("./Listen3").Listener<[ReplayEvent<NormalizeTuple<T>>]>, opts?: {
+                cbClose?: () => void;
+                key?: string | symbol;
+            }) => () => void;
+            removeListen: (k: (string | symbol) | import("./Listen3").Listener<[ReplayEvent<NormalizeTuple<T>>]> | null) => void;
+            once: (cb: import("./Listen3").Listener<[ReplayEvent<NormalizeTuple<T>>]>, opts?: {
+                key?: string | symbol;
+            }) => () => void;
+            count: () => number;
+            readonly getAllKeys: (string | symbol)[];
+        };
+        since: (seq: number) => ReplayEvent<NormalizeTuple<T>>[] | null;
+        keyframe: () => ReplayEvent<NormalizeTuple<T>> | null;
+    };
+    close: () => void;
+    stats: () => {
+        conflating: boolean;
+        dropped: number;
+        keyframes: number;
+        coalesced: number;
+        flushes: number;
+    };
+};