j-templates 8.0.13 → 8.0.15

package/Store/Diff/diffTree.js

@@ -1,458 +1,406 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PROJECTION_PREFIX = void 0;
-exports.DiffTreeFactory = DiffTreeFactory;
+import { ArraysEqual } from "../../Utils/array";
+import { JsonDeepClone, JsonDiff, JsonType } from "../../Utils/json";
 /** Reserved key prefix a projection's result is stored under: `$projection_<id>`. */
-exports.PROJECTION_PREFIX = "$projection_";
+export const PROJECTION_PREFIX = "$projection_";
 /**
- * Factory function that creates a DiffTree class.
- * Can operate in worker mode for async operations.
- * @param jsonDiffFactory - Optional factory for JSON diff utilities
- * @param worker - If true, sets up worker message handling
- * @returns DiffTree constructor
+ * Flattens nested objects/arrays, extracting keyed objects to root.
+ * @param root - Root object to store flattened values
+ * @param value - Value to flatten
+ * @param keyFunc - Function to extract key from objects
+ * @returns The root object with flattened values
  */
-function DiffTreeFactory(jsonDiffFactory, arraysEqual, worker) {
-    const { JsonDiff, JsonType, JsonDeepClone } = jsonDiffFactory();
-    /**
-     * Reconstructs a `DiffTreeProjectionMap` from its wire form: each projection's function
-     * source, `eval`'d back into a function, the same mechanic used to deserialize `keyFunc`.
-     */
-    function DeserializeProjections(serialized) {
-        const projections = {};
-        const ids = Object.keys(serialized);
-        for (let x = 0; x < ids.length; x++) {
-            const id = ids[x];
-            projections[id] = {
-                reads: serialized[id].reads,
-                projection: eval(serialized[id].projection),
-            };
-        }
-        return projections;
-    }
-    const ctx = this;
-    if (worker && ctx) {
-        let diffTree = null;
-        ctx.onmessage = function (event) {
-            const data = event.data;
-            switch (data.method) {
-                case "create": {
-                    const keyFunc = data.arguments[0]
-                        ? eval(data.arguments[0])
-                        : undefined;
-                    const projections = data.arguments[1]
-                        ? DeserializeProjections(data.arguments[1])
-                        : undefined;
-                    diffTree = new DiffTree(keyFunc, projections);
-                    ctx.postMessage(null);
-                    break;
-                }
-                case "diffpath": {
-                    const diff = diffTree.DiffPath(data.arguments[0], data.arguments[1], data.arguments[2]);
-                    ctx.postMessage(diff);
-                    break;
-                }
-                case "splicepath": {
-                    const diff = diffTree.SplicePath(data.arguments[0], data.arguments[1], data.arguments[2], data.arguments[3], data.arguments[4]);
-                    ctx.postMessage(diff);
-                    break;
-                }
-                case "diffbatch": {
-                    const diff = diffTree.DiffBatch(data.arguments[0]);
-                    ctx.postMessage(diff);
-                    break;
-                }
-                case "getpath": {
-                    const ret = diffTree.GetPath(data.arguments[0]);
-                    ctx.postMessage(ret);
-                    break;
-                }
-            }
-        };
+function FlattenValue(root, value, keyFunc) {
+    const type = JsonType(value);
+    switch (type) {
+        case "array":
+            const typedArray = value;
+            for (let x = 0; x < typedArray.length; x++)
+                FlattenValue(root, typedArray[x], keyFunc);
+            break;
+        case "object":
+            const typedObject = value;
+            const key = keyFunc(typedObject);
+            if (key)
+                root[key] = typedObject;
+            const keys = Object.keys(typedObject);
+            for (let x = 0; x < keys.length; x++)
+                FlattenValue(root, typedObject[keys[x]], keyFunc);
     }
-    /**
-     * Flattens nested objects/arrays, extracting keyed objects to root.
-     * @param root - Root object to store flattened values
-     * @param value - Value to flatten
-     * @param keyFunc - Function to extract key from objects
-     * @returns The root object with flattened values
-     */
-    function FlattenValue(root, value, keyFunc) {
-        const type = JsonType(value);
-        switch (type) {
-            case "array":
-                const typedArray = value;
-                for (let x = 0; x < typedArray.length; x++)
-                    FlattenValue(root, typedArray[x], keyFunc);
-                break;
-            case "object":
-                const typedObject = value;
-                const key = keyFunc(typedObject);
-                if (key)
-                    root[key] = typedObject;
-                const keys = Object.keys(typedObject);
-                for (let x = 0; x < keys.length; x++)
-                    FlattenValue(root, typedObject[keys[x]], keyFunc);
-        }
-        return root;
+    return root;
+}
+/**
+ * Retrieves a value from a source object using a dot-separated path.
+ * @param source - The source object
+ * @param path - Dot-separated path to the value (empty string returns source)
+ * @returns The value at the specified path
+ */
+function GetPathValue(source, path) {
+    if (path === "")
+        return [source, true];
+    const parts = path.split(".");
+    let curr = source;
+    let x = 0;
+    for (; curr && x < parts.length - 1; x++)
+        curr = curr[parts[x]];
+    if (curr && Object.hasOwn(curr, parts[x])) {
+        curr = curr[parts[x]];
+        x++;
     }
-    /**
-     * Retrieves a value from a source object using a dot-separated path.
-     * @param source - The source object
-     * @param path - Dot-separated path to the value (empty string returns source)
-     * @returns The value at the specified path
-     */
-    function GetPathValue(source, path) {
-        if (path === "")
-            return [source, true];
-        const parts = path.split(".");
-        let curr = source;
-        let x = 0;
-        for (; curr && x < parts.length - 1; x++)
-            curr = curr[parts[x]];
-        if (curr && Object.hasOwn(curr, parts[x])) {
-            curr = curr[parts[x]];
-            x++;
-        }
-        else
-            curr = undefined;
-        return [curr, x === parts.length];
+    else
+        curr = undefined;
+    return [curr, x === parts.length];
+}
+/**
+ * Sets a value in a source object at the specified path.
+ * @param source - The source object
+ * @param path - Array of path segments (strings for keys, numbers for indices)
+ * @param value - The value to set
+ */
+function SetPathValue(source, path, value) {
+    if (path.length === 0)
+        return;
+    let curr = source;
+    let x = 0;
+    for (; x < path.length - 1; x++)
+        curr = curr[path[x]];
+    curr[path[x]] = value;
+    InvalidateSnapshotForValue(curr);
+}
+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);
+}
+/**
+ * Clears the cached snapshot for a raw value that was just written to, and climbs to
+ * every parent whose own cached snapshot embedded it, so a write to a deeply nested value
+ * invalidates every cached ancestor that still holds a snapshot. Mirrors ObservableNode's
+ * `InvalidateSnapshotForValue`.
+ */
+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);
+}
+/**
+ * An immutable snapshot of a raw tree value (arrays and plain objects; other values are
+ * returned as-is), cached per raw value and reused until a write invalidates it. Mirrors
+ * ObservableNode's `CreateSnapshot`: a rebuild makes new containers but reuses the cached
+ * snapshots of unchanged children. A keyed child is read through the root entity `keyFunc`
+ * resolves it to, the parallel of ObservableNode's `alias`, so every reference to the same
+ * entity shares one snapshot and a write to the entity invalidates every holder.
+ */
+function CreateSnapshot(source, keyFunc, value) {
+    if (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(source, keyFunc, value, value[x]);
     }
-    /**
-     * Sets a value in a source object at the specified path.
-     * @param source - The source object
-     * @param path - Array of path segments (strings for keys, numbers for indices)
-     * @param value - The value to set
-     */
-    function SetPathValue(source, path, value) {
-        if (path.length === 0)
-            return;
-        let curr = source;
-        let x = 0;
-        for (; x < path.length - 1; x++)
-            curr = curr[path[x]];
-        curr[path[x]] = value;
-        InvalidateSnapshotForValue(curr);
+    else {
+        snapshot = {};
+        const keys = Object.keys(value);
+        for (let x = 0; x < keys.length; x++)
+            snapshot[keys[x]] = ChildSnapshot(source, keyFunc, value, value[keys[x]]);
     }
-    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);
+    valueSnapshotCache.set(value, snapshot);
+    return snapshot;
+}
+/**
+ * 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 entity (`source[key]`), 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(source, keyFunc, parent, child) {
+    if (JsonType(child) === "value")
+        return child;
+    CreateSnapshotLink(child, parent);
+    if (keyFunc) {
+        const key = keyFunc(child);
+        if (key) {
+            const root = source[key];
+            if (root !== undefined && root !== child) {
+                CreateSnapshotLink(root, parent);
+                return CreateSnapshot(source, keyFunc, root);
+            }
+        }
     }
-    /**
-     * Clears the cached snapshot for a raw value that was just written to, and climbs to
-     * every parent whose own cached snapshot embedded it, so a write to a deeply nested value
-     * invalidates every cached ancestor that still holds a snapshot. Mirrors ObservableNode's
-     * `InvalidateSnapshotForValue`.
-     */
-    function InvalidateSnapshotForValue(value) {
-        valueSnapshotCache.delete(value);
-        const parents = valueSnapshotHierarchy.get(value);
-        if (parents === undefined)
+    return CreateSnapshot(source, keyFunc, child);
+}
+/**
+ * Topologically sorts projections by their declared `reads` into a single array, run
+ * sequentially: a read of another projection's `$projection_<id>` output is a dependency
+ * edge, so that projection is sorted earlier. Runs once, at construction, so a cycle (or a
+ * read of an id that isn't registered) is rejected immediately instead of on first write.
+ */
+function BuildProjectionOrder(projections) {
+    const order = [];
+    const state = new Map();
+    function Visit(id, stack) {
+        if (state.get(id) === "done")
             return;
-        valueSnapshotHierarchy.delete(value);
-        for (const parent of parents)
-            if (valueSnapshotCache.has(parent))
-                InvalidateSnapshotForValue(parent);
+        if (state.get(id) === "visiting")
+            throw new Error(`DiffTree projection cycle detected: ${stack.concat(id).join(" -> ")}`);
+        const def = projections[id];
+        if (!def)
+            throw new Error(`DiffTree projection "${id}" is not defined`);
+        state.set(id, "visiting");
+        for (let x = 0; x < def.reads.length; x++) {
+            const read = def.reads[x];
+            const root = read.split(".", 1)[0];
+            if (root.endsWith("*") && x !== def.reads.length - 1)
+                throw `Wildcard reads only supported as the final read: ${root}`;
+            if (root.endsWith("*") && root.includes("."))
+                throw `Wildcard reads do not support dot nesting: ${root}`;
+            if (root.startsWith(PROJECTION_PREFIX) && read.endsWith("*"))
+                throw `Projection keys do not support wildcard reads: ${root}`;
+            if (root.startsWith(PROJECTION_PREFIX))
+                Visit(root.slice(PROJECTION_PREFIX.length), stack.concat(id));
+        }
+        state.set(id, "done");
+        order.push({ id, ...def });
     }
-    /**
-     * An immutable snapshot of a raw tree value (arrays and plain objects; other values are
-     * returned as-is), cached per raw value and reused until a write invalidates it. Mirrors
-     * ObservableNode's `CreateSnapshot`: a rebuild makes new containers but reuses the cached
-     * snapshots of unchanged children. A keyed child is read through the root entity `keyFunc`
-     * resolves it to, the parallel of ObservableNode's `alias`, so every reference to the same
-     * entity shares one snapshot and a write to the entity invalidates every holder.
-     */
-    function CreateSnapshot(source, keyFunc, value) {
-        if (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(source, keyFunc, value, value[x]);
+    const ids = Object.keys(projections);
+    for (let x = 0; x < ids.length; x++)
+        Visit(ids[x], []);
+    return order;
+}
+/**
+ * Runs every registered projection, sequentially in the dependency order
+ * `BuildProjectionOrder` computed, skipping ones whose declared `reads` all still resolve
+ * to the same cached snapshot as last time (so nothing they read has changed), and returns
+ * the diff of every projection whose result changed. A projection's result is stored at
+ * `$projection_<id>` the same way a `DiffPath` write is: diffed against what was there
+ * before and applied path by path, so a change to one field of a projection's result
+ * produces one small diff entry rather than replacing the whole thing.
+ *
+ * Because `order` runs dependencies before dependents, a projection that reads another's
+ * `$projection_<id>` output (chaining) always sees that projection's up-to-date result
+ * within the same pass.
+ *
+ * A projection whose `reads` names a root key that doesn't exist yet (a plain path never
+ * written, an entity never seen, or another projection that hasn't produced a result) is
+ * not run at all, so a projection's author never has to guard every parameter against
+ * missing data. It's tried again on every later write until every read exists. This also
+ * makes a blocked dependency propagate for free: a projection that never runs never writes
+ * `$projection_<id>`, so anything chaining off it stays blocked in turn.
+ *
+ * @param source - The root tree object
+ * @param keyFunc - Optional function to extract a key from objects, for reading through roots
+ * @param projections - Dependency-sorted projection entries, from `BuildProjectionOrder`
+ * @param memo - Per-tree, cross-call memo of each projection's last-read values, by id,
+ *   positional with its `reads`
+ * @returns Diff entries for every projection whose result changed
+ */
+function RunProjections(source, keyFunc, projections, memo) {
+    const diffResult = [];
+    for (let x = 0; x < projections.length; x++) {
+        const { id, reads, projection } = projections[x];
+        const values = [];
+        let allPathsExist = true;
+        let y = 0;
+        for (; allPathsExist && y < reads.length && !reads[y].endsWith("*"); y++) {
+            const read = reads[y];
+            const [value, found] = GetPathValue(source, read);
+            allPathsExist = found;
+            values[y] = (found && CreateSnapshot(source, keyFunc, value)) || value;
         }
-        else {
-            snapshot = {};
-            const keys = Object.keys(value);
-            for (let x = 0; x < keys.length; x++)
-                snapshot[keys[x]] = ChildSnapshot(source, keyFunc, value, value[keys[x]]);
+        if (y < reads.length && reads[y].endsWith("*")) {
+            const prefix = reads[y].slice(0, reads[y].length - 1);
+            const keys = Object.keys(source).filter(key => key.startsWith(prefix));
+            for (let z = 0; z < keys.length; z++) {
+                const [value, found] = GetPathValue(source, keys[z]);
+                allPathsExist = allPathsExist && found;
+                values.push((found && CreateSnapshot(source, keyFunc, value)) || value);
+            }
         }
-        valueSnapshotCache.set(value, snapshot);
-        return snapshot;
-    }
-    /**
-     * 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 entity (`source[key]`), 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(source, keyFunc, parent, child) {
-        if (JsonType(child) === "value")
-            return child;
-        CreateSnapshotLink(child, parent);
-        if (keyFunc) {
-            const key = keyFunc(child);
-            if (key) {
-                const root = source[key];
-                if (root !== undefined && root !== child) {
-                    CreateSnapshotLink(root, parent);
-                    return CreateSnapshot(source, keyFunc, root);
-                }
+        if (allPathsExist) {
+            const priorValues = memo.get(id);
+            if (!ArraysEqual(priorValues, values)) {
+                const result = projection(...values);
+                memo.set(id, values);
+                // The same diff-and-apply UpdateSource uses for any other write, so a keyed entity
+                // embedded in a projection's result is flattened to its own root like any other write,
+                // and the diff reported here is unfiltered, the same as DiffPath/DiffBatch return.
+                diffResult.push(...UpdateSource(source, PROJECTION_PREFIX + id, result, true, keyFunc));
             }
         }
-        return CreateSnapshot(source, keyFunc, child);
     }
-    /**
-     * Topologically sorts projections by their declared `reads` into a single array, run
-     * sequentially: a read of another projection's `$projection_<id>` output is a dependency
-     * edge, so that projection is sorted earlier. Runs once, at construction, so a cycle (or a
-     * read of an id that isn't registered) is rejected immediately instead of on first write.
-     */
-    function BuildProjectionOrder(projections) {
-        const order = [];
-        const state = new Map();
-        function Visit(id, stack) {
-            if (state.get(id) === "done")
-                return;
-            if (state.get(id) === "visiting")
-                throw new Error(`DiffTree projection cycle detected: ${stack.concat(id).join(" -> ")}`);
-            const def = projections[id];
-            if (!def)
-                throw new Error(`DiffTree projection "${id}" is not defined`);
-            state.set(id, "visiting");
-            for (let x = 0; x < def.reads.length; x++) {
-                const root = def.reads[x].split(".", 1)[0];
-                if (root.startsWith(exports.PROJECTION_PREFIX))
-                    Visit(root.slice(exports.PROJECTION_PREFIX.length), stack.concat(id));
-            }
-            state.set(id, "done");
-            order.push({ id, ...def });
+    return diffResult;
+}
+/**
+ * Resolves a path to its keyed root object if applicable.
+ * Searches up the path to find an object with a key from keyFunc.
+ * @param source - The source object
+ * @param path - Dot-separated path
+ * @param keyFunc - Function to extract key from objects
+ * @returns The resolved path (possibly shortened to root key)
+ */
+function ResolveKeyPath(source, path, keyFunc) {
+    const parts = path.split(".");
+    const pathValues = new Array(parts.length - 1);
+    let curr = source;
+    for (let x = 0; x < parts.length - 1; x++) {
+        curr = curr[parts[x]];
+        pathValues[x] = curr;
+    }
+    let y = pathValues.length - 1;
+    for (; y >= 0 && !(JsonType(pathValues[y]) === "object" && keyFunc(pathValues[y])); y--) { }
+    if (y >= 0) {
+        const key = keyFunc(pathValues[y]);
+        parts.splice(0, y + 1, key);
+        return parts.join(".");
+    }
+    return path;
+}
+/**
+ * Updates the source with a new value at the specified path and computes diffs.
+ * Also updates any keyed objects that were nested in the value.
+ * @param source - The source object to update
+ * @param path - Dot-separated path to update
+ * @param value - The new value
+ * @param keyFunc - Optional function to extract keys from objects
+ * @returns Diff results showing all changes made
+ */
+function UpdateSource(source, path, value, flatten, keyFunc) {
+    const diffResult = [];
+    if (keyFunc) {
+        const keyPath = ResolveKeyPath(source, path, keyFunc);
+        if (keyPath !== path) {
+            const keyDiffResult = UpdateSource(source, keyPath, value, flatten, keyFunc);
+            diffResult.push(...keyDiffResult);
         }
-        const ids = Object.keys(projections);
-        for (let x = 0; x < ids.length; x++)
-            Visit(ids[x], []);
-        return order;
     }
+    const [sourceValue] = GetPathValue(source, path);
+    JsonDiff(value, sourceValue, path, diffResult);
+    if (flatten && keyFunc) {
+        let flattened = {};
+        flattened = FlattenValue(flattened, value, keyFunc);
+        flattened = JsonDeepClone(flattened);
+        const keys = Object.keys(flattened);
+        for (let x = 0; x < keys.length; x++)
+            JsonDiff(flattened[keys[x]], source[keys[x]], keys[x], diffResult);
+    }
+    const filteredDiffResult = diffResult.filter((diff) => diff.value !== undefined);
+    for (let x = 0; x < filteredDiffResult.length; x++) {
+        SetPathValue(source, filteredDiffResult[x].path, filteredDiffResult[x].value);
+    }
+    return diffResult;
+}
+function SpliceSource(source, path, start, deleteCount, items, flatten, keyFunc) {
+    const [sourceValue, found] = GetPathValue(source, path);
+    if (!found)
+        throw `Value not found at path ${path}`;
+    if (!Array.isArray(sourceValue))
+        throw `Value found at path ${path} is not an array`;
+    deleteCount ??= sourceValue.length - start;
+    const spliceResult = {
+        path: path.split("."),
+        start,
+        deleteCount,
+        spliceResult: null,
+        diffResult: [],
+    };
+    spliceResult.spliceResult = sourceValue.splice(start, deleteCount, ...items);
+    InvalidateSnapshotForValue(sourceValue);
+    if (flatten && keyFunc) {
+        // Register the keyed entities the new items carry, diffed against the roots
+        // already held: a new entity is added whole, one re-inserted unchanged (an undo)
+        // produces no diff, so its readers aren't woken.
+        const flattened = JsonDeepClone(FlattenValue({}, items, keyFunc));
+        const keys = Object.keys(flattened);
+        for (let x = 0; x < keys.length; x++)
+            JsonDiff(flattened[keys[x]], source[keys[x]], keys[x], spliceResult.diffResult);
+    }
+    const filteredDiffResult = spliceResult.diffResult.filter((diff) => diff.value !== undefined);
+    for (let x = 0; x < filteredDiffResult.length; x++) {
+        SetPathValue(source, filteredDiffResult[x].path, filteredDiffResult[x].value);
+    }
+    return spliceResult;
+}
+/**
+ * Internal diff tree implementation.
+ * Maintains root state and computes diffs for path/value updates.
+ * @private
+ */
+export class DiffTree {
     /**
-     * Runs every registered projection, sequentially in the dependency order
-     * `BuildProjectionOrder` computed, skipping ones whose declared `reads` all still resolve
-     * to the same cached snapshot as last time (so nothing they read has changed), and returns
-     * the diff of every projection whose result changed. A projection's result is stored at
-     * `$projection_<id>` the same way a `DiffPath` write is: diffed against what was there
-     * before and applied path by path, so a change to one field of a projection's result
-     * produces one small diff entry rather than replacing the whole thing.
-     *
-     * Because `order` runs dependencies before dependents, a projection that reads another's
-     * `$projection_<id>` output (chaining) always sees that projection's up-to-date result
-     * within the same pass.
-     *
-     * A projection whose `reads` names a root key that doesn't exist yet (a plain path never
-     * written, an entity never seen, or another projection that hasn't produced a result) is
-     * not run at all, so a projection's author never has to guard every parameter against
-     * missing data. It's tried again on every later write until every read exists. This also
-     * makes a blocked dependency propagate for free: a projection that never runs never writes
-     * `$projection_<id>`, so anything chaining off it stays blocked in turn.
-     *
-     * @param source - The root tree object
-     * @param keyFunc - Optional function to extract a key from objects, for reading through roots
-     * @param projections - Dependency-sorted projection entries, from `BuildProjectionOrder`
-     * @param memo - Per-tree, cross-call memo of each projection's last-read values, by id,
-     *   positional with its `reads`
-     * @returns Diff entries for every projection whose result changed
+     * Creates a DiffTree instance.
+     * @param keyFunc - Optional function to extract a key from objects
+     * @param projections - Optional map of derived-value projections, keyed by id. Cycles
+     *   and reads of an unregistered projection id are rejected here, at construction.
      */
-    function RunProjections(source, keyFunc, projections, memo) {
-        const diffResult = [];
-        for (let x = 0; x < projections.length; x++) {
-            const { id, reads, projection } = projections[x];
-            const values = new Array(reads.length);
-            let allPathsExist = true;
-            for (let y = 0; allPathsExist && y < reads.length; y++) {
-                const [value, found] = GetPathValue(source, reads[y]);
-                allPathsExist = found;
-                values[y] = found && CreateSnapshot(source, keyFunc, value) || value;
-            }
-            if (allPathsExist) {
-                const priorValues = memo.get(id);
-                if (!arraysEqual(priorValues, values)) {
-                    const result = projection(...values);
-                    memo.set(id, values);
-                    // The same diff-and-apply UpdateSource uses for any other write, so a keyed entity
-                    // embedded in a projection's result is flattened to its own root like any other write,
-                    // and the diff reported here is unfiltered, the same as DiffPath/DiffBatch return.
-                    diffResult.push(...UpdateSource(source, exports.PROJECTION_PREFIX + id, result, true, keyFunc));
-                }
-            }
-        }
-        return diffResult;
+    constructor(keyFunc, projections) {
+        this.keyFunc = keyFunc;
+        this.rootState = {};
+        this.projectionMemo = new Map();
+        this.projectionOrder = projections ? BuildProjectionOrder(projections) : [];
+    }
+    RunProjections() {
+        if (this.projectionOrder.length === 0)
+            return [];
+        return RunProjections(this.rootState, this.keyFunc, this.projectionOrder, this.projectionMemo);
     }
     /**
-     * Resolves a path to its keyed root object if applicable.
-     * Searches up the path to find an object with a key from keyFunc.
-     * @param source - The source object
-     * @param path - Dot-separated path
-     * @param keyFunc - Function to extract key from objects
-     * @returns The resolved path (possibly shortened to root key)
+     * Computes diffs for a batch of path/value pairs.
+     * @param data - Array of objects with path and value properties
+     * @returns Combined diff results
      */
-    function ResolveKeyPath(source, path, keyFunc) {
-        const parts = path.split(".");
-        const pathValues = new Array(parts.length - 1);
-        let curr = source;
-        for (let x = 0; x < parts.length - 1; x++) {
-            curr = curr[parts[x]];
-            pathValues[x] = curr;
-        }
-        let y = pathValues.length - 1;
-        for (; y >= 0 &&
-            !(JsonType(pathValues[y]) === "object" && keyFunc(pathValues[y])); y--) { }
-        if (y >= 0) {
-            const key = keyFunc(pathValues[y]);
-            parts.splice(0, y + 1, key);
-            return parts.join(".");
-        }
-        return path;
+    DiffBatch(data) {
+        const results = data
+            .map(({ path, value }) => UpdateSource(this.rootState, path, value, true, this.keyFunc))
+            .flat(1);
+        results.push(...this.RunProjections());
+        return results;
     }
     /**
-     * Updates the source with a new value at the specified path and computes diffs.
-     * Also updates any keyed objects that were nested in the value.
-     * @param source - The source object to update
-     * @param path - Dot-separated path to update
-     * @param value - The new value
-     * @param keyFunc - Optional function to extract keys from objects
-     * @returns Diff results showing all changes made
+     * Computes the diff between a new value and the current value at a path.
+     * @param path - Dot-separated path to the value
+     * @param value - The new value to compare
+     * @returns Diff results showing changes
      */
-    function UpdateSource(source, path, value, flatten, keyFunc) {
-        const diffResult = [];
-        if (keyFunc) {
-            const keyPath = ResolveKeyPath(source, path, keyFunc);
-            if (keyPath !== path) {
-                const keyDiffResult = UpdateSource(source, keyPath, value, flatten, keyFunc);
-                diffResult.push(...keyDiffResult);
-            }
-        }
-        const [sourceValue] = GetPathValue(source, path);
-        JsonDiff(value, sourceValue, path, diffResult);
-        if (flatten && keyFunc) {
-            let flattened = {};
-            flattened = FlattenValue(flattened, value, keyFunc);
-            flattened = JsonDeepClone(flattened);
-            const keys = Object.keys(flattened);
-            for (let x = 0; x < keys.length; x++)
-                JsonDiff(flattened[keys[x]], source[keys[x]], keys[x], diffResult);
-        }
-        const filteredDiffResult = diffResult.filter((diff) => diff.value !== undefined);
-        for (let x = 0; x < filteredDiffResult.length; x++) {
-            SetPathValue(source, filteredDiffResult[x].path, filteredDiffResult[x].value);
-        }
-        return diffResult;
+    DiffPath(path, value, flatten = true) {
+        const results = UpdateSource(this.rootState, path, value, flatten, this.keyFunc);
+        results.push(...this.RunProjections());
+        return results;
     }
-    function SpliceSource(source, path, start, deleteCount, items, flatten, keyFunc) {
-        const [sourceValue, found] = GetPathValue(source, path);
-        if (!found)
-            throw `Value not found at path ${path}`;
-        if (!Array.isArray(sourceValue))
-            throw `Value found at path ${path} is not an array`;
-        deleteCount ??= sourceValue.length - start;
-        const spliceResult = {
-            path: path.split("."),
-            start,
-            deleteCount,
-            spliceResult: null,
-            diffResult: []
-        };
-        spliceResult.spliceResult = sourceValue.splice(start, deleteCount, ...items);
-        InvalidateSnapshotForValue(sourceValue);
-        if (flatten && keyFunc) {
-            // Register the keyed entities the new items carry, diffed against the roots
-            // already held: a new entity is added whole, one re-inserted unchanged (an undo)
-            // produces no diff, so its readers aren't woken.
-            const flattened = JsonDeepClone(FlattenValue({}, items, keyFunc));
-            const keys = Object.keys(flattened);
-            for (let x = 0; x < keys.length; x++)
-                JsonDiff(flattened[keys[x]], source[keys[x]], keys[x], spliceResult.diffResult);
-        }
-        const filteredDiffResult = spliceResult.diffResult.filter((diff) => diff.value !== undefined);
-        for (let x = 0; x < filteredDiffResult.length; x++) {
-            SetPathValue(source, filteredDiffResult[x].path, filteredDiffResult[x].value);
-        }
+    SplicePath(path, start, deleteCount, items, flatten = true) {
+        const spliceResult = SpliceSource(this.rootState, path, start, deleteCount, items, flatten, this.keyFunc);
+        spliceResult.diffResult.push(...this.RunProjections());
         return spliceResult;
     }
     /**
-     * Internal diff tree implementation.
-     * Maintains root state and computes diffs for path/value updates.
-     * @private
+     * Retrieves the current value at a path.
+     * @param path - Dot-separated path to the value
+     * @returns The value at the specified path
      */
-    class DiffTree {
-        /**
-         * Creates a DiffTree instance.
-         * @param keyFunc - Optional function to extract a key from objects
-         * @param projections - Optional map of derived-value projections, keyed by id. Cycles
-         *   and reads of an unregistered projection id are rejected here, at construction.
-         */
-        constructor(keyFunc, projections) {
-            this.keyFunc = keyFunc;
-            this.rootState = {};
-            this.projectionMemo = new Map();
-            this.projectionOrder = projections ? BuildProjectionOrder(projections) : [];
-        }
-        RunProjections() {
-            if (this.projectionOrder.length === 0)
-                return [];
-            return RunProjections(this.rootState, this.keyFunc, this.projectionOrder, this.projectionMemo);
-        }
-        /**
-         * Computes diffs for a batch of path/value pairs.
-         * @param data - Array of objects with path and value properties
-         * @returns Combined diff results
-         */
-        DiffBatch(data) {
-            const results = data
-                .map(({ path, value }) => UpdateSource(this.rootState, path, value, true, this.keyFunc))
-                .flat(1);
-            results.push(...this.RunProjections());
-            return results;
-        }
-        /**
-         * Computes the diff between a new value and the current value at a path.
-         * @param path - Dot-separated path to the value
-         * @param value - The new value to compare
-         * @returns Diff results showing changes
-         */
-        DiffPath(path, value, flatten = true) {
-            const results = UpdateSource(this.rootState, path, value, flatten, this.keyFunc);
-            results.push(...this.RunProjections());
-            return results;
-        }
-        SplicePath(path, start, deleteCount, items, flatten = true) {
-            const spliceResult = SpliceSource(this.rootState, path, start, deleteCount, items, flatten, this.keyFunc);
-            spliceResult.diffResult.push(...this.RunProjections());
-            return spliceResult;
-        }
-        /**
-         * Retrieves the current value at a path.
-         * @param path - Dot-separated path to the value
-         * @returns The value at the specified path
-         */
-        GetPath(path) {
-            const [value] = GetPathValue(this.rootState, path);
-            return value;
-        }
-        /**
-         * Returns an immutable, cached snapshot of the value at a path (empty string for the
-         * whole tree). Not part of `IDiffTree`; internal, for a future feature.
-         * @param path - Dot-separated path to the value
-         */
-        Snapshot(path) {
-            const [value, found] = GetPathValue(this.rootState, path);
-            if (!found)
-                throw `Unable to get snapshot for path ${path}`;
-            return CreateSnapshot(this.rootState, this.keyFunc, value);
-        }
+    GetPath(path) {
+        const [value] = GetPathValue(this.rootState, path);
+        return value;
+    }
+    /**
+     * Returns an immutable, cached snapshot of the value at a path (empty string for the
+     * whole tree). Not part of `IDiffTree`; internal, for a future feature.
+     * @param path - Dot-separated path to the value
+     */
+    Snapshot(path) {
+        const [value, found] = GetPathValue(this.rootState, path);
+        if (!found)
+            throw `Unable to get snapshot for path ${path}`;
+        return CreateSnapshot(this.rootState, this.keyFunc, value);
     }
-    return DiffTree;
 }