wenay-common2 1.0.62 → 1.0.63

package/lib/Common/Observe/reactive2.js

@@ -1,374 +1,17 @@
 "use strict";
-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';
-const isReactiveObj = (v) => {
-    if (!isObj(v))
-        return false;
-    if (Array.isArray(v))
-        return true;
-    const p = Object.getPrototypeOf(v);
-    return p == Object.prototype || p == null;
-};
-const hasSetImmediate = typeof setImmediate == 'function';
-function scheduler(drain) {
-    if (drain == 'micro')
-        return f => queueMicrotask(f);
-    if (typeof drain == 'number')
-        return f => { setTimeout(f, drain); };
-    if (typeof drain == 'function')
-        return f => drain(f);
-    return hasSetImmediate ? f => { setImmediate(f); } : f => { setTimeout(f, 0); };
-}
-function reactive(root, opts = {}) {
-    const { drain = 'immediate', depth = Infinity, eager = false } = opts;
-    const fire = scheduler(drain);
-    const eng = {
-        live: 0, pathLive: 0, dirty: new Set(), dirtyPaths: [],
-        dirtyPathKeys: new Set(), pathKey: createPathKeyer(),
-        scheduled: false, waiters: new Set(), depth,
-        schedule() {
-            if (eng.scheduled)
-                return;
-            eng.scheduled = true;
-            fire(function flush() {
-                eng.scheduled = false;
-                const batch = [...eng.dirty];
-                eng.dirty.clear();
-                const dirtyPaths = eng.dirtyPaths;
-                eng.dirtyPaths = [];
-                eng.dirtyPathKeys = new Set();
-                eng.pathKey = createPathKeyer();
-                let err;
-                for (const n of batch) {
-                    for (const cb of [...n.subs]) {
-                        try {
-                            cb();
-                        }
-                        catch (e) {
-                            err ??= e;
-                        }
-                    }
-                    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)
-                        w();
-                }
-                if (err !== undefined)
-                    setTimeout(() => { throw err; }, 0);
-            });
-        },
-    };
-    const rootNode = makeNode(root, null, [], 0, eng);
-    if (eager)
-        prewalk(rootNode);
-    return rootNode.proxy;
-}
-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) {
-            if (k == NODE)
-                return node;
-            if (k == 'toJSON' && Array.isArray(proxyTarget) && !Array.isArray(node.target) && node.target?.toJSON === undefined)
-                return () => node.target;
-            const v = node.target[k];
-            if (isReactiveObj(v) && level < eng.depth) {
-                let kid = node.kids.get(k);
-                if (!kid) {
-                    kid = makeNode(v, node, [...node.path, k], level + 1, eng);
-                    node.kids.set(k, kid);
-                }
-                else if (kid.target !== v)
-                    kid.target = v;
-                return kid.proxy;
-            }
-            return v;
-        },
-        set(_, k, v) {
-            v = toRaw(v);
-            if (Object.is(node.target[k], v))
-                return true;
-            node.target[k] = v;
-            if (Array.isArray(proxyTarget) && k == "length")
-                proxyTarget.length = v;
-            const kid = node.kids.get(k);
-            if (kid)
-                rebind(kid, v);
-            if (eng.live > 0)
-                bubble(node, k);
-            return true;
-        },
-        defineProperty(_, k, d) {
-            const old = node.target[k];
-            const desc = 'value' in d ? { ...d, value: toRaw(d.value) } : d;
-            const ok = Reflect.defineProperty(node.target, k, desc);
-            if (!ok)
-                return false;
-            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 kid = node.kids.get(k);
-                if (kid) {
-                    if (isReactiveObj(v))
-                        rebind(kid, v);
-                    else {
-                        node.kids.delete(k);
-                        markChanged(kid);
-                        detachTree(kid);
-                    }
-                }
-                if (eng.live > 0)
-                    bubble(node, k);
-            }
-            return true;
-        },
-        deleteProperty(_, k) {
-            if (!(k in node.target))
-                return true;
-            delete node.target[k];
-            const kid = node.kids.get(k);
-            if (kid) {
-                node.kids.delete(k);
-                markChanged(kid);
-                detachTree(kid);
-            }
-            if (eng.live > 0)
-                bubble(node, k);
-            return true;
-        },
-        has(_, k) { return k in node.target; },
-        ownKeys() {
-            const keys = Reflect.ownKeys(node.target);
-            for (const k of Reflect.ownKeys(proxyTarget)) {
-                const d = Reflect.getOwnPropertyDescriptor(proxyTarget, k);
-                if (d?.configurable === false && !keys.includes(k))
-                    keys.push(k);
-            }
-            return keys;
-        },
-        getOwnPropertyDescriptor(_, k) {
-            if (Array.isArray(proxyTarget) && k == "length")
-                return Reflect.getOwnPropertyDescriptor(proxyTarget, k);
-            const pd = Reflect.getOwnPropertyDescriptor(proxyTarget, k);
-            if (pd && pd.configurable === false)
-                return pd;
-            const d = Reflect.getOwnPropertyDescriptor(node.target, k);
-            if (d)
-                d.configurable = true;
-            return d;
-        },
-    });
-    return node;
-}
-function bubble(from, key) {
-    const eng = from.eng;
-    if (eng.pathLive > 0)
-        addDirtyPath(eng, dirtyPathFor(from, key));
-    for (let n = from; n && n.active; n = n.parent)
-        if (n.subs.size || n.pathSubs.size)
-            eng.dirty.add(n);
-    eng.schedule();
-}
-function rebind(node, next) {
-    node.target = next;
-    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;
-        if (isReactiveObj(cv))
-            rebind(kid, cv);
-        else {
-            node.kids.delete(k);
-            markChanged(kid);
-            detachTree(kid);
-        }
-    }
-}
-function markChanged(node) {
-    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 createPathKeyer() {
-    let symIds = null;
-    return function pathKey(path) {
-        let out = '';
-        for (const p of path) {
-            if (typeof p == 'symbol') {
-                symIds ??= new Map();
-                let id = symIds.get(p);
-                if (id == null) {
-                    id = symIds.size;
-                    symIds.set(p, id);
-                }
-                out += 'y' + id + '|';
-            }
-            else {
-                const s = String(p);
-                out += (typeof p)[0] + s.length + ':' + s + '|';
-            }
-        }
-        return out;
-    };
-}
-function addDirtyPath(eng, path) {
-    const k = eng.pathKey(path);
-    if (eng.dirtyPathKeys.has(k))
-        return;
-    eng.dirtyPathKeys.add(k);
-    eng.dirtyPaths.push(path);
-}
-function startsWithPath(path, prefix) {
-    return prefix.length <= path.length && prefix.every((k, i) => Object.is(k, path[i]));
-}
-function pathsForNode(node, dirtyPaths) {
-    const out = [];
-    const seen = new Set();
-    const pathKey = createPathKeyer();
-    for (const path of dirtyPaths) {
-        let next = null;
-        if (startsWithPath(path, node.path))
-            next = path.slice(node.path.length);
-        else if (startsWithPath(node.path, path))
-            next = [];
-        if (next == null)
-            continue;
-        const k = pathKey(next);
-        if (seen.has(k))
-            continue;
-        seen.add(k);
-        out.push(next);
+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]; } };
     }
-    return out;
-}
-function detachTree(node) {
-    if (!node.active)
-        return;
-    node.active = false;
-    node.parent = null;
-    for (const kid of node.kids.values())
-        detachTree(kid);
-    node.kids.clear();
-}
-function prewalk(node) {
-    if (node.level >= node.eng.depth)
-        return;
-    for (const k of Reflect.ownKeys(node.target)) {
-        if (isReactiveObj(node.target[k])) {
-            node.proxy[k];
-            const kid = node.kids.get(k);
-            if (kid)
-                prewalk(kid);
-        }
-    }
-}
-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)
-        throw new Error('onUpdate: not a reactive object');
-    if (!node.active)
-        throw new Error('onUpdate: reactive object is detached');
-    const sub = () => cb();
-    node.subs.add(sub);
-    node.eng.live++;
-    let done = false;
-    return () => { if (done)
-        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 && eng.dirtyPaths.length == 0)
-        return Promise.resolve();
-    return new Promise(resolve => { eng.waiters.add(resolve); });
-}
-function listenUpdate(p) {
-    const listen = (0, Listen_1.createListen)((emit) => onUpdate(p, () => emit()), {
-        event: (type, count, api) => {
-            if (type == "add" && count == 1 && !api.isRunning())
-                api.run();
-            if (type == "remove" && count == 0 && api.isRunning())
-                api.close();
-        },
-    });
-    return listen;
-}
-function listenUpdatePaths(p) {
-    const listen = (0, Listen_1.createListen)((emit) => onUpdatePaths(p, change => emit(change)), {
-        event: (type, count, api) => {
-            if (type == "add" && count == 1 && !api.isRunning())
-                api.run();
-            if (type == "remove" && count == 0 && api.isRunning())
-                api.close();
-        },
-    });
-    return listen;
-}
+    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("./reactive"), exports);

package/lib/Common/Observe/store-manager.d.ts

@@ -0,0 +1,123 @@
+import { ReplayRemote, ReplaySubscribeOpts } from '../events/replay-wire';
+import { createStore, Store, StoreMask, StorePatch, StoreSyncOpts } from './store';
+import { OfflineStorage, OfflineStore } from './store-offline';
+type RemoteStore<T extends object> = {
+    get(mask?: any): T | Promise<T>;
+    changed: any;
+    changedPaths?: any;
+    patches?: any;
+    changedData?: any;
+};
+export type StoreMirror<T extends object> = Store<T> & {
+    sync<M extends StoreMask<T>>(mask: M, opts?: StoreSyncOpts): Promise<() => void>;
+    syncPatches<M extends StoreMask<T>>(mask: M, opts?: StoreSyncOpts): Promise<() => void>;
+    syncChangedData<M extends StoreMask<T>>(mask: M, opts?: StoreSyncOpts): Promise<() => void>;
+};
+export type ManagedStoreKind = 'mirror' | 'replay' | 'offline';
+export type ManagedStoreState = 'idle' | 'starting' | 'ready' | 'stopped' | 'error';
+export type ManagedStoreSyncMode = 'pull' | 'patches' | 'changedData';
+export type ManagedStoreUsage = {
+    count: number;
+    weight: number;
+    lastUsedAt?: number;
+};
+export type ManagedStorePriorityContext = {
+    key: string;
+    now: number;
+    usage?: ManagedStoreUsage;
+};
+type CommonResource<T extends object> = {
+    key?: string;
+    initial: T;
+    tags?: readonly string[];
+    priority?: number | ((ctx: ManagedStorePriorityContext) => number);
+    usageKey?: string;
+    explicitOnly?: boolean;
+    large?: boolean;
+    autoStart?: boolean;
+    storeOpts?: Parameters<typeof createStore<T>>[1];
+};
+export type ManagedMirrorResource<T extends object> = CommonResource<T> & {
+    kind?: 'mirror';
+    remote: RemoteStore<T>;
+    mask: StoreMask<T>;
+    sync?: {
+        mode?: ManagedStoreSyncMode;
+        opts?: StoreSyncOpts;
+    };
+};
+export type ManagedReplayResource<T extends object> = CommonResource<T> & {
+    kind?: 'replay';
+    remote: ReplayRemote<[StorePatch]>;
+    syncOpts?: ReplaySubscribeOpts;
+};
+export type ManagedOfflineResource<T extends object> = CommonResource<T> & {
+    kind?: 'offline';
+    remote?: ReplayRemote<[StorePatch]>;
+    storage: OfflineStorage;
+    storageKey?: string;
+    version?: number;
+    debounceMs?: number;
+    syncOpts?: ReplaySubscribeOpts;
+    migrate?: (oldSnapshot: unknown, fromVersion: number, toVersion: number) => T | Promise<T>;
+};
+export type ManagedStoreResource<T extends object = any> = ManagedMirrorResource<T> | ManagedReplayResource<T> | ManagedOfflineResource<T>;
+export type ManagedStoreResources = Record<string, ManagedStoreResource<any>>;
+export type ManagedStoreOf<R> = R extends ManagedOfflineResource<infer T> ? OfflineStore<T> : R extends ManagedReplayResource<infer T> ? Store<T> : R extends ManagedMirrorResource<infer T> ? StoreMirror<T> : never;
+export type ManagedStoreStatus = {
+    key: string;
+    state: ManagedStoreState;
+    kind: ManagedStoreKind;
+    error?: unknown;
+    startedAt?: number;
+    stoppedAt?: number;
+};
+export type ManagedStorePlanItem = {
+    key: string;
+    kind: ManagedStoreKind;
+    score: number;
+    state: ManagedStoreState;
+    large: boolean;
+    explicitOnly: boolean;
+    tags: readonly string[];
+};
+export type ManagedStoreStartOpts = {
+    explicit?: boolean;
+    reason?: string;
+};
+export type ManagedStorePlanOpts = {
+    keys?: Iterable<string>;
+    tags?: readonly string[];
+    includeLarge?: boolean;
+    includeExplicit?: boolean;
+    limit?: number;
+    now?: number;
+};
+export type ManagedStoreHandle<TStore> = {
+    readonly key: string;
+    readonly kind: ManagedStoreKind;
+    start(opts?: ManagedStoreStartOpts): Promise<TStore>;
+    stop(): void;
+    get(): TStore | undefined;
+    status(): ManagedStoreStatus;
+    touch(weight?: number): void;
+};
+export declare const managedStore: {
+    mirror<T extends object>(resource: ManagedMirrorResource<T>): ManagedMirrorResource<T>;
+    replay<T extends object>(resource: ManagedReplayResource<T>): ManagedReplayResource<T>;
+    offline<T extends object>(resource: ManagedOfflineResource<T>): ManagedOfflineResource<T>;
+};
+export declare function createStoreManager<const R extends ManagedStoreResources>(resources: R): {
+    handles: { [K in keyof R]: ManagedStoreHandle<ManagedStoreOf<R[K]>>; };
+    statusListen: import("../events/Listen").ListenApi<[ManagedStoreStatus]>;
+    plan: (opts?: ManagedStorePlanOpts) => ManagedStorePlanItem[];
+    start: <K extends keyof R & string>(key: K, opts?: ManagedStoreStartOpts) => Promise<ManagedStoreOf<R[K]>>;
+    startMany: (keys: Iterable<keyof R & string>, opts?: ManagedStoreStartOpts) => Promise<Partial<{ [K in keyof R]: ManagedStoreOf<R[K]>; }>>;
+    startPlanned: (opts?: ManagedStorePlanOpts & ManagedStoreStartOpts) => Promise<Partial<{ [K in keyof R]: ManagedStoreOf<R[K]>; }>>;
+    stop: <K extends keyof R & string>(key: K) => void;
+    stopAll: () => void;
+    get: <K extends keyof R & string>(key: K) => ManagedStoreOf<R[K]> | undefined;
+    touch: <K extends keyof R & string>(key: K, weight?: number) => void;
+    usage: () => Map<string, ManagedStoreUsage>;
+};
+export {};