json-diff-ts 5.0.0-alpha.5 → 5.0.0-alpha.7

package/dist/index.cjs

@@ -167,12 +167,12 @@ var revertChangeset = (obj, changeset) => {
   }
   return obj;
 };
-var atomizeChangeset = (obj, path = "$", embeddedKey) => {
+var atomizeChangeset = (obj, path = "$", embeddedKey, embeddedKeyIsPath) => {
   if (Array.isArray(obj)) {
-    return handleArray(obj, path, embeddedKey);
+    return handleArray(obj, path, embeddedKey, embeddedKeyIsPath);
   } else if (obj.changes || embeddedKey) {
     if (embeddedKey) {
-      const [updatedPath, atomicChange] = handleEmbeddedKey(embeddedKey, obj, path);
+      const [updatedPath, atomicChange] = handleEmbeddedKey(embeddedKey, obj, path, embeddedKeyIsPath);
       path = updatedPath;
       if (atomicChange) {
         return atomicChange;
@@ -180,7 +180,7 @@ var atomizeChangeset = (obj, path = "$", embeddedKey) => {
     } else {
       path = append(path, obj.key);
     }
-    return atomizeChangeset(obj.changes || obj, path, obj.embeddedKey);
+    return atomizeChangeset(obj.changes || obj, path, obj.embeddedKey, obj.embeddedKeyIsPath);
   } else {
     const valueType = getTypeOfObj(obj.value);
     let finalPath = path;
@@ -207,7 +207,7 @@ var atomizeChangeset = (obj, path = "$", embeddedKey) => {
     ];
   }
 };
-function handleEmbeddedKey(embeddedKey, obj, path) {
+function handleEmbeddedKey(embeddedKey, obj, path, isPath) {
   if (embeddedKey === "$index") {
     path = `${path}[${obj.key}]`;
     return [path];
@@ -225,12 +225,12 @@ function handleEmbeddedKey(embeddedKey, obj, path) {
       ]
     ];
   } else {
-    path = filterExpression(path, embeddedKey, obj.key);
+    path = filterExpression(path, embeddedKey, obj.key, isPath);
     return [path];
   }
 }
-var handleArray = (obj, path, embeddedKey) => {
-  return obj.reduce((memo, change) => [...memo, ...atomizeChangeset(change, path, embeddedKey)], []);
+var handleArray = (obj, path, embeddedKey, embeddedKeyIsPath) => {
+  return obj.reduce((memo, change) => [...memo, ...atomizeChangeset(change, path, embeddedKey, embeddedKeyIsPath)], []);
 };
 var unatomizeChangeset = (changes) => {
   if (!Array.isArray(changes)) {
@@ -250,15 +250,17 @@ var unatomizeChangeset = (changes) => {
     } else {
       for (let i = 1; i < segments.length; i++) {
         const segment = segments[i];
-        const result = /^([^[\]]+)\[\?\(@(?:\.?([^=[]*)|(?:\['([^']*)'\]))=+'([^']+)'\)\]$|^(.+)\[(\d+)\]$/.exec(segment);
+        const result = /^([^[\]]+)\[\?\(@(?:\.?([^=[]*)|(?:\['([^']*(?:''[^']*)*)'\]))=+'([^']*(?:''[^']*)*)'\)\]$|^(.+)\[(\d+)\]$/.exec(segment);
         if (result) {
           let key;
           let embeddedKey;
           let arrKey;
+          let isPath;
           if (result[1]) {
             key = result[1];
-            embeddedKey = result[3] || result[2] || "$value";
-            arrKey = result[4];
+            embeddedKey = result[3]?.replace(/''/g, "'") || result[2] || "$value";
+            isPath = !result[3] && !!result[2] && result[2].includes(".") && NESTED_PATH_RE.test(result[2]) ? true : void 0;
+            arrKey = result[4]?.replace(/''/g, "'");
           } else {
             key = result[5];
             embeddedKey = "$index";
@@ -267,6 +269,7 @@ var unatomizeChangeset = (changes) => {
           if (i === segments.length - 1) {
             ptr.key = key;
             ptr.embeddedKey = embeddedKey;
+            if (isPath) ptr.embeddedKeyIsPath = true;
             ptr.type = "UPDATE" /* UPDATE */;
             ptr.changes = [
               {
@@ -279,6 +282,7 @@ var unatomizeChangeset = (changes) => {
           } else {
             ptr.key = key;
             ptr.embeddedKey = embeddedKey;
+            if (isPath) ptr.embeddedKeyIsPath = true;
             ptr.type = "UPDATE" /* UPDATE */;
             const newPtr = {};
             ptr.changes = [
@@ -480,12 +484,15 @@ var compareArray = (oldObj, newObj, path, keyPath, options) => {
   const indexedOldObj = convertArrayToObj(oldObj, uniqKey);
   const indexedNewObj = convertArrayToObj(newObj, uniqKey);
   const diffs = compareObject(indexedOldObj, indexedNewObj, path, keyPath, true, options);
+  const isFunctionKey = typeof uniqKey === "function" && uniqKey.length === 2;
   if (diffs.length) {
+    const resolvedKey = isFunctionKey ? uniqKey(newObj[0] ?? oldObj[0], true) : uniqKey;
     return [
       {
         type: "UPDATE" /* UPDATE */,
         key: getKey(path),
-        embeddedKey: typeof uniqKey === "function" && uniqKey.length === 2 ? uniqKey(newObj[0], true) : uniqKey,
+        embeddedKey: resolvedKey,
+        ...isFunctionKey && typeof resolvedKey === "string" && NESTED_PATH_RE.test(resolvedKey) && resolvedKey.includes(".") ? { embeddedKeyIsPath: true } : {},
         changes: diffs
       }
     ];
@@ -543,13 +550,13 @@ var comparePrimitives = (oldObj, newObj, path) => {
   }
   return changes;
 };
-var removeKey = (obj, key, embeddedKey) => {
+var removeKey = (obj, key, embeddedKey, isPath) => {
   if (Array.isArray(obj)) {
     if (embeddedKey === "$index") {
       obj.splice(Number(key), 1);
       return;
     }
-    const index = indexOfItemInArray(obj, embeddedKey, key);
+    const index = indexOfItemInArray(obj, embeddedKey, key, isPath);
     if (index === -1) {
       console.warn(`Element with the key '${embeddedKey}' and value '${key}' could not be found in the array!`);
       return;
@@ -560,13 +567,20 @@ var removeKey = (obj, key, embeddedKey) => {
     return;
   }
 };
-var indexOfItemInArray = (arr, key, value) => {
+var resolveProperty = (obj, key, isPath) => {
+  if (obj == null) return void 0;
+  if (typeof key !== "string" || !isPath || !key.includes(".")) return obj[key];
+  return key.split(".").reduce((cur, seg) => cur?.[seg], obj);
+};
+var indexOfItemInArray = (arr, key, value, isPath) => {
   if (key === "$value") {
     return arr.indexOf(value);
   }
   for (let i = 0; i < arr.length; i++) {
     const item = arr[i];
-    if (item && item[key] ? item[key].toString() === value.toString() : void 0) {
+    if (item == null) continue;
+    const resolved = resolveProperty(item, key, isPath);
+    if (resolved != null && String(resolved) === String(value)) {
       return i;
     }
   }
@@ -584,7 +598,7 @@ var addKeyValue = (obj, key, value, embeddedKey) => {
     return obj ? obj[key] = value : null;
   }
 };
-var applyLeafChange = (obj, change, embeddedKey) => {
+var applyLeafChange = (obj, change, embeddedKey, isPath) => {
   const { type, key, value } = change;
   switch (type) {
     case "ADD" /* ADD */:
@@ -592,7 +606,7 @@ var applyLeafChange = (obj, change, embeddedKey) => {
     case "UPDATE" /* UPDATE */:
       return modifyKeyValue(obj, key, value);
     case "REMOVE" /* REMOVE */:
-      return removeKey(obj, key, embeddedKey);
+      return removeKey(obj, key, embeddedKey, isPath);
   }
 };
 var applyArrayChange = (arr, change) => {
@@ -609,7 +623,7 @@ var applyArrayChange = (arr, change) => {
   }
   for (const subchange of changes) {
     if (subchange.value !== null && subchange.value !== void 0 || subchange.type === "REMOVE" /* REMOVE */ || subchange.value === null && subchange.type === "ADD" /* ADD */ || subchange.value === void 0 && subchange.type === "ADD" /* ADD */) {
-      applyLeafChange(arr, subchange, change.embeddedKey);
+      applyLeafChange(arr, subchange, change.embeddedKey, change.embeddedKeyIsPath);
     } else {
       let element;
       if (change.embeddedKey === "$index") {
@@ -620,7 +634,10 @@ var applyArrayChange = (arr, change) => {
           element = arr[index];
         }
       } else {
-        element = arr.find((el) => el[change.embeddedKey]?.toString() === subchange.key.toString());
+        element = arr.find((el) => {
+          const resolved = resolveProperty(el, change.embeddedKey, change.embeddedKeyIsPath);
+          return resolved != null && String(resolved) === String(subchange.key);
+        });
       }
       if (element) {
         applyChangeset(element, subchange.changes);
@@ -636,7 +653,7 @@ var applyBranchChange = (obj, change) => {
     return applyChangeset(obj, change.changes);
   }
 };
-var revertLeafChange = (obj, change, embeddedKey = "$index") => {
+var revertLeafChange = (obj, change, embeddedKey = "$index", isPath) => {
   const { type, key, value, oldValue } = change;
   if (key === "$root") {
     switch (type) {
@@ -666,7 +683,7 @@ var revertLeafChange = (obj, change, embeddedKey = "$index") => {
   }
   switch (type) {
     case "ADD" /* ADD */:
-      return removeKey(obj, key, embeddedKey);
+      return removeKey(obj, key, embeddedKey, isPath);
     case "UPDATE" /* UPDATE */:
       return modifyKeyValue(obj, key, oldValue);
     case "REMOVE" /* REMOVE */:
@@ -676,7 +693,7 @@ var revertLeafChange = (obj, change, embeddedKey = "$index") => {
 var revertArrayChange = (arr, change) => {
   for (const subchange of change.changes) {
     if (subchange.value != null || subchange.type === "REMOVE" /* REMOVE */) {
-      revertLeafChange(arr, subchange, change.embeddedKey);
+      revertLeafChange(arr, subchange, change.embeddedKey, change.embeddedKeyIsPath);
     } else {
       let element;
       if (change.embeddedKey === "$index") {
@@ -687,7 +704,10 @@ var revertArrayChange = (arr, change) => {
           element = arr[index];
         }
       } else {
-        element = arr.find((el) => el[change.embeddedKey]?.toString() === subchange.key.toString());
+        element = arr.find((el) => {
+          const resolved = resolveProperty(el, change.embeddedKey, change.embeddedKeyIsPath);
+          return resolved != null && String(resolved) === String(subchange.key);
+        });
       }
       if (element) {
         revertChangeset(element, subchange.changes);
@@ -707,9 +727,17 @@ function append(basePath, nextSegment) {
   return nextSegment.includes(".") ? `${basePath}[${nextSegment}]` : `${basePath}.${nextSegment}`;
 }
 var IDENT_RE = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
-function filterExpression(basePath, filterKey, filterValue) {
+var NESTED_PATH_RE = /^[a-zA-Z_][a-zA-Z0-9_]*(?:\.[a-zA-Z_][a-zA-Z0-9_]*)*$/;
+function filterExpression(basePath, filterKey, filterValue, isPath) {
   const escapedValue = `'${filterValue.replace(/'/g, "''")}'`;
-  const memberAccess = IDENT_RE.test(filterKey) ? `.${filterKey}` : `['${filterKey.replace(/'/g, "''")}']`;
+  let memberAccess;
+  if (isPath && NESTED_PATH_RE.test(filterKey)) {
+    memberAccess = "." + filterKey;
+  } else if (IDENT_RE.test(filterKey)) {
+    memberAccess = `.${filterKey}`;
+  } else {
+    memberAccess = `['${filterKey.replace(/'/g, "''")}']`;
+  }
   return `${basePath}[?(@${memberAccess}==${escapedValue})]`;
 }
 
@@ -927,12 +955,13 @@ function findFilterClose(s, from) {
   }
   return -1;
 }
+var NESTED_PATH_RE2 = /^[a-zA-Z_][a-zA-Z0-9_]*(?:\.[a-zA-Z_][a-zA-Z0-9_]*)*$/;
 function parseFilter(inner) {
   if (inner.startsWith("@.")) {
     const eq = inner.indexOf("==");
     if (eq === -1) throw new Error(`Invalid filter: missing '==' in ${inner}`);
     const key = inner.slice(2, eq);
-    if (!key || !SIMPLE_PROPERTY_RE.test(key)) {
+    if (!key || !NESTED_PATH_RE2.test(key)) {
       throw new Error(`Invalid property name in filter: '${key}'. Use bracket notation for non-identifier keys: @['${key}']`);
     }
     return { type: "keyFilter", property: key, value: parseFilterLiteral(inner.slice(eq + 2)) };
@@ -940,7 +969,7 @@ function parseFilter(inner) {
   if (inner.startsWith("@['")) {
     const [key, endIdx] = extractQuotedString(inner, 3);
     const valStart = endIdx + 4;
-    return { type: "keyFilter", property: key, value: parseFilterLiteral(inner.slice(valStart)) };
+    return { type: "keyFilter", property: key, value: parseFilterLiteral(inner.slice(valStart)), literalKey: true };
   }
   if (inner.startsWith("@==")) {
     return { type: "valueFilter", value: parseFilterLiteral(inner.slice(3)) };
@@ -1014,7 +1043,14 @@ function buildAtomPath(segments) {
         result += `[${seg.index}]`;
         break;
       case "keyFilter": {
-        const memberAccess = SIMPLE_PROPERTY_RE.test(seg.property) ? `.${seg.property}` : `['${seg.property.replace(/'/g, "''")}']`;
+        let memberAccess;
+        if (seg.literalKey) {
+          memberAccess = `['${seg.property.replace(/'/g, "''")}']`;
+        } else if (NESTED_PATH_RE2.test(seg.property)) {
+          memberAccess = `.${seg.property}`;
+        } else {
+          memberAccess = `['${seg.property.replace(/'/g, "''")}']`;
+        }
         result += `[?(@${memberAccess}==${formatFilterLiteral(seg.value)})]`;
         break;
       }
@@ -1031,7 +1067,7 @@ function canonicalizeFilterForAtom(inner) {
     if (eqIdx === -1) return `[?(${inner})]`;
     const key = inner.slice(2, eqIdx);
     const valuePart = inner.slice(eqIdx);
-    if (SIMPLE_PROPERTY_RE.test(key)) {
+    if (NESTED_PATH_RE2.test(key)) {
       return `[?(@.${key}${valuePart})]`;
     }
     return `[?(@['${key.replace(/'/g, "''")}']${valuePart})]`;
@@ -1211,7 +1247,7 @@ function validateAtom(atom) {
         errors.push(`operations[${i}]: must be an object`);
         continue;
       }
-      if (!["add", "remove", "replace"].includes(op.op)) {
+      if (!["add", "remove", "replace", "move", "copy"].includes(op.op)) {
         errors.push(`operations[${i}]: invalid op '${op.op}'`);
       }
       if (typeof op.path !== "string") {
@@ -1231,6 +1267,33 @@ function validateAtom(atom) {
       if (op.op === "replace" && !("value" in op)) {
         errors.push(`operations[${i}]: replace operation must have value`);
       }
+      if (op.op === "move") {
+        if (typeof op.from !== "string") {
+          errors.push(`operations[${i}]: move operation must have from (string)`);
+        }
+        if ("value" in op) {
+          errors.push(`operations[${i}]: move operation must not have value`);
+        }
+        if ("oldValue" in op) {
+          errors.push(`operations[${i}]: move operation must not have oldValue`);
+        }
+        if (typeof op.from === "string" && typeof op.path === "string") {
+          if (op.from === op.path) {
+            errors.push(`operations[${i}]: move operation from must not equal path (self-move)`);
+          }
+          if (op.from !== "$" && (op.path.startsWith(op.from + ".") || op.path.startsWith(op.from + "["))) {
+            errors.push(`operations[${i}]: move operation path must not be a subtree of from`);
+          }
+        }
+      }
+      if (op.op === "copy") {
+        if (typeof op.from !== "string") {
+          errors.push(`operations[${i}]: copy operation must have from (string)`);
+        }
+        if ("oldValue" in op) {
+          errors.push(`operations[${i}]: copy operation must not have oldValue`);
+        }
+      }
     }
   }
   return { valid: errors.length === 0, errors };
@@ -1489,6 +1552,9 @@ function fromAtom(atom) {
     throw new Error(`Invalid atom: ${validation.errors.join(", ")}`);
   }
   return atom.operations.map((op) => {
+    if (op.op === "move" || op.op === "copy") {
+      throw new Error(`${op.op} operations cannot be converted to v4 atomic changes`);
+    }
     const atomicPath = atomPathToAtomicPath(op.path);
     const key = extractKeyFromAtomicPath(atomicPath);
     switch (op.op) {
@@ -1534,11 +1600,14 @@ function invertAtom(atom) {
     if (op.op === "remove" && !("oldValue" in op)) {
       throw new Error(`operations[${i}]: remove operation missing oldValue \u2014 atom is not reversible`);
     }
+    if (op.op === "copy" && !("value" in op)) {
+      throw new Error(`operations[${i}]: copy operation missing value \u2014 atom is not reversible`);
+    }
   }
   const invertedOps = [...atom.operations].reverse().map((op) => {
     const extensions = {};
     for (const key of Object.keys(op)) {
-      if (!["op", "path", "value", "oldValue"].includes(key)) {
+      if (!["op", "path", "from", "value", "oldValue"].includes(key)) {
         extensions[key] = op[key];
       }
     }
@@ -1549,6 +1618,10 @@ function invertAtom(atom) {
         return { op: "add", path: op.path, value: op.oldValue, ...extensions };
       case "replace":
         return { op: "replace", path: op.path, value: op.oldValue, oldValue: op.value, ...extensions };
+      case "move":
+        return { op: "move", from: op.path, path: op.from, ...extensions };
+      case "copy":
+        return { op: "remove", path: op.path, oldValue: op.value, ...extensions };
       /* istanbul ignore next -- exhaustive switch */
       default:
         throw new Error(`Unknown operation: ${op.op}`);
@@ -1562,6 +1635,49 @@ function invertAtom(atom) {
   }
   return envelope;
 }
+var NESTED_PATH_RE3 = /^[a-zA-Z_][a-zA-Z0-9_]*(?:\.[a-zA-Z_][a-zA-Z0-9_]*)*$/;
+function resolveValueAtPath(obj, atomPath) {
+  const segments = parseAtomPath(atomPath);
+  let current = obj;
+  for (const seg of segments) {
+    switch (seg.type) {
+      case "root":
+        break;
+      case "property":
+        if (current == null || typeof current !== "object") {
+          throw new Error(`Cannot access property '${seg.name}' on ${current === null ? "null" : typeof current} at path: ${atomPath}`);
+        }
+        current = current[seg.name];
+        break;
+      case "index":
+        if (!Array.isArray(current)) {
+          throw new Error(`Cannot access index ${seg.index} on non-array at path: ${atomPath}`);
+        }
+        current = current[seg.index];
+        break;
+      case "keyFilter": {
+        if (!Array.isArray(current)) {
+          throw new Error(`Cannot apply key filter on non-array at path: ${atomPath}`);
+        }
+        const prop = seg.property;
+        const isPath = !seg.literalKey && prop.includes(".") && NESTED_PATH_RE3.test(prop);
+        current = current.find((el) => {
+          const resolved = isPath ? prop.split(".").reduce((c, s) => c?.[s], el) : el[prop];
+          return JSON.stringify(resolved) === JSON.stringify(seg.value);
+        });
+        break;
+      }
+      case "valueFilter": {
+        if (!Array.isArray(current)) {
+          throw new Error(`Cannot apply value filter on non-array at path: ${atomPath}`);
+        }
+        current = current.find((el) => JSON.stringify(el) === JSON.stringify(seg.value));
+        break;
+      }
+    }
+  }
+  return current;
+}
 function applyAtom(obj, atom) {
   const validation = validateAtom(atom);
   if (!validation.valid) {
@@ -1569,7 +1685,33 @@ function applyAtom(obj, atom) {
   }
   let result = obj;
   for (const op of atom.operations) {
-    if (op.path === "$") {
+    if (op.op === "move") {
+      const value = resolveValueAtPath(result, op.from);
+      const removeOp = { op: "remove", path: op.from, oldValue: value };
+      if (removeOp.path === "$") {
+        result = applyRootOp(result, removeOp);
+      } else {
+        const removeChange = atomOpToAtomicChange(removeOp);
+        applyChangeset(result, unatomizeChangeset([removeChange]));
+      }
+      const addOp = { op: "add", path: op.path, value };
+      if (addOp.path === "$") {
+        result = applyRootOp(result, addOp);
+      } else {
+        const addChange = atomOpToAtomicChange(addOp);
+        applyChangeset(result, unatomizeChangeset([addChange]));
+      }
+    } else if (op.op === "copy") {
+      const source = resolveValueAtPath(result, op.from);
+      const value = source === void 0 ? void 0 : JSON.parse(JSON.stringify(source));
+      const addOp = { op: "add", path: op.path, value };
+      if (addOp.path === "$") {
+        result = applyRootOp(result, addOp);
+      } else {
+        const addChange = atomOpToAtomicChange(addOp);
+        applyChangeset(result, unatomizeChangeset([addChange]));
+      }
+    } else if (op.path === "$") {
       result = applyRootOp(result, op);
     } else {
       const atomicChange = atomOpToAtomicChange(op);