fast-equals 5.0.0-beta.0 → 5.0.0-beta.1

package/README.md

@@ -202,6 +202,7 @@ console.log(strictDeepEqual(array, ['foo'])); // false;
 
 Performs the same comparison as `circularDeepEqual` but performs a strict comparison of the objects. In this includes:
 
+- Checking `Symbol` properties on the object
 - Checking non-enumerable properties in object comparisons
 - Checking full descriptor of properties on the object to match
 - Checking non-index properties on arrays

package/index.d.ts

@@ -0,0 +1,65 @@
+import type {
+  CreateCustomComparatorConfig,
+  CreateState,
+  EqualityComparator,
+} from './src/internalTypes';
+import { createInternalComparator, sameValueZeroEqual } from './src/utils';
+export { sameValueZeroEqual };
+
+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>;
+}
+
+/**
+ * Whether the items passed are deeply-equal in value.
+ */
+export declare const deepEqual: <A, B>(a: A, b: B) => boolean;
+/**
+ * Whether the items passed are deeply-equal in value based on strict comparison.
+ */
+export declare const strictDeepEqual: <A, B>(a: A, b: B) => boolean;
+/**
+ * Whether the items passed are deeply-equal in value, including circular references.
+ */
+export declare const circularDeepEqual: <A, B>(a: A, b: B) => boolean;
+/**
+ * Whether the items passed are deeply-equal in value, including circular references,
+ * based on strict comparison.
+ */
+export declare const strictCircularDeepEqual: <A, B>(a: A, b: B) => boolean;
+/**
+ * Whether the items passed are shallowly-equal in value.
+ */
+export declare const shallowEqual: <A, B>(a: A, b: B) => boolean;
+/**
+ * Whether the items passed are shallowly-equal in value based on strict comparison
+ */
+export declare const strictShallowEqual: <A, B>(a: A, b: B) => boolean;
+/**
+ * Whether the items passed are shallowly-equal in value, including circular references.
+ */
+export declare const circularShallowEqual: <A, B>(a: A, b: B) => boolean;
+/**
+ * Whether the items passed are shallowly-equal in value, including circular references,
+ * based on strict comparison.
+ */
+export declare const strictCircularShallowEqual: <A, B>(a: A, b: B) => boolean;
+/**
+ * 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 declare function createCustomEqual<Meta>(
+  options?: CustomEqualCreatorOptions<Meta>,
+): <A, B>(a: A, b: B, metaOverride?: Meta) => boolean;

package/package.json

@@ -105,6 +105,6 @@
   },
   "sideEffects": false,
   "type": "module",
-  "types": "index.d.ts",
-  "version": "5.0.0-beta.0"
+  "types": "./index.d.ts",
+  "version": "5.0.0-beta.1"
 }