fast-equals 5.0.1 → 5.1.1

package/src/comparator.ts

@@ -1,13 +1,17 @@
 import {
   areArraysEqual as areArraysEqualDefault,
   areDatesEqual as areDatesEqualDefault,
+  areErrorsEqual as areErrorsEqualDefault,
+  areFunctionsEqual as areFunctionsEqualDefault,
   areMapsEqual as areMapsEqualDefault,
+  areNumbersEqual as areNumbersEqualDefault,
   areObjectsEqual as areObjectsEqualDefault,
   areObjectsEqualStrict as areObjectsEqualStrictDefault,
   arePrimitiveWrappersEqual as arePrimitiveWrappersEqualDefault,
   areRegExpsEqual as areRegExpsEqualDefault,
   areSetsEqual as areSetsEqualDefault,
-  areTypedArraysEqual,
+  areTypedArraysEqual as areTypedArraysEqualDefault,
+  areUrlsEqual as areUrlsEqualDefault,
 } from './equals';
 import { combineComparators, createIsCircular } from './utils';
 import type {
@@ -22,12 +26,14 @@ import type {
 const ARGUMENTS_TAG = '[object Arguments]';
 const BOOLEAN_TAG = '[object Boolean]';
 const DATE_TAG = '[object Date]';
+const ERROR_TAG = '[object Error]';
 const MAP_TAG = '[object Map]';
 const NUMBER_TAG = '[object Number]';
 const OBJECT_TAG = '[object Object]';
 const REG_EXP_TAG = '[object RegExp]';
 const SET_TAG = '[object Set]';
 const STRING_TAG = '[object String]';
+const URL_TAG = '[object URL]';
 
 const { isArray } = Array;
 const isTypedArray =
@@ -53,12 +59,16 @@ interface CreateIsEqualOptions<Meta> {
 export function createEqualityComparator<Meta>({
   areArraysEqual,
   areDatesEqual,
+  areErrorsEqual,
+  areFunctionsEqual,
   areMapsEqual,
+  areNumbersEqual,
   areObjectsEqual,
   arePrimitiveWrappersEqual,
   areRegExpsEqual,
   areSetsEqual,
   areTypedArraysEqual,
+  areUrlsEqual,
 }: ComparatorConfig<Meta>): EqualityComparator<Meta> {
   /**
    * compare the value of the two objects and return true if they are equivalent in values
@@ -69,17 +79,29 @@ export function createEqualityComparator<Meta>({
       return true;
     }
 
-    // If the items are not non-nullish objects, then the only possibility
-    // of them being equal but not strictly is if they are both `NaN`. Since
-    // `NaN` is uniquely not equal to itself, we can use self-comparison of
-    // both objects, which is faster than `isNaN()`.
-    if (
-      a == null ||
-      b == null ||
-      typeof a !== 'object' ||
-      typeof b !== 'object'
-    ) {
-      return a !== a && b !== b;
+    // If either of the items are nullish and fail the strictly equal check
+    // above, then they must be unequal.
+    if (a == null || b == null) {
+      return false;
+    }
+
+    const type = typeof a;
+
+    if (type !== typeof b) {
+      return false;
+    }
+
+    if (type !== 'object') {
+      if (type === 'number') {
+        return areNumbersEqual(a, b, state);
+      }
+
+      if (type === 'function') {
+        return areFunctionsEqual(a, b, state);
+      }
+
+      // If a primitive value that is not strictly equal, it must be unequal.
+      return false;
     }
 
     const constructor = a.constructor;
@@ -148,6 +170,8 @@ export function createEqualityComparator<Meta>({
       return areDatesEqual(a, b, state);
     }
 
+    // For RegExp, the properties are not enumerable, and therefore will give false positives if
+    // tested like a standard object.
     if (tag === REG_EXP_TAG) {
       return areRegExpsEqual(a, b, state);
     }
@@ -171,6 +195,18 @@ export function createEqualityComparator<Meta>({
       );
     }
 
+    // If a URL tag, it should be tested explicitly. Like RegExp, the properties are not
+    // enumerable, and therefore will give false positives if tested like a standard object.
+    if (tag === URL_TAG) {
+      return areUrlsEqual(a, b, state);
+    }
+
+    // If an error tag, it should be tested explicitly. Like RegExp, the properties are not
+    // enumerable, and therefore will give false positives if tested like a standard object.
+    if (tag === ERROR_TAG) {
+      return areErrorsEqual(a, b, state);
+    }
+
     // If an arguments tag, it should be treated as a standard object.
     if (tag === ARGUMENTS_TAG) {
       return areObjectsEqual(a, b, state);
@@ -211,9 +247,12 @@ export function createEqualityComparatorConfig<Meta>({
       ? areObjectsEqualStrictDefault
       : areArraysEqualDefault,
     areDatesEqual: areDatesEqualDefault,
+    areErrorsEqual: areErrorsEqualDefault,
+    areFunctionsEqual: areFunctionsEqualDefault,
     areMapsEqual: strict
       ? combineComparators(areMapsEqualDefault, areObjectsEqualStrictDefault)
       : areMapsEqualDefault,
+    areNumbersEqual: areNumbersEqualDefault,
     areObjectsEqual: strict
       ? areObjectsEqualStrictDefault
       : areObjectsEqualDefault,
@@ -224,7 +263,8 @@ export function createEqualityComparatorConfig<Meta>({
       : areSetsEqualDefault,
     areTypedArraysEqual: strict
       ? areObjectsEqualStrictDefault
-      : areTypedArraysEqual,
+      : areTypedArraysEqualDefault,
+    areUrlsEqual: areUrlsEqualDefault,
   };
 
   if (createCustomConfig) {

package/src/equals.ts

@@ -36,6 +36,28 @@ export function areDatesEqual(a: Date, b: Date): boolean {
   return sameValueZeroEqual(a.getTime(), b.getTime());
 }
 
+/**
+ * Whether the errors passed are equal in value.
+ */
+export function areErrorsEqual(a: Error, b: Error): boolean {
+  return (
+    a.name === b.name &&
+    a.message === b.message &&
+    a.cause === b.cause &&
+    a.stack === b.stack
+  );
+}
+
+/**
+ * Whether the functions passed are equal in value.
+ */
+export function areFunctionsEqual(
+  a: (...args: any[]) => any,
+  b: (...args: any[]) => any,
+): boolean {
+  return a === b;
+}
+
 /**
  * Whether the `Map`s are equal in value.
  */
@@ -96,6 +118,11 @@ export function areMapsEqual(
   return true;
 }
 
+/**
+ * Whether the numbers are equal in value.
+ */
+export const areNumbersEqual = sameValueZeroEqual;
+
 /**
  * Whether the objects are equal in value.
  */
@@ -298,3 +325,18 @@ export function areTypedArraysEqual(a: TypedArray, b: TypedArray) {
 
   return true;
 }
+
+/**
+ * Whether the URL instances are equal in value.
+ */
+export function areUrlsEqual(a: URL, b: URL): boolean {
+  return (
+    a.hostname === b.hostname &&
+    a.pathname === b.pathname &&
+    a.protocol === b.protocol &&
+    a.port === b.port &&
+    a.hash === b.hash &&
+    a.username === b.username &&
+    a.password === b.password
+  );
+}

package/src/index.ts

@@ -8,7 +8,24 @@ import type { CustomEqualCreatorOptions } from './internalTypes';
 import { sameValueZeroEqual } from './utils';
 
 export { sameValueZeroEqual };
-export * from './internalTypes';
+export type {
+  AnyEqualityComparator,
+  Cache,
+  CircularState,
+  ComparatorConfig,
+  CreateCustomComparatorConfig,
+  CreateState,
+  CustomEqualCreatorOptions,
+  DefaultState,
+  Dictionary,
+  EqualityComparator,
+  EqualityComparatorCreator,
+  InternalEqualityComparator,
+  PrimitiveWrapper,
+  State,
+  TypeEqualityComparator,
+  TypedArray,
+} from './internalTypes';
 
 /**
  * Whether the items passed are deeply-equal in value.

package/src/internalTypes.ts

@@ -52,11 +52,23 @@ export interface ComparatorConfig<Meta> {
    * Whether the dates passed are equal in value.
    */
   areDatesEqual: TypeEqualityComparator<any, Meta>;
+  /**
+   * Whether the errors passed are equal in value.
+   */
+  areErrorsEqual: TypeEqualityComparator<any, Meta>;
+  /**
+   * Whether the functions passed are equal in value.
+   */
+  areFunctionsEqual: TypeEqualityComparator<any, Meta>;
   /**
    * Whether the maps passed are equal in value. In strict mode, this includes
    * additional properties added to the map.
    */
   areMapsEqual: TypeEqualityComparator<any, Meta>;
+  /**
+   * Whether the numbers passed are equal in value.
+   */
+  areNumbersEqual: TypeEqualityComparator<any, Meta>;
   /**
    * Whether the objects passed are equal in value. In strict mode, this includes
    * non-enumerable properties added to the map, as well as symbol properties.
@@ -80,6 +92,10 @@ export interface ComparatorConfig<Meta> {
    * additional properties added to the typed array.
    */
   areTypedArraysEqual: TypeEqualityComparator<any, Meta>;
+  /**
+   * Whether the URLs passed are equal in value.
+   */
+  areUrlsEqual: TypeEqualityComparator<any, Meta>;
 }
 
 export type CreateCustomComparatorConfig<Meta> = (

package/src/utils.ts

@@ -1,4 +1,4 @@
-import {
+import type {
   AnyEqualityComparator,
   Cache,
   CircularState,
@@ -84,5 +84,5 @@ export const hasOwn =
  * Whether the values passed are strictly equal or both NaN.
  */
 export function sameValueZeroEqual(a: any, b: any): boolean {
-  return a || b ? a === b : a === b || (a !== a && b !== b);
+  return a === b || (!a && !b && a !== a && b !== b);
 }