wenay-common2 1.0.62 → 1.0.63

package/lib/Common/Observe/store-manager.js

@@ -0,0 +1,227 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.managedStore = void 0;
+exports.createStoreManager = createStoreManager;
+const Listen_1 = require("../events/Listen");
+const store_1 = require("./store");
+const store_offline_1 = require("./store-offline");
+const store_replay_1 = require("./store-replay");
+function kindOf(resource) {
+    return resource.kind ?? 'mirror';
+}
+function hasAnyTag(resourceTags, tags) {
+    if (!tags?.length)
+        return true;
+    if (!resourceTags?.length)
+        return false;
+    return tags.some(tag => resourceTags.includes(tag));
+}
+function resourceScore(key, resource, usage, now) {
+    const base = typeof resource.priority == 'function'
+        ? resource.priority({ key, usage, now })
+        : resource.priority ?? 0;
+    const usageScore = usage ? usage.weight + Math.min(usage.count, 50) : 0;
+    const recency = usage?.lastUsedAt ? Math.max(0, 1_000_000 - (now - usage.lastUsedAt)) / 1_000_000 : 0;
+    return base + usageScore + recency;
+}
+exports.managedStore = {
+    mirror(resource) {
+        return { ...resource, kind: 'mirror' };
+    },
+    replay(resource) {
+        return { ...resource, kind: 'replay' };
+    },
+    offline(resource) {
+        return { ...resource, kind: 'offline' };
+    },
+};
+function createStoreManager(resources) {
+    const usages = new Map();
+    const [emitStatus, statusListen] = (0, Listen_1.listen)();
+    function usageFor(key, resource) {
+        const usageKey = resource.usageKey ?? key;
+        let usage = usages.get(usageKey);
+        if (!usage) {
+            usage = { count: 0, weight: 0 };
+            usages.set(usageKey, usage);
+        }
+        return usage;
+    }
+    function createHandle(key, resource) {
+        const kind = kindOf(resource);
+        let state = 'idle';
+        let store;
+        let stopSync;
+        let pending;
+        let error;
+        let startedAt;
+        let stoppedAt;
+        function setState(next, nextError) {
+            state = next;
+            error = nextError;
+            if (next == 'ready')
+                startedAt = Date.now();
+            if (next == 'stopped')
+                stoppedAt = Date.now();
+            emitStatus(status());
+        }
+        function status() {
+            return { key, state, kind, error, startedAt, stoppedAt };
+        }
+        async function start(opts = {}) {
+            if (resource.explicitOnly && !opts.explicit) {
+                throw new Error(`store manager: ${key} is explicitOnly`);
+            }
+            if (state == 'ready' && store)
+                return store;
+            if (pending)
+                return pending;
+            pending = (async () => {
+                setState('starting');
+                try {
+                    if (kind == 'mirror') {
+                        const r = resource;
+                        store ??= (0, store_1.createStoreMirror)(r.remote, r.initial, r.storeOpts);
+                        const mode = r.sync?.mode ?? 'pull';
+                        const opts = r.sync?.opts;
+                        stopSync = mode == 'patches'
+                            ? await store.syncPatches(r.mask, opts)
+                            : mode == 'changedData'
+                                ? await store.syncChangedData(r.mask, opts)
+                                : await store.sync(r.mask, opts);
+                    }
+                    else if (kind == 'replay') {
+                        const r = resource;
+                        store ??= (0, store_1.createStore)(r.initial, r.storeOpts);
+                        const sub = (0, store_replay_1.syncStoreReplay)(store, r.remote, r.syncOpts);
+                        stopSync = sub;
+                        await sub.ready;
+                    }
+                    else {
+                        const r = resource;
+                        store = await (0, store_offline_1.createOfflineStore)({
+                            key: r.storageKey ?? key,
+                            remote: r.remote,
+                            initial: r.initial,
+                            storage: r.storage,
+                            version: r.version,
+                            debounceMs: r.debounceMs,
+                            storeOpts: r.storeOpts,
+                            syncOpts: r.syncOpts,
+                            migrate: r.migrate,
+                        });
+                        await store.ready;
+                    }
+                    setState('ready');
+                    return store;
+                }
+                catch (e) {
+                    setState('error', e);
+                    throw e;
+                }
+                finally {
+                    pending = undefined;
+                }
+            })();
+            return pending;
+        }
+        function stop() {
+            stopSync?.();
+            stopSync = undefined;
+            if (kind == 'offline') {
+                store?.close?.();
+                store = undefined;
+            }
+            if (state != 'idle')
+                setState('stopped');
+        }
+        function touch(weight = 1) {
+            const usage = usageFor(key, resource);
+            usage.count++;
+            usage.weight += weight;
+            usage.lastUsedAt = Date.now();
+        }
+        return { key, kind, start, stop, get: () => store, status, touch };
+    }
+    const handles = {};
+    for (const key of Object.keys(resources))
+        handles[key] = createHandle(key, resources[key]);
+    function plan(opts = {}) {
+        const now = opts.now ?? Date.now();
+        const keySet = opts.keys ? new Set([...opts.keys].map(String)) : null;
+        const out = [];
+        for (const key of Object.keys(resources)) {
+            if (keySet && !keySet.has(key))
+                continue;
+            const resource = resources[key];
+            if (!hasAnyTag(resource.tags, opts.tags))
+                continue;
+            if (resource.explicitOnly && !opts.includeExplicit)
+                continue;
+            if (resource.large && !opts.includeLarge)
+                continue;
+            const usage = usages.get(resource.usageKey ?? key);
+            out.push({
+                key,
+                kind: kindOf(resource),
+                score: resourceScore(key, resource, usage, now),
+                state: handles[key].status().state,
+                large: !!resource.large,
+                explicitOnly: !!resource.explicitOnly,
+                tags: resource.tags ?? [],
+            });
+        }
+        out.sort((a, b) => b.score - a.score || a.key.localeCompare(b.key));
+        return opts.limit == null ? out : out.slice(0, opts.limit);
+    }
+    async function start(key, opts) {
+        const handle = handles[key];
+        if (!handle)
+            throw new Error(`store manager: unknown resource ${key}`);
+        return handle.start(opts);
+    }
+    async function startMany(keys, opts) {
+        const out = {};
+        for (const key of keys)
+            out[key] = await start(key, opts);
+        return out;
+    }
+    async function startPlanned(opts = {}) {
+        const out = {};
+        for (const item of plan(opts))
+            out[item.key] = await handles[item.key].start(opts);
+        return out;
+    }
+    function stop(key) {
+        const handle = handles[key];
+        if (!handle)
+            throw new Error(`store manager: unknown resource ${key}`);
+        handle.stop();
+    }
+    function stopAll() {
+        for (const handle of Object.values(handles))
+            handle.stop();
+    }
+    function get(key) {
+        return handles[key]?.get();
+    }
+    function touch(key, weight) {
+        const handle = handles[key];
+        if (!handle)
+            throw new Error(`store manager: unknown resource ${key}`);
+        handle.touch(weight);
+    }
+    return {
+        handles: handles,
+        statusListen,
+        plan,
+        start,
+        startMany,
+        startPlanned,
+        stop,
+        stopAll,
+        get,
+        touch,
+        usage: () => new Map(usages),
+    };
+}

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

@@ -68,20 +68,20 @@ export declare function persistStore<T extends object>(store: Store<T>, opts: Pe
     seq: () => number;
     status: () => OfflineStoreStatus;
     statusListen: {
-        on: import("../events/Listen3").ListenOnCurrent<[OfflineStoreStatus]>;
-        once: (cb: import("../events/Listen3").Listener<[OfflineStoreStatus]>, opts?: {
-            key?: import("../events/Listen3").ListenKey;
-            current?: import("../events/Listen3").ListenCurrent<[OfflineStoreStatus]> | undefined;
-        }) => import("../events/Listen3").ListenOff;
-        emit: import("../events/Listen3").Listener<[OfflineStoreStatus]>;
-        has(key: import("../events/Listen3").ListenKey): boolean;
-        off(keyOrCallback: import("../events/Listen3").ListenKey | import("../events/Listen3").Listener<[OfflineStoreStatus]> | null): void;
+        on: import("../events/Listen").ListenOnCurrent<[OfflineStoreStatus]>;
+        once: (cb: import("../events/Listen").Listener<[OfflineStoreStatus]>, opts?: {
+            key?: import("../events/Listen").ListenKey;
+            current?: import("../events/Listen").ListenCurrent<[OfflineStoreStatus]> | undefined;
+        }) => import("../events/Listen").ListenOff;
+        emit: import("../events/Listen").Listener<[OfflineStoreStatus]>;
+        has(key: import("../events/Listen").ListenKey): boolean;
+        off(keyOrCallback: import("../events/Listen").ListenKey | import("../events/Listen").Listener<[OfflineStoreStatus]> | null): void;
         close(): void;
         count(): number;
-        keys(): import("../events/Listen3").ListenKey[];
+        keys(): import("../events/Listen").ListenKey[];
         isRunning(): boolean;
         run(): void;
-        onClose(cb: () => void): import("../events/Listen3").ListenOff;
+        onClose(cb: () => void): import("../events/Listen").ListenOff;
     };
     setSyncStatus: (patch: Partial<OfflineStoreStatus>) => void;
 };

package/lib/Common/Observe/store-offline.js

@@ -4,7 +4,7 @@ exports.createMemoryOfflineStorage = createMemoryOfflineStorage;
 exports.persistStore = persistStore;
 exports.createOfflineStore = createOfflineStore;
 const common_1 = require("../core/common");
-const Listen3_1 = require("../events/Listen3");
+const Listen_1 = require("../events/Listen");
 const store_1 = require("./store");
 const store_replay_1 = require("./store-replay");
 function isRecord(v) {
@@ -66,7 +66,7 @@ function persistStore(store, opts) {
         seq,
         savedAt,
     };
-    const [emitStatus, statusListen] = (0, Listen3_1.listenStore)({
+    const [emitStatus, statusListen] = (0, Listen_1.listenStore)({
         current: () => [copyStatus(status)],
     });
     function updateStatus(patch = {}) {

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

@@ -1,5 +1,5 @@
 import { createListen } from "../events/Listen";
-import { listenUpdate, listenUpdatePaths, reactive, ReactiveChange } from "./reactive2";
+import { listenUpdate, listenUpdatePaths, reactive, ReactiveChange } from "./reactive";
 export type StorePath = readonly PropertyKey[];
 export type StoreDrain = "micro" | "immediate" | number | ((flush: () => void) => void);
 export type StoreSubOpts = {

package/lib/Common/Observe/store.js

@@ -7,7 +7,7 @@ exports.createStore = createStore;
 exports.exposeStore = exposeStore;
 exports.createStoreMirror = createStoreMirror;
 const Listen_1 = require("../events/Listen");
-const reactive2_1 = require("./reactive2");
+const reactive_1 = require("./reactive");
 const hasSetImmediate = typeof setImmediate == "function";
 function pathText(path) {
     return path.map(String).join(".");
@@ -119,7 +119,7 @@ function setAt(root, path, value) {
     p[path[path.length - 1]] = value;
 }
 function snapshotValue(value, seen = new WeakMap()) {
-    value = (0, reactive2_1.toRaw)(value);
+    value = (0, reactive_1.toRaw)(value);
     if (!isObj(value))
         return value;
     const old = seen.get(value);
@@ -158,7 +158,7 @@ function maskPaths(mask, base = []) {
     return out;
 }
 function pickSnapshot(root, mask, base = []) {
-    root = (0, reactive2_1.toRaw)(root);
+    root = (0, reactive_1.toRaw)(root);
     if (mask === true || mask == null)
         return snapshotValue(getAt(root, base));
     const out = {};
@@ -259,7 +259,7 @@ function maskFromPaths(paths) {
     return out ?? true;
 }
 function makePatch(root, path) {
-    root = (0, reactive2_1.toRaw)(root);
+    root = (0, reactive_1.toRaw)(root);
     const exists = hasAt(root, path);
     return {
         path: [...path],
@@ -311,9 +311,9 @@ 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.createListen)((emit) => {
-        const known = new Set(Reflect.ownKeys((0, reactive2_1.toRaw)(store.state)));
+        const known = new Set(Reflect.ownKeys((0, reactive_1.toRaw)(store.state)));
         function emitKey(key) {
-            const raw = (0, reactive2_1.toRaw)(store.state);
+            const raw = (0, reactive_1.toRaw)(store.state);
             const exists = isObj(raw) && key in raw;
             if (exists)
                 known.add(key);
@@ -331,7 +331,7 @@ function createEachListen(store, opts = {}) {
                     keys.add(path[0]);
             }
             if (root) {
-                for (const key of Reflect.ownKeys((0, reactive2_1.toRaw)(store.state)))
+                for (const key of Reflect.ownKeys((0, reactive_1.toRaw)(store.state)))
                     keys.add(key);
                 for (const key of known)
                     keys.add(key);
@@ -372,7 +372,7 @@ function watchTarget(root, path) {
         if (!isObj(cur) || !(k in cur))
             return lastReactive;
         const next = cur[k];
-        if ((0, reactive2_1.isReactive)(next)) {
+        if ((0, reactive_1.isReactive)(next)) {
             cur = next;
             lastReactive = next;
         }
@@ -427,10 +427,10 @@ function subscribePath(store, path, cb, opts = {}, once = false) {
     function attach() {
         offUpdate?.();
         const target = watchTarget(store._state, path);
-        offUpdate = (0, reactive2_1.onUpdate)(target, () => {
+        offUpdate = (0, reactive_1.onUpdate)(target, () => {
             const exists = hasAt(store._state, path);
             const value = getAt(store._state, path);
-            const valueIsObject = (0, reactive2_1.isReactive)(value);
+            const valueIsObject = (0, reactive_1.isReactive)(value);
             const watchedSelf = target === value;
             if (!valueIsObject && !watchedSelf && sameLeaf(lastValue, value, lastExists, exists))
                 return;
@@ -541,7 +541,7 @@ function createSelection(store, base, mask, defaults = {}) {
     };
 }
 function createStore(initial, opts = {}) {
-    const state = (0, reactive2_1.reactive)(initial, opts);
+    const state = (0, reactive_1.reactive)(initial, opts);
     let store;
     store = {
         _state: state,
@@ -556,8 +556,8 @@ function createStore(initial, 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),
+        listen: () => (0, reactive_1.listenUpdate)(state),
+        listenPaths: () => (0, reactive_1.listenUpdatePaths)(state),
         count: () => Array.from(store._counts.values()).reduce((a, b) => a + b, 0),
     };
     return store;

package/lib/Common/async/promiseProgress.d.ts

@@ -1,6 +1,6 @@
 export declare function promiseProgress<T extends any = unknown>(array: ((() => Promise<T>) | (() => any) | Promise<T>)[]): {
-    onOk: (cb: (...data: [data: T, i: number, countOk: number, countError: number, count: number]) => any) => import("../events/Listen3").ListenOff;
-    onError: (cb: (...data: [error: any, i: number, countOk: number, countError: number, count: number]) => any) => import("../events/Listen3").ListenOff;
+    onOk: (cb: (...data: [data: T, i: number, countOk: number, countError: number, count: number]) => any) => import("../events/Listen").ListenOff;
+    onError: (cb: (...data: [error: any, i: number, countOk: number, countError: number, count: number]) => any) => import("../events/Listen").ListenOff;
     all: () => Promise<any[]>;
     allSettled: () => Promise<PromiseSettledResult<any>[]>;
     items: () => Promise<any>[];

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

@@ -1 +1,129 @@
-export * from "./Listen3";
+export type Listener<T extends any[]> = (...args: T) => void;
+export type NormalizeTuple<T> = T extends any[] ? T : [T];
+export type ListenKey = string | symbol;
+export type ListenOff = () => void;
+type CloseCallback = () => void;
+declare const LISTEN_ON_BRAND: unique symbol;
+export type ListenOn<Z extends any[] = any[]> = ((cb: Listener<Z>, opts?: {
+    cbClose?: CloseCallback;
+    key?: ListenKey;
+}) => ListenOff) & {
+    readonly [LISTEN_ON_BRAND]: Z;
+};
+export type ListenOnCurrent<Z extends any[] = any[]> = ((cb: Listener<Z>, opts?: {
+    cbClose?: CloseCallback;
+    key?: ListenKey;
+    current?: ListenCurrent<Z>;
+}) => ListenOff) & {
+    readonly [LISTEN_ON_BRAND]: Z;
+};
+export type ListenCurrentProvider<Z extends any[]> = () => Z | undefined;
+export type ListenCurrent<Z extends any[]> = boolean | ListenCurrentProvider<Z>;
+export type ListenCoreApi<T = any> = {
+    emit: Listener<NormalizeTuple<T>>;
+    has(key: ListenKey): boolean;
+    on: ListenOn<NormalizeTuple<T>>;
+    off(keyOrCallback: Listener<NormalizeTuple<T>> | null | ListenKey): void;
+    once(cb: Listener<NormalizeTuple<T>>, opts?: {
+        key?: ListenKey;
+    }): ListenOff;
+    close(): void;
+    count(): number;
+    keys(): ListenKey[];
+};
+export type ListenApi<T = any> = ListenCoreApi<T> & {
+    isRunning(): boolean;
+    run(): void;
+    onClose(cb: CloseCallback): ListenOff;
+};
+export type ListenCoreOptions<T = any> = {
+    fast?: boolean;
+    onRemove?: (key: ListenKey) => void;
+    event?: (type: 'add' | 'remove', count: number, api: ListenCoreApi<T>) => void;
+};
+export type ListenOptions<T = any> = {
+    event?: (type: 'add' | 'remove', count: number, api: ListenApi<T>) => void;
+    fast?: boolean;
+    closeOn?: ListenApi<any>;
+};
+export type ListenStoreOptions<T> = ListenOptions<T> & {
+    current: ListenCurrentProvider<NormalizeTuple<T>>;
+};
+export type ListenOnBrand<Z extends any[] = any[]> = {
+    readonly [LISTEN_ON_BRAND]: Z;
+};
+export declare function getListenByOn(fn: any): any;
+export declare function isListenOn(fn: any): boolean;
+export declare function registerListenOn(on: Function, api: any): void;
+export declare function createListenCore<T>(options?: ListenCoreOptions<T>): ListenCoreApi<T>;
+export declare function createListen<T>(producer: (emit: Listener<NormalizeTuple<T>>) => (void | ListenOff), options?: ListenOptions<T>): ListenApi<T>;
+export declare function createFastListen<T>(producer: (emit: Listener<NormalizeTuple<T>>) => (void | ListenOff)): ListenApi<T>;
+export declare function listen<T>(options?: ListenOptions<T>): readonly [Listener<NormalizeTuple<T>>, ListenApi<T>];
+export declare function withStoreListen<T>(base: ListenApi<T>, currentProvider: ListenCurrentProvider<NormalizeTuple<T>>): {
+    on: ListenOnCurrent<NormalizeTuple<T>>;
+    once: (cb: Listener<NormalizeTuple<T>>, opts?: {
+        key?: ListenKey;
+        current?: ListenCurrent<NormalizeTuple<T>>;
+    }) => ListenOff;
+    emit: Listener<NormalizeTuple<T>>;
+    has(key: ListenKey): boolean;
+    off(keyOrCallback: ListenKey | Listener<NormalizeTuple<T>> | null): void;
+    close(): void;
+    count(): number;
+    keys(): ListenKey[];
+    isRunning(): boolean;
+    run(): void;
+    onClose(cb: CloseCallback): ListenOff;
+};
+export type ListenStoreApi<T> = ReturnType<typeof withStoreListen<T>>;
+export declare function createStoreListen<T>(producer: (emit: Listener<NormalizeTuple<T>>) => (void | ListenOff), options: ListenStoreOptions<T>): {
+    on: ListenOnCurrent<NormalizeTuple<T>>;
+    once: (cb: Listener<NormalizeTuple<T>>, opts?: {
+        key?: ListenKey;
+        current?: ListenCurrent<NormalizeTuple<T>> | undefined;
+    }) => ListenOff;
+    emit: Listener<NormalizeTuple<T>>;
+    has(key: ListenKey): boolean;
+    off(keyOrCallback: ListenKey | Listener<NormalizeTuple<T>> | null): void;
+    close(): void;
+    count(): number;
+    keys(): ListenKey[];
+    isRunning(): boolean;
+    run(): void;
+    onClose(cb: CloseCallback): ListenOff;
+};
+export declare function listenStore<T>(options: ListenStoreOptions<T>): readonly [Listener<NormalizeTuple<T>>, {
+    on: ListenOnCurrent<NormalizeTuple<T>>;
+    once: (cb: Listener<NormalizeTuple<T>>, opts?: {
+        key?: ListenKey;
+        current?: ListenCurrent<NormalizeTuple<T>> | undefined;
+    }) => ListenOff;
+    emit: Listener<NormalizeTuple<T>>;
+    has(key: ListenKey): boolean;
+    off(keyOrCallback: ListenKey | Listener<NormalizeTuple<T>> | null): void;
+    close(): void;
+    count(): number;
+    keys(): ListenKey[];
+    isRunning(): boolean;
+    run(): void;
+    onClose(cb: CloseCallback): ListenOff;
+}];
+export declare function toSlimListen<T>(full: ListenApi<T>): {
+    on: (cb: Listener<NormalizeTuple<T>>, opts?: {
+        key?: ListenKey;
+    }) => ListenOff;
+    off: (keyOrCallback: Listener<NormalizeTuple<T>> | null | ListenKey) => void;
+    close: () => void;
+    count: () => number;
+};
+export type SlimListen<T> = ReturnType<typeof toSlimListen<T>>;
+export declare function slimListen<T>(options?: ListenOptions<T>): readonly [Listener<NormalizeTuple<T>>, {
+    on: (cb: Listener<NormalizeTuple<T>>, opts?: {
+        key?: ListenKey;
+    } | undefined) => ListenOff;
+    off: (keyOrCallback: ListenKey | Listener<NormalizeTuple<T>> | null) => void;
+    close: () => void;
+    count: () => number;
+}];
+export declare function isListenCallback(obj: any): obj is ListenApi;
+export {};