fast-equals 1.6.0 → 2.0.0

package/README.md

@@ -20,7 +20,7 @@ Starting with version `1.5.0`, circular objects are supported for both deep and
 ## Table of contents
 
 - [Usage](#usage)
-- [Importing](#importing)
+  - [Specific builds](#specific-builds)
 - [Available methods](#available-methods)
   - [deepEqual](#deepequal)
   - [shallowEqual](#shallowequal)
@@ -33,55 +33,46 @@ Starting with version `1.5.0`, circular objects are supported for both deep and
 
 ## Usage
 
-You can either import the full object:
+You can either import the individual functions desired:
 
 ```javascript
-import fe from "fast-equals";
+import { deepEqual } from 'fast-equals';
 
-console.log(fe.deep({ foo: "bar" }, { foo: "bar" })); // true
+console.log(deepEqual({ foo: 'bar' }, { foo: 'bar' })); // true
 ```
 
-Or the individual imports desired:
+Or if you want to import all functions under a namespace:
 
 ```javascript
-import { deepEqual } from "fast-equals";
+import * as fe from 'fast-equals';
 
-console.log(deepEqual({ foo: "bar" }, { foo: "bar" })); // true
+console.log(fe.deep({ foo: 'bar' }, { foo: 'bar' })); // true
 ```
 
-## Importing
+#### Specific builds
 
-ESM in browsers:
+There are three builds, an ESM build for modern build systems / runtimes, a CommonJS build for traditional NodeJS environments, and a UMD build for legacy implementations. The ideal one will likely be chosen for you automatically, however if you want to use a specific build you can always import it directly:
 
-```javascript
-import fe from "fast-equals";
-```
+- ESM => `fast-equals/dist/fast-equals.esm.js`
+  - For older `nodejs` versions that do not allow ESM with file extensions other than `.mjs` => `fast-equals/dist/fast-equals.mjs`
+- CommonJS => `fast-equals/dist/fast-equals.cjs.js`
+- UMD => `fast-equals/dist/fast-equals.js`
 
-ESM in NodeJS:
+There is also a pre-minified version of the UMD build available:
 
-```javascript
-import fe from "fast-equals/mjs";
-```
-
-CommonJS:
-
-```javascript
-const fe = require("fast-equals").default;
-```
+- Minified UMD => `fast-equals/dist/fast-equals.min.js`
 
 ## Available methods
 
 #### deepEqual
 
-_Aliased on the default export as `fe.deep`_
-
 Performs a deep equality comparison on the two objects passed and returns a boolean representing the value equivalency of the objects.
 
 ```javascript
-import { deepEqual } from "fast-equals";
+import { deepEqual } from 'fast-equals';
 
-const objectA = { foo: { bar: "baz" } };
-const objectB = { foo: { bar: "baz" } };
+const objectA = { foo: { bar: 'baz' } };
+const objectB = { foo: { bar: 'baz' } };
 
 console.log(objectA === objectB); // false
 console.log(deepEqual(objectA, objectB)); // true
@@ -89,18 +80,16 @@ console.log(deepEqual(objectA, objectB)); // true
 
 #### shallowEqual
 
-_Aliased on the default export as `fe.shallow`_
-
 Performs a shallow equality comparison on the two objects passed and returns a boolean representing the value equivalency of the objects.
 
 ```javascript
-import { shallowEqual } from "fast-equals";
+import { shallowEqual } from 'fast-equals';
 
-const nestedObject = { bar: "baz" };
+const nestedObject = { bar: 'baz' };
 
 const objectA = { foo: nestedObject };
 const objectB = { foo: nestedObject };
-const objectC = { foo: { bar: "baz" } };
+const objectC = { foo: { bar: 'baz' } };
 
 console.log(objectA === objectB); // false
 console.log(shallowEqual(objectA, objectB)); // true
@@ -109,18 +98,16 @@ console.log(shallowEqual(objectA, objectC)); // false
 
 #### sameValueZeroEqual
 
-_Aliased on the default export as `fe.sameValueZero`_
-
 Performs a [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) comparison on the two objects passed and returns a boolean representing the value equivalency of the objects. In simple terms, this means either strictly equal or both `NaN`.
 
 ```javascript
-import { sameValueZeroEqual } from "fast-equals";
+import { sameValueZeroEqual } from 'fast-equals';
 
-const mainObject = { foo: NaN, bar: "baz" };
+const mainObject = { foo: NaN, bar: 'baz' };
 
-const objectA = "baz";
+const objectA = 'baz';
 const objectB = NaN;
-const objectC = { foo: NaN, bar: "baz" };
+const objectC = { foo: NaN, bar: 'baz' };
 
 console.log(sameValueZeroEqual(mainObject.bar, objectA)); // true
 console.log(sameValueZeroEqual(mainObject.foo, objectB)); // true
@@ -129,8 +116,6 @@ console.log(sameValueZeroEqual(mainObject, objectC)); // false
 
 #### circularDeepEqual
 
-_Aliased on the default export as `fe.circularDeep`_
-
 Performs the same comparison as `deepEqual` but supports circular objects. It is slower than `deepEqual`, so only use if you know circular objects are present.
 
 ```javascript
@@ -138,50 +123,53 @@ function Circular(value) {
   this.me = {
     deeply: {
       nested: {
-        reference: this
-      }
+        reference: this,
+      },
     },
-    value
+    value,
   };
 }
 
-console.log(circularDeepEqual(new Circular("foo"), new Circular("foo"))); // true
-console.log(circularDeepEqual(new Circular("foo"), new Circular("bar"))); // false
+console.log(circularDeepEqual(new Circular('foo'), new Circular('foo'))); // true
+console.log(circularDeepEqual(new Circular('foo'), new Circular('bar'))); // false
 ```
 
 #### circularShallowEqual
 
-_Aliased on the default export as `fe.circularShallow`_
-
 Performs the same comparison as `shallowequal` but supports circular objects. It is slower than `shallowEqual`, so only use if you know circular objects are present.
 
 ```javascript
-const array = ["foo"];
+const array = ['foo'];
 
 array.push(array);
 
-console.log(circularShallowEqual(array, ["foo", array])); // true
+console.log(circularShallowEqual(array, ['foo', array])); // true
 console.log(circularShallowEqual(array, [array])); // false
 ```
 
 #### createCustomEqual
 
-_Aliased on the default export as `fe.createCustom`_
-
 Creates a custom equality comparator that will be used on nested values in the object. Unlike `deepEqual` and `shallowEqual`, this is a partial-application function that will receive the internal comparator and should return a function that compares two objects.
 
 The signature is as follows:
 
-```javascript
-createCustomEqual(deepEqual: function) => (objectA: any, objectB: any, meta: any) => boolean;
+```typescript
+type EqualityComparator = (a: any, b: any, meta?: any) => boolean;
+type EqualityComparatorCreator = (
+  deepEqual: EqualityComparator,
+) => EqualityComparator;
+
+function createCustomEqual(
+  createIsEqual?: EqualityComparatorCreator,
+): EqualityComparator;
 ```
 
-The `meta` parameter is whatever you want it to be. It will be passed through to all equality checks, and is meant specifically for use with custom equality methods. For example, with the `circularDeepEqual` and `circularShallowEqual` methods, it is used to pass through a cache of processed objects.
+The `meta` parameter in `EqualityComparator` is whatever you want it to be. It will be passed through to all equality checks, and is meant specifically for use with custom equality methods. For example, with the `circularDeepEqual` and `circularShallowEqual` methods, it is used to pass through a cache of processed objects.
 
 An example for a custom equality comparison that also checks against values in the meta object:
 
 ```javascript
-import { createCustomEqual } from "fast-equals";
+import { createCustomEqual } from 'fast-equals';
 
 const isDeepEqualOrFooMatchesMeta = createCustomEqual(deepEqual => {
   return (objectA, objectB, meta) => {
@@ -193,16 +181,16 @@ const isDeepEqualOrFooMatchesMeta = createCustomEqual(deepEqual => {
   };
 });
 
-const objectA = { foo: "bar" };
-const objectB = { foo: "baz" };
-const meta = "bar";
+const objectA = { foo: 'bar' };
+const objectB = { foo: 'baz' };
+const meta = 'bar';
 
 console.log(isDeepEqualOrFooMatchesMeta(objectA, objectB)); // true
 ```
 
 ## Benchmarks
 
-All benchmarks were performed on an i7 8-core Arch Linux laptop with 16GB of memory using NodeJS version `8.11.1`, and are based on averages of running comparisons based deep equality on the following object types:
+All benchmarks were performed on an i7 8-core Arch Linux laptop with 16GB of memory using NodeJS version `10.15.3`, and are based on averages of running comparisons based deep equality on the following object types:
 
 - Primitives (`String`, `Number`, `null`, `undefined`)
 - `Function`
@@ -213,53 +201,46 @@ All benchmarks were performed on an i7 8-core Arch Linux laptop with 16GB of mem
 - `react` elements
 - A mixed object with a combination of all the above types
 
-|                            | Operations / second | Relative margin of error |
-| -------------------------- | ------------------- | ------------------------ |
-| **fast-equals**            | **130,726**         | **0.79%**                |
-| nano-equal                 | 103,950             | 0.85%                    |
-| shallow-equal-fuzzy        | 101,535             | 0.60%                    |
-| react-fast-compare         | 94,724              | 0.82%                    |
-| fast-deep-equal            | 92,172              | 0.85%                    |
-| underscore.isEqual         | 63,431              | 0.88%                    |
-| **fast-equals (circular)** | **53,778**          | **0.85%**                |
-| deep-equal                 | 29,739              | 0.54%                    |
-| lodash.isEqual             | 26,201              | 0.70%                    |
-| deep-eql                   | 16,496              | 0.60%                    |
-| assert.deepStrictEqual     | 1,565               | 1.04%                    |
+|                            | Operations / second |
+| -------------------------- | ------------------- |
+| **fast-equals**            | **142,730**         |
+| nano-equal                 | 115,530             |
+| shallow-equal-fuzzy        | 102,633             |
+| fast-deep-equal            | 102,335             |
+| react-fast-compare         | 100,036             |
+| **fast-equals (circular)** | **79,589**          |
+| underscore.isEqual         | 63,390              |
+| deep-equal                 | 48,783              |
+| lodash.isEqual             | 24,456              |
+| deep-eql                   | 24,196              |
+| assert.deepStrictEqual     | 1,382               |
 
 Caveats that impact the benchmark (and accuracy of comparison):
 
-- `nano-equal` does not strictly compare object property structure, array length, or object type, nor `SameValueZero` equality for dates
-- `shallow-equal-fuzzy` does not strictly compare object type or regexp values, nor `SameValueZero` equality for dates
+- `assert.deepStrictEqual` does not support `NaN` or `SameValueZero` equality for dates
+- `deep-eql` does not support `SameValueZero` equality for zero equality (positive and negative zero are not equal)
+- `deep-equal` does not support `NaN` and does not strictly compare object type, or date / regexp values, nor uses `SameValueZero` equality for dates
 - `fast-deep-equal` does not support `NaN` or `SameValueZero` equality for dates
+- `nano-equal` does not strictly compare object property structure, array length, or object type, nor `SameValueZero` equality for dates
 - `react-fast-compare` does not support `NaN` or `SameValueZero` equality for dates, and does not compare `function` equality
+- `shallow-equal-fuzzy` does not strictly compare object type or regexp values, nor `SameValueZero` equality for dates
 - `underscore.isEqual` does not support `SameValueZero` equality for primitives or dates
-- `deep-equal` does not support `NaN` and does not strictly compare object type, or date / regexp values, nor uses `SameValueZero` equality for dates
-- `deep-eql` does not support `SameValueZero` equality for zero equality (positive and negative zero are not equal)
-- `assert.deepStrictEqual` does not support `NaN` or `SameValueZero` equality for dates
 
-All of these have the potential of inflating the respective library's numbers in comparison to `fast-equals`, but it was the closest apples-to-apples comparison I could create of a reasonable sample size. `Map`s, `Promise`s, and `Set`s were excluded from the benchmark entirely because no library other than `lodash` supported their comparison. The same logic applies to `react` elements (which can be circular objects), but simple elements are non-circular objects so I kept the `react` comparison very basic to allow it to be included.
+All of these have the potential of inflating the respective library's numbers in comparison to `fast-equals`, but it was the closest apples-to-apples comparison I could create of a reasonable sample size. `Map`s, `Promise`s, and `Set`s were excluded from the benchmark entirely because no library other than `deep-eql` fully supported their comparison. The same logic applies to `react` elements (which can be circular objects), but simple elements are non-circular objects so I kept the `react` comparison very basic to allow it to be included.
 
 ## Development
 
 Standard practice, clone the repo and `npm i` to get the dependencies. The following npm scripts are available:
 
 - benchmark => run benchmark tests against other equality libraries
-- build => build unminified dist version with source map and NODE_ENV=development via webpack
-- build:minified => build minified dist version with NODE_ENV=production via webpack
-- clean => run `clean:dist`, `clean:es`, and `clean:lib` scripts
-- clean:dist => run `rimraf` on the `dist` folder
-- clean:es => run `rimraf` on the `es` folder
-- clean:lib => run `rimraf` on the `lib` folder
+- build => build `main`, `module`, and `browser` distributables with `rollup`
+- clean => run `rimraf` on the `dist` folder
 - dev => start webpack playground App
-- dist => run `build` and `build:minified` scripts
+- dist => run `build`
 - lint => run ESLint on all files in `src` folder (also runs on `dev` script)
 - lint:fix => run `lint` script, but with auto-fixer
-- prepublish =>
 - prepublish:compile => run `lint`, `test:coverage`, `transpile:lib`, `transpile:es`, and `dist` scripts
 - start => run `dev`
 - test => run AVA with NODE_ENV=test on all files in `test` folder
 - test:coverage => run same script as `test` with code coverage calculation via `nyc`
 - test:watch => run same script as `test` but keep persistent watcher
-- transpile:es => run Babel on all files, in `src` folder (transpiled to `es` folder without transpilation of ES2015 export syntax)
-- transpile:lib => run Babel on all files in `src` folder (transpiled to `lib` folder)