fast-equals 5.0.0-beta.2 → 5.0.0-beta.4

package/src/index.ts

@@ -1,128 +1,34 @@
-import { createComparator } from './comparator';
-import {
-  areArraysEqual,
-  areDatesEqual,
-  areMapsEqual,
-  areObjectsEqual,
-  areObjectsEqualStrict,
-  arePrimitiveWrappersEqual,
-  areRegExpsEqual,
-  areSetsEqual,
-} from './equals';
+import { createComparator, createComparatorConfig } from './comparator';
 import type {
   CircularState,
-  ComparatorConfig,
-  CreateCustomComparatorConfig,
-  CreateState,
+  CustomEqualCreatorOptions,
   DefaultState,
-  EqualityComparator,
 } from './internalTypes';
-import {
-  combineComparators,
-  createInternalComparator,
-  createIsCircular,
-  sameValueZeroEqual,
-} from './utils';
+import { createInternalComparator, sameValueZeroEqual } from './utils';
 
 export { sameValueZeroEqual };
 export * from './internalTypes';
 
-interface DefaultEqualCreatorOptions<Meta> {
-  comparator?: EqualityComparator<Meta>;
-  circular?: boolean;
-  strict?: boolean;
-}
-
-interface CustomEqualCreatorOptions<Meta>
-  extends DefaultEqualCreatorOptions<Meta> {
-  createCustomConfig?: CreateCustomComparatorConfig<Meta>;
-  createInternalComparator?: typeof createInternalComparator;
-  createState?: CreateState<Meta>;
-}
-
-function createComparatorConfig<Meta>({
-  circular,
-  strict,
-}: DefaultEqualCreatorOptions<Meta>) {
-  const config: ComparatorConfig<Meta> = {
-    areArraysEqual,
-    areDatesEqual,
-    areMapsEqual,
-    areObjectsEqual,
-    arePrimitiveWrappersEqual,
-    areRegExpsEqual,
-    areSetsEqual,
-  };
-
-  if (strict) {
-    config.areArraysEqual = areObjectsEqual;
-    config.areMapsEqual = combineComparators(areMapsEqual, areObjectsEqual);
-    config.areObjectsEqual = areObjectsEqualStrict;
-    config.areSetsEqual = combineComparators(areSetsEqual, areObjectsEqual);
-  }
-
-  if (circular) {
-    config.areArraysEqual = createIsCircular(config.areArraysEqual);
-    config.areMapsEqual = createIsCircular(config.areMapsEqual);
-    config.areObjectsEqual = createIsCircular(config.areObjectsEqual);
-    config.areSetsEqual = createIsCircular(config.areSetsEqual);
-  }
-
-  return config;
-}
-
-function createDefaultEqualCreator(
-  options: DefaultEqualCreatorOptions<undefined> = {},
-) {
-  const config = createComparatorConfig(options);
-  const isEqual = createComparator(config);
-  const isEqualComparator =
-    options.comparator || createInternalComparator(isEqual);
-  const strict = !!options.strict;
-
-  if (options.circular) {
-    return function equals<A, B>(a: A, b: B): boolean {
-      return isEqual(a, b, {
-        cache: new WeakMap(),
-        equals: isEqualComparator,
-        meta: undefined,
-        strict,
-      });
-    };
-  }
-
-  const state = Object.freeze({
-    cache: undefined,
-    equals: isEqualComparator,
-    meta: undefined,
-    strict,
-  });
-
-  return function equals<A, B>(a: A, b: B): boolean {
-    return isEqual(a, b, state);
-  };
-}
-
 /**
  * Whether the items passed are deeply-equal in value.
  */
-export const deepEqual = createDefaultEqualCreator();
+export const deepEqual = createCustomEqual();
 
 /**
  * Whether the items passed are deeply-equal in value based on strict comparison.
  */
-export const strictDeepEqual = createDefaultEqualCreator({ strict: true });
+export const strictDeepEqual = createCustomEqual({ strict: true });
 
 /**
  * Whether the items passed are deeply-equal in value, including circular references.
  */
-export const circularDeepEqual = createDefaultEqualCreator({ circular: true });
+export const circularDeepEqual = createCustomEqual({ circular: true });
 
 /**
  * Whether the items passed are deeply-equal in value, including circular references,
  * based on strict comparison.
  */
-export const strictCircularDeepEqual = createDefaultEqualCreator({
+export const strictCircularDeepEqual = createCustomEqual({
   circular: true,
   strict: true,
 });
@@ -130,14 +36,14 @@ export const strictCircularDeepEqual = createDefaultEqualCreator({
 /**
  * Whether the items passed are shallowly-equal in value.
  */
-export const shallowEqual = createDefaultEqualCreator({
+export const shallowEqual = createCustomEqual({
   comparator: sameValueZeroEqual,
 });
 
 /**
  * Whether the items passed are shallowly-equal in value based on strict comparison
  */
-export const strictShallowEqual = createDefaultEqualCreator({
+export const strictShallowEqual = createCustomEqual({
   comparator: sameValueZeroEqual,
   strict: true,
 });
@@ -145,7 +51,7 @@ export const strictShallowEqual = createDefaultEqualCreator({
 /**
  * Whether the items passed are shallowly-equal in value, including circular references.
  */
-export const circularShallowEqual = createDefaultEqualCreator({
+export const circularShallowEqual = createCustomEqual({
   comparator: sameValueZeroEqual,
   circular: true,
 });
@@ -154,7 +60,7 @@ export const circularShallowEqual = createDefaultEqualCreator({
  * Whether the items passed are shallowly-equal in value, including circular references,
  * based on strict comparison.
  */
-export const strictCircularShallowEqual = createDefaultEqualCreator({
+export const strictCircularShallowEqual = createCustomEqual({
   comparator: sameValueZeroEqual,
   circular: true,
   strict: true,
@@ -172,43 +78,50 @@ export function createCustomEqual<Meta>(
   options: CustomEqualCreatorOptions<Meta> = {},
 ) {
   const {
+    circular,
     comparator,
     createInternalComparator: createCustomInternalComparator,
-    createCustomConfig,
     createState,
+    strict: baseStrict = false,
   } = options;
 
-  const baseConfig = createComparatorConfig(options);
-  const config = createCustomConfig
-    ? Object.assign({}, baseConfig, createCustomConfig(baseConfig))
-    : baseConfig;
-  const isEqualCustom = comparator || createComparator(config);
-  const isEqualCustomComparator = createCustomInternalComparator
-    ? createCustomInternalComparator(isEqualCustom)
-    : createInternalComparator(isEqualCustom);
-  const strict = !!options.strict;
+  const config = createComparatorConfig<Meta>(options);
+  const isEqualCustom = createComparator(config);
+  const isEqualCustomComparator =
+    comparator ||
+    (createCustomInternalComparator
+      ? createCustomInternalComparator(isEqualCustom)
+      : createInternalComparator(isEqualCustom));
 
   if (createState) {
-    return function isEqual<A, B>(a: A, b: B, metaOverride?: Meta): boolean {
-      const customState = createState(isEqualCustom);
+    return function isEqual<A, B>(
+      a: A,
+      b: B,
+      metaOverride?: Meta | undefined,
+    ): boolean {
+      const {
+        cache = circular ? new WeakMap() : undefined,
+        equals = isEqualCustomComparator,
+        meta,
+        strict = baseStrict,
+      } = createState!(isEqualCustom);
 
       return isEqualCustom(a, b, {
-        cache: customState.cache || new WeakMap(),
-        equals: customState.equals || isEqualCustomComparator,
-        // @ts-expect-error - inferred `Meta` may be undefined, which is okay
-        meta: metaOverride !== undefined ? metaOverride : customState.meta,
-        strict: customState.strict !== undefined ? customState.strict : strict,
-      });
+        cache,
+        equals,
+        meta: metaOverride !== undefined ? metaOverride : meta,
+        strict,
+      } as CircularState<Meta>);
     };
   }
 
-  if (options.circular) {
+  if (circular) {
     return function equals<A, B>(a: A, b: B): boolean {
       return isEqualCustom(a, b, {
         cache: new WeakMap(),
         equals: isEqualCustomComparator,
         meta: undefined as Meta,
-        strict,
+        strict: baseStrict,
       } as CircularState<Meta>);
     };
   }
@@ -217,7 +130,7 @@ export function createCustomEqual<Meta>(
     cache: undefined,
     equals: isEqualCustomComparator,
     meta: undefined,
-    strict,
+    strict: baseStrict,
   });
 
   return function equals<A, B>(a: A, b: B): boolean {

package/src/internalTypes.ts

@@ -32,6 +32,7 @@ export interface ComparatorConfig<Meta> {
   arePrimitiveWrappersEqual: TypeEqualityComparator<any, Meta>;
   areRegExpsEqual: TypeEqualityComparator<any, Meta>;
   areSetsEqual: TypeEqualityComparator<any, Meta>;
+  areTypedArraysEqual: TypeEqualityComparator<any, Meta>;
 }
 
 export type CreateCustomComparatorConfig<Meta> = (
@@ -67,8 +68,30 @@ export type InternalEqualityComparator<Meta> = (
   state: State<Meta>,
 ) => boolean;
 
+export type TypedArray =
+  | Float32Array
+  | Float64Array
+  | Int8Array
+  | Int16Array
+  | Int32Array
+  | Uint16Array
+  | Uint32Array
+  | Uint8Array
+  | Uint8ClampedArray;
+
 export type TypeEqualityComparator<Type, Meta = undefined> = (
   a: Type,
   b: Type,
   state: State<Meta>,
 ) => boolean;
+
+export interface CustomEqualCreatorOptions<Meta> {
+  circular?: boolean;
+  comparator?: EqualityComparator<Meta>;
+  createCustomConfig?: CreateCustomComparatorConfig<Meta>;
+  createInternalComparator?: <Meta>(
+    compare: EqualityComparator<Meta>,
+  ) => InternalEqualityComparator<Meta>;
+  createState?: CreateState<Meta>;
+  strict?: boolean;
+}

package/src/utils.ts

@@ -12,6 +12,12 @@ import {
 const { getOwnPropertyNames, getOwnPropertySymbols } = Object;
 const { hasOwnProperty } = Object.prototype;
 
+const SUPPORTS_ARRAY_BUFFER =
+  typeof ArrayBuffer === 'function' && Boolean(ArrayBuffer.isView);
+
+/**
+ * Combine two comparators into a single comparators.
+ */
 export function combineComparators<Meta>(
   comparatorA: AnyEqualityComparator<Meta>,
   comparatorB: AnyEqualityComparator<Meta>,
@@ -79,6 +85,10 @@ export function createIsCircular<
   } as AreItemsEqual;
 }
 
+/**
+ * Get the properties to strictly examine, which include both own properties that are
+ * not enumerable and symbol properties.
+ */
 export function getStrictProperties(
   object: Dictionary,
 ): Array<string | symbol> {
@@ -87,11 +97,18 @@ export function getStrictProperties(
   );
 }
 
+/**
+ * Whether the object contains the property passed as an own property.
+ */
 export const hasOwn =
   Object.hasOwn ||
   ((object: Dictionary, property: number | string | symbol) =>
     hasOwnProperty.call(object, property));
 
+export function isArrayBuffer(value: any): value is ArrayBuffer {
+  return SUPPORTS_ARRAY_BUFFER && ArrayBuffer.isView(value);
+}
+
 /**
  * Whether the values passed are strictly equal or both NaN.
  */