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

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,10 +727,18 @@ 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) {
-  const value = typeof filterValue === "number" ? filterValue : `'${filterValue}'`;
-  const memberAccess = typeof filterKey === "string" && !IDENT_RE.test(filterKey) ? `['${filterKey}']` : `.${filterKey}`;
-  return `${basePath}[?(@${memberAccess}==${value})]`;
+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, "''")}'`;
+  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})]`;
 }
 
 // src/jsonCompare.ts
@@ -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})]`;