@helpers4/object 2.0.0-alpha.2 → 2.0.0-alpha.3

package/README.md

@@ -14,6 +14,8 @@ A set of helpers for working with URLs.
 <!-- AUTOMATIC-METHODS -->
 - get
 - set
+- quickCompare
+- deepCompare
 - deepMerge
 - removeUndefinedNull
 - deepClone

package/lib/index.d.ts

@@ -1,5 +1,10 @@
 export declare function get<T = any>(obj: any, path: string, defaultValue?: T): T | undefined;
 export declare function set(obj: Record<string, any>, path: string, value: any): Record<string, any>;
+export declare function quickCompare(objA: object, objB: object): boolean;
+export interface DeepCompareResult {
+  [key: string]: "onlyA" | "onlyB" | false | DeepCompareResult;
+}
+export declare function deepCompare(objA: object | undefined | null, objB: object | undefined | null): true | false | DeepCompareResult;
 export declare function deepMerge<T extends Record<string, any>>(target: T, ...sources: Record<string, any>[]): T;
 export declare function removeUndefinedNull<T extends Record<string, string | boolean | number>>(obj: T): T;  /** * Remove null and undefined values from an object. * * @param obj a null object * @returns null */ export function removeUndefinedNull<T extends Record<string, string | boolean | number>>(obj: null): null;  /** * Remove null and undefined values from an object. * * @param obj an undefined object * @returns undefined */ export function removeUndefinedNull<T extends Record<string, string | boolean | number>>(obj: undefined): undefined;  /** * Remove null and undefined values from an object. * * @param obj an object * @returns A shallow copy of the object without null or undefined values */ export function removeUndefinedNull<T extends Record<string, string | boolean | number>>(obj: T | null | undefined): T | null | undefined;
 export declare function deepClone<T>(obj: T): T;

package/lib/index.js

@@ -24,6 +24,157 @@ function set(obj, path, value) {
   current[keys[keys.length - 1]] = value;
   return obj;
 }
+// helpers/object/quickCompare.ts
+function quickCompare(objA, objB) {
+  if (objA === objB) {
+    return true;
+  }
+  if (typeof objA === "function" || typeof objB === "function") {
+    return objA === objB;
+  }
+  try {
+    return JSON.stringify(objA) === JSON.stringify(objB);
+  } catch {
+    return objA === objB;
+  }
+}
+// helpers/array/quickCompare.ts
+function quickCompare2(arrA, arrB) {
+  try {
+    return JSON.stringify(arrA) === JSON.stringify(arrB);
+  } catch {
+    return arrA === arrB;
+  }
+}
+
+// helpers/date/compare.ts
+function compare(dateA, dateB, options = {}) {
+  const { precision = "milliseconds" } = options;
+  if (!(dateA instanceof Date) || !(dateB instanceof Date)) {
+    return dateA === dateB;
+  }
+  if (isNaN(dateA.getTime()) || isNaN(dateB.getTime())) {
+    return isNaN(dateA.getTime()) && isNaN(dateB.getTime());
+  }
+  switch (precision) {
+    case "days":
+      return dateA.toDateString() === dateB.toDateString();
+    case "hours":
+      const hoursA = Math.floor(dateA.getTime() / (1000 * 60 * 60));
+      const hoursB = Math.floor(dateB.getTime() / (1000 * 60 * 60));
+      return hoursA === hoursB;
+    case "minutes":
+      const minutesA = Math.floor(dateA.getTime() / (1000 * 60));
+      const minutesB = Math.floor(dateB.getTime() / (1000 * 60));
+      return minutesA === minutesB;
+    case "seconds":
+      const secondsA = Math.floor(dateA.getTime() / 1000);
+      const secondsB = Math.floor(dateB.getTime() / 1000);
+      return secondsA === secondsB;
+    case "milliseconds":
+    default:
+      return dateA.getTime() === dateB.getTime();
+  }
+}
+
+// helpers/type/isSpecialObject.ts
+function isSpecialObject(value) {
+  if (value === null || value === undefined) {
+    return false;
+  }
+  if (typeof value === "function") {
+    return true;
+  }
+  if (typeof value !== "object") {
+    return false;
+  }
+  if (Array.isArray(value)) {
+    return false;
+  }
+  if (value instanceof Date || value instanceof Promise || value instanceof RegExp || value instanceof Error || value instanceof Map || value instanceof Set || value instanceof WeakMap || value instanceof WeakSet || value instanceof ArrayBuffer || value instanceof DataView) {
+    return true;
+  }
+  if (value.constructor?.name === "Observable") {
+    return true;
+  }
+  if (typeof HTMLElement !== "undefined" && value instanceof HTMLElement) {
+    return true;
+  }
+  const constructorName = value.constructor?.name;
+  if (constructorName && [
+    "Buffer",
+    "URL",
+    "URLSearchParams",
+    "File",
+    "Blob",
+    "FormData",
+    "Headers",
+    "Request",
+    "Response",
+    "EventTarget",
+    "Symbol"
+  ].includes(constructorName)) {
+    return true;
+  }
+  return false;
+}
+
+// helpers/object/deepCompare.ts
+function deepCompare(objA, objB) {
+  if (objA === objB) {
+    return true;
+  }
+  if (objA == null || objB == null) {
+    return false;
+  }
+  if (objA instanceof Date && objB instanceof Date) {
+    return compare(objA, objB);
+  }
+  if (Array.isArray(objA) && Array.isArray(objB)) {
+    return quickCompare2(objA, objB);
+  }
+  if (Array.isArray(objA) || Array.isArray(objB)) {
+    return false;
+  }
+  if (isSpecialObject(objA) || isSpecialObject(objB)) {
+    return objA === objB;
+  }
+  const keys = Array.from(new Set([...Object.keys(objA), ...Object.keys(objB)]));
+  const differences = {};
+  for (const key of keys) {
+    const hasA = key in objA;
+    const hasB = key in objB;
+    if (!hasA && hasB) {
+      differences[key] = "onlyB";
+    } else if (hasA && !hasB) {
+      differences[key] = "onlyA";
+    } else if (hasA && hasB) {
+      const valueA = objA[key];
+      const valueB = objB[key];
+      if (Array.isArray(valueA) && Array.isArray(valueB)) {
+        if (!quickCompare2(valueA, valueB)) {
+          differences[key] = false;
+        }
+      } else if (valueA instanceof Date && valueB instanceof Date) {
+        if (!compare(valueA, valueB)) {
+          differences[key] = false;
+        }
+      } else if (isSpecialObject(valueA) || isSpecialObject(valueB)) {
+        if (valueA !== valueB) {
+          differences[key] = false;
+        }
+      } else if (valueA !== null && valueB !== null && valueA !== undefined && valueB !== undefined && typeof valueA === "object" && typeof valueB === "object" && !isSpecialObject(valueA) && !isSpecialObject(valueB)) {
+        const nestedResult = deepCompare(valueA, valueB);
+        if (nestedResult !== true) {
+          differences[key] = nestedResult === false ? false : nestedResult;
+        }
+      } else if (valueA !== valueB) {
+        differences[key] = false;
+      }
+    }
+  }
+  return Object.keys(differences).length > 0 ? differences : true;
+}
 // helpers/object/deepMerge.ts
 function deepMerge(target, ...sources) {
   if (!sources.length)
@@ -72,7 +223,9 @@ function deepClone(obj) {
 export {
   set,
   removeUndefinedNull,
+  quickCompare,
   get,
   deepMerge,
+  deepCompare,
   deepClone
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@helpers4/object",
-  "version": "2.0.0-alpha.2",
+  "version": "2.0.0-alpha.3",
   "description": "A set of helpers in TS/JS, compatible with tree-shaking, for object.",
   "author": "baxyz <baxy@etik.com>",
   "license": "AGPL-3.0",
@@ -22,6 +22,8 @@
     "object",
     "get",
     "set",
+    "quickCompare",
+    "deepCompare",
     "deepMerge",
     "removeUndefinedNull",
     "deepClone"