wenay-common2 1.0.50 → 1.0.53

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

@@ -1,4 +1,8 @@
 type Fn = () => void;
+export type ReactiveChange = {
+    paths: PropertyKey[][];
+};
+type PathUpdateFn = (change: ReactiveChange) => void;
 type Drain = 'micro' | 'immediate' | number | ((flush: Fn) => void);
 export type Opts = {
     drain?: Drain;
@@ -7,7 +11,9 @@ export type Opts = {
 };
 export declare function reactive<T extends object>(root: T, opts?: Opts): T;
 export declare function isReactive(p: any): boolean;
+export declare function toRaw<T>(p: T): T;
 export declare function onUpdate(p: any, cb: Fn): () => void;
+export declare function onUpdatePaths(p: any, cb: PathUpdateFn): () => void;
 export declare function flushReactive(p: any): Promise<void>;
 export declare function listenUpdate(p: any): {
     func: import("../events/Listen3").Listener<[]>;
@@ -18,6 +24,7 @@ export declare function listenUpdate(p: any): {
     onClose: (cb: () => void) => () => void;
     removeEventClose: (cb: () => void) => void;
     on: import("../events/Listen3").ListenOn<[]>;
+    off: (k: (string | symbol) | import("../events/Listen3").Listener<[]> | null) => void;
     addListen: (cb: import("../events/Listen3").Listener<[]>, opts?: {
         cbClose?: () => void;
         key?: string | symbol;
@@ -29,5 +36,26 @@ export declare function listenUpdate(p: any): {
     count: () => number;
     readonly getAllKeys: (string | symbol)[];
 };
+export declare function listenUpdatePaths(p: any): {
+    func: import("../events/Listen3").Listener<[ReactiveChange]>;
+    isRun: () => boolean;
+    run: () => void;
+    close: () => void;
+    eventClose: (cb: () => void) => () => void;
+    onClose: (cb: () => void) => () => void;
+    removeEventClose: (cb: () => void) => void;
+    on: import("../events/Listen3").ListenOn<[ReactiveChange]>;
+    off: (k: (string | symbol) | import("../events/Listen3").Listener<[ReactiveChange]> | null) => void;
+    addListen: (cb: import("../events/Listen3").Listener<[ReactiveChange]>, opts?: {
+        cbClose?: () => void;
+        key?: string | symbol;
+    }) => () => void;
+    removeListen: (k: (string | symbol) | import("../events/Listen3").Listener<[ReactiveChange]> | null) => void;
+    once: (cb: import("../events/Listen3").Listener<[ReactiveChange]>, opts?: {
+        key?: string | symbol;
+    }) => () => void;
+    count: () => number;
+    readonly getAllKeys: (string | symbol)[];
+};
 export type Reactive<T extends object> = T;
 export {};

package/lib/Common/ObserveAll2/reactive2.js

@@ -2,9 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.reactive = reactive;
 exports.isReactive = isReactive;
+exports.toRaw = toRaw;
 exports.onUpdate = onUpdate;
+exports.onUpdatePaths = onUpdatePaths;
 exports.flushReactive = flushReactive;
 exports.listenUpdate = listenUpdate;
+exports.listenUpdatePaths = listenUpdatePaths;
 const Listen_1 = require("../events/Listen");
 const NODE = Symbol('reactive2.node');
 const isObj = (v) => v != null && typeof v == 'object';
@@ -30,7 +33,7 @@ function reactive(root, opts = {}) {
     const { drain = 'immediate', depth = Infinity, eager = false } = opts;
     const fire = scheduler(drain);
     const eng = {
-        live: 0, dirty: new Set(), scheduled: false, waiters: new Set(), depth,
+        live: 0, pathLive: 0, dirty: new Set(), dirtyPaths: [], scheduled: false, waiters: new Set(), depth,
         schedule() {
             if (eng.scheduled)
                 return;
@@ -39,8 +42,10 @@ function reactive(root, opts = {}) {
                 eng.scheduled = false;
                 const batch = [...eng.dirty];
                 eng.dirty.clear();
+                const dirtyPaths = eng.dirtyPaths;
+                eng.dirtyPaths = [];
                 let err;
-                for (const n of batch)
+                for (const n of batch) {
                     for (const cb of [...n.subs]) {
                         try {
                             cb();
@@ -49,7 +54,20 @@ function reactive(root, opts = {}) {
                             err ??= e;
                         }
                     }
-                if (!eng.scheduled && eng.dirty.size == 0) {
+                    if (n.pathSubs.size) {
+                        const paths = pathsForNode(n, dirtyPaths);
+                        if (paths.length)
+                            for (const cb of [...n.pathSubs]) {
+                                try {
+                                    cb({ paths });
+                                }
+                                catch (e) {
+                                    err ??= e;
+                                }
+                            }
+                    }
+                }
+                if (!eng.scheduled && eng.dirty.size == 0 && eng.dirtyPaths.length == 0) {
                     const waiters = [...eng.waiters];
                     eng.waiters.clear();
                     for (const w of waiters)
@@ -60,13 +78,16 @@ function reactive(root, opts = {}) {
             });
         },
     };
-    const rootNode = makeNode(root, null, 0, eng);
+    const rootNode = makeNode(root, null, [], 0, eng);
     if (eager)
         prewalk(rootNode);
     return rootNode.proxy;
 }
-function makeNode(target, parent, level, eng) {
-    const node = { target, parent, active: true, level, subs: new Set(), kids: new Map(), proxy: null, eng };
+function makeNode(target, parent, path, level, eng) {
+    const node = {
+        target, parent, path, active: true, level,
+        subs: new Set(), pathSubs: new Set(), kids: new Map(), proxy: null, eng,
+    };
     const proxyTarget = (Array.isArray(target) ? [] : {});
     node.proxy = new Proxy(proxyTarget, {
         get(_, k) {
@@ -78,7 +99,7 @@ function makeNode(target, parent, level, eng) {
             if (isReactiveObj(v) && level < eng.depth) {
                 let kid = node.kids.get(k);
                 if (!kid) {
-                    kid = makeNode(v, node, level + 1, eng);
+                    kid = makeNode(v, node, [...node.path, k], level + 1, eng);
                     node.kids.set(k, kid);
                 }
                 else if (kid.target !== v)
@@ -88,8 +109,10 @@ function makeNode(target, parent, level, eng) {
             return v;
         },
         set(_, k, v) {
+            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;
@@ -97,21 +120,23 @@ function makeNode(target, parent, level, eng) {
             if (kid)
                 rebind(kid, v);
             if (eng.live > 0)
-                bubble(node);
+                bubble(node, dirtyPath);
             return true;
         },
         defineProperty(_, k, d) {
             const old = node.target[k];
-            const ok = Reflect.defineProperty(node.target, k, d);
+            const desc = 'value' in d ? { ...d, value: toRaw(d.value) } : d;
+            const ok = Reflect.defineProperty(node.target, k, desc);
             if (!ok)
                 return false;
-            if (d.configurable === false) {
-                const mirror = Reflect.defineProperty(proxyTarget, k, d);
+            if (desc.configurable === false) {
+                const mirror = Reflect.defineProperty(proxyTarget, k, desc);
                 if (!mirror)
                     return false;
             }
             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))
@@ -123,13 +148,14 @@ function makeNode(target, parent, level, eng) {
                     }
                 }
                 if (eng.live > 0)
-                    bubble(node);
+                    bubble(node, dirtyPath);
             }
             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) {
@@ -138,7 +164,7 @@ function makeNode(target, parent, level, eng) {
                 detachTree(kid);
             }
             if (eng.live > 0)
-                bubble(node);
+                bubble(node, dirtyPath);
             return true;
         },
         has(_, k) { return k in node.target; },
@@ -165,16 +191,18 @@ function makeNode(target, parent, level, eng) {
     });
     return node;
 }
-function bubble(from) {
+function bubble(from, dirtyPath) {
     const eng = from.eng;
+    if (eng.pathLive > 0 && dirtyPath)
+        addDirtyPath(eng, dirtyPath);
     for (let n = from; n && n.active; n = n.parent)
-        if (n.subs.size)
+        if (n.subs.size || n.pathSubs.size)
             eng.dirty.add(n);
     eng.schedule();
 }
 function rebind(node, next) {
     node.target = next;
-    if (node.subs.size)
+    if (node.subs.size || node.pathSubs.size)
         node.eng.dirty.add(node);
     for (const [k, kid] of [...node.kids]) {
         const cv = isReactiveObj(next) ? next[k] : undefined;
@@ -188,11 +216,37 @@ function rebind(node, next) {
     }
 }
 function markChanged(node) {
-    if (node.subs.size)
+    if (node.subs.size || node.pathSubs.size)
         node.eng.dirty.add(node);
     for (const kid of node.kids.values())
         markChanged(kid);
 }
+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 samePath(a, b) {
+    return a.length == b.length && a.every((k, i) => Object.is(k, b[i]));
+}
+function startsWithPath(path, prefix) {
+    return prefix.length <= path.length && prefix.every((k, i) => Object.is(k, path[i]));
+}
+function pathsForNode(node, dirtyPaths) {
+    const out = [];
+    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);
+    }
+    return out;
+}
 function detachTree(node) {
     if (!node.active)
         return;
@@ -218,6 +272,10 @@ function isReactive(p) {
     const node = p && p[NODE];
     return !!node && node.active;
 }
+function toRaw(p) {
+    const node = p && p[NODE];
+    return node ? node.target : p;
+}
 function onUpdate(p, cb) {
     const node = p && p[NODE];
     if (!node)
@@ -232,12 +290,33 @@ function onUpdate(p, cb) {
         return; done = true; if (node.subs.delete(sub))
         node.eng.live--; };
 }
+function onUpdatePaths(p, cb) {
+    const node = p && p[NODE];
+    if (!node)
+        throw new Error('onUpdatePaths: not a reactive object');
+    if (!node.active)
+        throw new Error('onUpdatePaths: reactive object is detached');
+    const sub = (change) => cb(change);
+    node.pathSubs.add(sub);
+    node.eng.live++;
+    node.eng.pathLive++;
+    let done = false;
+    return () => {
+        if (done)
+            return;
+        done = true;
+        if (node.pathSubs.delete(sub)) {
+            node.eng.live--;
+            node.eng.pathLive--;
+        }
+    };
+}
 function flushReactive(p) {
     const node = p && p[NODE];
     if (!node)
         throw new Error('flushReactive: not a reactive object');
     const eng = node.eng;
-    if (!eng.scheduled && eng.dirty.size == 0)
+    if (!eng.scheduled && eng.dirty.size == 0 && eng.dirtyPaths.length == 0)
         return Promise.resolve();
     return new Promise(resolve => { eng.waiters.add(resolve); });
 }
@@ -252,3 +331,14 @@ function listenUpdate(p) {
     });
     return listen;
 }
+function listenUpdatePaths(p) {
+    const listen = (0, Listen_1.funcListenCallbackBase)((emit) => onUpdatePaths(p, change => emit(change)), {
+        event: (type, count, api) => {
+            if (type == "add" && count == 1 && !api.isRun())
+                api.run();
+            if (type == "remove" && count == 0 && api.isRun())
+                api.close();
+        },
+    });
+    return listen;
+}

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

@@ -1,4 +1,4 @@
-import { listenUpdate, reactive } from "./reactive2";
+import { listenUpdate, listenUpdatePaths, reactive, ReactiveChange } from "./reactive2";
 export type StorePath = readonly PropertyKey[];
 export type StoreDrain = "micro" | "immediate" | number | ((flush: () => void) => void);
 export type StoreSubOpts = {
@@ -6,6 +6,11 @@ export type StoreSubOpts = {
     drain?: StoreDrain;
     key?: string;
 };
+export type StoreChange = ReactiveChange;
+export type StoreSyncOpts = StoreSubOpts & {
+    partial?: boolean;
+    onError?: (error: any) => void;
+};
 export type StoreCtx<T = any> = {
     store: Store<any>;
     node: StoreNode<T>;
@@ -60,11 +65,13 @@ export type Store<T extends object> = {
     once(cb: (value: T, ctx: StoreCtx<T>) => void, opts?: StoreSubOpts): () => void;
     update<M extends StoreMask<T>>(mask: M, opts?: StoreSubOpts): StoreSelection<T, M>;
     listen(): ReturnType<typeof listenUpdate>;
+    listenPaths(): ReturnType<typeof listenUpdatePaths>;
     count(): number;
 };
 type RemoteStore<T extends object> = {
     get(mask?: any): T | Promise<T>;
     changed: any;
+    changedPaths?: 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>): {
@@ -72,20 +79,42 @@ export declare function exposeStore<T extends object>(store: Store<T>): {
     set: (path: StorePath, value: any) => void;
     replace: (path: StorePath, value: any) => void;
     changed: {
-        func: import("../events/Listen3").Listener<[]>;
+        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("../events/Listen3").ListenOn<[]>;
-        addListen: (cb: import("../events/Listen3").Listener<[]>, opts?: {
+        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("../events/Listen3").Listener<[]> | null) => void;
-        once: (cb: import("../events/Listen3").Listener<[]>, opts?: {
+        removeListen: (k: (string | symbol) | import("../..").Listener<[ReactiveChange]> | null) => void;
+        once: (cb: import("../..").Listener<[ReactiveChange]>, opts?: {
             key?: string | symbol;
         }) => () => void;
         count: () => number;
@@ -93,6 +122,6 @@ export declare function exposeStore<T extends object>(store: Store<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?: StoreSubOpts) => Promise<() => void>;
+    sync: <M extends StoreMask<T>>(mask: M, subOpts?: StoreSyncOpts) => Promise<() => void>;
 };
 export {};

package/lib/Common/ObserveAll2/store.js

@@ -5,9 +5,22 @@ exports.exposeStore = exposeStore;
 exports.createStoreMirror = createStoreMirror;
 const reactive2_1 = require("./reactive2");
 const hasSetImmediate = typeof setImmediate == "function";
-function pathKey(path) {
+function pathText(path) {
     return path.map(String).join(".");
 }
+const symbolIds = new Map();
+let nextSymbolId = 1;
+function symbolKey(k) {
+    let id = symbolIds.get(k);
+    if (id == null) {
+        id = nextSymbolId++;
+        symbolIds.set(k, id);
+    }
+    return id;
+}
+function pathKey(path) {
+    return JSON.stringify(path.map(k => typeof k == "symbol" ? ["symbol", symbolKey(k)] : ["key", String(k)]));
+}
 function schedule(drain, flush) {
     if (drain == null) {
         flush();
@@ -102,6 +115,7 @@ function setAt(root, path, value) {
     p[path[path.length - 1]] = value;
 }
 function snapshotValue(value, seen = new WeakMap()) {
+    value = (0, reactive2_1.toRaw)(value);
     if (!isObj(value))
         return value;
     if (value instanceof Date)
@@ -135,26 +149,92 @@ function maskPaths(mask, base = []) {
     if (!isObj(mask))
         return [base];
     const out = [];
-    for (const k of Object.keys(mask))
+    for (const k of Reflect.ownKeys(mask))
         out.push(...maskPaths(mask[k], [...base, k]));
     return out;
 }
 function pickSnapshot(root, mask, base = []) {
+    root = (0, reactive2_1.toRaw)(root);
     if (mask === true || mask == null)
         return snapshotValue(getAt(root, base));
     const out = {};
-    for (const k of Object.keys(mask))
+    for (const k of Reflect.ownKeys(mask))
         out[k] = pickSnapshot(root, mask[k], [...base, k]);
     return out;
 }
+function deleteAt(root, path) {
+    if (path.length == 0) {
+        replaceRoot(root, {});
+        return;
+    }
+    const parent = getAt(root, path.slice(0, -1));
+    if (isObj(parent))
+        delete parent[path[path.length - 1]];
+}
 function applyMask(root, mask, data, base = []) {
     if (mask === true || mask == null) {
-        setAt(root, base, snapshotValue(data));
+        if (data === undefined && base.length)
+            deleteAt(root, base);
+        else
+            setAt(root, base, snapshotValue(data));
         return;
     }
-    for (const k of Object.keys(mask))
+    for (const k of Reflect.ownKeys(mask))
         applyMask(root, mask[k], data?.[k], [...base, k]);
 }
+function pathToMask(path) {
+    let out = true;
+    for (let i = path.length - 1; i >= 0; i--)
+        out = { [path[i]]: out };
+    return out;
+}
+function hasMaskKey(mask, key) {
+    return isObj(mask) && Reflect.ownKeys(mask).some(k => Object.is(k, key));
+}
+function mergeMasks(a, b) {
+    if (a === undefined)
+        return b;
+    if (b === undefined)
+        return a;
+    if (a === true || a == null || b === true || b == null)
+        return true;
+    if (!isObj(a) || !isObj(b))
+        return true;
+    const out = {};
+    for (const k of Reflect.ownKeys(a))
+        out[k] = a[k];
+    for (const k of Reflect.ownKeys(b)) {
+        out[k] = hasMaskKey(a, k) ? mergeMasks(a[k], b[k]) : b[k];
+    }
+    return out;
+}
+function startsWithPath(path, prefix) {
+    return prefix.length <= path.length && prefix.every((k, i) => Object.is(k, path[i]));
+}
+function intersectMaskWithPaths(mask, dirtyPaths) {
+    const baseMask = mask ?? true;
+    if (!Array.isArray(dirtyPaths))
+        return baseMask;
+    if (dirtyPaths.length == 0)
+        return undefined;
+    const selected = maskPaths(baseMask);
+    let out = undefined;
+    for (const dirty of dirtyPaths) {
+        if (!Array.isArray(dirty))
+            continue;
+        if (dirty.length == 0) {
+            out = mergeMasks(out, baseMask);
+            continue;
+        }
+        for (const selectedPath of selected) {
+            if (startsWithPath(dirty, selectedPath))
+                out = mergeMasks(out, pathToMask(dirty));
+            else if (startsWithPath(selectedPath, dirty))
+                out = mergeMasks(out, pathToMask(selectedPath));
+        }
+    }
+    return out;
+}
 function watchTarget(root, path) {
     let cur = root;
     let lastReactive = root;
@@ -183,7 +263,7 @@ function makeCtx(store, path) {
         store,
         node: getNode(store, path),
         path: [...path],
-        pathString: pathKey(path),
+        pathString: pathText(path),
         exists: hasAt(store._state, path),
     };
 }
@@ -259,7 +339,7 @@ function getNode(store, path) {
         return cached;
     const api = {
         get path() { return [...path]; },
-        get pathString() { return pathKey(path); },
+        get pathString() { return pathText(path); },
         get: () => getAt(store._state, path),
         has: () => hasAt(store._state, path),
         snapshot: () => snapshotValue(getAt(store._state, path)),
@@ -309,8 +389,12 @@ function createSelection(store, base, mask, defaults = {}) {
                 off(); };
         },
         once(cb, opts = {}) {
+            let done = false;
             let off = () => { };
-            off = this.on((v, c) => { off(); cb(v, c); }, { ...opts, current: opts.current ?? defaults.current });
+            off = this.on(function fireOnce(v, c) { if (done)
+                return; done = true; off(); cb(v, c); }, { ...opts, current: opts.current ?? defaults.current });
+            if (done)
+                off();
             return off;
         },
         onEach(cb, opts = {}) {
@@ -337,6 +421,7 @@ function createStore(initial, opts = {}) {
         once: (cb, opts) => getNode(store, []).once(cb, opts),
         update: (mask, opts) => createSelection(store, [], mask, 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),
     };
     return store;
@@ -357,25 +442,65 @@ function exposeStore(store) {
             node.replace(value);
         },
         changed: store.listen(),
+        changedPaths: store.listenPaths(),
+    };
+}
+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
+        return () => { };
+    return () => {
+        if (typeof handle == "function")
+            handle();
+        else if (typeof handle?.off == "function")
+            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 = {}) {
     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);
+        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);
         }
         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?.(); };
+            await pull(baseMask);
+        let pendingMask = undefined;
+        let chain = Promise.resolve();
+        const drained = createDrained(() => {
+            const nextMask = pendingMask === undefined ? baseMask : pendingMask;
+            pendingMask = undefined;
+            chain = chain.then(() => pull(nextMask)).catch(report);
+        }, subOpts.drain);
+        const queue = (nextMask) => {
+            pendingMask = pendingMask === undefined ? nextMask : mergeMasks(pendingMask, nextMask);
+            drained.push();
+        };
+        const changedPaths = remote.changedPaths;
+        const usePaths = subOpts.partial !== false && (typeof changedPaths?.on == "function" || typeof changedPaths?.addListen == "function");
+        const off = usePaths
+            ? subscribeRemote(changedPaths, (change) => {
+                const nextMask = intersectMaskWithPaths(baseMask, change?.paths);
+                if (nextMask !== undefined)
+                    queue(nextMask);
+            })
+            : subscribeRemote(remote.changed, () => queue(baseMask));
+        return () => { drained.close(); off(); };
     }
     return Object.assign(store, { sync });
 }

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

@@ -37,6 +37,7 @@ export declare function funcListenCore<T>(options?: ListenCoreOptions<T>): {
     func: Listener<NormalizeTuple<T>>;
     has: (k: key) => boolean;
     on: ListenOn<NormalizeTuple<T>>;
+    off: (k: Listener<NormalizeTuple<T>> | null | key) => void;
     addListen: (cb: Listener<NormalizeTuple<T>>, opts?: {
         key?: key;
     }) => () => void;
@@ -58,11 +59,12 @@ export declare function funcListenCallbackBase<T>(b: (e: Listener<NormalizeTuple
     onClose: (cb: cbClose) => () => void;
     removeEventClose: (cb: cbClose) => void;
     on: ListenOn<NormalizeTuple<T>>;
+    off: (k: key | Listener<NormalizeTuple<T>> | null) => void;
     addListen: (cb: Listener<NormalizeTuple<T>>, opts?: {
         cbClose?: cbClose;
         key?: key;
     }) => () => void;
-    removeListen: (k: key | Listener<NormalizeTuple<T>> | null) => void;
+    removeListen: (k: Listener<NormalizeTuple<T>> | null | key) => void;
     once: (cb: Listener<NormalizeTuple<T>>, opts?: {
         key?: key;
     }) => () => void;
@@ -79,6 +81,7 @@ export declare function funcListenCallbackFast<T>(a: (e: (Listener<NormalizeTupl
     onClose: (cb: cbClose) => () => void;
     removeEventClose: (cb: cbClose) => void;
     on: ListenOn<NormalizeTuple<T>>;
+    off: (k: key | Listener<NormalizeTuple<T>> | null) => void;
     addListen: (cb: Listener<NormalizeTuple<T>>, opts?: {
         cbClose?: cbClose;
         key?: key;
@@ -100,6 +103,7 @@ export declare function UseListen<T>(data?: ListenOptions<T>): readonly [(...a:
     onClose: (cb: cbClose) => () => void;
     removeEventClose: (cb: cbClose) => void;
     on: ListenOn<NormalizeTuple<T>>;
+    off: (k: key | Listener<NormalizeTuple<T>> | null) => void;
     addListen: (cb: Listener<NormalizeTuple<T>>, opts?: {
         cbClose?: cbClose;
         key?: key;
@@ -118,6 +122,7 @@ export declare function withStoreListen<T>(base: ListenApi<T>, currentProvider:
         key?: key;
         current?: ListenCurrent<NormalizeTuple<T>>;
     }) => () => void;
+    removeListen: (k: Listener<NormalizeTuple<T>> | null | key) => void;
     once: (cb: Listener<NormalizeTuple<T>>, opts?: {
         key?: key;
         current?: ListenCurrent<NormalizeTuple<T>>;
@@ -130,7 +135,7 @@ export declare function withStoreListen<T>(base: ListenApi<T>, currentProvider:
     eventClose: (cb: cbClose) => () => void;
     onClose: (cb: cbClose) => () => void;
     removeEventClose: (cb: cbClose) => void;
-    removeListen: (k: key | Listener<NormalizeTuple<T>> | null) => void;
+    off: (k: key | Listener<NormalizeTuple<T>> | null) => void;
     count: () => number;
 };
 export type ListenStoreApi<T> = ReturnType<typeof withStoreListen<T>>;
@@ -141,6 +146,7 @@ export declare function funcListenCallbackStore<T>(b: (e: Listener<NormalizeTupl
         key?: key;
         current?: ListenCurrent<NormalizeTuple<T>> | undefined;
     }) => () => void;
+    removeListen: (k: key | Listener<NormalizeTuple<T>> | null) => void;
     once: (cb: Listener<NormalizeTuple<T>>, opts?: {
         key?: key;
         current?: ListenCurrent<NormalizeTuple<T>> | undefined;
@@ -153,7 +159,7 @@ export declare function funcListenCallbackStore<T>(b: (e: Listener<NormalizeTupl
     eventClose: (cb: cbClose) => () => void;
     onClose: (cb: cbClose) => () => void;
     removeEventClose: (cb: cbClose) => void;
-    removeListen: (k: key | Listener<NormalizeTuple<T>> | null) => void;
+    off: (k: key | Listener<NormalizeTuple<T>> | null) => void;
     count: () => number;
 };
 export declare function UseListenStore<T>(data: ListenStoreOptions<T>): readonly [(...a: NormalizeTuple<T>) => void, {
@@ -163,6 +169,7 @@ export declare function UseListenStore<T>(data: ListenStoreOptions<T>): readonly
         key?: key;
         current?: ListenCurrent<NormalizeTuple<T>> | undefined;
     }) => () => void;
+    removeListen: (k: key | Listener<NormalizeTuple<T>> | null) => void;
     once: (cb: Listener<NormalizeTuple<T>>, opts?: {
         key?: key;
         current?: ListenCurrent<NormalizeTuple<T>> | undefined;
@@ -175,13 +182,14 @@ export declare function UseListenStore<T>(data: ListenStoreOptions<T>): readonly
     eventClose: (cb: cbClose) => () => void;
     onClose: (cb: cbClose) => () => void;
     removeEventClose: (cb: cbClose) => void;
-    removeListen: (k: key | Listener<NormalizeTuple<T>> | null) => void;
+    off: (k: key | Listener<NormalizeTuple<T>> | null) => void;
     count: () => number;
 }];
 export declare function toListen2<T>(full: ListenApi<T>): {
     on: (cb: Listener<NormalizeTuple<T>>, opts?: {
         key?: key;
     }) => () => void;
+    off: (k: Listener<NormalizeTuple<T>> | null | key) => void;
     close: () => void;
     count: () => number;
 };
@@ -190,6 +198,7 @@ export declare function UseListen2<T>(data?: ListenOptions<T>): readonly [(...a:
     on: (cb: Listener<NormalizeTuple<T>>, opts?: {
         key?: key;
     } | undefined) => () => void;
+    off: (k: key | Listener<NormalizeTuple<T>> | null) => void;
     close: () => void;
     count: () => number;
 }];

package/lib/Common/events/Listen3.js

@@ -68,8 +68,7 @@ function funcListenCore(options = {}) {
             event?.('add', subs.size, api);
             return function off() { removeOne(k); };
         }),
-        addListen: (cb, opts = {}) => api.on(cb, opts),
-        removeListen: (k) => {
+        off: (k) => {
             if (typeof k == 'function') {
                 for (const [kk, cb] of [...subs])
                     if (cb === k)
@@ -79,6 +78,8 @@ function funcListenCore(options = {}) {
             if (k != null)
                 removeOne(k);
         },
+        addListen: (cb, opts = {}) => api.on(cb, opts),
+        removeListen: (k) => api.off(k),
         once: (cb, opts = {}) => {
             let off = () => { };
             off = api.on(((...e) => { off(); cb(...e); }), opts);
@@ -151,8 +152,9 @@ function funcListenCallbackBase(b, options = {}) {
             event?.('add', core.count(), api);
             return off;
         }),
+        off: core.off,
         addListen: (cb, opts = {}) => api.on(cb, opts),
-        removeListen: core.removeListen,
+        removeListen: (k) => api.off(k),
         once: (cb, opts = {}) => {
             let off = () => { };
             off = api.on(((...e) => { off(); cb(...e); }), opts);
@@ -193,6 +195,7 @@ function withStoreListen(base, currentProvider) {
             return off;
         }),
         addListen: (cb, opts = {}) => api.on(cb, opts),
+        removeListen: (k) => api.off(k),
         once: (cb, opts = {}) => {
             if (opts.current) {
                 const m = currentValue(opts.current);
@@ -226,6 +229,7 @@ function UseListenStore(data) {
 function toListen2(full) {
     return {
         on: (cb, opts) => full.on(cb, opts),
+        off: (k) => full.off(k),
         close: () => full.close(),
         count: () => full.count(),
     };

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

@@ -33,6 +33,7 @@ export declare function funcListenCallbackSnapshot<T extends realSocket2<any | a
         onClose: (cb: () => void) => () => void;
         removeEventClose: (cb: () => void) => void;
         on: import("./Listen3").ListenOn<[data: getTypeCallback<T>, memo: T3]>;
+        off: (k: (string | symbol) | import("./Listen3").Listener<[data: getTypeCallback<T>, memo: T3]> | null) => void;
         addListen: (cb: import("./Listen3").Listener<[data: getTypeCallback<T>, memo: T3]>, opts?: {
             cbClose?: () => void;
             key?: string | symbol;

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

@@ -13,6 +13,7 @@ export declare function SocketServerHook(opt?: {
             onClose: (cb: () => void) => () => void;
             removeEventClose: (cb: () => void) => void;
             on: import("./Listen3").ListenOn<[unknown]>;
+            off: (k: (string | symbol) | import("./Listen3").Listener<[unknown]> | null) => void;
             addListen: (cb: import("./Listen3").Listener<[unknown]>, opts?: {
                 cbClose?: () => void;
                 key?: string | symbol;
@@ -34,6 +35,7 @@ export declare function SocketServerHook(opt?: {
         onClose: (cb: () => void) => () => void;
         removeEventClose: (cb: () => void) => void;
         on: import("./Listen3").ListenOn<[unknown]>;
+        off: (k: (string | symbol) | import("./Listen3").Listener<[unknown]> | null) => void;
         addListen: (cb: import("./Listen3").Listener<[unknown]>, opts?: {
             cbClose?: () => void;
             key?: string | symbol;
@@ -55,6 +57,7 @@ export declare function WebSocketServerHook(s: ReturnType<typeof SocketServerHoo
             on: (z: (...args: any[]) => void) => import("../rcp/listen-socket").tSubHandle;
             once: (z: (...args: any[]) => void) => import("../rcp/listen-socket").tSubHandle;
             close: () => void;
+            off: () => boolean;
             removeCallback: () => boolean;
         };
     };

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

@@ -10,6 +10,7 @@ export declare function UseListenTransform<TSource extends any[], TTarget extend
     onClose: (cb: () => void) => () => void;
     removeEventClose: (cb: () => void) => void;
     on: import("./Listen3").ListenOn<NormalizeTuple<TTarget>>;
+    off: (k: (string | symbol) | Listener<NormalizeTuple<TTarget>> | null) => void;
     addListen: (cb: Listener<NormalizeTuple<TTarget>>, opts?: {
         cbClose?: () => void;
         key?: string | symbol;

package/lib/Common/rcp/createRpcServerAutoWithProtocolDetection.js

@@ -13,7 +13,7 @@ function createRpcServerAuto2({ socket, object: target, socketKey: key, debug =
     const listenSockets = new Set();
     function unsubscribeAllActive() {
         for (const w of [...listenSockets])
-            w.removeCallback();
+            w.off();
     }
     function getListenSocket(parent) {
         let result = cache.get(parent);
@@ -24,10 +24,10 @@ function createRpcServerAuto2({ socket, object: target, socketKey: key, debug =
             function subscribe(z) {
                 if (typeof z !== "function")
                     return Promise.reject(new TypeError("Listen callback expects a function"));
-                subs.get(z)?.removeCallback();
+                subs.get(z)?.off();
                 const w = (0, listen_socket_1.listenSocket)(parent, { addListenClose: disconnectListen });
                 subs.set(z, w);
-                const done = w.callback(z);
+                const done = w.on(z);
                 done.then(() => { if (subs.get(z) == w)
                     subs.delete(z); });
                 return done;
@@ -35,7 +35,7 @@ function createRpcServerAuto2({ socket, object: target, socketKey: key, debug =
             function subscribeOnce(z) {
                 if (typeof z !== "function")
                     return Promise.reject(new TypeError("Listen once expects a function"));
-                subs.get(z)?.removeCallback();
+                subs.get(z)?.off();
                 const w = (0, listen_socket_1.listenSocket)(parent, { addListenClose: disconnectListen });
                 subs.set(z, w);
                 const done = w.once(z);
@@ -44,11 +44,11 @@ function createRpcServerAuto2({ socket, object: target, socketKey: key, debug =
                 return done;
             }
             function unsubscribeAll() {
-                subs.forEach(w => w.removeCallback());
+                subs.forEach(w => w.off());
                 subs.clear();
                 return true;
             }
-            result = { callback: subscribe, removeCallback: unsubscribeAll, on: subscribe, once: subscribeOnce, close: () => parent.close?.() };
+            result = { on: subscribe, off: unsubscribeAll, callback: subscribe, removeCallback: unsubscribeAll, once: subscribeOnce, close: () => parent.close?.() };
             listenSockets.add(result);
             cache.set(parent, result);
         }

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

@@ -2,6 +2,7 @@ import { funcListenCallbackBase, type Listener } from "../events/Listen";
 import { type Off } from "./rpc-off";
 type ListenCallbackResult<T extends any[] = any[]> = ReturnType<typeof funcListenCallbackBase<T>>;
 export type tSubHandle = Off<void, {
+    off: () => void;
     unsubscribe: () => void;
     removeCallback: () => void;
 }>;
@@ -12,9 +13,10 @@ export declare function listenSocket<Z extends any[] = any[]>(e: ListenCallbackR
     readonly paramsModify?: (...e: Z) => any[];
     readonly throttle?: number;
 }): {
+    on: (z: Listener<Z>) => Promise<void>;
+    off: () => boolean;
     callback: (z: Listener<Z>) => Promise<void>;
     removeCallback: () => boolean;
-    on: (z: Listener<Z>) => Promise<void>;
     once: (z: Listener<Z>) => Promise<void>;
     close: () => void;
 };
@@ -23,6 +25,7 @@ export declare function listenSocketFirst<Z extends any[] = any[]>(e: ListenCall
     on: (z: (a: Z[0]) => void) => tSubHandle;
     once: (z: (a: Z[0]) => void) => tSubHandle;
     close: () => void;
+    off: () => boolean;
     removeCallback: () => boolean;
 };
 export declare function listenSocketAll<Z extends any[] = any[]>(e: ListenCallbackResult<Z>, options?: Omit<Parameters<typeof listenSocket>[1], "paramsModify">): {
@@ -30,6 +33,7 @@ export declare function listenSocketAll<Z extends any[] = any[]>(e: ListenCallba
     on: (z: (...args: Z) => void) => tSubHandle;
     once: (z: (...args: Z) => void) => tSubHandle;
     close: () => void;
+    off: () => boolean;
     removeCallback: () => boolean;
 };
 type SmartCallback<Z extends any[]> = Z extends [infer Single] ? (a: Single) => void : (...args: Z) => void;
@@ -38,6 +42,7 @@ export declare function listenSocketSmart<Z extends any[] = any[]>(e: ListenCall
     on: (z: SmartCallback<Z>) => tSubHandle;
     once: (z: SmartCallback<Z>) => tSubHandle;
     close: () => void;
+    off: () => boolean;
     removeCallback: () => boolean;
 };
 export {};

package/lib/Common/rcp/listen-socket.js

@@ -58,7 +58,7 @@ function listenSocket(e, d) {
             resolveWait = null;
         }
     }
-    function removeCallback() {
+    function off() {
         if (throttleCh) {
             throttleCh.cancel();
             throttleCh = null;
@@ -79,9 +79,10 @@ function listenSocket(e, d) {
         finish();
         return true;
     }
-    function callback(z) {
+    const removeCallback = off;
+    function on(z) {
         if (typeof z !== "function") {
-            throw new TypeError("listenSocket.callback expects a function");
+            throw new TypeError("listenSocket.on expects a function");
         }
         if (last)
             stop?.(last);
@@ -110,7 +111,7 @@ function listenSocket(e, d) {
                 if (status())
                     wrapped(...a);
                 else
-                    removeCallback();
+                    off();
             };
         }
         let inner = handler;
@@ -146,12 +147,12 @@ function listenSocket(e, d) {
             }
             inner(...a);
         };
-        activeOff = subscribe(active, { cbClose: removeCallback });
-        closeSignalOff = subscribeClose?.(removeCallback) ?? null;
+        activeOff = subscribe(active, { cbClose: off });
+        closeSignalOff = subscribeClose?.(off) ?? null;
         const wait = new Promise((resolve) => {
             resolveWait = () => { resolve(); };
         });
-        return (0, rpc_off_1.makeOff)(wait, removeCallback, { unsubscribe: removeCallback, removeCallback });
+        return (0, rpc_off_1.makeOff)(wait, off, { off, unsubscribe: off, removeCallback });
     }
     function once(z) {
         if (typeof z !== "function") {
@@ -160,7 +161,7 @@ function listenSocket(e, d) {
         let fired = false;
         const oneShot = ((...a) => {
             if (a[0] === rpc_protocol_1.RPC_STOP) {
-                removeCallback();
+                off();
                 return;
             }
             if (fired)
@@ -171,13 +172,18 @@ function listenSocket(e, d) {
             }
             finally {
                 (0, rpc_off_1.endCallback)(z);
-                removeCallback();
+                off();
             }
         });
-        return callback(oneShot);
+        return on(oneShot);
     }
     function closeStream() { e.close?.(); }
-    return { callback, removeCallback, on: callback, once, close: closeStream };
+    function callback(z) {
+        if (typeof z !== "function")
+            throw new TypeError("listenSocket.callback expects a function");
+        return on(z);
+    }
+    return { on, off, callback, removeCallback, once, close: closeStream };
 }
 function listenSocketFirst(e, options) {
     const r = listenSocket(e, {
@@ -186,9 +192,10 @@ function listenSocketFirst(e, options) {
     });
     return {
         callback: r.callback,
-        on: r.callback,
+        on: r.on,
         once: r.once,
         close: r.close,
+        off: r.off,
         removeCallback: r.removeCallback,
     };
 }
@@ -196,9 +203,10 @@ function listenSocketAll(e, options) {
     const r = listenSocket(e, { ...options });
     return {
         callback: r.callback,
-        on: r.callback,
+        on: r.on,
         once: r.once,
         close: r.close,
+        off: r.off,
         removeCallback: r.removeCallback,
     };
 }
@@ -206,9 +214,10 @@ function listenSocketSmart(e, options) {
     const r = listenSocket(e, { ...options });
     return {
         callback: r.callback,
-        on: r.callback,
+        on: r.on,
         once: r.once,
         close: r.close,
+        off: r.off,
         removeCallback: r.removeCallback,
     };
 }

package/lib/Common/rcp/rpc-client.js

@@ -348,7 +348,7 @@ function createClient(socket, key, opts) {
             if (sub.consumers.size == 0)
                 sub.stop();
         };
-        return (0, rpc_off_1.makeOff)(p, unsub, { unsubscribe: unsub, removeCallback: unsub });
+        return (0, rpc_off_1.makeOff)(p, unsub, { off: unsub, unsubscribe: unsub, removeCallback: unsub });
     }
     const sendCall = (path, args, wait) => {
         const last = path[path.length - 1];

package/lib/Common/rcp/rpc-server-auto.js

@@ -10,7 +10,7 @@ function createRpcServerAuto({ socket, object: target, socketKey: key, debug, ho
     const registry = new Map();
     function unsubscribeAllActive() {
         for (const { subs } of registry.values()) {
-            subs.forEach(w => w.removeCallback());
+            subs.forEach(w => w.off());
             subs.clear();
         }
         registry.clear();
@@ -26,10 +26,10 @@ function createRpcServerAuto({ socket, object: target, socketKey: key, debug, ho
                     return Promise.resolve();
                 if (!registry.has(parent))
                     registry.set(parent, { subs });
-                subs.get(z)?.removeCallback();
+                subs.get(z)?.off();
                 const w = (0, listen_socket_1.listenSocket)(parent, { addListenClose: disconnectListen, throttle });
                 subs.set(z, w);
-                const done = w.callback(z);
+                const done = w.on(z);
                 done.then(() => {
                     if (subs.get(z) == w)
                         subs.delete(z);
@@ -45,7 +45,7 @@ function createRpcServerAuto({ socket, object: target, socketKey: key, debug, ho
                     return Promise.resolve();
                 if (!registry.has(parent))
                     registry.set(parent, { subs });
-                subs.get(z)?.removeCallback();
+                subs.get(z)?.off();
                 const w = (0, listen_socket_1.listenSocket)(parent, { addListenClose: disconnectListen, throttle });
                 let fired = false;
                 const oneShot = (...a) => {
@@ -57,23 +57,23 @@ function createRpcServerAuto({ socket, object: target, socketKey: key, debug, ho
                         z(rpc_protocol_1.RPC_STOP);
                     }
                     finally {
-                        w.removeCallback();
+                        w.off();
                     }
                 };
                 subs.set(z, w);
-                const done = w.callback(oneShot);
+                const done = w.on(oneShot);
                 done.then(() => { if (subs.get(z) == w)
                     subs.delete(z); if (subs.size == 0)
                     registry.delete(parent); });
                 return done;
             }
             function unsubscribeAll() {
-                subs.forEach(w => w.removeCallback());
+                subs.forEach(w => w.off());
                 subs.clear();
                 registry.delete(parent);
                 return true;
             }
-            result = { callback: subscribe, removeCallback: unsubscribeAll, on: subscribe, once: subscribeOnce, close: () => parent.close?.() };
+            result = { on: subscribe, off: unsubscribeAll, callback: subscribe, removeCallback: unsubscribeAll, once: subscribeOnce, close: () => parent.close?.() };
             result[rpc_protocol_1.IS_RPC_LISTEN] = true;
             cache.set(parent, result);
         }

package/lib/Common/rcp/rpc-server.js

@@ -12,6 +12,7 @@ const SERVERS = new WeakMap();
 function createServer(socket, key, target, hooks, limits, auth, opt) {
     const lim = (0, rpc_limits_1.resolveLimits)(limits);
     const IS_RPC_PIPE = Symbol.for("isRpcPipe");
+    const hasRpcListen = (obj) => !!obj && typeof obj == "object" && Object.prototype.hasOwnProperty.call(obj, rpc_protocol_1.IS_RPC_LISTEN);
     function transformTree(obj) {
         let current = obj;
         if (hooks?.resolveTransform && !(0, rpc_dynamic_1.isNoStrict)(current)) {
@@ -20,7 +21,7 @@ function createServer(socket, key, target, hooks, limits, auth, opt) {
         if (current == null || typeof current != "object" || (0, rpc_dynamic_1.isNoStrict)(current))
             return current;
         const out = {};
-        if (current[rpc_protocol_1.IS_RPC_LISTEN])
+        if (hasRpcListen(current))
             out[rpc_protocol_1.IS_RPC_LISTEN] = true;
         for (const k of Object.keys(current)) {
             if (!(0, rpc_limits_1.isSafeKey)(k))
@@ -82,7 +83,7 @@ function createServer(socket, key, target, hooks, limits, auth, opt) {
                     cx.push(obj);
                 }
                 else if (v && typeof v == "object" && !(0, rpc_dynamic_1.isNoStrict)(v)) {
-                    if (v[rpc_protocol_1.IS_RPC_LISTEN])
+                    if (hasRpcListen(v))
                         lp.push(path);
                     index(v, path);
                 }

package/package.json

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