fast-equals 5.3.3 → 5.4.0

package/src/equals.ts

@@ -1,355 +0,0 @@
-import type {
-  Dictionary,
-  PrimitiveWrapper,
-  State,
-  TypedArray,
-} from './internalTypes.js';
-import { getStrictProperties, hasOwn, sameValueZeroEqual } from './utils.js';
-
-const PREACT_VNODE = '__v';
-const PREACT_OWNER = '__o';
-const REACT_OWNER = '_owner';
-
-const { getOwnPropertyDescriptor, keys } = Object;
-
-/**
- * Whether the arrays are equal in value.
- */
-export function areArraysEqual(a: any[], b: any[], state: State<any>) {
-  let index = a.length;
-
-  if (b.length !== index) {
-    return false;
-  }
-
-  while (index-- > 0) {
-    if (!state.equals(a[index], b[index], index, index, a, b, state)) {
-      return false;
-    }
-  }
-
-  return true;
-}
-
-/**
- * Whether the dates passed are equal in value.
- */
-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.
- */
-export function areMapsEqual(
-  a: Map<any, any>,
-  b: Map<any, any>,
-  state: State<any>,
-): boolean {
-  const size = a.size;
-
-  if (size !== b.size) {
-    return false;
-  }
-
-  if (!size) {
-    return true;
-  }
-
-  const matchedIndices = new Array<true | undefined>(size);
-  const aIterable = a.entries();
-
-  let aResult: IteratorResult<[any, any]>;
-  let bResult: IteratorResult<[any, any]>;
-  let index = 0;
-
-  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-  while ((aResult = aIterable.next())) {
-    if (aResult.done) {
-      break;
-    }
-
-    const bIterable = b.entries();
-
-    let hasMatch = false;
-    let matchIndex = 0;
-
-    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-    while ((bResult = bIterable.next())) {
-      if (bResult.done) {
-        break;
-      }
-
-      if (matchedIndices[matchIndex]) {
-        matchIndex++;
-        continue;
-      }
-
-      const aEntry = aResult.value;
-      const bEntry = bResult.value;
-
-      if (
-        state.equals(aEntry[0], bEntry[0], index, matchIndex, a, b, state) &&
-        state.equals(aEntry[1], bEntry[1], aEntry[0], bEntry[0], a, b, state)
-      ) {
-        hasMatch = matchedIndices[matchIndex] = true;
-        break;
-      }
-
-      matchIndex++;
-    }
-
-    if (!hasMatch) {
-      return false;
-    }
-
-    index++;
-  }
-
-  return true;
-}
-
-/**
- * Whether the numbers are equal in value.
- */
-export const areNumbersEqual = sameValueZeroEqual;
-
-/**
- * Whether the objects are equal in value.
- */
-export function areObjectsEqual(
-  a: Dictionary,
-  b: Dictionary,
-  state: State<any>,
-): boolean {
-  const properties = keys(a);
-
-  let index = properties.length;
-
-  if (keys(b).length !== index) {
-    return false;
-  }
-
-  // Decrementing `while` showed faster results than either incrementing or
-  // decrementing `for` loop and than an incrementing `while` loop. Declarative
-  // methods like `some` / `every` were not used to avoid incurring the garbage
-  // cost of anonymous callbacks.
-  while (index-- > 0) {
-    if (!isPropertyEqual(a, b, state, properties[index]!)) {
-      return false;
-    }
-  }
-
-  return true;
-}
-
-/**
- * Whether the objects are equal in value with strict property checking.
- */
-export function areObjectsEqualStrict(
-  a: Dictionary,
-  b: Dictionary,
-  state: State<any>,
-): boolean {
-  const properties = getStrictProperties(a);
-
-  let index = properties.length;
-
-  if (getStrictProperties(b).length !== index) {
-    return false;
-  }
-
-  let property: string | symbol;
-  let descriptorA: ReturnType<typeof getOwnPropertyDescriptor>;
-  let descriptorB: ReturnType<typeof getOwnPropertyDescriptor>;
-
-  // Decrementing `while` showed faster results than either incrementing or
-  // decrementing `for` loop and than an incrementing `while` loop. Declarative
-  // methods like `some` / `every` were not used to avoid incurring the garbage
-  // cost of anonymous callbacks.
-  while (index-- > 0) {
-    property = properties[index]!;
-
-    if (!isPropertyEqual(a, b, state, property)) {
-      return false;
-    }
-
-    descriptorA = getOwnPropertyDescriptor(a, property);
-    descriptorB = getOwnPropertyDescriptor(b, property);
-
-    if (
-      (descriptorA || descriptorB) &&
-      (!descriptorA ||
-        !descriptorB ||
-        descriptorA.configurable !== descriptorB.configurable ||
-        descriptorA.enumerable !== descriptorB.enumerable ||
-        descriptorA.writable !== descriptorB.writable)
-    ) {
-      return false;
-    }
-  }
-
-  return true;
-}
-
-/**
- * Whether the primitive wrappers passed are equal in value.
- */
-export function arePrimitiveWrappersEqual(
-  a: PrimitiveWrapper,
-  b: PrimitiveWrapper,
-): boolean {
-  return sameValueZeroEqual(a.valueOf(), b.valueOf());
-}
-
-/**
- * Whether the regexps passed are equal in value.
- */
-export function areRegExpsEqual(a: RegExp, b: RegExp): boolean {
-  return a.source === b.source && a.flags === b.flags;
-}
-
-/**
- * Whether the `Set`s are equal in value.
- */
-export function areSetsEqual(
-  a: Set<any>,
-  b: Set<any>,
-  state: State<any>,
-): boolean {
-  const size = a.size;
-
-  if (size !== b.size) {
-    return false;
-  }
-
-  if (!size) {
-    return true;
-  }
-
-  const matchedIndices = new Array<true | undefined>(size);
-  const aIterable = a.values();
-
-  let aResult: IteratorResult<any>;
-  let bResult: IteratorResult<any>;
-
-  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-  while ((aResult = aIterable.next())) {
-    if (aResult.done) {
-      break;
-    }
-
-    const bIterable = b.values();
-
-    let hasMatch = false;
-    let matchIndex = 0;
-
-    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-    while ((bResult = bIterable.next())) {
-      if (bResult.done) {
-        break;
-      }
-
-      if (
-        !matchedIndices[matchIndex] &&
-        state.equals(
-          aResult.value,
-          bResult.value,
-          aResult.value,
-          bResult.value,
-          a,
-          b,
-          state,
-        )
-      ) {
-        hasMatch = matchedIndices[matchIndex] = true;
-        break;
-      }
-
-      matchIndex++;
-    }
-
-    if (!hasMatch) {
-      return false;
-    }
-  }
-
-  return true;
-}
-
-/**
- * Whether the TypedArray instances are equal in value.
- */
-export function areTypedArraysEqual(a: TypedArray, b: TypedArray) {
-  let index = a.length;
-
-  if (b.length !== index) {
-    return false;
-  }
-
-  while (index-- > 0) {
-    if (a[index] !== b[index]) {
-      return false;
-    }
-  }
-
-  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
-  );
-}
-
-function isPropertyEqual(
-  a: Dictionary,
-  b: Dictionary,
-  state: State<any>,
-  property: string | symbol,
-) {
-  if (
-    (property === REACT_OWNER ||
-      property === PREACT_OWNER ||
-      property === PREACT_VNODE) &&
-    (a.$$typeof || b.$$typeof)
-  ) {
-    return true;
-  }
-
-  return (
-    hasOwn(b, property) &&
-    state.equals(a[property], b[property], property, property, a, b, state)
-  );
-}

package/src/index.ts

@@ -1,112 +0,0 @@
-import {
-  createEqualityComparatorConfig,
-  createEqualityComparator,
-  createInternalEqualityComparator,
-  createIsEqual,
-} from './comparator.js';
-import type { CustomEqualCreatorOptions } from './internalTypes.js';
-import { sameValueZeroEqual } from './utils.js';
-
-export { sameValueZeroEqual };
-export type {
-  AnyEqualityComparator,
-  Cache,
-  CircularState,
-  ComparatorConfig,
-  CreateCustomComparatorConfig,
-  CreateState,
-  CustomEqualCreatorOptions,
-  DefaultState,
-  Dictionary,
-  EqualityComparator,
-  EqualityComparatorCreator,
-  InternalEqualityComparator,
-  PrimitiveWrapper,
-  State,
-  TypeEqualityComparator,
-  TypedArray,
-} from './internalTypes.js';
-
-/**
- * Whether the items passed are deeply-equal in value.
- */
-export const deepEqual = createCustomEqual();
-
-/**
- * Whether the items passed are deeply-equal in value based on strict comparison.
- */
-export const strictDeepEqual = createCustomEqual({ strict: true });
-
-/**
- * Whether the items passed are deeply-equal in value, including circular references.
- */
-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 = createCustomEqual({
-  circular: true,
-  strict: true,
-});
-
-/**
- * Whether the items passed are shallowly-equal in value.
- */
-export const shallowEqual = createCustomEqual({
-  createInternalComparator: () => sameValueZeroEqual,
-});
-
-/**
- * Whether the items passed are shallowly-equal in value based on strict comparison
- */
-export const strictShallowEqual = createCustomEqual({
-  strict: true,
-  createInternalComparator: () => sameValueZeroEqual,
-});
-
-/**
- * Whether the items passed are shallowly-equal in value, including circular references.
- */
-export const circularShallowEqual = createCustomEqual({
-  circular: true,
-  createInternalComparator: () => sameValueZeroEqual,
-});
-
-/**
- * Whether the items passed are shallowly-equal in value, including circular references,
- * based on strict comparison.
- */
-export const strictCircularShallowEqual = createCustomEqual({
-  circular: true,
-  createInternalComparator: () => sameValueZeroEqual,
-  strict: true,
-});
-
-/**
- * Create a custom equality comparison method.
- *
- * This can be done to create very targeted comparisons in extreme hot-path scenarios
- * where the standard methods are not performant enough, but can also be used to provide
- * support for legacy environments that do not support expected features like
- * `RegExp.prototype.flags` out of the box.
- */
-export function createCustomEqual<Meta = undefined>(
-  options: CustomEqualCreatorOptions<Meta> = {},
-) {
-  const {
-    circular = false,
-    createInternalComparator: createCustomInternalComparator,
-    createState,
-    strict = false,
-  } = options;
-
-  const config = createEqualityComparatorConfig<Meta>(options);
-  const comparator = createEqualityComparator(config);
-  const equals = createCustomInternalComparator
-    ? createCustomInternalComparator(comparator)
-    : createInternalEqualityComparator(comparator);
-
-  return createIsEqual({ circular, comparator, createState, equals, strict });
-}

package/src/utils.ts

@@ -1,96 +0,0 @@
-import type {
-  AnyEqualityComparator,
-  Cache,
-  CircularState,
-  Dictionary,
-  State,
-  TypeEqualityComparator,
-} from './internalTypes.js';
-
-const { getOwnPropertyNames, getOwnPropertySymbols } = Object;
-const { hasOwnProperty } = Object.prototype;
-
-/**
- * Combine two comparators into a single comparators.
- */
-export function combineComparators<Meta>(
-  comparatorA: AnyEqualityComparator<Meta>,
-  comparatorB: AnyEqualityComparator<Meta>,
-) {
-  return function isEqual<A, B>(a: A, b: B, state: State<Meta>) {
-    return comparatorA(a, b, state) && comparatorB(a, b, state);
-  };
-}
-
-/**
- * Wrap the provided `areItemsEqual` method to manage the circular state, allowing
- * for circular references to be safely included in the comparison without creating
- * stack overflows.
- */
-export function createIsCircular<
-  AreItemsEqual extends TypeEqualityComparator<any, any>,
->(areItemsEqual: AreItemsEqual): AreItemsEqual {
-  return function isCircular(
-    a: any,
-    b: any,
-    state: CircularState<Cache<any, any>>,
-  ) {
-    if (!a || !b || typeof a !== 'object' || typeof b !== 'object') {
-      return areItemsEqual(a, b, state);
-    }
-
-    const { cache } = state;
-
-    const cachedA = cache.get(a);
-    const cachedB = cache.get(b);
-
-    if (cachedA && cachedB) {
-      return cachedA === b && cachedB === a;
-    }
-
-    cache.set(a, b);
-    cache.set(b, a);
-
-    const result = areItemsEqual(a, b, state);
-
-    cache.delete(a);
-    cache.delete(b);
-
-    return result;
-  } as AreItemsEqual;
-}
-
-/**
- * Get the `@@toStringTag` of the value, if it exists.
- */
-export function getShortTag(value: any): string | undefined {
-  return value != null ? value[Symbol.toStringTag] : undefined;
-}
-
-/**
- * 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> {
-  return (getOwnPropertyNames(object) as Array<string | symbol>).concat(
-    getOwnPropertySymbols(object),
-  );
-}
-
-/**
- * Whether the object contains the property passed as an own property.
- */
-export const hasOwn =
-  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-  Object.hasOwn ||
-  ((object: Dictionary, property: number | string | symbol) =>
-    hasOwnProperty.call(object, property));
-
-/**
- * Whether the values passed are strictly equal or both NaN.
- */
-export function sameValueZeroEqual(a: any, b: any): boolean {
-  return a === b || (!a && !b && a !== a && b !== b);
-}