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

package/dist/index.d.cts

@@ -191,10 +191,11 @@ declare function parseAtomPath(path: string): AtomPathSegment[];
  */
 declare function buildAtomPath(segments: AtomPathSegment[]): string;
 
-type AtomOp = 'add' | 'remove' | 'replace';
+type AtomOp = 'add' | 'remove' | 'replace' | 'move' | 'copy';
 interface IAtomOperation {
     op: AtomOp;
     path: string;
+    from?: string;
     value?: any;
     oldValue?: any;
     [key: string]: any;

package/dist/index.d.ts

@@ -191,10 +191,11 @@ declare function parseAtomPath(path: string): AtomPathSegment[];
  */
 declare function buildAtomPath(segments: AtomPathSegment[]): string;
 
-type AtomOp = 'add' | 'remove' | 'replace';
+type AtomOp = 'add' | 'remove' | 'replace' | 'move' | 'copy';
 interface IAtomOperation {
     op: AtomOp;
     path: string;
+    from?: string;
     value?: any;
     oldValue?: any;
     [key: string]: any;

package/dist/index.js

@@ -1187,7 +1187,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") {
@@ -1207,6 +1207,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 };
@@ -1465,6 +1492,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) {
@@ -1510,11 +1540,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];
       }
     }
@@ -1525,6 +1558,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}`);
@@ -1538,6 +1575,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) {
@@ -1545,7 +1625,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);