wenay-common2 1.0.58 → 1.0.61

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

@@ -1,4 +1,4 @@
-import { Store, StorePatch } from './store';
+import { Store, StorePatch, StoreDrain, StoreEachCtx } from './store';
 import { ReplayListenOptions, ReplayEvent } from '../events/replay-listen';
 import { ReplayRemote, ReplaySubscribeOpts } from '../events/replay-wire';
 import { ReplayStorage } from '../events/replay-history';
@@ -77,6 +77,16 @@ export declare function syncStoreReplay<T extends object>(store: Store<T>, remot
     isStale: () => boolean;
     lastTs: () => number;
 };
+export declare function syncStoreReplayEach<T extends object>(remote: ReplayRemote<[StorePatch]>, cb: (key: string, value: T[keyof T] | undefined, ctx: StoreEachCtx) => void, opts?: ReplaySubscribeOpts & {
+    drain?: StoreDrain;
+    initial?: T;
+}): (() => void) & {
+    store: Store<T>;
+    ready: Promise<void>;
+    seq: () => number;
+    isStale: () => boolean;
+    lastTs: () => number;
+};
 export declare function storeReplayAt<T extends object>(storage: ReplayStorage<[StorePatch]>, at?: {
     seq?: number;
     ts?: number;

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

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.storePatchKey = storePatchKey;
 exports.exposeStoreReplay = exposeStoreReplay;
 exports.syncStoreReplay = syncStoreReplay;
+exports.syncStoreReplayEach = syncStoreReplayEach;
 exports.storeReplayAt = storeReplayAt;
 const store_1 = require("./store");
 const replay_listen_1 = require("../events/replay-listen");
@@ -54,6 +55,20 @@ function exposeStoreReplay(store, opts = {}) {
 function syncStoreReplay(store, remote, opts = {}) {
     return (0, replay_wire_1.replaySubscribe)(remote, function applyLine(patch) { (0, store_1.applyStorePatch)(store, patch); }, opts);
 }
+function syncStoreReplayEach(remote, cb, opts = {}) {
+    const { drain, initial, ...wireOpts } = opts;
+    const store = (0, store_1.createStore)((initial ?? {}), drain !== undefined ? { drain } : {});
+    const offEach = store.each().on(cb);
+    const sub = syncStoreReplay(store, remote, wireOpts);
+    function off() { offEach(); sub(); }
+    return Object.assign(off, {
+        store,
+        ready: sub.ready,
+        seq: sub.seq,
+        isStale: sub.isStale,
+        lastTs: sub.lastTs,
+    });
+}
 function storeReplayAt(storage, at = {}) {
     const envelopes = (0, replay_history_1.openHistory)(storage).at(at);
     if (!envelopes)

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

@@ -1,3 +1,4 @@
+import { funcListenCallbackBase } from "../events/Listen";
 import { listenUpdate, listenUpdatePaths, reactive, ReactiveChange } from "./reactive2";
 export type StorePath = readonly PropertyKey[];
 export type StoreDrain = "micro" | "immediate" | number | ((flush: () => void) => void);
@@ -67,6 +68,12 @@ export type StoreSelectionCtx<T, M> = {
     mask: M;
     paths: PropertyKey[][];
 };
+export type StoreEachOpts = {
+    depth?: number;
+};
+export type StoreEachCtx = {
+    path: PropertyKey[];
+};
 export type Store<T extends object> = {
     readonly state: T;
     readonly node: StoreNode<T>;
@@ -76,6 +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]>>;
     listen(): ReturnType<typeof listenUpdate>;
     listenPaths(): ReturnType<typeof listenUpdatePaths>;
     count(): number;

package/lib/Common/ObserveAll2/store.js

@@ -307,6 +307,48 @@ 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)));
+        function emitKey(key) {
+            const raw = (0, reactive2_1.toRaw)(store.state);
+            const exists = isObj(raw) && key in raw;
+            if (exists)
+                known.add(key);
+            else
+                known.delete(key);
+            emit(key, exists ? store.state[key] : undefined, { path: [key] });
+        }
+        const off = store.listenPaths().on(function eachStoreChange(change) {
+            const keys = new Set();
+            let root = false;
+            for (const path of change.paths) {
+                if (path.length == 0)
+                    root = true;
+                else
+                    keys.add(path[0]);
+            }
+            if (root) {
+                for (const key of Reflect.ownKeys((0, reactive2_1.toRaw)(store.state)))
+                    keys.add(key);
+                for (const key of known)
+                    keys.add(key);
+            }
+            for (const key of keys)
+                emitKey(key);
+        });
+        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) => {
@@ -458,6 +500,7 @@ function getNode(store, path) {
     store._nodeCache.set(k, proxy);
     return proxy;
 }
+let warnedRootOnEach = false;
 function createSelection(store, base, mask, defaults = {}) {
     const fullPaths = maskPaths(mask, base);
     const rootNode = getNode(store, base);
@@ -486,6 +529,10 @@ function createSelection(store, base, mask, defaults = {}) {
             return off;
         },
         onEach(cb, opts = {}) {
+            if (fullPaths.some(p => p.length == base.length) && !warnedRootOnEach) {
+                warnedRootOnEach = true;
+                console.warn("store: update(true).onEach fires ONCE per drain window with the WHOLE value (per selected path, not per key). For per-changed-key delivery use store.each(); for a subset — an explicit key mask.");
+            }
             const o = { ...defaults, ...opts };
             const offs = fullPaths.map(p => subscribePath(store, p, cb, o, false));
             return () => { for (const off of offs)
@@ -508,6 +555,7 @@ function createStore(initial, opts = {}) {
         on: (cb, opts) => getNode(store, []).on(cb, 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),
         count: () => Array.from(store._counts.values()).reduce((a, b) => a + b, 0),

package/lib/Common/rcp/listen-deep.d.ts

@@ -9,7 +9,7 @@ type WithSubHandle<R> = R extends {
     once: (...a: A) => tSubHandle & Promise<void>;
 } : R;
 type Obj = Record<string, any>;
-type InferArgs<T> = T extends {
+export type InferArgs<T> = T extends {
     addListen: (cb: (...args: infer R) => void, ...rest: any[]) => any;
 } ? R : never;
 export type ReplaySocketListen<Z extends any[]> = WithSubHandle<ReturnType<typeof listenSocket<Z>>> & {
@@ -19,7 +19,7 @@ export type ReplaySocketListen<Z extends any[]> = WithSubHandle<ReturnType<typeo
     keyframe: () => Promise<ReplayEvent<Z> | null>;
     frame: (seq: number, hint?: unknown) => Promise<ReplayEvent<Z>[]>;
 };
-type IsReplayMember<V> = V extends {
+export type IsReplayMember<V> = V extends {
     addListen: Function;
     getSince: Function;
     keyframe: Function;

package/lib/Common/rcp/rpc-client.d.ts

@@ -2,6 +2,7 @@ import { type SocketTmpl } from "./rpc-protocol";
 import { type RpcLimits } from "./rpc-limits";
 import { makeOff } from "./rpc-off";
 import { type RpcOpt } from "./rpc-caps";
+import type { IsReplayMember, InferArgs, ReplaySocketListen } from "./listen-deep";
 type UnwrapPromise<T> = T extends Promise<infer R> ? R : T;
 export type DeepDataOnly<T> = T extends Function ? never : T extends readonly any[] ? {
     [I in keyof T]: DeepDataOnly<T[I]>;
@@ -9,11 +10,11 @@ export type DeepDataOnly<T> = T extends Function ? never : T extends readonly an
     [K in keyof T as T[K] extends Function ? never : K]: DeepDataOnly<T[K]>;
 } : T;
 export type ClientAPIAll<T> = {
-    [K in keyof T as T[K] extends Function ? K : T[K] extends object ? K : never]: T[K] extends (...args: infer A) => infer R ? (...args: A) => Promise<DeepDataOnly<UnwrapPromise<R>>> : T[K] extends object ? ClientAPIAll<T[K]> : never;
+    [K in keyof T as T[K] extends Function ? K : T[K] extends object ? K : never]: IsReplayMember<T[K]> extends true ? ReplaySocketListen<InferArgs<T[K]>> : T[K] extends (...args: infer A) => infer R ? (...args: A) => Promise<DeepDataOnly<UnwrapPromise<R>>> : T[K] extends object ? ClientAPIAll<T[K]> : never;
 };
 type NonFalsy<T> = Exclude<T, false | null | 0 | "" | undefined>;
 export type ClientAPIStrict<T> = {
-    [K in keyof T as NonFalsy<T[K]> extends Function ? K : NonFalsy<T[K]> extends object ? K : never]: NonFalsy<T[K]> extends (...args: infer A) => infer R ? (...args: A) => Promise<DeepDataOnly<UnwrapPromise<R>>> : NonFalsy<T[K]> extends object ? ClientAPIStrict<NonFalsy<T[K]>> : never;
+    [K in keyof T as NonFalsy<T[K]> extends Function ? K : NonFalsy<T[K]> extends object ? K : never]: IsReplayMember<NonFalsy<T[K]>> extends true ? ReplaySocketListen<InferArgs<NonFalsy<T[K]>>> : NonFalsy<T[K]> extends (...args: infer A) => infer R ? (...args: A) => Promise<DeepDataOnly<UnwrapPromise<R>>> : NonFalsy<T[K]> extends object ? ClientAPIStrict<NonFalsy<T[K]>> : never;
 };
 export interface PipeArrayAPI<T> extends Promise<DeepDataOnly<T[]>> {
     [index: number]: PipeAPI<T>;

package/package.json

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