@volynets/reflex-store 0.0.0-stage → 0.0.1

package/dist/chunks/keyed-C-QvvUv4.js

@@ -0,0 +1,647 @@
+import { setCurrentConsumer, currentConsumer, createConsumer, readConsumerLazy, disposeNode, untracked, unlinkAllSources, CONSUMER_INITIAL_STATE, createProducer, readProducer, getActiveRuntimeContext, enterReactiveBatch, leaveReactiveBatch, writeProducer, disposeWatcher, createWatcher, runWatcher, Both } from '@volynets/reflex-runtime/internal';
+import { h as cloneValue, j as readProjectionPath, k as storeControls, f as depthOf, l as isStructural } from './shared-BHHficW8.js';
+import { s as storeName, a as setStoreName } from './names-BF36AyM3.js';
+import { batch } from '@volynets/reflex';
+
+/** A memo with owner-controlled suspension; no node exists until its first read. */ class Demand {
+    constructor(compute){
+        this.compute = compute;
+        this.disposed = false;
+    }
+    read() {
+        if (this.disposed) throw new Error("Cannot read a disposed store derivation");
+        const node = this.node ??= createConsumer(this.compute);
+        return readConsumerLazy.call(node);
+    }
+    peek() {
+        return untracked(()=>this.read());
+    }
+    collect() {
+        const node = this.node;
+        if (!node || node.firstOut !== null) return;
+        unlinkAllSources(node);
+        node.state = CONSUMER_INITIAL_STATE;
+        node.payload = undefined;
+    }
+    dispose() {
+        this.disposed = true;
+        if (this.node) disposeNode(this.node);
+        this.node = undefined;
+    }
+}
+/** Retain tracked semantic locations until their owner's next collection boundary. */ class Observations {
+    constructor(compute, equals = Object.is, keyEquals){
+        this.compute = compute;
+        this.equals = equals;
+        this.keyEquals = keyEquals;
+    }
+    read(key) {
+        if (this.keyEquals && this.entries) {
+            const previous = currentConsumer;
+            setCurrentConsumer(null);
+            try {
+                for (const known of this.entries.keys()){
+                    if (this.keyEquals(known, key)) {
+                        key = known;
+                        break;
+                    }
+                }
+            } finally{
+                setCurrentConsumer(previous);
+            }
+        }
+        let node = this.entries?.get(key);
+        if (!node) {
+            if (currentConsumer === null) return this.compute(key);
+            let initialized = false;
+            let previous;
+            node = createConsumer(()=>{
+                const next = this.compute(key);
+                if (!initialized || !(this.equals === Object.is ? Object.is(previous, next) : untracked(()=>this.equals(previous, next)))) previous = next;
+                initialized = true;
+                return previous;
+            });
+            (this.entries ??= new Map()).set(key, node);
+        }
+        return readConsumerLazy.call(node);
+    }
+    collect() {
+        if (!this.entries) return;
+        for (const [key, node] of this.entries){
+            if (node.firstOut !== null) continue;
+            this.entries.delete(key);
+            disposeNode(node);
+        }
+    }
+    dispose() {
+        if (!this.entries) return;
+        for (const node of this.entries.values())disposeNode(node);
+        this.entries = undefined;
+    }
+}
+
+const sameKeys = (a, b)=>{
+    if (a.length !== b.length) return false;
+    for(let i = 0; i < a.length; i++)if (a[i] !== b[i]) return false;
+    return true;
+};
+class Projection {
+    constructor(fn, seed, options, returnsValue = false){
+        this.options = options;
+        this.views = new Set();
+        this.disposed = false;
+        const clone = options.clone ?? cloneValue;
+        let initialSeed = seed;
+        let current;
+        let initialized = false;
+        this.state = new Demand(()=>{
+            const draft = returnsValue ? undefined : untracked(()=>clone(initialized ? current : initialSeed));
+            const result = fn(draft);
+            const next = result === undefined ? draft : untracked(()=>clone(result));
+            const equals = options.equals;
+            if (!initialized || !(equals === undefined || equals === Object.is ? Object.is(current, next) : untracked(()=>equals(current, next)))) current = next;
+            initialSeed = undefined;
+            initialized = true;
+            return current;
+        });
+    }
+    view(path, array) {
+        const view = new View(this, path, array);
+        this.views.add(new WeakRef(view));
+        return view;
+    }
+    read(path) {
+        if (this.disposed) throw new Error("Cannot read a disposed store projection");
+        const value = this.state.read();
+        return path.length === 0 ? value : readProjectionPath(value, path);
+    }
+    collect() {
+        for (const ref of this.views){
+            const view = ref.deref();
+            if (view) view.collect();
+            else this.views.delete(ref);
+        }
+        this.state.collect();
+    }
+    dispose() {
+        this.disposed = true;
+        for (const ref of this.views)ref.deref()?.dispose();
+        this.views.clear();
+        this.state.dispose();
+    }
+}
+class View {
+    constructor(owner, path, array){
+        this.owner = owner;
+        this.path = path;
+        this.children = new Map();
+        const read = ()=>owner.read(path);
+        const parent = ()=>{
+            const value = read();
+            return typeof value === "object" && value !== null ? value : undefined;
+        };
+        const get = (key)=>{
+            const value = parent();
+            return value === undefined ? undefined : Reflect.get(value, key);
+        };
+        const valueAt = (key)=>{
+            const value = parent();
+            return this.wrap(key, value === undefined ? undefined : Reflect.get(value, key), value);
+        };
+        const existsAt = (key)=>{
+            const value = parent();
+            return value !== undefined && key in value;
+        };
+        const descriptorAt = (key)=>{
+            const value = parent();
+            return value === undefined ? undefined : Object.getOwnPropertyDescriptor(value, key)?.enumerable;
+        };
+        const keysAt = ()=>{
+            const value = parent();
+            return value === undefined ? [] : Reflect.ownKeys(value);
+        };
+        const dispose = ()=>owner.dispose();
+        this.proxy = new Proxy(array ? [] : Object.create(null), {
+            get: (_target, key)=>{
+                if (key === storeName) return owner.options.name;
+                if (key === Symbol.dispose) return dispose;
+                // Inspect one parent snapshot without subscribing to structural identity.
+                const previous = currentConsumer;
+                let container;
+                let value;
+                setCurrentConsumer(null);
+                try {
+                    container = parent();
+                    value = container === undefined ? undefined : Reflect.get(container, key);
+                } finally{
+                    setCurrentConsumer(previous);
+                }
+                if (this.shouldWrap(value, container)) return this.child(key, Array.isArray(value));
+                return (this.values ??= new Observations(valueAt)).read(key);
+            },
+            has: (_target, key)=>(this.exists ??= new Observations(existsAt)).read(key),
+            ownKeys: ()=>{
+                const keys = (this.keys ??= new Observations(keysAt, sameKeys)).read(undefined);
+                return array && !keys.includes("length") ? [
+                    ...keys,
+                    "length"
+                ] : [
+                    ...keys
+                ];
+            },
+            getOwnPropertyDescriptor: (_target, key)=>{
+                const enumerable = (this.descriptors ??= new Observations(descriptorAt)).read(key);
+                if (array && key === "length") return {
+                    configurable: false,
+                    enumerable: false,
+                    writable: true,
+                    value: untracked(()=>get(key)) ?? 0
+                };
+                if (enumerable === undefined) return undefined;
+                return {
+                    configurable: true,
+                    enumerable,
+                    writable: false,
+                    value: untracked(()=>get(key))
+                };
+            },
+            set: ()=>false,
+            deleteProperty: ()=>false,
+            defineProperty: ()=>false,
+            setPrototypeOf: ()=>false,
+            preventExtensions: ()=>false
+        });
+        storeControls.set(this.proxy, {
+            raw: read,
+            collect: ()=>owner.collect(),
+            dispose
+        });
+    }
+    shouldWrap(value, parent) {
+        return this.owner.options.depth !== "shallow" && (parent === undefined || depthOf(parent) !== "shallow") && isStructural(value);
+    }
+    wrap(key, value, parent) {
+        return this.shouldWrap(value, parent) ? this.child(key, Array.isArray(value)) : value;
+    }
+    child(key, array) {
+        const existing = this.children.get(key);
+        const cached = existing?.view.deref();
+        if (cached && existing.array === array) return cached.proxy;
+        const view = this.owner.view([
+            ...this.path,
+            key
+        ], array);
+        this.children.set(key, {
+            array,
+            view: new WeakRef(view)
+        });
+        return view.proxy;
+    }
+    collect() {
+        this.values?.collect();
+        this.exists?.collect();
+        this.descriptors?.collect();
+        this.keys?.collect();
+        for (const [key, entry] of this.children)if (!entry.view.deref()) this.children.delete(key);
+    }
+    dispose() {
+        this.values?.dispose();
+        this.exists?.dispose();
+        this.descriptors?.dispose();
+        this.keys?.dispose();
+        this.children.clear();
+    }
+}
+function createStoreProjection(fn, seed, options = {}) {
+    const owner = new Projection(fn, seed, options);
+    return owner.view([], Array.isArray(seed)).proxy;
+}
+/** Pure-return derivations never consume a mutable draft of their previous state. */ function createDerivedProjection(compute, options) {
+    const owner = new Projection(compute, {}, options, true);
+    return owner.view([], false).proxy;
+}
+
+function createSignalNode(payload) {
+    return createProducer(payload);
+}
+
+let transactionContext;
+/** Publish a synchronous logical action at one runtime batch boundary. */ function transaction(action) {
+    if (transactionContext !== undefined && transactionContext === getActiveRuntimeContext()) return action();
+    return batch(()=>{
+        const previous = transactionContext;
+        transactionContext = getActiveRuntimeContext();
+        enterReactiveBatch();
+        try {
+            return action();
+        } finally{
+            transactionContext = previous;
+            leaveReactiveBatch();
+        }
+    });
+}
+class Cells {
+    read(key, value) {
+        if (currentConsumer === null) return value;
+        let entry = this.nodes.get(key);
+        if (!entry) {
+            entry = {
+                node: createProducer(0),
+                value
+            };
+            this.nodes.set(key, entry);
+        }
+        readProducer(entry.node);
+        return value;
+    }
+    write(key, value) {
+        const entry = this.nodes.get(key);
+        if (!entry || Object.is(entry.value, value)) return;
+        entry.value = value;
+        writeProducer(entry.node, entry.node.payload + 1);
+    }
+    clear(value) {
+        for (const entry of this.nodes.values()){
+            if (Object.is(entry.value, value)) continue;
+            entry.value = value;
+            writeProducer(entry.node, entry.node.payload + 1);
+        }
+    }
+    collect() {
+        for (const [key, { node }] of this.nodes){
+            if (node.firstOut !== null) continue;
+            this.nodes.delete(key);
+            disposeNode(node);
+        }
+    }
+    dispose() {
+        for (const { node } of this.nodes.values())disposeNode(node);
+        this.nodes.clear();
+    }
+    constructor(){
+        // Values live outside producer payloads so foreign objects remain valid even
+        // when runtime dev validation accepts only primitive/plain payloads.
+        this.nodes = new Map();
+    }
+}
+class ReactiveMap {
+    constructor(initial, options = {}){
+        this.initial = initial;
+        this.options = options;
+        this.disposed = false;
+        this.valuesByKey = new Cells();
+        this.existsByKey = new Cells();
+        setStoreName(this, options.name);
+        storeControls.set(this, {
+            raw: ()=>this.backing(),
+            collect: ()=>this.collect(),
+            dispose: ()=>this.dispose()
+        });
+    }
+    backing() {
+        if (this.disposed) throw new Error("Cannot use a disposed reactive map");
+        if (!this.data) {
+            this.data = untracked(()=>new Map(typeof this.initial === "function" ? this.initial() : this.initial));
+            this.initial = undefined;
+        }
+        return this.data;
+    }
+    get size() {
+        const size = this.backing().size;
+        if (currentConsumer !== null) readProducer(this.sizeNode ??= createProducer(size));
+        return size;
+    }
+    get [Symbol.toStringTag]() {
+        return "ReactiveMap";
+    }
+    get(key) {
+        return this.valuesByKey.read(key, this.backing().get(key));
+    }
+    has(key) {
+        return this.existsByKey.read(key, this.backing().has(key));
+    }
+    set(key, value) {
+        const data = this.backing();
+        const previous = data.get(key);
+        const existed = previous !== undefined || data.has(key);
+        if (existed) {
+            const equals = this.options.equals;
+            if (equals == null || equals === Object.is ? Object.is(previous, value) : untracked(()=>equals(previous, value))) return this;
+        }
+        this.commitSet(data, key, value, existed);
+        return this;
+    }
+    commitSet(data, key, value, existed) {
+        transaction(()=>{
+            data.set(key, value);
+            this.valuesByKey.write(key, value);
+            if (!existed) {
+                this.existsByKey.write(key, true);
+                if (this.sizeNode) writeProducer(this.sizeNode, data.size);
+                if (this.keysNode) writeProducer(this.keysNode, this.keysNode.payload + 1);
+            }
+            if (this.valuesNode) writeProducer(this.valuesNode, this.valuesNode.payload + 1);
+        });
+    }
+    delete(key) {
+        const data = this.backing();
+        if (!data.has(key)) return false;
+        transaction(()=>{
+            data.delete(key);
+            this.valuesByKey.write(key, undefined);
+            this.existsByKey.write(key, false);
+            if (this.sizeNode) writeProducer(this.sizeNode, data.size);
+            if (this.keysNode) writeProducer(this.keysNode, this.keysNode.payload + 1);
+            if (this.valuesNode) writeProducer(this.valuesNode, this.valuesNode.payload + 1);
+        });
+        return true;
+    }
+    clear() {
+        const data = this.backing();
+        if (data.size === 0) return;
+        transaction(()=>{
+            data.clear();
+            // Only materialized semantic locations need invalidation, even for a large map.
+            this.valuesByKey.clear(undefined);
+            this.existsByKey.clear(false);
+            if (this.sizeNode) writeProducer(this.sizeNode, 0);
+            if (this.keysNode) writeProducer(this.keysNode, this.keysNode.payload + 1);
+            if (this.valuesNode) writeProducer(this.valuesNode, this.valuesNode.payload + 1);
+        });
+    }
+    keys() {
+        const data = this.backing();
+        if (currentConsumer !== null) readProducer(this.keysNode ??= createProducer(0));
+        return data.keys();
+    }
+    values() {
+        const data = this.backing();
+        if (currentConsumer !== null) readProducer(this.valuesNode ??= createProducer(0));
+        return data.values();
+    }
+    entries() {
+        const data = this.backing();
+        if (currentConsumer !== null) readProducer(this.valuesNode ??= createProducer(0));
+        return data.entries();
+    }
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+    forEach(callback, thisArg) {
+        const data = this.backing();
+        if (currentConsumer !== null) readProducer(this.valuesNode ??= createProducer(0));
+        data.forEach((value, key)=>callback.call(thisArg, value, key, this));
+    }
+    collect() {
+        this.valuesByKey.collect();
+        this.existsByKey.collect();
+        if (this.sizeNode?.firstOut === null) {
+            disposeNode(this.sizeNode);
+            this.sizeNode = undefined;
+        }
+        if (this.keysNode?.firstOut === null) {
+            disposeNode(this.keysNode);
+            this.keysNode = undefined;
+        }
+        if (this.valuesNode?.firstOut === null) {
+            disposeNode(this.valuesNode);
+            this.valuesNode = undefined;
+        }
+    }
+    [Symbol.dispose]() {
+        this.dispose();
+    }
+    dispose() {
+        this.disposed = true;
+        this.valuesByKey.dispose();
+        this.existsByKey.dispose();
+        if (this.sizeNode) disposeNode(this.sizeNode);
+        if (this.keysNode) disposeNode(this.keysNode);
+        if (this.valuesNode) disposeNode(this.valuesNode);
+        this.sizeNode = this.keysNode = this.valuesNode = undefined;
+        this.data = undefined;
+        this.initial = undefined;
+    }
+}
+/** A native Set-shaped membership collection over keyed reactive observations. */ class ReactiveSet {
+    constructor(initial, options = {}){
+        this.members = new ReactiveMap(()=>Array.from(typeof initial === "function" ? initial() : initial ?? [], (value)=>[
+                    value,
+                    true
+                ]));
+        setStoreName(this, options.name);
+        storeControls.set(this, {
+            raw: ()=>new Set(this.members.keys()),
+            collect: ()=>this.collect(),
+            dispose: ()=>this.dispose()
+        });
+    }
+    get size() {
+        return this.members.size;
+    }
+    get [Symbol.toStringTag]() {
+        return "ReactiveSet";
+    }
+    has(value) {
+        return this.members.has(value);
+    }
+    add(value) {
+        this.members.set(value, true);
+        return this;
+    }
+    delete(value) {
+        return this.members.delete(value);
+    }
+    clear() {
+        this.members.clear();
+    }
+    values() {
+        return this.members.keys();
+    }
+    keys() {
+        return this.values();
+    }
+    *entries() {
+        for (const value of this.values())yield [
+            value,
+            value
+        ];
+    }
+    [Symbol.iterator]() {
+        return this.values();
+    }
+    forEach(callback, thisArg) {
+        for (const value of this.values())callback.call(thisArg, value, value, this);
+    }
+    collect() {
+        this.members.collect();
+    }
+    dispose() {
+        this.members.dispose();
+    }
+    [Symbol.dispose]() {
+        this.dispose();
+    }
+}
+function reactiveSet(initial, options) {
+    return new ReactiveSet(initial, options);
+}
+function createReactiveMap(initial, options) {
+    return new ReactiveMap(initial, options);
+}
+
+/// <reference lib="esnext.disposable" />
+function withDispose(resource, name) {
+    setStoreName(resource, name);
+    Object.defineProperty(resource, Symbol.dispose, {
+        configurable: true,
+        value: ()=>resource.dispose()
+    });
+    return resource;
+}
+
+// Map uses SameValueZero. Preserve Object.is semantics for signed zero.
+const negativeZero = Symbol("negative zero");
+function identityKey(key) {
+    return key === 0 && 1 / key === -Infinity ? negativeZero : key;
+}
+function createSelector(source, options = {}) {
+    const equals = options.equals ?? Object.is;
+    const identityEquality = equals === Object.is;
+    const entries = new Map();
+    let watcher;
+    let current;
+    let initialized = false;
+    let disposed = false;
+    const lookup = (key)=>{
+        if (identityEquality) return entries.get(identityKey(key));
+        return untracked(()=>{
+            for (const entry of entries.values())if (equals(entry.key, key)) return entry;
+            return undefined;
+        });
+    };
+    const sync = (next)=>{
+        if (initialized && (identityEquality ? Object.is(current, next) : untracked(()=>equals(current, next)))) return;
+        const previous = initialized ? lookup(current) : undefined;
+        current = next;
+        initialized = true;
+        const selected = lookup(next);
+        if (!previous && !selected) return;
+        transaction(()=>{
+            if (previous) writeProducer(previous.node, false);
+            if (selected) writeProducer(selected.node, true);
+        });
+    };
+    const read = (key)=>{
+        if (disposed) throw new Error("Cannot read a disposed selector");
+        if (currentConsumer === null) return identityEquality ? Object.is(source(), key) : untracked(()=>equals(source(), key));
+        if (!watcher) {
+            watcher = createWatcher(()=>sync(source()));
+            try {
+                runWatcher(watcher);
+            } catch (error) {
+                disposeWatcher(watcher);
+                watcher = undefined;
+                throw error;
+            }
+        } else if ((watcher.state & Both) !== 0) {
+            sync(untracked(source));
+        }
+        let entry = lookup(key);
+        if (!entry) {
+            entry = {
+                key,
+                node: createSignalNode(identityEquality ? Object.is(current, key) : untracked(()=>equals(current, key)))
+            };
+            entries.set(identityKey(key), entry);
+        }
+        return readProducer(entry.node);
+    };
+    return withDispose(Object.assign(read, {
+        collect () {
+            for (const [key, entry] of entries){
+                if (entry.node.firstOut !== null) continue;
+                entries.delete(key);
+                disposeNode(entry.node);
+            }
+            if (entries.size === 0 && watcher) {
+                disposeWatcher(watcher);
+                watcher = undefined;
+                initialized = false;
+            }
+        },
+        dispose () {
+            disposed = true;
+            if (watcher) disposeWatcher(watcher);
+            watcher = undefined;
+            for (const entry of entries.values())disposeNode(entry.node);
+            entries.clear();
+        }
+    }), options.name);
+}
+function createKeyedProjection(source, keyOf, project, options = {}) {
+    const keyEquals = options.keyEquals ?? Object.is;
+    const valueEquals = options.equals ?? Object.is;
+    const sourceValue = new Demand(source);
+    const projected = new Demand(()=>project(sourceValue.read()));
+    const keys = new Observations((key)=>{
+        const activeKey = keyOf(sourceValue.read());
+        const requestedKey = key === negativeZero ? -0 : key;
+        const matches = keyEquals === Object.is ? Object.is(activeKey, requestedKey) : untracked(()=>keyEquals(activeKey, requestedKey));
+        return matches ? projected.read() : options.fallback;
+    }, valueEquals === Object.is ? Object.is : (a, b)=>a === undefined || b === undefined ? Object.is(a, b) : valueEquals(a, b), options.keyEquals ? (a, b)=>keyEquals(a === negativeZero ? -0 : a, b === negativeZero ? -0 : b) : undefined);
+    return withDispose(Object.assign((key)=>keys.read(identityKey(key)), {
+        collect () {
+            keys.collect();
+            projected.collect();
+            sourceValue.collect();
+        },
+        dispose () {
+            keys.dispose();
+            projected.dispose();
+            sourceValue.dispose();
+        }
+    }), options.name);
+}
+
+export { ReactiveMap as R, createSelector as a, ReactiveSet as b, createReactiveMap as c, createKeyedProjection as d, createStoreProjection as e, createDerivedProjection as f, reactiveSet as r, transaction as t };

package/dist/chunks/names-BF36AyM3.js

@@ -0,0 +1,11 @@
+const storeName = Symbol.for("@volynets/reflex-store/name");
+function getStoreName(resource) {
+    return resource[storeName];
+}
+function setStoreName(resource, name) {
+    if (name !== undefined) Object.defineProperty(resource, storeName, {
+        value: name
+    });
+}
+
+export { setStoreName as a, getStoreName as g, storeName as s };