@oscarpalmer/atoms 0.110.2 → 0.111.1

package/dist/atoms.full.js

@@ -2622,9 +2622,11 @@ function tryStructuredClone(value, depth, references) {
  * Find the differences between two values
  * @param first First value to compare
  * @param second Second value to compare
+ * @param options Comparison options
  * @returns The differences between the two values
  */
-function diff(first, second) {
+function diff(first, second, options) {
+    const relaxedNullish = typeof options === 'object' && options?.relaxedNullish === true;
     const result = {
         original: {
             from: first,
@@ -2633,7 +2635,8 @@ function diff(first, second) {
         type: 'partial',
         values: {},
     };
-    const same = Object.is(first, second);
+    const same = (relaxedNullish && first == null && second == null) ||
+        Object.is(first, second);
     const firstIsArrayOrObject = isArrayOrPlainObject(first);
     const secondIsArrayOrObject = isArrayOrPlainObject(second);
     if (same || (!firstIsArrayOrObject && !secondIsArrayOrObject)) {
@@ -2644,7 +2647,7 @@ function diff(first, second) {
         result.type = 'full';
         return result;
     }
-    const diffs = getDiffs(first, second);
+    const diffs = getDiffs(first, second, relaxedNullish);
     const { length } = diffs;
     if (length === 0) {
         result.type = 'none';
@@ -2655,7 +2658,7 @@ function diff(first, second) {
     }
     return result;
 }
-function getDiffs(first, second, prefix) {
+function getDiffs(first, second, relaxedNullish, prefix) {
     const changes = [];
     const checked = new Set();
     if (Array.isArray(first) && Array.isArray(second)) {
@@ -2682,28 +2685,27 @@ function getDiffs(first, second, prefix) {
             if (checked.has(key)) {
                 continue;
             }
+            checked.add(key);
             const from = first?.[key];
             const to = second?.[key];
-            if (!equal(from, to)) {
-                const prefixed = join([prefix, key], '.');
-                const change = {
-                    from,
-                    to,
-                    key: prefixed,
-                };
-                const nested = isArrayOrPlainObject(from) || isArrayOrPlainObject(to);
-                const diffs = nested
-                    ? getDiffs(from, to, prefixed)
-                    : [];
-                if (!nested || (nested && diffs.length > 0)) {
-                    changes.push(change);
-                }
-                const diffsLength = diffs.length;
-                for (let diffIndex = 0; diffIndex < diffsLength; diffIndex += 1) {
-                    changes.push(diffs[diffIndex]);
-                }
+            if ((relaxedNullish && from == null && to == null) || equal(from, to)) {
+                continue;
+            }
+            const prefixed = join([prefix, key], '.');
+            const change = {
+                from,
+                to,
+                key: prefixed,
+            };
+            const nested = isArrayOrPlainObject(from) || isArrayOrPlainObject(to);
+            const diffs = nested ? getDiffs(from, to, relaxedNullish, prefixed) : [];
+            if (!nested || (nested && diffs.length > 0)) {
+                changes.push(change);
+            }
+            const diffsLength = diffs.length;
+            for (let diffIndex = 0; diffIndex < diffsLength; diffIndex += 1) {
+                changes.push(diffs[diffIndex]);
             }
-            checked.add(key);
         }
     }
     return changes;

package/dist/value/diff.js

@@ -1,7 +1,8 @@
 import { isArrayOrPlainObject } from "../internal/is.js";
 import { join } from "../internal/string.js";
 import { equal } from "../internal/value/equal.js";
-function diff(first, second) {
+function diff(first, second, options) {
+	const relaxedNullish = typeof options === "object" && options?.relaxedNullish === true;
 	const result = {
 		original: {
 			from: first,
@@ -10,7 +11,7 @@ function diff(first, second) {
 		type: "partial",
 		values: {}
 	};
-	const same = Object.is(first, second);
+	const same = relaxedNullish && first == null && second == null || Object.is(first, second);
 	const firstIsArrayOrObject = isArrayOrPlainObject(first);
 	const secondIsArrayOrObject = isArrayOrPlainObject(second);
 	if (same || !firstIsArrayOrObject && !secondIsArrayOrObject) {
@@ -21,7 +22,7 @@ function diff(first, second) {
 		result.type = "full";
 		return result;
 	}
-	const diffs = getDiffs(first, second);
+	const diffs = getDiffs(first, second, relaxedNullish);
 	const { length } = diffs;
 	if (length === 0) result.type = "none";
 	for (let index = 0; index < length; index += 1) {
@@ -33,7 +34,7 @@ function diff(first, second) {
 	}
 	return result;
 }
-function getDiffs(first, second, prefix) {
+function getDiffs(first, second, relaxedNullish, prefix) {
 	const changes = [];
 	const checked = /* @__PURE__ */ new Set();
 	if (Array.isArray(first) && Array.isArray(second)) {
@@ -55,22 +56,21 @@ function getDiffs(first, second, prefix) {
 		for (let innerIndex = 0; innerIndex < length; innerIndex += 1) {
 			const key = keys[innerIndex];
 			if (checked.has(key)) continue;
+			checked.add(key);
 			const from = first?.[key];
 			const to = second?.[key];
-			if (!equal(from, to)) {
-				const prefixed = join([prefix, key], ".");
-				const change = {
-					from,
-					to,
-					key: prefixed
-				};
-				const nested = isArrayOrPlainObject(from) || isArrayOrPlainObject(to);
-				const diffs = nested ? getDiffs(from, to, prefixed) : [];
-				if (!nested || nested && diffs.length > 0) changes.push(change);
-				const diffsLength = diffs.length;
-				for (let diffIndex = 0; diffIndex < diffsLength; diffIndex += 1) changes.push(diffs[diffIndex]);
-			}
-			checked.add(key);
+			if (relaxedNullish && from == null && to == null || equal(from, to)) continue;
+			const prefixed = join([prefix, key], ".");
+			const change = {
+				from,
+				to,
+				key: prefixed
+			};
+			const nested = isArrayOrPlainObject(from) || isArrayOrPlainObject(to);
+			const diffs = nested ? getDiffs(from, to, relaxedNullish, prefixed) : [];
+			if (!nested || nested && diffs.length > 0) changes.push(change);
+			const diffsLength = diffs.length;
+			for (let diffIndex = 0; diffIndex < diffsLength; diffIndex += 1) changes.push(diffs[diffIndex]);
 		}
 	}
 	return changes;

package/package.json

@@ -100,5 +100,5 @@
 	},
 	"type": "module",
 	"types": "./types/index.d.ts",
-	"version": "0.110.2"
+	"version": "0.111.1"
 }

package/src/value/diff.ts

@@ -1,9 +1,13 @@
 import {isArrayOrPlainObject} from '../internal/is';
 import {join} from '../internal/string';
 import {equal} from '../internal/value/equal';
-import type {ArrayOrPlainObject} from '../models';
 
-export type DiffType = 'full' | 'none' | 'partial';
+type DiffOptions = {
+	/**
+	 * Should `null` and `undefined` be considered equal and ignored in results?
+	 */
+	relaxedNullish?: boolean;
+};
 
 /**
  * The result of a comparison beteen two values
@@ -25,6 +29,8 @@ export type DiffResult<First, Second = First> = {
 	values: Record<string, DiffValue>;
 };
 
+export type DiffType = 'full' | 'none' | 'partial';
+
 /**
  * The difference between two values
  */
@@ -47,12 +53,17 @@ type KeyedDiffValue = {
  * Find the differences between two values
  * @param first First value to compare
  * @param second Second value to compare
+ * @param options Comparison options
  * @returns The differences between the two values
  */
 export function diff<First, Second = First>(
 	first: First,
 	second: Second,
+	options?: DiffOptions,
 ): DiffResult<First, Second> {
+	const relaxedNullish =
+		typeof options === 'object' && options?.relaxedNullish === true;
+
 	const result: DiffResult<First, Second> = {
 		original: {
 			from: first,
@@ -62,7 +73,9 @@ export function diff<First, Second = First>(
 		values: {},
 	};
 
-	const same = Object.is(first, second);
+	const same =
+		(relaxedNullish && first == null && second == null) ||
+		Object.is(first, second);
 
 	const firstIsArrayOrObject = isArrayOrPlainObject(first);
 	const secondIsArrayOrObject = isArrayOrPlainObject(second);
@@ -79,10 +92,7 @@ export function diff<First, Second = First>(
 		return result;
 	}
 
-	const diffs = getDiffs(
-		first as ArrayOrPlainObject,
-		second as ArrayOrPlainObject,
-	);
+	const diffs = getDiffs(first, second, relaxedNullish);
 
 	const {length} = diffs;
 
@@ -100,8 +110,9 @@ export function diff<First, Second = First>(
 }
 
 function getDiffs(
-	first: ArrayOrPlainObject,
-	second: ArrayOrPlainObject,
+	first: unknown,
+	second: unknown,
+	relaxedNullish: boolean,
 	prefix?: string,
 ): KeyedDiffValue[] {
 	const changes: KeyedDiffValue[] = [];
@@ -138,40 +149,36 @@ function getDiffs(
 				continue;
 			}
 
+			checked.add(key);
+
 			const from = first?.[key as never];
 			const to = second?.[key as never];
 
-			if (!equal(from, to)) {
-				const prefixed = join([prefix, key], '.');
-
-				const change = {
-					from,
-					to,
-					key: prefixed,
-				};
+			if ((relaxedNullish && from == null && to == null) || equal(from, to)) {
+				continue;
+			}
 
-				const nested = isArrayOrPlainObject(from) || isArrayOrPlainObject(to);
+			const prefixed = join([prefix, key], '.');
 
-				const diffs = nested
-					? getDiffs(
-							from as ArrayOrPlainObject,
-							to as ArrayOrPlainObject,
-							prefixed,
-						)
-					: [];
+			const change = {
+				from,
+				to,
+				key: prefixed,
+			};
 
-				if (!nested || (nested && diffs.length > 0)) {
-					changes.push(change);
-				}
+			const nested = isArrayOrPlainObject(from) || isArrayOrPlainObject(to);
 
-				const diffsLength = diffs.length;
+			const diffs = nested ? getDiffs(from, to, relaxedNullish, prefixed) : [];
 
-				for (let diffIndex = 0; diffIndex < diffsLength; diffIndex += 1) {
-					changes.push(diffs[diffIndex]);
-				}
+			if (!nested || (nested && diffs.length > 0)) {
+				changes.push(change);
 			}
 
-			checked.add(key);
+			const diffsLength = diffs.length;
+
+			for (let diffIndex = 0; diffIndex < diffsLength; diffIndex += 1) {
+				changes.push(diffs[diffIndex]);
+			}
 		}
 	}
 

package/types/value/diff.d.ts

@@ -1,4 +1,9 @@
-export type DiffType = 'full' | 'none' | 'partial';
+type DiffOptions = {
+    /**
+     * Should `null` and `undefined` be considered equal and ignored in results?
+     */
+    relaxedNullish?: boolean;
+};
 /**
  * The result of a comparison beteen two values
  */
@@ -18,6 +23,7 @@ export type DiffResult<First, Second = First> = {
      */
     values: Record<string, DiffValue>;
 };
+export type DiffType = 'full' | 'none' | 'partial';
 /**
  * The difference between two values
  */
@@ -35,6 +41,8 @@ export type DiffValue<First = unknown, Second = First> = {
  * Find the differences between two values
  * @param first First value to compare
  * @param second Second value to compare
+ * @param options Comparison options
  * @returns The differences between the two values
  */
-export declare function diff<First, Second = First>(first: First, second: Second): DiffResult<First, Second>;
+export declare function diff<First, Second = First>(first: First, second: Second, options?: DiffOptions): DiffResult<First, Second>;
+export {};