json-diff-ts 5.0.0-alpha.6 → 5.0.0-alpha.8

package/dist/index.cjs

@@ -487,12 +487,14 @@ var compareArray = (oldObj, newObj, path, keyPath, options) => {
   const isFunctionKey = typeof uniqKey === "function" && uniqKey.length === 2;
   if (diffs.length) {
     const resolvedKey = isFunctionKey ? uniqKey(newObj[0] ?? oldObj[0], true) : uniqKey;
+    const sampleEl = newObj[0] ?? oldObj[0];
+    const isNestedPath = typeof resolvedKey === "string" && resolvedKey.includes(".") && NESTED_PATH_RE.test(resolvedKey) && (isFunctionKey || !(sampleEl != null && typeof sampleEl === "object" && resolvedKey in sampleEl));
     return [
       {
         type: "UPDATE" /* UPDATE */,
         key: getKey(path),
         embeddedKey: resolvedKey,
-        ...isFunctionKey && typeof resolvedKey === "string" && NESTED_PATH_RE.test(resolvedKey) && resolvedKey.includes(".") ? { embeddedKeyIsPath: true } : {},
+        ...isNestedPath ? { embeddedKeyIsPath: true } : {},
         changes: diffs
       }
     ];
@@ -533,7 +535,8 @@ var convertArrayToObj = (arr, uniqKey) => {
       obj[i] = value;
     }
   } else {
-    const keyFunction = typeof uniqKey === "string" ? (item) => item[uniqKey] : uniqKey;
+    const maybeNestedPath = typeof uniqKey === "string" && uniqKey.includes(".") && NESTED_PATH_RE.test(uniqKey);
+    const keyFunction = typeof uniqKey === "string" ? maybeNestedPath ? (item) => item != null && typeof item === "object" && uniqKey in item ? item[uniqKey] : resolveProperty(item, uniqKey, true) : (item) => item[uniqKey] : uniqKey;
     obj = keyBy(arr, keyFunction);
   }
   return obj;
@@ -580,7 +583,7 @@ var indexOfItemInArray = (arr, key, value, isPath) => {
     const item = arr[i];
     if (item == null) continue;
     const resolved = resolveProperty(item, key, isPath);
-    if (resolved != null && String(resolved) === String(value)) {
+    if (resolved !== void 0 && String(resolved) === String(value)) {
       return i;
     }
   }
@@ -636,7 +639,7 @@ var applyArrayChange = (arr, change) => {
       } else {
         element = arr.find((el) => {
           const resolved = resolveProperty(el, change.embeddedKey, change.embeddedKeyIsPath);
-          return resolved != null && String(resolved) === String(subchange.key);
+          return resolved !== void 0 && String(resolved) === String(subchange.key);
         });
       }
       if (element) {
@@ -706,7 +709,7 @@ var revertArrayChange = (arr, change) => {
       } else {
         element = arr.find((el) => {
           const resolved = resolveProperty(el, change.embeddedKey, change.embeddedKeyIsPath);
-          return resolved != null && String(resolved) === String(subchange.key);
+          return resolved !== void 0 && String(resolved) === String(subchange.key);
         });
       }
       if (element) {
@@ -1247,7 +1250,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") {
@@ -1267,6 +1270,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 };
@@ -1334,7 +1364,8 @@ function walkChanges(changes, basePath, oldCtx, newCtx, ops, options) {
             childChange.key,
             childOld,
             childNew,
-            childChange
+            childChange,
+            change.embeddedKeyIsPath
           );
           if (childChange.changes) {
             const oldEl = findElement(childOld, change.embeddedKey, childChange.key);
@@ -1377,7 +1408,7 @@ function emitLeafOp(change, path, ops, options) {
     }
   }
 }
-function buildCanonicalFilterPath(basePath, embeddedKey, changeKey, oldArr, newArr, change) {
+function buildCanonicalFilterPath(basePath, embeddedKey, changeKey, oldArr, newArr, change, embeddedKeyIsPath) {
   if (embeddedKey === "$index") {
     return `${basePath}[${changeKey}]`;
   }
@@ -1397,9 +1428,11 @@ function buildCanonicalFilterPath(basePath, embeddedKey, changeKey, oldArr, newA
     const memberAccess2 = typeof keyName === "string" && SIMPLE_PROPERTY_RE2.test(keyName) ? `.${keyName}` : `.${changeKey}`;
     return `${basePath}[?(@${memberAccess2}=='${changeKey}')]`;
   }
-  const element = findElementByKey(oldArr, newArr, embeddedKey, changeKey, change.type);
-  const typedVal = element ? element[embeddedKey] : changeKey;
-  const memberAccess = SIMPLE_PROPERTY_RE2.test(embeddedKey) ? `.${embeddedKey}` : `['${embeddedKey.replace(/'/g, "''")}']`;
+  const isNestedPath = embeddedKeyIsPath && NESTED_PATH_RE3.test(embeddedKey);
+  const element = findElementByKey(oldArr, newArr, embeddedKey, changeKey, change.type, isNestedPath);
+  const resolved = element !== void 0 ? resolveNestedKey(element, embeddedKey, !!isNestedPath) : void 0;
+  const typedVal = resolved !== void 0 ? resolved : changeKey;
+  const memberAccess = SIMPLE_PROPERTY_RE2.test(embeddedKey) || isNestedPath ? `.${embeddedKey}` : `['${embeddedKey.replace(/'/g, "''")}']`;
   return `${basePath}[?(@${memberAccess}==${formatFilterLiteral(typedVal)})]`;
 }
 function findActualValue(oldArr, newArr, stringKey, opType) {
@@ -1438,13 +1471,20 @@ function findElement(arr, embeddedKey, changeKey) {
   }
   return arr.find((item) => item && String(item[embeddedKey]) === changeKey);
 }
-function findElementByKey(oldArr, newArr, embeddedKey, changeKey, opType) {
+function resolveNestedKey(item, key, isPath) {
+  if (isPath) {
+    return key.split(".").reduce((c, s) => c?.[s], item);
+  }
+  return item?.[key];
+}
+function findElementByKey(oldArr, newArr, embeddedKey, changeKey, opType, isPath) {
+  const match = (item) => item && String(resolveNestedKey(item, embeddedKey, !!isPath)) === changeKey;
   if (opType === "REMOVE" /* REMOVE */ || opType === "UPDATE" /* UPDATE */) {
-    const el = oldArr?.find((item) => item && String(item[embeddedKey]) === changeKey);
+    const el = oldArr?.find(match);
     if (el) return el;
   }
   if (opType === "ADD" /* ADD */ || opType === "UPDATE" /* UPDATE */) {
-    const el = newArr?.find((item) => item && String(item[embeddedKey]) === changeKey);
+    const el = newArr?.find(match);
     if (el) return el;
   }
   return void 0;
@@ -1525,6 +1565,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) {
@@ -1570,11 +1613,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];
       }
     }
@@ -1585,6 +1631,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}`);
@@ -1598,6 +1648,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) {
@@ -1605,7 +1698,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);