chore: improve getobjectdiff performance

Author: DoneDeal0

src/lib/object-diff/index.ts

@@ -14,21 +14,19 @@ function getLeanDiff(
   showOnly: ObjectDiffOptions["showOnly"] = DEFAULT_OBJECT_DIFF_OPTIONS.showOnly,
 ): ObjectDiff["diff"] {
   const { statuses, granularity } = showOnly;
-  return diff.reduce(
-    (acc, value) => {
-      if (granularity === GRANULARITY.DEEP && value.diff) {
-        const leanDiff = getLeanDiff(value.diff, showOnly);
-        if (leanDiff.length > 0) {
-          return [...acc, { ...value, diff: leanDiff }];
-        }
+  const res: ObjectDiff["diff"] = [];
+  for (let i = 0; i < diff.length; i++) {
+    const value = diff[i];
+    if (granularity === GRANULARITY.DEEP && value.diff) {
+      const leanDiff = getLeanDiff(value.diff, showOnly);
+      if (leanDiff.length > 0) {
+        res.push({ ...value, diff: leanDiff });
       }
-      if (statuses.includes(value.status)) {
-        return [...acc, value];
-      }
-      return acc;
-    },
-    [] as ObjectDiff["diff"],
-  );
+    } else if (statuses.includes(value.status)) {
+      res.push(value);
+    }
+  }
+  return res;
 }
 
 function getObjectStatus(diff: ObjectDiff["diff"]): OBJECT_STATUS {
@@ -50,34 +48,37 @@ function formatSingleObjectDiff(
     };
   }
   const diff: ObjectDiff["diff"] = [];
-  Object.entries(data).forEach(([property, value]) => {
+
+  for (const [property, value] of Object.entries(data)) {
     if (isObject(value)) {
       const subPropertiesDiff: Diff[] = [];
-      Object.entries(value).forEach(([subProperty, subValue]) => {
+      for (const [subProperty, subValue] of Object.entries(value)) {
         subPropertiesDiff.push({
           property: subProperty,
           previousValue: status === OBJECT_STATUS.ADDED ? undefined : subValue,
           currentValue: status === OBJECT_STATUS.ADDED ? subValue : undefined,
           status,
         });
-      });
-      return diff.push({
+      }
+      diff.push({
         property,
         previousValue:
           status === OBJECT_STATUS.ADDED ? undefined : data[property],
         currentValue: status === OBJECT_STATUS.ADDED ? value : undefined,
         status,
         diff: subPropertiesDiff,
       });
+    } else {
+      diff.push({
+        property,
+        previousValue:
+          status === OBJECT_STATUS.ADDED ? undefined : data[property],
+        currentValue: status === OBJECT_STATUS.ADDED ? value : undefined,
+        status,
+      });
     }
-    return diff.push({
-      property,
-      previousValue:
-        status === OBJECT_STATUS.ADDED ? undefined : data[property],
-      currentValue: status === OBJECT_STATUS.ADDED ? value : undefined,
-      status,
-    });
-  });
+  }
+
   if (options.showOnly && options.showOnly.statuses.length > 0) {
     return {
       type: "object",
@@ -92,20 +93,6 @@ function formatSingleObjectDiff(
   };
 }
 
-function getPreviousMatch(
-  previousValue: unknown | undefined,
-  nextSubProperty: unknown,
-  options?: ObjectDiffOptions,
-): unknown | undefined {
-  if (!previousValue) {
-    return undefined;
-  }
-  const previousMatch = Object.entries(previousValue).find(([subPreviousKey]) =>
-    isEqual(subPreviousKey, nextSubProperty, options),
-  );
-  return previousMatch ? previousMatch[1] : undefined;
-}
-
 function getValueStatus(
   previousValue: unknown,
   nextValue: unknown,
@@ -128,80 +115,70 @@ function getPropertyStatus(subPropertiesDiff: Diff[]): OBJECT_STATUS {
 function getDeletedProperties(
   previousValue: Record<string, unknown> | undefined,
   nextValue: Record<string, unknown>,
-): { property: string; value: unknown }[] | undefined {
-  if (!previousValue) return undefined;
-  const prevKeys = Object.keys(previousValue);
-  const nextKeys = Object.keys(nextValue);
-  const deletedKeys = prevKeys.filter((prevKey) => !nextKeys.includes(prevKey));
-  if (deletedKeys.length > 0) {
-    return deletedKeys.map((deletedKey) => ({
-      property: deletedKey,
-      value: previousValue[deletedKey],
-    }));
+): { property: string; value: unknown }[] {
+  const res: { property: string; value: unknown }[] = [];
+  if (!previousValue) return res;
+  for (const [property, value] of Object.entries(previousValue)) {
+    if (!(property in nextValue)) {
+      res.push({ property, value });
+    }
   }
-  return undefined;
+  return res;
 }
 
 function getSubPropertiesDiff(
-  previousValue: Record<string, unknown> | undefined,
+  previousValue: Record<string, unknown> | undefined = {},
   nextValue: Record<string, unknown>,
   options?: ObjectDiffOptions,
 ): Diff[] {
   const subPropertiesDiff: Diff[] = [];
-  let subDiff: Diff[];
-  const deletedMainSubProperties = getDeletedProperties(
-    previousValue,
-    nextValue,
-  );
-  if (deletedMainSubProperties) {
-    deletedMainSubProperties.forEach((deletedProperty) => {
+  const allKeys = new Set([
+    ...Object.keys(previousValue),
+    ...Object.keys(nextValue),
+  ]);
+
+  for (const property of allKeys) {
+    const prevSubValue = previousValue[property];
+    const nextSubValue = nextValue[property];
+    if (!(property in nextValue)) {
       subPropertiesDiff.push({
-        property: deletedProperty.property,
-        previousValue: deletedProperty.value,
+        property,
+        previousValue: prevSubValue,
         currentValue: undefined,
         status: OBJECT_STATUS.DELETED,
       });
-    });
-  }
-  Object.entries(nextValue).forEach(([nextSubProperty, nextSubValue]) => {
-    const previousMatch = getPreviousMatch(
-      previousValue,
-      nextSubProperty,
-      options,
-    );
-    if (!previousMatch) {
-      return subPropertiesDiff.push({
-        property: nextSubProperty,
-        previousValue: previousMatch,
+      continue;
+    }
+    if (!(property in previousValue)) {
+      subPropertiesDiff.push({
+        property,
+        previousValue: undefined,
         currentValue: nextSubValue,
-        status:
-          !previousValue || !(nextSubProperty in previousValue)
-            ? OBJECT_STATUS.ADDED
-            : previousMatch === nextSubValue
-              ? OBJECT_STATUS.EQUAL
-              : OBJECT_STATUS.UPDATED,
+        status: OBJECT_STATUS.ADDED,
       });
+      continue;
     }
-    if (isObject(nextSubValue)) {
-      const data: Diff[] = getSubPropertiesDiff(
-        previousMatch as Record<string, unknown>,
-        nextSubValue,
-        options,
-      );
-      if (data && data.length > 0) {
-        subDiff = data;
-      }
-    }
-    if (previousMatch) {
+    if (isObject(nextSubValue) && isObject(prevSubValue)) {
+      const subDiff = getSubPropertiesDiff(prevSubValue, nextSubValue, options);
+      const status =
+        subDiff.length > 0 ? OBJECT_STATUS.UPDATED : OBJECT_STATUS.EQUAL;
+      subPropertiesDiff.push({
+        property,
+        previousValue: prevSubValue,
+        currentValue: nextSubValue,
+        status,
+        ...(status !== OBJECT_STATUS.EQUAL && { diff: subDiff }),
+      });
+    } else {
+      const status = getValueStatus(prevSubValue, nextSubValue, options);
       subPropertiesDiff.push({
-        property: nextSubProperty,
-        previousValue: previousMatch,
+        property,
+        previousValue: prevSubValue,
         currentValue: nextSubValue,
-        status: getValueStatus(previousMatch, nextSubValue, options),
-        ...(!!subDiff && { diff: subDiff }),
+        status,
       });
     }
-  });
+  }
   return subPropertiesDiff;
 }
 
@@ -235,10 +212,10 @@ export function getObjectDiff(
     return formatSingleObjectDiff(prevData, OBJECT_STATUS.DELETED, options);
   }
   const diff: ObjectDiff["diff"] = [];
-  Object.entries(nextData).forEach(([nextProperty, nextValue]) => {
+  for (const [nextProperty, nextValue] of Object.entries(nextData)) {
     const previousValue = prevData[nextProperty];
     if (!previousValue) {
-      return diff.push({
+      diff.push({
         property: nextProperty,
         previousValue,
         currentValue: nextValue,
@@ -248,15 +225,14 @@ export function getObjectDiff(
             ? OBJECT_STATUS.EQUAL
             : OBJECT_STATUS.UPDATED,
       });
-    }
-    if (isObject(nextValue)) {
+    } else if (isObject(nextValue)) {
       const subPropertiesDiff: Diff[] = getSubPropertiesDiff(
         previousValue as Record<string, unknown>,
         nextValue,
         options,
       );
       const subPropertyStatus = getPropertyStatus(subPropertiesDiff);
-      return diff.push({
+      diff.push({
         property: nextProperty,
         previousValue,
         currentValue: nextValue,
@@ -265,23 +241,23 @@ export function getObjectDiff(
           diff: subPropertiesDiff,
         }),
       });
-    }
-    return diff.push({
-      property: nextProperty,
-      previousValue,
-      currentValue: nextValue,
-      status: getValueStatus(previousValue, nextValue, options),
-    });
-  });
-  const deletedProperties = getDeletedProperties(prevData, nextData);
-  if (deletedProperties) {
-    deletedProperties.forEach((deletedProperty) => {
+    } else {
       diff.push({
-        property: deletedProperty.property,
-        previousValue: deletedProperty.value,
-        currentValue: undefined,
-        status: OBJECT_STATUS.DELETED,
+        property: nextProperty,
+        previousValue,
+        currentValue: nextValue,
+        status: getValueStatus(previousValue, nextValue, options),
       });
+    }
+  }
+  const deletedProperties = getDeletedProperties(prevData, nextData);
+  for (let i = 0; i < deletedProperties.length; i++) {
+    const deletedProperty = deletedProperties[i];
+    diff.push({
+      property: deletedProperty.property,
+      previousValue: deletedProperty.value,
+      currentValue: undefined,
+      status: OBJECT_STATUS.DELETED,
     });
   }
   if (options.showOnly && options.showOnly.statuses.length > 0) {