fast-equals 3.0.3 → 4.0.0-beta.0

package/src/objects.ts

@@ -0,0 +1,61 @@
+import { createIsCircular } from './utils';
+
+import type { InternalEqualityComparator } from './utils';
+
+interface Dictionary<Value> {
+  [key: string]: Value;
+}
+
+const OWNER = '_owner';
+const { hasOwnProperty } = Object.prototype;
+
+/**
+ * Whether the objects are equal in value.
+ */
+export function areObjectsEqual(
+  a: Dictionary<any>,
+  b: Dictionary<any>,
+  isEqual: InternalEqualityComparator,
+  meta: any,
+): boolean {
+  const keysA = Object.keys(a);
+
+  let index = keysA.length;
+
+  if (Object.keys(b).length !== index) {
+    return false;
+  }
+
+  let key: string;
+
+  // 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) {
+    key = keysA[index];
+
+    if (key === OWNER) {
+      const reactElementA = !!a.$$typeof;
+      const reactElementB = !!b.$$typeof;
+
+      if ((reactElementA || reactElementB) && reactElementA !== reactElementB) {
+        return false;
+      }
+    }
+
+    if (
+      !hasOwnProperty.call(b, key) ||
+      !isEqual(a[key], b[key], key, key, a, b, meta)
+    ) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+/**
+ * Whether the objects are equal in value, including circular references.
+ */
+export const areObjectsEqualCircular = createIsCircular(areObjectsEqual);

package/src/regexps.ts

@@ -0,0 +1,11 @@
+/**
+ * Whether the regexps passed are equal in value.
+ *
+ * @NOTE
+ * This is a standalone function instead of done inline in the comparator
+ * to allow for overrides. An example of this would be supporting a
+ * pre-ES2015 environment where the `flags` property is not available.
+ */
+export function areRegExpsEqual(a: RegExp, b: RegExp): boolean {
+  return a.source === b.source && a.flags === b.flags;
+}

package/src/sets.ts

@@ -0,0 +1,61 @@
+import { createIsCircular } from './utils';
+
+import type { InternalEqualityComparator } from './utils';
+
+/**
+ * Whether the `Set`s are equal in value.
+ */
+export function areSetsEqual(
+  a: Set<any>,
+  b: Set<any>,
+  isEqual: InternalEqualityComparator,
+  meta: any,
+): boolean {
+  let isValueEqual = a.size === b.size;
+
+  if (!isValueEqual) {
+    return false;
+  }
+
+  if (!a.size) {
+    return true;
+  }
+
+  // The use of `forEach()` is to avoid the transpilation cost of `for...of` comparisons, and
+  // the inability to control the performance of the resulting code. It also avoids excessive
+  // iteration compared to doing comparisons of `keys()` and `values()`. As a result, though,
+  // we cannot short-circuit the iterations; bookkeeping must be done to short-circuit the
+  // equality checks themselves.
+
+  const matchedIndices: Record<number, true> = {};
+
+  a.forEach((aValue, aKey) => {
+    if (!isValueEqual) {
+      return;
+    }
+
+    let hasMatch = false;
+    let matchIndex = 0;
+
+    b.forEach((bValue, bKey) => {
+      if (
+        !hasMatch &&
+        !matchedIndices[matchIndex] &&
+        (hasMatch = isEqual(aValue, bValue, aKey, bKey, a, b, meta))
+      ) {
+        matchedIndices[matchIndex] = true;
+      }
+
+      matchIndex++;
+    });
+
+    isValueEqual = hasMatch;
+  });
+
+  return isValueEqual;
+}
+
+/**
+ * Whether the `Set`s are equal in value, including circular references.
+ */
+export const areSetsEqualCircular = createIsCircular(areSetsEqual);

package/src/utils.ts

@@ -0,0 +1,130 @@
+export type InternalEqualityComparator = (
+  a: any,
+  b: any,
+  indexOrKeyA: any,
+  indexOrKeyB: any,
+  parentA: any,
+  parentB: any,
+  meta: any,
+) => boolean;
+
+export type EqualityComparator<Meta> = <A, B>(
+  a: A,
+  b: B,
+  meta?: Meta,
+) => boolean;
+
+export type EqualityComparatorCreator<Meta> = (
+  fn: EqualityComparator<Meta>,
+) => InternalEqualityComparator;
+
+export type NativeEqualityComparator = <A, B>(a: A, b: B) => boolean;
+
+export type TypeEqualityComparator<Type, Meta> = (
+  a: Type,
+  b: Type,
+  isEqual: InternalEqualityComparator,
+  meta: Meta,
+) => boolean;
+
+/**
+ * Default equality comparator pass-through, used as the standard `isEqual` creator for
+ * use inside the built comparator.
+ */
+export function createDefaultIsNestedEqual<Meta>(
+  comparator: EqualityComparator<Meta>,
+): InternalEqualityComparator {
+  return function isEqual<A, B>(
+    a: A,
+    b: B,
+    indexOrKeyA: any,
+    indexOrKeyB: any,
+    parentA: any,
+    parentB: any,
+    meta: Meta,
+  ) {
+    return comparator(a, b, meta);
+  };
+}
+
+/**
+ * Wrap the provided `areItemsEqual` method to manage the circular cache, 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,
+    isEqual: InternalEqualityComparator,
+    cache: WeakMap<any, any>,
+  ) {
+    if (!a || !b || typeof a !== 'object' || typeof b !== 'object') {
+      return areItemsEqual(a, b, isEqual, cache);
+    }
+
+    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, isEqual, cache);
+
+    cache.delete(a);
+    cache.delete(b);
+
+    return result;
+  } as AreItemsEqual;
+}
+
+/**
+ * Targeted shallow merge of two objects.
+ *
+ * @NOTE
+ * This exists as a tinier compiled version of the `__assign` helper that
+ * `tsc` injects in case of `Object.assign` not being present.
+ */
+export function merge<A extends object, B extends object>(a: A, b: B): A & B {
+  const merged: Record<string, any> = {};
+
+  for (const key in a) {
+    merged[key] = a[key];
+  }
+
+  for (const key in b) {
+    merged[key] = b[key];
+  }
+
+  return merged as A & B;
+}
+
+/**
+ * Whether the value is a plain object.
+ *
+ * @NOTE
+ * This is a same-realm compariosn only.
+ */
+export function isPlainObject(value: any): boolean {
+  return value.constructor === Object || value.constructor == null;
+}
+
+/**
+ * When the value is `Promise`-like, aka "then-able".
+ */
+export function isPromiseLike(value: any): boolean {
+  return typeof value.then === 'function';
+}
+
+/**
+ * Whether the values passed are strictly equal or both NaN.
+ */
+export function sameValueZeroEqual(a: any, b: any): boolean {
+  return a === b || (a !== a && b !== b);
+}