@volynets/reflex-store 0.0.0-stage → 0.0.1

package/dist/chunks/createStore-DHj16Ehk.js

@@ -0,0 +1,12 @@
+/**
+ * Declares a compile-time store shape for the compiled-store transform.
+ *
+ * Data properties become leaf cells; methods become batched actions; getters
+ * become lazy computed values. leaf() and opaque() mark object values as
+ * replaceable leaves. If this function executes at runtime, the transform did
+ * not run.
+ */ function createStore(_shape, _options) {
+    throw new Error("createStore() is a compile-time API and must be erased by a transform before runtime.");
+}
+
+export { createStore as c };

package/dist/chunks/hydrate-Bdtl9XyA.js

@@ -0,0 +1,137 @@
+import { f as createDerivedProjection, t as transaction } from './keyed-C-QvvUv4.js';
+import { i as isPlain, g as getStoreControl, f as depthOf } from './shared-BHHficW8.js';
+import { untracked } from '@volynets/reflex-runtime/internal';
+
+/** Marks one compiled store value as a replaceable leaf. */ function leaf(value) {
+    return value;
+}
+
+/**
+ * Creates a lazy, read-only structured projection from a pure-return callback.
+ * Return a plain object; use reactiveMap for state with dynamic keys.
+ */ function derive(compute, options = {}) {
+    return createDerivedProjection(()=>{
+        const value = compute();
+        if (!isPlain(value) || Array.isArray(value)) throw new TypeError("derive() must return a plain object");
+        return value;
+    }, options);
+}
+
+/** Wrap one synchronous logical state change, preserving arguments and receiver. */ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+function action(callback) {
+    if (Object.prototype.toString.call(callback) === "[object AsyncFunction]") throw new TypeError("action() requires a synchronous callback");
+    let receiver;
+    let arguments_;
+    // Reuse executors; save/restore the frame for recursion and eager re-entry.
+    const invoke = ()=>{
+        const result = callback.apply(receiver, arguments_);
+        if (result && typeof result.then === "function") throw new TypeError("action() cannot return a promise");
+        return result;
+    };
+    const execute = ()=>transaction(invoke);
+    return function(...args) {
+        const previousReceiver = receiver;
+        const previousArguments = arguments_;
+        // Reuse one executor frame while preserving receiver across recursive actions.
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        receiver = this;
+        arguments_ = args;
+        try {
+            return untracked(execute);
+        } finally{
+            receiver = previousReceiver;
+            arguments_ = previousArguments;
+        }
+    };
+}
+
+const hydrationShapes = new WeakMap();
+function hydrationShape(control) {
+    const cached = hydrationShapes.get(control);
+    if (cached) return cached;
+    const branches = control.branches.map((path)=>({
+            path,
+            keys: new Set()
+        }));
+    const parents = new Map(branches.map((branch)=>[
+            JSON.stringify(branch.path),
+            branch
+        ]));
+    for (const candidates of [
+        control.paths,
+        control.branches
+    ]){
+        for (const path of candidates){
+            if (path.length === 0) continue;
+            parents.get(JSON.stringify(path.slice(0, -1)))?.keys.add(path[path.length - 1]);
+        }
+    }
+    hydrationShapes.set(control, branches);
+    return branches;
+}
+/** Restore all compiled data fields after validating the complete static schema. */ function hydrate(store, data) {
+    const control = getStoreControl(store);
+    if (!control?.hydrate || !control.paths || !control.branches) throw new TypeError("hydrate() requires a compiled store");
+    untracked(()=>{
+        for (const { path, keys } of hydrationShape(control)){
+            const branch = readPath(data, path);
+            if (!isPlain(branch) || Array.isArray(branch)) throw new TypeError("Invalid hydration branch: " + path.join("."));
+            const actual = Reflect.ownKeys(branch);
+            if (actual.length !== keys.size) throw new TypeError("Hydration data does not match the compiled store shape");
+            for (const key of actual)if (typeof key !== "string" || !keys.has(key)) throw new TypeError("Hydration data does not match the compiled store shape");
+        }
+        const seen = new Map();
+        const paths = control.paths;
+        const ordered = new Array(paths.length);
+        for(let i = 0; i < paths.length; i++)ordered[i] = restoreValue(readPath(data, paths[i]), seen);
+        transaction(()=>control.hydrate(ordered));
+    });
+}
+function restoreValue(value, seen) {
+    if (value === null || typeof value !== "object" || depthOf(value) === "opaque") return value;
+    const cached = seen.get(value);
+    if (cached !== undefined) return cached;
+    if (value instanceof Map) {
+        const result = new Map();
+        seen.set(value, result);
+        for (const [key, item] of value)result.set(key, restoreValue(item, seen));
+        return result;
+    }
+    if (value instanceof Set) {
+        const result = new Set(value);
+        seen.set(value, result);
+        return result;
+    }
+    if (!isPlain(value)) return value;
+    const array = Array.isArray(value);
+    const result = array ? [] : Object.create(Object.getPrototypeOf(value));
+    seen.set(value, result);
+    const output = {
+        configurable: true,
+        writable: true,
+        enumerable: true,
+        value: undefined
+    };
+    for (const key of Reflect.ownKeys(value)){
+        if (array && key === "length") continue;
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        if (!("value" in descriptor)) throw new TypeError("Hydration values must contain data properties");
+        output.enumerable = descriptor.enumerable;
+        output.value = restoreValue(descriptor.value, seen);
+        Object.defineProperty(result, key, output);
+    }
+    if (array) result.length = value.length;
+    return result;
+}
+function readPath(data, path) {
+    let value = data;
+    for (const key of path){
+        if (value === null || typeof value !== "object") throw new TypeError("Missing hydration field: " + path.join("."));
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        if (!descriptor || !("value" in descriptor)) throw new TypeError("Hydration fields must be own data properties: " + path.join("."));
+        value = descriptor.value;
+    }
+    return value;
+}
+
+export { action as a, derive as d, hydrate as h, leaf as l };