j-templates 8.1.2 → 9.0.0

package/Utils/json.js

@@ -1,3 +1,15 @@
+/** How an inserted splice item gets its value */
+export var SPLICE_ACTION;
+(function (SPLICE_ACTION) {
+    /** The element at `from` in the array before the splice is applied */
+    SPLICE_ACTION[SPLICE_ACTION["MOVE"] = 1] = "MOVE";
+    /** A new value */
+    SPLICE_ACTION[SPLICE_ACTION["INSERT"] = 2] = "INSERT";
+})(SPLICE_ACTION || (SPLICE_ACTION = {}));
+/** The default strategy: every changed object and array is diffed into, arrays by position */
+export const JsonDiffDefaultStrategy = () => "diff";
+/** The default identity: an element is its own identity, so elements are compared by === */
+export const JsonDiffDefaultIdentity = (value) => value;
 const jsonProto = Object.getPrototypeOf({});
 const arrayProto = Object.getPrototypeOf([]);
 const strProto = Object.getPrototypeOf("");
@@ -94,126 +106,579 @@ export function JsonDeepClone(value, type = JsonType(value)) {
             return value;
     }
 }
+/**
+ * Applies a diff result to a root value in place, one record at a time in order. A diff doesn't own
+ * its values (see JsonDiff), so each value written or inserted is deep-cloned first: the root never
+ * shares an object with the diff, the value it was computed from, or another record, unless
+ * `clone` says otherwise.
+ * - A write assigns its value at its path
+ * - A delete removes the property its path ends with
+ * - A splice record splices the array at its path in place (see JsonApplySplices)
+ * @param root - The value to update; must be an object or array
+ * @param diff - The diff result to apply
+ * @param assign - Assigns a written value (already cloned) to its parent
+ * @param remove - Removes a deleted property from its parent
+ * @param spliced - Called with each array a splice record changed, after it's changed
+ * @param clone - Copies each value before it's written or inserted. A caller that already owns the
+ *   diff's values can pass one that keeps them, or parts of them, as they are.
+ * @throws For a write or delete with an empty path: the root can't be replaced or removed, only
+ *   changed inside. JsonDiff records one only when the root's JSON type changes.
+ */
+export function JsonApplyDiff(root, diff, assign = DefaultAssign, remove = DefaultRemove, spliced, clone = JsonDeepClone) {
+    // The objects along the last path walked, so records under the same parent walk it once:
+    // walked[y] is [path[y - 1], the object at path[0..y)]
+    const walked = [["", root]];
+    for (let x = 0; x < diff.length; x++) {
+        const record = diff[x];
+        const path = record.path;
+        if (path.length === 0 && record.type !== "splice")
+            throw new Error("Unable to replace the root of a diff: apply it to an object holding the root");
+        if (record.type !== "splice") {
+            const parent = Walk(walked, path, path.length - 1);
+            const prop = path[path.length - 1];
+            record.type === "write" ? assign(parent, prop, clone(record.value)) : remove(parent, prop);
+            // The value at the path was replaced or removed, so anything walked through it is gone
+            walked.length = Math.min(walked.length, path.length);
+        }
+        else {
+            const array = Walk(walked, path, path.length);
+            if (!Array.isArray(array))
+                throw new Error(`Unable to splice ${path.join(".")}: not an array`);
+            JsonApplySplices(array, record.splices, clone);
+            // The array is the same object, but its elements moved
+            walked.length = Math.min(walked.length, path.length + 1);
+            spliced?.(array);
+        }
+    }
+}
+function DefaultAssign(parent, prop, value) {
+    parent[prop] = value;
+}
+function DefaultRemove(parent, prop) {
+    delete parent[prop];
+}
+/** The object at `path[0..depth)`, walking from the deepest object in `walked` still on the path */
+function Walk(walked, path, depth) {
+    for (let y = 0; y < depth; y++) {
+        const property = path[y];
+        const index = y + 1;
+        if (index < walked.length && walked[index][0] === property)
+            continue;
+        const child = walked[y][1][property];
+        if (index < walked.length) {
+            walked[index] = [property, child];
+            // Deeper entries were under the old object; clearing the next one makes the walk refresh each
+            if (index + 1 < walked.length)
+                walked[index + 1][0] = null;
+        }
+        else
+            walked.push([property, child]);
+    }
+    return walked[depth][1];
+}
+/** Sets an array's elements to `items` in place. Unlike `splice(0, length, ...items)`, any length works. */
+function ReplaceArrayContents(array, items) {
+    for (let x = 0; x < items.length; x++)
+        array[x] = items[x];
+    array.length = items.length;
+}
+/**
+ * Applies splices to an array in place, in one pass however many there are: the new contents are
+ * built from the old ones, then written back into the same array. A moved item is the old element
+ * at its `from`, as is; an inserted item's value is deep-cloned.
+ * @param splices - In ascending, non-overlapping order, as JsonDiffArraySplice returns them: each
+ *   one's index is at or after where the one before it ended
+ * @param clone - Copies each inserted value; see JsonApplyDiff
+ * @throws When a splice starts before the one before it ended
+ */
+export function JsonApplySplices(array, splices, clone = JsonDeepClone) {
+    if (splices.length === 0)
+        return;
+    // `array` isn't changed until the end, so it's read as the original throughout
+    const result = [];
+    // The next old element to copy. The array as the splices so far left it is `result`, then the old
+    // elements from `read` on.
+    let read = 0;
+    for (let x = 0; x < splices.length; x++) {
+        const splice = splices[x];
+        if (splice.index < result.length)
+            throw new Error(`Unable to apply splice at ${splice.index}: splices must be in ascending, non-overlapping order`);
+        // Copy the old elements up to the splice; an index past the end splices at the end, as
+        // Array.prototype.splice does
+        for (; result.length < splice.index && read < array.length; read++)
+            result.push(array[read]);
+        read = Math.min(read + splice.delete, array.length);
+        for (let y = 0; y < splice.insert.length; y++) {
+            const item = splice.insert[y];
+            result.push(item.type === SPLICE_ACTION.MOVE ? array[item.from] : clone(item.value));
+        }
+    }
+    for (; read < array.length; read++)
+        result.push(array[read]);
+    ReplaceArrayContents(array, result);
+}
+/**
+ * Whether two JSON values differ, without recording how: it stops at the first difference and
+ * skips any subtree both values share, so it costs no more than walking what differs. An
+ * undefined property counts as absent, as in JSON. Arrays are compared by position.
+ * @param newValue - The new value
+ * @param oldValue - The old value to compare against
+ * @returns true when the values differ
+ */
+export function JsonHasChanges(newValue, oldValue) {
+    if (newValue === oldValue)
+        return false;
+    const type = JsonType(newValue);
+    if (type !== JsonType(oldValue))
+        return true;
+    switch (type) {
+        case "array": {
+            const newArray = newValue;
+            const oldArray = oldValue;
+            if (newArray.length !== oldArray.length)
+                return true;
+            for (let x = 0; x < newArray.length; x++)
+                if (JsonHasChanges(newArray[x], oldArray[x]))
+                    return true;
+            return false;
+        }
+        case "object": {
+            const newObject = newValue;
+            const oldObject = oldValue;
+            const newKeys = Object.keys(newObject);
+            let defined = 0;
+            for (let x = 0; x < newKeys.length; x++) {
+                const value = newObject[newKeys[x]];
+                if (value === undefined)
+                    continue;
+                defined++;
+                if (!Object.hasOwn(oldObject, newKeys[x]) || JsonHasChanges(value, oldObject[newKeys[x]]))
+                    return true;
+            }
+            // Every defined key of the new value is in the old one, so they differ only when the old
+            // one defines more
+            const oldKeys = Object.keys(oldObject);
+            if (oldKeys.length === defined)
+                return false;
+            let oldDefined = 0;
+            for (let x = 0; x < oldKeys.length; x++)
+                if (oldObject[oldKeys[x]] !== undefined)
+                    oldDefined++;
+            return oldDefined !== defined;
+        }
+        default:
+            return true;
+    }
+}
+/**
+ * `newValue`, with every part that has no changes from the same place in `oldValue` (as
+ * JsonHasChanges compares them) replaced by `oldValue`'s object, so unchanged parts keep their
+ * identity. Neither value is changed: a container of `newValue` is copied only when one of its
+ * children is replaced, and kept as it is otherwise. Arrays are compared by position.
+ *
+ *   old: { a: { x: 1 }, b: { y: 1 } }
+ *   new: { a: { x: 1 }, b: { y: 2 } }
+ *   result: { a: old.a, b: new.b }, a new object
+ *
+ * @param newValue - The new value
+ * @param oldValue - The value whose objects are kept where nothing changed
+ * @returns `oldValue` itself when nothing changed, otherwise `newValue` or a copy of it holding
+ *   `oldValue`'s unchanged parts
+ */
+export function JsonMaintainUnchanged(newValue, oldValue) {
+    if (newValue === oldValue)
+        return newValue;
+    const type = JsonType(newValue);
+    if (type !== JsonType(oldValue))
+        return newValue;
+    switch (type) {
+        case "array": {
+            const newArray = newValue;
+            const oldArray = oldValue;
+            let copy;
+            let unchanged = newArray.length === oldArray.length;
+            for (let x = 0; x < newArray.length; x++) {
+                const value = x < oldArray.length ? JsonMaintainUnchanged(newArray[x], oldArray[x]) : newArray[x];
+                unchanged &&= value === oldArray[x];
+                if (value !== newArray[x])
+                    (copy ??= newArray.slice())[x] = value;
+            }
+            return unchanged ? oldValue : (copy ?? newValue);
+        }
+        case "object": {
+            const newObject = newValue;
+            const oldObject = oldValue;
+            const newKeys = Object.keys(newObject);
+            let copy;
+            let unchanged = true;
+            let defined = 0;
+            for (let x = 0; x < newKeys.length; x++) {
+                const key = newKeys[x];
+                const newProp = newObject[key];
+                if (newProp === undefined)
+                    continue;
+                defined++;
+                if (!Object.hasOwn(oldObject, key)) {
+                    unchanged = false;
+                    continue;
+                }
+                const value = JsonMaintainUnchanged(newProp, oldObject[key]);
+                unchanged &&= value === oldObject[key];
+                if (value !== newProp)
+                    SetOwnProperty(copy ??= { ...newObject }, key, value);
+            }
+            // Every defined key of the new value matched, so the old one is kept unless it defines more
+            if (unchanged) {
+                const oldKeys = Object.keys(oldObject);
+                let oldDefined = 0;
+                for (let x = 0; x < oldKeys.length && oldDefined <= defined; x++)
+                    if (oldObject[oldKeys[x]] !== undefined)
+                        oldDefined++;
+                if (oldDefined === defined)
+                    return oldValue;
+            }
+            return (copy ?? newValue);
+        }
+        default:
+            return newValue;
+    }
+}
+/** Sets a key as an own property, even `__proto__`, which plain assignment would make the prototype */
+export function SetOwnProperty(target, key, value) {
+    if (key === "__proto__")
+        Object.defineProperty(target, key, { value, enumerable: true, writable: true, configurable: true });
+    else
+        target[key] = value;
+}
 /**
  * Computes the differences between two JSON values.
- * Returns an array of paths and values that changed from oldValue to newValue.
+ * Returns an array of paths and values that changed from oldValue to newValue. A value is only
+ * written whole where its JSON type changes (or a strategy says so); an object or array of the
+ * same type is always diffed into, however much of it changed. So the root itself is only ever
+ * written when its type changes, and a diff of values of the same type can always be applied
+ * in place. A record doesn't
+ * own its value: it references `newValue`'s objects, so two records can share one, and
+ * JsonApplyDiff clones each value as it's applied.
  * @template T - The type of the JSON values being compared
  * @param newValue - The new value
  * @param oldValue - The old value to compare against
- * @param rootPath - Optional dot-separated string for the base path (for internal recursion)
- * @param initResult - Optional initial result array (for internal recursion)
+ * @param rootPath - Optional dot-separated string for the base path
+ * @param strategy - Optional choice of how each changed object or array is diffed; without one,
+ *   everything is diffed by walking into it, arrays by position
+ * @param identity - Optional identity a spliced array's elements are compared by; without one,
+ *   elements are compared by ===. See JsonDiffIdentityFunc
  * @returns Array of change records with path and new value
  */
-export function JsonDiff(newValue, oldValue, rootPath, initResult) {
-    const result = initResult ?? [];
-    const startPath = rootPath ? rootPath.split(".") : [];
-    JsonDiffRecursive(startPath, newValue, oldValue, result);
+export function JsonDiff(newValue, oldValue, rootPath, strategy, identity) {
+    const result = [];
+    JsonDiffInto(newValue, oldValue, rootPath ? rootPath.split(".") : [], result, strategy, identity);
     return result;
 }
 /**
- * Recursive helper for JsonDiff that traverses and compares values.
+ * Appends the differences between two JSON values to `result`, so several values can be diffed into
+ * one result.
+ * @param path - The path the values are at
+ * @param strategy - See JsonDiff
+ * @param identity - See JsonDiff
+ * @returns The result
+ */
+export function JsonDiffInto(newValue, oldValue, path, result, strategy = JsonDiffDefaultStrategy, identity = JsonDiffDefaultIdentity) {
+    JsonDiffRecursive(path, newValue, oldValue, result, { strategy, identity });
+    return result;
+}
+/**
+ * Recursive helper for JsonDiff that traverses and compares values. Values of the same JSON type
+ * are diffed into; anything else is written.
  * @internal
  * @param path - Current path being evaluated
  * @param newValue - New value at this path
  * @param oldValue - Old value at this path
  * @param resp - Result array to populate with changes
- * @returns true if the entire subtree changed, false otherwise
+ * @param options - The diff's strategy and identity, see JsonDiff
  */
-function JsonDiffRecursive(path, newValue, oldValue, resp) {
+function JsonDiffRecursive(path, newValue, oldValue, resp, options) {
     if (newValue === oldValue)
-        return false;
+        return;
     const newType = JsonType(newValue);
     const oldType = JsonType(oldValue);
-    const changedPathLength = resp.length;
-    let allChildrenChanged = true;
-    if (newType === oldType)
+    const choice = newType !== "value" ? options.strategy(newValue, oldValue, path) : undefined;
+    if (choice === "skip")
+        return;
+    if (newType === oldType && choice !== "write")
         switch (newType) {
             case "array": {
-                allChildrenChanged = JsonDiffArrays(path, newValue, oldValue, resp);
-                break;
+                if (choice === "splice") {
+                    const splices = JsonDiffArraySplice(newValue, oldValue, options.identity);
+                    splices.length > 0 && resp.push({ type: "splice", path, splices });
+                }
+                else
+                    JsonDiffArrays(path, newValue, oldValue, resp, options);
+                return;
             }
             case "object": {
-                allChildrenChanged = JsonDiffObjects(path, newValue, oldValue, resp);
-                break;
+                JsonDiffObjects(path, newValue, oldValue, resp, options);
+                return;
             }
         }
-    if (allChildrenChanged) {
-        resp.length > changedPathLength && resp.splice(changedPathLength);
-        resp.push({
-            path,
-            value: newValue,
-        });
-        return true;
+    resp.push({
+        type: "write",
+        path,
+        value: newValue,
+    });
+}
+/**
+ * The splices that turn `oldValue` into `newValue`, matching elements by identity without walking
+ * into them: two elements are the same when their identities are ===. With the default identity,
+ * that's the elements themselves. A matched element is never diffed into, even when it isn't === to
+ * its match. An identity that repeats is matched in order, and a repeat with no old element left to
+ * match is inserted.
+ *
+ * It works in four stages, followed through this example in the comments below:
+ *
+ *   old: [A, B, C, D, E, F]
+ *   new: [A, E, B, X, D, F]
+ *
+ * 1. Trim the elements identical at the start and end (A and F): they can't need a change.
+ * 2. Match each remaining new element to the old index holding the same element, or -1.
+ * 3. Choose which matched elements stay in place: the longest run of them still in their old
+ *    order (B, D). Keeping the longest run is what keeps the number of moves as small as possible.
+ * 4. Walk both arrays from kept element to kept element. Between two kept elements, delete the
+ *    old elements that aren't kept (C, E) and insert the new ones that aren't (E as a move, X as
+ *    a new value).
+ *
+ * @returns The splices, in the order to apply them; none when the arrays hold the same elements.
+ *   Applied in order to [A, B, C, D, E, F], with each move read from the array before any splice:
+ *
+ *   splice(1, 0, E)   [A, E, B, C, D, E, F]
+ *   splice(3, 1, X)   [A, E, B, X, D, E, F]
+ *   splice(5, 1)      [A, E, B, X, D, F]
+ *
+ * @param identity - What elements are compared by; see JsonDiffIdentityFunc. Elements that are
+ *   === are the same element without calling it, and it's called at most a few times for each
+ *   other element, so it must give the same identity for the same value.
+ */
+export function JsonDiffArraySplice(newValue, oldValue, identity = JsonDiffDefaultIdentity) {
+    const newLength = newValue.length;
+    const oldLength = oldValue.length;
+    // Every comparison below is between identities. Inserted values are still read from newValue.
+    const same = (a, b) => a === b || identity(a) === identity(b);
+    // Stage 1: trim the elements with the same identity at the start and end. An append, a delete or a single
+    // replaced element leaves little or nothing in the middle, so the stages after this cost little.
+    //
+    //   start: A === A, B !== E → start = 1
+    //   end:   F === F, E !== D → newEnd = oldEnd = 5
+    //   middle old (indexes 1-4): [B, C, D, E]
+    //   middle new (indexes 1-4): [E, B, X, D]
+    const shared = Math.min(newLength, oldLength);
+    let start = 0;
+    for (; start < shared && same(newValue[start], oldValue[start]); start++) { }
+    if (start === newLength && start === oldLength)
+        return [];
+    let newEnd = newLength;
+    let oldEnd = oldLength;
+    for (; newEnd > start && oldEnd > start && same(newValue[newEnd - 1], oldValue[oldEnd - 1]); newEnd--, oldEnd--) { }
+    // Stage 2: match each new element in the middle to an old index holding an element with the same
+    // identity.
+    //
+    // oldIndexes maps each old identity to every index it's at. The lists are filled from the end, so
+    // each holds its indexes highest first and pop() hands them out lowest first: the first copy of a
+    // repeated value in the new array matches its first copy in the old array, and so on. Once a
+    // value's indexes run out, any further copy has no match.
+    //
+    //   oldIndexes: B → [1], C → [2], D → [3], E → [4]
+    const oldIndexes = new Map();
+    for (let x = oldEnd - 1; x >= start; x--) {
+        const id = identity(oldValue[x]);
+        const indexes = oldIndexes.get(id);
+        indexes ? indexes.push(x) : oldIndexes.set(id, [x]);
+    }
+    // matched[x] is the old index the new element at start + x matched, or -1 when it has none.
+    //
+    //   new:      E   B   X   D
+    //   matched:  4   1  -1   3
+    const middle = newEnd - start;
+    const matched = new Int32Array(middle);
+    for (let x = 0; x < middle; x++)
+        matched[x] = oldIndexes.get(identity(newValue[start + x]))?.pop() ?? -1;
+    // Stage 3: choose which matched elements stay in place. They're the longest run whose old
+    // indexes increase from left to right, because only those can keep their order without moving.
+    //
+    //   matched:  4   1  -1   3
+    //   longest increasing run: 1, 3 → B and D are kept
+    //   E (4) is matched but out of order → it will be moved
+    //   X (-1) has no match → it will be inserted
+    //
+    // keptNew is indexed by position in the new middle; keptOld marks the same kept elements by
+    // their position in the old middle.
+    //
+    //   keptNew (E, B, X, D): 0 1 0 1
+    //   keptOld (B, C, D, E): 1 0 1 0 → C and E aren't kept, so they will be deleted
+    const keptNew = KeptMatches(matched);
+    const keptOld = new Uint8Array(oldEnd - start);
+    for (let x = 0; x < middle; x++)
+        if (keptNew[x])
+            keptOld[matched[x] - start] = 1;
+    // Stage 4: walk both arrays at once. The kept elements appear in the same order in both, so after
+    // skipping the elements that aren't kept, both cursors stop at the same kept element (or both
+    // reach the end). Each stop emits one splice:
+    // - delete: the old elements skipped, which aren't kept
+    // - insert: the new elements skipped, as a move when they were matched, otherwise as a new value
+    //
+    // A splice's index is the new cursor's position when it starts. The splices before it have already
+    // made the array match the new array up to that position, so that's where this one goes.
+    //
+    //   index 1: old skips nothing before B; new skips E (matched 4)    → { 1, delete 0, [MOVE 4] }
+    //   index 3: old skips C before D;       new skips X (no match)     → { 3, delete 1, [INSERT X] }
+    //   index 5: old skips E to the end;     new has nothing left       → { 5, delete 1, [] }
+    //
+    // The last stop is what deletes old elements left over at the end of the array.
+    const splices = [];
+    let oldIndex = start;
+    let newIndex = start;
+    while (oldIndex < oldEnd || newIndex < newEnd) {
+        const index = newIndex;
+        let deleteCount = 0;
+        for (; oldIndex < oldEnd && !keptOld[oldIndex - start]; oldIndex++)
+            deleteCount++;
+        const insert = [];
+        for (; newIndex < newEnd && !keptNew[newIndex - start]; newIndex++) {
+            const from = matched[newIndex - start];
+            insert.push(from < 0 ? { type: SPLICE_ACTION.INSERT, value: newValue[newIndex] } : { type: SPLICE_ACTION.MOVE, from });
+        }
+        // Two kept elements next to each other in both arrays leave nothing to splice between them
+        if (deleteCount > 0 || insert.length > 0)
+            splices.push({ index, delete: deleteCount, insert });
+        // Step past the kept element both cursors stopped at. At the end, this takes both past the end
+        // and the loop stops.
+        oldIndex++;
+        newIndex++;
+    }
+    return splices;
+}
+/**
+ * Which matched elements to keep in place: the longest run of them, from left to right, whose old
+ * indexes increase. That's the longest increasing subsequence of `matched`, ignoring the -1s, and
+ * every matched element left out of it has to move. O(n log n).
+ *
+ * For example, matched [4, 1, -1, 3] keeps the elements at 1 and 3 (old indexes 1 and 3), and a
+ * rotate, matched [4, 0, 1, 2, 3], keeps everything but the first, so only that one moves.
+ *
+ * @param matched - Each new element's matched old index, or -1 when it has none
+ * @returns 1 for each element kept, by position in `matched`
+ */
+function KeptMatches(matched) {
+    const length = matched.length;
+    // previous[x]: the element before x in the longest run found that ends at x, or -1. Following it
+    // back from the end of the longest run gives the whole run.
+    const previous = new Int32Array(length);
+    // tails[k]: of every increasing run of length k + 1 found so far, the element ending the one with
+    // the smallest old index. A smaller ending is better, since more elements can extend it. Their old
+    // indexes always increase along tails, which is what lets the search below be a binary search.
+    const tails = [];
+    for (let x = 0; x < length; x++) {
+        const value = matched[x];
+        // An unmatched element can't be kept
+        if (value < 0)
+            continue;
+        // Find the first run in tails whose ending old index isn't below this element's. This element
+        // can extend the run before it (every ending before it is lower), so it ends a run of length
+        // low + 1: either a better ending for that length, or, past the end of tails, a new longest run.
+        let low = 0;
+        let high = tails.length;
+        while (low < high) {
+            const mid = (low + high) >> 1;
+            if (matched[tails[mid]] < value)
+                low = mid + 1;
+            else
+                high = mid;
+        }
+        previous[x] = low > 0 ? tails[low - 1] : -1;
+        tails[low] = x;
     }
-    return false;
+    // The last entry of tails ends a longest run; follow previous back from it to mark the whole run
+    //
+    //   matched [4, 1, -1, 3]:
+    //   x=0 (4):  tails [0]          (run: 4)
+    //   x=1 (1):  tails [1]          (1 is a better ending than 4 for length 1)
+    //   x=3 (3):  tails [1, 3]       (3 extends the run ending at 1; previous[3] = 1)
+    //   back from 3 → 1 → done: kept = [0, 1, 0, 1]
+    const kept = new Uint8Array(length);
+    for (let x = tails.length > 0 ? tails[tails.length - 1] : -1; x >= 0; x = previous[x])
+        kept[x] = 1;
+    return kept;
 }
 /**
- * Compares two arrays and records differences.
+ * Compares two arrays by position and records differences: each changed position, then the
+ * length when it changed. Elements identical at the start, and at the end when the lengths are the
+ * same, aren't diffed.
  * @internal
  * @param path - Current path being evaluated
  * @param newValue - New array
  * @param oldValue - Old array to compare against
  * @param resp - Result array to populate with changes
- * @returns true if the entire array changed, false otherwise
+ * @param options - The diff's strategy and identity, see JsonDiff
  */
-function JsonDiffArrays(path, newValue, oldValue, resp) {
-    if (oldValue.length === 0 || newValue.length === 0) {
-        return oldValue.length !== newValue.length;
-    }
-    let allChildrenChanged = true;
-    if (newValue.length > 0 || oldValue.length > 0) {
-        for (let y = 0; y < newValue.length; y++) {
-            const arrayPath = path.concat(y);
-            const oldValueElem = oldValue[y];
-            allChildrenChanged =
-                JsonDiffRecursive(arrayPath, newValue[y], oldValueElem, resp) &&
-                    allChildrenChanged;
-        }
-    }
-    else
-        allChildrenChanged = false;
-    if (newValue.length !== oldValue.length)
+function JsonDiffArrays(path, newValue, oldValue, resp, options) {
+    const sameLength = newValue.length === oldValue.length;
+    const shared = Math.min(newValue.length, oldValue.length);
+    let start = 0;
+    for (; start < shared && newValue[start] === oldValue[start]; start++) { }
+    // Arrays are equal, no diffing required
+    if (sameLength && start === newValue.length)
+        return;
+    let end = newValue.length;
+    if (sameLength)
+        for (; end > start && newValue[end - 1] === oldValue[end - 1]; end--) { }
+    for (let x = start; x < end; x++)
+        // Checked before the path is built: most elements of a diffed array are often unchanged
+        newValue[x] !== oldValue[x] && JsonDiffRecursive(path.concat(x), newValue[x], oldValue[x], resp, options);
+    if (!sameLength)
         resp.push({
+            type: "write",
             path: path.concat("length"),
             value: newValue.length,
         });
-    return allChildrenChanged;
 }
 /**
- * Compares two objects and records differences.
- * Uses sorted keys and two-pointer technique for efficient comparison.
+ * Compares two objects and records differences, walking their sorted keys together: a key in
+ * both is diffed, a key only the new value has is written, and a key only the old value has is
+ * deleted. A new key holding undefined counts as absent and isn't written.
  * @internal
  * @param path - Current path being evaluated
  * @param newValue - New object
  * @param oldValue - Old object to compare against
  * @param resp - Result array to populate with changes
- * @returns true if the entire object should be replaced (keys removed), false otherwise
+ * @param options - The diff's strategy and identity, see JsonDiff
  */
-function JsonDiffObjects(path, newValue, oldValue, resp) {
+function JsonDiffObjects(path, newValue, oldValue, resp, options) {
     const newKeys = Object.keys(newValue).sort();
     const oldKeys = Object.keys(oldValue).sort();
-    if (newKeys.length === 0 && oldKeys.length === 0)
-        return false;
-    if (newKeys.length < oldKeys.length)
-        return true;
     let newKeyIndex = 0;
     let oldKeyIndex = 0;
-    while (newKeyIndex < newKeys.length) {
-        const childPath = path.concat(newKeys[newKeyIndex]);
-        if (oldKeyIndex < oldKeys.length &&
-            newKeys[newKeyIndex] === oldKeys[oldKeyIndex]) {
-            JsonDiffRecursive(childPath, newValue[newKeys[newKeyIndex]], oldValue[oldKeys[oldKeyIndex]], resp);
-            oldKeyIndex++;
+    while (newKeyIndex < newKeys.length || oldKeyIndex < oldKeys.length) {
+        const newKey = newKeys[newKeyIndex];
+        const oldKey = oldKeys[oldKeyIndex];
+        // Both lists are sorted the same way `<` compares strings
+        if (oldKeyIndex >= oldKeys.length || (newKeyIndex < newKeys.length && newKey < oldKey)) {
+            newValue[newKey] !== undefined && resp.push({
+                type: "write",
+                path: path.concat(newKey),
+                value: newValue[newKey],
+            });
+            newKeyIndex++;
         }
-        else if (newValue[newKeys[newKeyIndex]] !== undefined) {
+        else if (newKeyIndex >= newKeys.length || oldKey < newKey) {
             resp.push({
-                path: childPath,
-                value: newValue[newKeys[newKeyIndex]],
+                type: "delete",
+                path: path.concat(oldKey),
             });
+            oldKeyIndex++;
+        }
+        else {
+            // Checked before the path is built: most properties of a diffed object are often unchanged
+            newValue[newKey] !== oldValue[oldKey] && JsonDiffRecursive(path.concat(newKey), newValue[newKey], oldValue[oldKey], resp, options);
+            newKeyIndex++;
+            oldKeyIndex++;
         }
-        newKeyIndex++;
     }
-    if (oldKeyIndex < oldKeys.length)
-        return true;
-    return false;
 }

package/package.json

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