wenay-common2 1.0.48 → 1.0.49

package/lib/Common/ObserveAll2/store.js

@@ -0,0 +1,381 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStore = createStore;
+exports.exposeStore = exposeStore;
+exports.createStoreMirror = createStoreMirror;
+const reactive2_1 = require("./reactive2");
+const hasSetImmediate = typeof setImmediate == "function";
+function pathKey(path) {
+    return path.map(String).join(".");
+}
+function schedule(drain, flush) {
+    if (drain == null) {
+        flush();
+        return;
+    }
+    if (drain == "micro") {
+        queueMicrotask(flush);
+        return;
+    }
+    if (drain == "immediate") {
+        (hasSetImmediate ? setImmediate : setTimeout)(flush, 0);
+        return;
+    }
+    if (typeof drain == "number") {
+        setTimeout(flush, drain);
+        return;
+    }
+    drain(flush);
+}
+function createDrained(fn, drain) {
+    let scheduled = false;
+    let latest = null;
+    let closed = false;
+    return {
+        push(...a) {
+            if (closed)
+                return;
+            if (drain == null) {
+                fn(...a);
+                return;
+            }
+            latest = a;
+            if (scheduled)
+                return;
+            scheduled = true;
+            schedule(drain, () => {
+                scheduled = false;
+                const x = latest;
+                latest = null;
+                if (!closed && x)
+                    fn(...x);
+            });
+        },
+        close() { closed = true; latest = null; },
+    };
+}
+function isObj(v) {
+    return v != null && typeof v == "object";
+}
+function getAt(root, path) {
+    let cur = root;
+    for (const k of path) {
+        if (!isObj(cur))
+            return undefined;
+        cur = cur[k];
+    }
+    return cur;
+}
+function hasAt(root, path) {
+    let cur = root;
+    for (const k of path) {
+        if (!isObj(cur) || !(k in cur))
+            return false;
+        cur = cur[k];
+    }
+    return true;
+}
+function ensureParent(root, path) {
+    let cur = root;
+    for (let i = 0; i < path.length - 1; i++) {
+        const k = path[i];
+        if (!isObj(cur[k]))
+            cur[k] = {};
+        cur = cur[k];
+    }
+    return cur;
+}
+function replaceRoot(root, value) {
+    for (const k of Reflect.ownKeys(root))
+        if (!isObj(value) || !(k in value))
+            delete root[k];
+    if (isObj(value))
+        for (const k of Reflect.ownKeys(value))
+            root[k] = value[k];
+}
+function setAt(root, path, value) {
+    if (path.length == 0) {
+        replaceRoot(root, value);
+        return;
+    }
+    const p = ensureParent(root, path);
+    p[path[path.length - 1]] = value;
+}
+function snapshotValue(value, seen = new WeakMap()) {
+    if (!isObj(value))
+        return value;
+    if (value instanceof Date)
+        return new Date(value.valueOf());
+    if (value instanceof RegExp)
+        return new RegExp(value.source, value.flags);
+    if (value instanceof Map) {
+        const out = new Map();
+        seen.set(value, out);
+        value.forEach((v, k) => out.set(snapshotValue(k, seen), snapshotValue(v, seen)));
+        return out;
+    }
+    if (value instanceof Set) {
+        const out = new Set();
+        seen.set(value, out);
+        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))
+        out[k] = snapshotValue(value[k], seen);
+    return out;
+}
+function maskPaths(mask, base = []) {
+    if (mask === true || mask == null)
+        return [base];
+    if (!isObj(mask))
+        return [base];
+    const out = [];
+    for (const k of Object.keys(mask))
+        out.push(...maskPaths(mask[k], [...base, k]));
+    return out;
+}
+function pickSnapshot(root, mask, base = []) {
+    if (mask === true || mask == null)
+        return snapshotValue(getAt(root, base));
+    const out = {};
+    for (const k of Object.keys(mask))
+        out[k] = pickSnapshot(root, mask[k], [...base, k]);
+    return out;
+}
+function applyMask(root, mask, data, base = []) {
+    if (mask === true || mask == null) {
+        setAt(root, base, snapshotValue(data));
+        return;
+    }
+    for (const k of Object.keys(mask))
+        applyMask(root, mask[k], data?.[k], [...base, k]);
+}
+function watchTarget(root, path) {
+    let cur = root;
+    let lastReactive = root;
+    for (const k of path) {
+        if (!isObj(cur) || !(k in cur))
+            return lastReactive;
+        const next = cur[k];
+        if ((0, reactive2_1.isReactive)(next)) {
+            cur = next;
+            lastReactive = next;
+        }
+        else
+            return lastReactive;
+    }
+    return lastReactive;
+}
+function sameLeaf(a, b, ae, be) {
+    if (ae !== be)
+        return false;
+    if (!ae && !be)
+        return true;
+    return Object.is(a, b);
+}
+function makeCtx(store, path) {
+    return {
+        store,
+        node: getNode(store, path),
+        path: [...path],
+        pathString: pathKey(path),
+        exists: hasAt(store._state, path),
+    };
+}
+function incCount(store, path) {
+    const k = pathKey(path);
+    store._counts.set(k, (store._counts.get(k) ?? 0) + 1);
+}
+function decCount(store, path) {
+    const k = pathKey(path);
+    const n = (store._counts.get(k) ?? 0) - 1;
+    if (n > 0)
+        store._counts.set(k, n);
+    else
+        store._counts.delete(k);
+}
+function subscribePath(store, path, cb, opts = {}, once = false) {
+    let done = false;
+    let offUpdate = null;
+    let lastExists = hasAt(store._state, path);
+    let lastValue = getAt(store._state, path);
+    const drained = createDrained((value, ctx) => {
+        if (done)
+            return;
+        cb(value, ctx);
+        if (once)
+            off();
+    }, opts.drain);
+    function emitNow() {
+        drained.push(getAt(store._state, path), makeCtx(store, path));
+    }
+    function attach() {
+        offUpdate?.();
+        const target = watchTarget(store._state, path);
+        offUpdate = (0, reactive2_1.onUpdate)(target, () => {
+            const exists = hasAt(store._state, path);
+            const value = getAt(store._state, path);
+            const valueIsObject = (0, reactive2_1.isReactive)(value);
+            const watchedSelf = target === value;
+            if (!valueIsObject && !watchedSelf && sameLeaf(lastValue, value, lastExists, exists))
+                return;
+            lastExists = exists;
+            lastValue = value;
+            const nextTarget = watchTarget(store._state, path);
+            if (nextTarget !== target && !done)
+                attach();
+            emitNow();
+        });
+    }
+    function off() {
+        if (done)
+            return;
+        done = true;
+        drained.close();
+        offUpdate?.();
+        offUpdate = null;
+        decCount(store, path);
+    }
+    incCount(store, path);
+    if (opts.current && lastExists) {
+        cb(lastValue, makeCtx(store, path));
+        if (once) {
+            off();
+            return off;
+        }
+    }
+    attach();
+    return off;
+}
+function getNode(store, path) {
+    const k = pathKey(path);
+    const cached = store._nodeCache.get(k);
+    if (cached)
+        return cached;
+    const api = {
+        get path() { return [...path]; },
+        get pathString() { return pathKey(path); },
+        get: () => getAt(store._state, path),
+        has: () => hasAt(store._state, path),
+        snapshot: () => snapshotValue(getAt(store._state, path)),
+        set: (value) => setAt(store._state, path, value),
+        replace: (value) => setAt(store._state, path, value),
+        on: (cb, opts) => subscribePath(store, path, cb, opts, false),
+        once: (cb, opts) => subscribePath(store, path, cb, opts, true),
+        update: (mask, opts) => createSelection(store, path, mask, opts),
+        at: (key) => getNode(store, [...path, key]),
+        count: () => store._counts.get(pathKey(path)) ?? 0,
+    };
+    const proxy = new Proxy(api, {
+        get(target, p) {
+            if (p === "then")
+                return undefined;
+            if (p in target)
+                return target[p];
+            if (typeof p == "symbol")
+                return undefined;
+            return getNode(store, [...path, p]);
+        },
+        ownKeys() {
+            const v = getAt(store._state, path);
+            return isObj(v) ? Reflect.ownKeys(v) : [];
+        },
+        getOwnPropertyDescriptor() { return { enumerable: true, configurable: true }; },
+    });
+    store._nodeCache.set(k, proxy);
+    return proxy;
+}
+function createSelection(store, base, mask, defaults = {}) {
+    const fullPaths = maskPaths(mask, base);
+    const rootNode = getNode(store, base);
+    const ctx = () => ({ store, node: rootNode, mask, paths: fullPaths.map(p => [...p]) });
+    const get = () => pickSnapshot(store._state, mask, base);
+    return {
+        mask,
+        paths: fullPaths.map(p => [...p]),
+        get,
+        on(cb, opts = {}) {
+            const o = { ...defaults, ...opts, current: false };
+            const drained = createDrained(() => cb(get(), ctx()), opts.drain ?? defaults.drain ?? "micro");
+            const offs = fullPaths.map(p => subscribePath(store, p, () => drained.push(), o, false));
+            if ((opts.current ?? defaults.current))
+                cb(get(), ctx());
+            return () => { drained.close(); for (const off of offs)
+                off(); };
+        },
+        once(cb, opts = {}) {
+            let off = () => { };
+            off = this.on((v, c) => { off(); cb(v, c); }, { ...opts, current: opts.current ?? defaults.current });
+            return off;
+        },
+        onEach(cb, opts = {}) {
+            const o = { ...defaults, ...opts };
+            const offs = fullPaths.map(p => subscribePath(store, p, cb, o, false));
+            return () => { for (const off of offs)
+                off(); };
+        },
+    };
+}
+function createStore(initial, opts = {}) {
+    const state = (0, reactive2_1.reactive)(initial, opts);
+    let store;
+    store = {
+        _state: state,
+        _nodeCache: new Map(),
+        _counts: new Map(),
+        state,
+        get node() { return getNode(store, []); },
+        get: () => state,
+        snapshot: () => snapshotValue(state),
+        replace: (value) => replaceRoot(state, value),
+        on: (cb, opts) => getNode(store, []).on(cb, opts),
+        once: (cb, opts) => getNode(store, []).once(cb, opts),
+        update: (mask, opts) => createSelection(store, [], mask, opts),
+        listen: () => (0, reactive2_1.listenUpdate)(state),
+        count: () => Array.from(store._counts.values()).reduce((a, b) => a + b, 0),
+    };
+    return store;
+}
+function exposeStore(store) {
+    return {
+        get: (mask) => mask ? store.update(mask).get() : store.snapshot(),
+        set: (path, value) => {
+            let node = store.node;
+            for (const k of path)
+                node = node.at(k);
+            node.replace(value);
+        },
+        replace: (path, value) => {
+            let node = store.node;
+            for (const k of path)
+                node = node.at(k);
+            node.replace(value);
+        },
+        changed: store.listen(),
+    };
+}
+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);
+        }
+        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?.(); };
+    }
+    return Object.assign(store, { sync });
+}

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

@@ -1,88 +1 @@
-export type Listener<T extends any[]> = (...r: T) => void;
-export type NormalizeTuple<T> = T extends any[] ? T : [T];
-type key = string | symbol;
-declare const LISTEN_ON_BRAND: unique symbol;
-export type ListenOn<Z extends any[] = any[]> = ((cb: Listener<Z>, opts?: {
-    cbClose?: () => void;
-    key?: string;
-}) => (() => void)) & {
-    readonly [LISTEN_ON_BRAND]: Z;
-};
-export declare function getListenByOn(fn: any): any;
-export declare function isListenOn(fn: any): boolean;
-export declare function funcListenCallbackBase<T>(b: (e: Listener<NormalizeTuple<T>>) => (void | (() => void)), { fast, event, addListenClose }?: {
-    event?: (type: "add" | "remove", count: number, api: ReturnType<typeof funcListenCallbackBase<T>>) => void;
-    fast?: boolean;
-    addListenClose?: ReturnType<typeof funcListenCallbackBase<any>>;
-}): {
-    func: Listener<NormalizeTuple<T>>;
-    isRun: () => boolean;
-    run: () => void;
-    close: () => void;
-    eventClose: (cb: () => void) => () => void;
-    onClose: (cb: () => void) => () => void;
-    removeEventClose: (cb: (() => void)) => void;
-    addListen: (cb: Listener<NormalizeTuple<T>>, { cbClose, key }?: {
-        cbClose?: () => void;
-        key?: key;
-    }) => () => void;
-    removeListen: (k: Listener<NormalizeTuple<T>> | null | key) => void;
-    on: ListenOn<NormalizeTuple<T>>;
-    once: (cb: Listener<NormalizeTuple<T>>, opts?: {
-        key?: key;
-    }) => () => void;
-    count: () => number;
-    readonly getAllKeys: (Listener<NormalizeTuple<T>> | key)[];
-};
-export declare function funcListenCallbackFast<T>(a: (e: (Listener<NormalizeTuple<T>> | null)) => (void | (() => void))): {
-    func: Listener<NormalizeTuple<T>>;
-    isRun: () => boolean;
-    run: () => void;
-    close: () => void;
-    eventClose: (cb: () => void) => () => void;
-    onClose: (cb: () => void) => () => void;
-    removeEventClose: (cb: () => void) => void;
-    addListen: (cb: Listener<NormalizeTuple<T>>, { cbClose, key }?: {
-        cbClose?: (() => void) | undefined;
-        key?: key;
-    }) => () => void;
-    removeListen: (k: key | Listener<NormalizeTuple<T>> | null) => void;
-    on: ListenOn<NormalizeTuple<T>>;
-    once: (cb: Listener<NormalizeTuple<T>>, opts?: {
-        key?: key;
-    }) => () => void;
-    count: () => number;
-    readonly getAllKeys: (key | Listener<NormalizeTuple<T>>)[];
-};
-export declare const funcListenCallback: typeof funcListenCallbackBase;
-export declare function UseListen<T>(data?: Parameters<typeof funcListenCallbackBase<T>>[1]): readonly [(...a: NormalizeTuple<T>) => void, {
-    func: Listener<NormalizeTuple<T>>;
-    isRun: () => boolean;
-    run: () => void;
-    close: () => void;
-    eventClose: (cb: () => void) => () => void;
-    onClose: (cb: () => void) => () => void;
-    removeEventClose: (cb: () => void) => void;
-    addListen: (cb: Listener<NormalizeTuple<T>>, { cbClose, key }?: {
-        cbClose?: (() => void) | undefined;
-        key?: key;
-    }) => () => void;
-    removeListen: (k: key | Listener<NormalizeTuple<T>> | null) => void;
-    on: ListenOn<NormalizeTuple<T>>;
-    once: (cb: Listener<NormalizeTuple<T>>, opts?: {
-        key?: key;
-    }) => () => void;
-    count: () => number;
-    readonly getAllKeys: (key | Listener<NormalizeTuple<T>>)[];
-}];
-export type Listen2<T> = {
-    on: (cb: Listener<NormalizeTuple<T>>, opts?: {
-        key?: string;
-    }) => (() => void);
-    close: () => void;
-    count: () => number;
-};
-export declare function toListen2<T>(full: ReturnType<typeof funcListenCallbackBase<T>>): Listen2<T>;
-export declare function UseListen2<T>(data?: Parameters<typeof funcListenCallbackBase<T>>[1]): readonly [(...a: NormalizeTuple<T>) => void, Listen2<T>];
-export declare function isListenCallback(obj: any): obj is ReturnType<typeof funcListenCallbackBase>;
-export {};
+export * from "./Listen3";

package/lib/Common/events/Listen.js

@@ -1,191 +1,17 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.funcListenCallback = void 0;
-exports.getListenByOn = getListenByOn;
-exports.isListenOn = isListenOn;
-exports.funcListenCallbackBase = funcListenCallbackBase;
-exports.funcListenCallbackFast = funcListenCallbackFast;
-exports.UseListen = UseListen;
-exports.toListen2 = toListen2;
-exports.UseListen2 = UseListen2;
-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 funcListenCallbackBase(b, { fast = true, event, addListenClose } = {}) {
-    const obj = new Map();
-    const cbKeys = new Map();
-    let evClose = null;
-    let sinh = null;
-    let a = (...e) => { obj.forEach(z => z(...e)); };
-    let close = null;
-    let cached = null;
-    let closeUnsubscribe = null;
-    const getArr = () => cached ?? (cached = Array.from(obj.values()));
-    const rebuild = () => {
-        cached = null;
-        const size = obj.size;
-        if (size === 0) {
-            a = null;
-            return;
-        }
-        if (size === 1) {
-            a = obj.values().next().value;
-            return;
-        }
-        if (size === 2) {
-            const [a0, a1] = getArr();
-            a = ((...e) => { a0(...e); a1(...e); });
-            return;
-        }
-        a = ((...e) => {
-            const ar = getArr();
-            for (let i = 0, len = ar.length; i < len; i++)
-                ar[i](...e);
-        });
-    };
-    const func = (...e) => { a?.(...e); };
-    function forgetKey(k) {
-        const removed = obj.get(k);
-        if (typeof removed == "function") {
-            const keys = cbKeys.get(removed);
-            if (keys) {
-                const i = keys.indexOf(k);
-                if (i >= 0)
-                    keys.splice(i, 1);
-                if (keys.length == 0)
-                    cbKeys.delete(removed);
-            }
-        }
-        const e = evClose?.get(k);
-        evClose?.delete(k);
-        if (e) {
-            evClose?.delete(e);
-            sinh?.delete(e);
-        }
-    }
-    function removeKey(k) {
-        if (!obj.has(k))
-            return;
-        obj.delete(k);
-        forgetKey(k);
-        if (fast)
-            rebuild();
-        event?.("remove", obj.size, api);
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
     }
-    const run = () => {
-        close = (b(func) ?? (() => { }));
-        if (addListenClose && !closeUnsubscribe) {
-            closeUnsubscribe = addListenClose.addListen(() => {
-                api.close();
-            });
-        }
-    };
-    const api = {
-        func,
-        isRun: () => close !== null,
-        run,
-        close: () => {
-            close?.();
-            close = null;
-            obj.clear();
-            cbKeys.clear();
-            if (fast)
-                rebuild();
-            sinh = null;
-            if (evClose) {
-                evClose.forEach(cb => cb());
-                evClose = null;
-            }
-            if (closeUnsubscribe) {
-                closeUnsubscribe();
-                closeUnsubscribe = null;
-            }
-        },
-        eventClose: (cb) => {
-            evClose = evClose ?? new Map();
-            evClose.set(cb, cb);
-            return () => { evClose?.delete(cb); };
-        },
-        onClose: (cb) => api.eventClose(cb),
-        removeEventClose: (cb) => {
-            const e = sinh?.get(cb);
-            if (e)
-                evClose?.delete(e);
-            sinh?.delete(cb);
-            evClose?.delete(cb);
-        },
-        addListen: (cb, { cbClose, key } = {}) => {
-            const k = key ?? Symbol();
-            if (obj.has(k))
-                forgetKey(k);
-            obj.set(k, cb);
-            let keys = cbKeys.get(cb);
-            if (!keys)
-                cbKeys.set(cb, keys = []);
-            keys.push(k);
-            if (cbClose) {
-                evClose = evClose ?? new Map();
-                evClose.set(k, cbClose);
-                sinh = sinh ?? new Map();
-                sinh.set(cbClose, cb);
-            }
-            if (fast)
-                rebuild();
-            event?.("add", obj.size, api);
-            return () => removeKey(k);
-        },
-        removeListen: (k) => {
-            if (typeof k == "function" && !obj.has(k))
-                for (const kk of [...(cbKeys.get(k) ?? [])])
-                    removeKey(kk);
-            else
-                removeKey(k);
-        },
-        on: ((cb, opts = {}) => api.addListen(cb, opts)),
-        once: (cb, opts = {}) => {
-            let off = () => { };
-            off = api.addListen(((...e) => { off(); cb(...e); }), opts);
-            return off;
-        },
-        count: () => obj.size,
-        get getAllKeys() { return [...obj.keys()]; }
-    };
-    listenByOn.set(api.on, api);
-    return api;
-}
-function funcListenCallbackFast(a) {
-    return funcListenCallbackBase(a, { fast: true });
-}
-exports.funcListenCallback = funcListenCallbackBase;
-function UseListen(data = { fast: true }) {
-    let t;
-    const a = funcListenCallbackBase((e) => { t = e; }, { fast: true, ...data });
-    a.run();
-    t = a.func;
-    return [t, a];
-}
-function toListen2(full) {
-    return {
-        on: (cb, opts) => full.addListen(cb, opts),
-        close: () => full.close(),
-        count: () => full.count(),
-    };
-}
-function UseListen2(data = { fast: true }) {
-    const [emit, full] = UseListen(data);
-    return [emit, toListen2(full)];
-}
-const LISTEN_CORE = ["func", "addListen", "removeListen", "eventClose", "removeEventClose"];
-function isListenCallback(obj) {
-    if (obj == null || typeof obj !== "object")
-        return false;
-    const ks = new Set(Object.keys(obj));
-    for (const k of LISTEN_CORE)
-        if (!ks.has(k))
-            return false;
-    for (const k of LISTEN_CORE)
-        if (typeof obj[k] !== "function")
-            return false;
-    return true;
-}
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Listen3"), exports);

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

@@ -0,0 +1 @@
+export * from "./Listen3";

package/lib/Common/events/Listen2.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Listen3"), exports);