j-templates 8.0.9 → 8.0.11

package/Store/Store/store.js

@@ -63,7 +63,6 @@ class Store {
             this.UpdateRootObject(rootGroup[0].path[0], rootGroup);
         }
     }
-    // protected SpliceRootMap(spliceResult: DiffSpliceResult) {
     SpliceRootObject(rootPath, start, deleteCount, items) {
         const rootObject = this.rootMap.get(rootPath);
         observableNode_1.ObservableNode.ApplySplice(rootObject[rootPath], start, deleteCount, items, this.cloneData);

package/Store/Store/storeAsync.js

@@ -125,12 +125,13 @@ class StoreAsync extends store_1.Store {
      * @returns The array of deleted elements.
      */
     async Splice(key, start, deleteCount, ...items) {
+        items = (0, json_1.JsonDeepClone)(items);
         return await this.queue.Next(async () => {
             if (!this.Has(key))
                 throw "Key not found in store";
             const spliceResult = await this.diff.SplicePath(key, start, deleteCount, items);
             this.UpdateRootMap(spliceResult.diffResult);
-            this.SpliceRootObject(spliceResult.path[0], spliceResult.start, spliceResult.deleteCount, (0, json_1.JsonDeepClone)(items));
+            this.SpliceRootObject(spliceResult.path[0], spliceResult.start, spliceResult.deleteCount, items);
             return spliceResult.spliceResult;
         });
     }

package/Store/Tree/observableNode.d.ts

@@ -39,6 +39,7 @@ export declare namespace ObservableNode {
      * @returns A proxied version of the value that emits change events.
      */
     function Create<T>(value: T): T;
+    function Snapshot<T>(proxy: T): T | undefined;
     /**
      * Marks an observable node or its property as changed, triggering reactive updates.
      * Used internally to notify dependencies that a value has been modified.

package/Store/Tree/observableNode.js

@@ -6,6 +6,7 @@ const json_2 = require("../../Utils/json");
 const observableScope_1 = require("./observableScope");
 const NODE_VALUE = Symbol("NODE_VALUE");
 const NODE_PROXY = Symbol("NODE_PROXY");
+const NODE_SNAPSHOT = Symbol("NODE_SNAPSHOT");
 const toJSON = "toJSON";
 const IS_NODE = Symbol("IS_NODE");
 const OBJECT_SCOPE = Symbol("OBJECT_SCOPE");
@@ -17,6 +18,24 @@ function Property(value, prop) {
     return value[prop];
 }
 const wrapperCache = new WeakMap();
+const valueSnapshotCache = new WeakMap();
+const valueSnapshotHierarchy = new WeakMap();
+function CreateSnapshotLink(child, parent) {
+    let parents = valueSnapshotHierarchy.get(child);
+    if (!parents)
+        valueSnapshotHierarchy.set(child, (parents = new Set()));
+    parents.add(parent);
+}
+function InvalidateSnapshotForValue(value) {
+    valueSnapshotCache.delete(value);
+    const parents = valueSnapshotHierarchy.get(value);
+    if (parents === undefined)
+        return;
+    valueSnapshotHierarchy.delete(value);
+    for (const parent of parents)
+        if (valueSnapshotCache.has(parent))
+            InvalidateSnapshotForValue(parent);
+}
 function getOwnPropertyDescriptor(target, prop) {
     const descriptor = Object.getOwnPropertyDescriptor(target[NODE_VALUE], prop);
     return {
@@ -93,45 +112,67 @@ function CloneProxy(value, type = (0, json_2.JsonType)(value)) {
 function GetPropertyScope(object, prop) {
     return object[prop] ??= observableScope_1.ObservableScope.Basic(Property.bind(null, object[NODE_VALUE], prop));
 }
+function SetObjectValue(object, prop, value) {
+    const propExists = Object.hasOwn(object[NODE_VALUE], prop);
+    object[NODE_VALUE][prop] = value;
+    InvalidateSnapshotForValue(object[NODE_VALUE]);
+    observableScope_1.ObservableScope.Update(object[prop]);
+    !propExists && observableScope_1.ObservableScope.Update(object[ITERATOR_SCOPE]);
+}
+function SetArrayValue(object, prop, value) {
+    object[NODE_VALUE][prop] = value;
+    InvalidateSnapshotForValue(object[NODE_VALUE]);
+    observableScope_1.ObservableScope.Update(object[OBJECT_SCOPE]);
+}
 function CreateProxyFactory(alias) {
-    function ToJsonCopy(value) {
-        const type = (0, json_2.JsonType)(value);
-        switch (type) {
-            case "array": {
-                const typedValue = value;
-                const arrayValue = alias(typedValue, false) ?? typedValue;
-                return arrayValue.map(ToJsonCopy);
-            }
-            case "object": {
-                const typedValue = alias(value) ?? value;
-                const objectValue = alias(typedValue, false) ?? typedValue;
-                const keys = Object.keys(objectValue);
-                const copy = {};
-                for (let x = 0; x < keys.length; x++)
-                    copy[keys[x]] = ToJsonCopy(typedValue[keys[x]]);
-                return copy;
-            }
-            default:
-                return value;
+    /**
+     * An immutable snapshot of a raw node value (arrays and plain objects; other values are
+     * returned as they are). A snapshot is cached per raw value in valueSnapshotCache and
+     * returned as-is until a write invalidates it: every write path calls Invalidate, which
+     * clears the written value and every cached ancestor, found through the parent links
+     * recorded here. A rebuild makes new containers but reuses the cached snapshots of
+     * unchanged children, so a snapshot handed out never changes and unchanged parts are
+     * shared between snapshots. Keyed children are read through their root.
+     */
+    function CreateSnapshot(value) {
+        if ((0, json_2.JsonType)(value) === "value")
+            return value;
+        const cached = valueSnapshotCache.get(value);
+        if (cached !== undefined)
+            return cached;
+        let snapshot;
+        if (Array.isArray(value)) {
+            snapshot = new Array(value.length);
+            for (let x = 0; x < value.length; x++)
+                snapshot[x] = ChildSnapshot(value, value[x]);
         }
+        else {
+            snapshot = {};
+            const keys = Object.keys(value);
+            for (let x = 0; x < keys.length; x++)
+                snapshot[keys[x]] = ChildSnapshot(value, value[keys[x]]);
+        }
+        valueSnapshotCache.set(value, snapshot);
+        return snapshot;
     }
-    function ToJsonDefault(value) {
-        return (0, json_1.JsonDeepClone)(value);
+    /**
+     * A child's snapshot, linking the child to its parent so a write to the child
+     * invalidates the parent. A keyed child's snapshot comes from its root, so the root is
+     * linked too; the parent's own embedded copy stays linked because a positional write
+     * (one that changes which entity a slot holds) mutates that copy in place.
+     */
+    function ChildSnapshot(parent, child) {
+        if ((0, json_2.JsonType)(child) === "value")
+            return child;
+        CreateSnapshotLink(child, parent);
+        const resolved = alias?.(child, false);
+        if (resolved !== undefined && resolved !== child) {
+            CreateSnapshotLink(resolved, parent);
+            return CreateSnapshot(resolved);
+        }
+        return CreateSnapshot(child);
     }
-    const ToJson = alias !== undefined ? ToJsonCopy : ToJsonDefault;
     const readOnly = alias !== undefined;
-    function SetObjectValue(object, prop, value) {
-        object[NODE_VALUE][prop] = value;
-        observableScope_1.ObservableScope.Update(object[prop]);
-    }
-    function SetArrayValue(object, prop, value) {
-        object[NODE_VALUE][prop] = value;
-        observableScope_1.ObservableScope.Update(object[OBJECT_SCOPE]);
-    }
-    function CreateProxy(value) {
-        value = UnwrapProxy(value);
-        return CreateProxyFromValue(value);
-    }
     function CreateArrayProxy(value) {
         const wrapper = Object.assign([], {
             [NODE_VALUE]: value,
@@ -172,10 +213,12 @@ function CreateProxyFactory(alias) {
                 return true;
             case toJSON:
                 return function () {
-                    return ToJson(object[NODE_VALUE]);
+                    return CreateSnapshot(object[NODE_VALUE]);
                 };
             case NODE_VALUE:
                 return object[NODE_VALUE];
+            case NODE_SNAPSHOT:
+                return CreateSnapshot(object[NODE_VALUE]);
             default: {
                 const scope = object[OBJECT_SCOPE];
                 const array = observableScope_1.ObservableScope.Value(scope);
@@ -199,6 +242,7 @@ function CreateProxyFactory(alias) {
                                 array.length = proxyArray.length;
                                 for (let x = 0; x < proxyArray.length; x++)
                                     array[x] = UnwrapProxy(proxyArray[x]);
+                                InvalidateSnapshotForValue(object[NODE_VALUE]);
                                 observableScope_1.ObservableScope.Update(scope);
                                 break;
                         }
@@ -237,9 +281,11 @@ function CreateProxyFactory(alias) {
         switch (prop) {
             case IS_NODE:
                 return true;
+            case NODE_SNAPSHOT:
+                return CreateSnapshot(object[NODE_VALUE]);
             case toJSON:
                 return function () {
-                    return ToJson(object[NODE_VALUE]);
+                    return CreateSnapshot(object[NODE_VALUE]);
                 };
             case NODE_VALUE:
                 return object[NODE_VALUE];
@@ -334,6 +380,12 @@ var ObservableNode;
         return DefaultCreateProxy(value);
     }
     ObservableNode.Create = Create;
+    function Snapshot(proxy) {
+        if (proxy[IS_NODE])
+            return proxy[NODE_SNAPSHOT];
+        return undefined;
+    }
+    ObservableNode.Snapshot = Snapshot;
     /**
      * Marks an observable node or its property as changed, triggering reactive updates.
      * Used internally to notify dependencies that a value has been modified.
@@ -349,23 +401,18 @@ var ObservableNode;
     }
     ObservableNode.Update = Update;
     function Assign(value, prop, propValue) {
-        const propExists = Object.hasOwn(value, prop);
-        value[prop] = propValue;
+        // const propExists = Object.hasOwn(value as Object, prop);
+        // value[prop] = propValue;
         const wrapper = wrapperCache.get(value);
         if (wrapper) {
             if (Array.isArray(wrapper))
-                observableScope_1.ObservableScope.Update(wrapper[OBJECT_SCOPE]);
-            else {
-                const scope = wrapper[prop];
-                if (scope) {
-                    // A prop was just added to the object, fire the iterator scope
-                    if (!propExists)
-                        observableScope_1.ObservableScope.Update(wrapper[ITERATOR_SCOPE]);
-                    observableScope_1.ObservableScope.Update(scope);
-                }
-                else
-                    observableScope_1.ObservableScope.Update(wrapper[ITERATOR_SCOPE]);
-            }
+                SetArrayValue(wrapper, prop, propValue);
+            else
+                SetObjectValue(wrapper, prop, propValue);
+        }
+        else {
+            InvalidateSnapshotForValue(value);
+            value[prop] = propValue;
         }
     }
     ObservableNode.Assign = Assign;
@@ -411,6 +458,7 @@ var ObservableNode;
     ObservableNode.Apply = Apply;
     function ApplySplice(rootNode, start, deleteCount, items, cloneData = true) {
         const root = rootNode[NODE_VALUE];
+        InvalidateSnapshotForValue(rootNode[NODE_VALUE]);
         const addItems = cloneData ? (0, json_1.JsonDeepClone)(items) : items;
         root.splice(start, deleteCount, ...addItems);
         ObservableNode.Update(root);
@@ -426,6 +474,7 @@ var ObservableNode;
         const root = rootNode[NODE_VALUE];
         if (diffResult.length === 1 && diffResult[0].path.length === 0) {
             // Replacing rootNode
+            InvalidateSnapshotForValue(root);
             const rootPatch = cloneData ? (0, json_1.JsonDeepClone)(diffResult[0].value) : diffResult[0].value;
             const rootType = (0, json_2.JsonType)(root);
             const rootPatchType = (0, json_2.JsonType)(rootPatch);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "j-templates",
-  "version": "8.0.9",
+  "version": "8.0.11",
   "description": "j-templates",
   "license": "MIT",
   "repository": "https://github.com/TypesInCode/jTemplates",