fast-equals 1.6.3 → 2.0.0

package/package.json

@@ -1,58 +1,50 @@
 {
   "author": "tony_quetano@planttheidea.com",
-  "ava": {
-    "failFast": true,
-    "files": [
-      "test/*.js"
-    ],
-    "require": [
-      "@babel/register"
-    ],
-    "sources": [
-      "src/*.js"
-    ],
-    "verbose": true
-  },
   "browser": "dist/fast-equals.js",
   "bugs": {
     "url": "https://github.com/planttheidea/fast-equals/issues"
   },
   "description": "A blazing fast equality comparison, either shallow or deep",
   "devDependencies": {
-    "@babel/cli": "^7.2.3",
-    "@babel/core": "^7.0.0",
-    "@babel/preset-env": "^7.3.1",
-    "@babel/preset-react": "^7.0.0",
-    "@babel/register": "^7.0.0",
-    "ava": "^1.1.0",
-    "babel-eslint": "^10.0.1",
-    "babel-loader": "^8.0.5",
-    "benchee": "^1.0.3",
+    "@types/jest": "^24.0.12",
+    "@types/lodash": "^4.14.121",
+    "@types/node": "^11.13.8",
+    "@types/ramda": "^0.26.8",
+    "@types/react": "^16.8.3",
+    "@typescript-eslint/eslint-plugin": "^1.7.0",
+    "@typescript-eslint/parser": "^1.7.0",
+    "benchee": "^1.1.0",
     "cli-table2": "^0.2.0",
     "decircularize": "^1.0.0",
     "deep-eql": "^4.0.0",
     "deep-equal": "^1.0.1",
     "eslint": "^5.12.1",
-    "eslint-config-rapid7": "^3.1.0",
-    "eslint-friendly-formatter": "^4.0.1",
-    "eslint-loader": "^2.1.1",
+    "eslint-config-airbnb": "^17.1.0",
+    "eslint-loader": "^2.1.2",
+    "eslint-plugin-import": "^2.17.2",
+    "eslint-plugin-jsx-a11y": "^6.2.1",
+    "eslint-plugin-react": "^7.12.4",
     "fast-deep-equal": "^2.0.1",
     "fs-extra": "^7.0.1",
     "html-webpack-plugin": "^3.2.0",
     "in-publish": "^2.0.0",
+    "jest": "^24.7.1",
     "lodash": "^4.17.11",
     "nano-equal": "^2.0.2",
-    "nyc": "^13.1.0",
+    "nyc": "^14.1.0",
     "optimize-js-plugin": "^0.0.4",
-    "react": "^16.7.0",
+    "react": "^16.8.6",
     "react-dom": "^16.7.0",
     "react-fast-compare": "^2.0.4",
     "rollup": "^1.1.2",
-    "rollup-plugin-babel": "^4.3.2",
     "rollup-plugin-node-resolve": "^4.0.0",
     "rollup-plugin-terser": "^4.0.2",
+    "rollup-plugin-typescript2": "^0.21.0",
     "shallow-equal-fuzzy": "^0.0.2",
     "sinon": "^7.2.3",
+    "ts-jest": "^24.0.2",
+    "ts-loader": "^5.4.4",
+    "typescript": "^3.4.5",
     "underscore": "^1.9.1",
     "webpack": "^4.29.0",
     "webpack-cli": "^3.2.1",
@@ -75,30 +67,22 @@
     "url": "git+https://github.com/planttheidea/fast-equals.git"
   },
   "scripts": {
-    "benchmark": "NODE_ENV=production BABEL_ENV=test babel src --out-dir lib --no-comments && node benchmark/index.js",
+    "benchmark": "npm run dist && node benchmark/index.js",
     "build": "NODE_ENV=production rollup -c",
-    "clean": "npm run clean:es && npm run clean:lib && npm run clean:dist",
-    "clean:dist": "rimraf dist",
-    "clean:es": "rimraf es",
-    "clean:lib": "rimraf lib",
-    "clean:mjs": "rimraf mjs",
-    "copy:mjs": "npm run clean:mjs && node ./es-to-mjs.js",
-    "dev": "NODE_ENV=development webpack-dev-server --colors --progress --config=webpack/webpack.config.dev.js",
-    "dist": "npm run clean:dist && npm run build",
-    "lint": "NODE_ENV=test eslint src --max-warnings 0",
-    "lint:fix": "NODE_ENV=test eslint src --fix",
+    "dev": "NODE_ENV=development webpack-dev-server --progress --colors --config=webpack/webpack.config.js",
+    "dist": "rimraf dist && npm run build",
+    "lint": "eslint src/*.ts",
+    "lint:fix": "npm run lint -- --fix",
+    "start": "npm run dev",
     "prepublish": "if in-publish; then npm run prepublish:compile; fi",
-    "prepublish:compile": "npm run lint && npm run test:coverage && npm run transpile:lib && npm run transpile:es && npm run copy:mjs && npm run dist",
+    "prepublish:compile": "npm run lint && npm run test:coverage && npm run dist",
     "release": "release-it",
     "release:beta": "release-it --config=.release-it.beta.json",
-    "start": "npm run dev",
-    "test": "NODE_PATH=. BABEL_ENV=test ava",
-    "test:coverage": "nyc npm test",
-    "test:watch": "npm test -- --watch",
-    "transpile:es": "npm run clean:es && BABEL_ENV=es babel src --out-dir es",
-    "transpile:lib": "npm run clean:lib && BABEL_ENV=lib babel src --out-dir lib"
+    "test": "NODE_PATH=. jest",
+    "test:coverage": "npm test -- --coverage",
+    "test:watch": "npm test -- --watch"
   },
   "sideEffects": false,
   "types": "index.d.ts",
-  "version": "1.6.3"
+  "version": "2.0.0"
 }

package/es/comparator.js

@@ -1,86 +0,0 @@
-// constants
-import { HAS_MAP_SUPPORT, HAS_SET_SUPPORT } from './constants'; // utils
-
-import { areArraysEqual, areMapsEqual, areObjectsEqual, areRegExpsEqual, areSetsEqual, isPlainObject, isPromiseLike, sameValueZeroEqual } from './utils';
-var isArray = Array.isArray;
-
-var createComparator = function createComparator(createIsEqual) {
-  // eslint-disable-next-line no-use-before-define
-  var isEqual = typeof createIsEqual === 'function' ? createIsEqual(comparator) : comparator;
-  /**
-   * @function comparator
-   *
-   * @description
-   * compare the value of the two objects and return true if they are equivalent in values
-   *
-   * @param {any} objectA the object to test against
-   * @param {any} objectB the object to test
-   * @param {any} [meta] an optional meta object that is passed through to all equality test calls
-   * @returns {boolean} are objectA and objectB equivalent in value
-   */
-
-  function comparator(objectA, objectB, meta) {
-    if (sameValueZeroEqual(objectA, objectB)) {
-      return true;
-    }
-
-    var typeOfA = typeof objectA;
-
-    if (typeOfA !== typeof objectB || typeOfA !== 'object' || !objectA || !objectB) {
-      return false;
-    }
-
-    if (isPlainObject(objectA) && isPlainObject(objectB)) {
-      return areObjectsEqual(objectA, objectB, isEqual, meta);
-    }
-
-    var arrayA = isArray(objectA);
-    var arrayB = isArray(objectB);
-
-    if (arrayA || arrayB) {
-      return arrayA === arrayB && areArraysEqual(objectA, objectB, isEqual, meta);
-    }
-
-    var dateA = objectA instanceof Date;
-    var dateB = objectB instanceof Date;
-
-    if (dateA || dateB) {
-      return dateA === dateB && sameValueZeroEqual(objectA.getTime(), objectB.getTime());
-    }
-
-    var regexpA = objectA instanceof RegExp;
-    var regexpB = objectB instanceof RegExp;
-
-    if (regexpA || regexpB) {
-      return regexpA === regexpB && areRegExpsEqual(objectA, objectB);
-    }
-
-    if (isPromiseLike(objectA) || isPromiseLike(objectB)) {
-      return objectA === objectB;
-    }
-
-    if (HAS_MAP_SUPPORT) {
-      var mapA = objectA instanceof Map;
-      var mapB = objectB instanceof Map;
-
-      if (mapA || mapB) {
-        return mapA === mapB && areMapsEqual(objectA, objectB, isEqual, meta);
-      }
-    }
-
-    if (HAS_SET_SUPPORT) {
-      var setA = objectA instanceof Set;
-      var setB = objectB instanceof Set;
-
-      if (setA || setB) {
-        return setA === setB && areSetsEqual(objectA, objectB, isEqual, meta);
-      }
-    }
-
-    return areObjectsEqual(objectA, objectB, isEqual, meta);
-  }
-
-  return comparator;
-};
-
-export default createComparator;

package/es/constants.js

@@ -1,14 +0,0 @@
-/**
- * @constant {boolean} HAS_MAP_SUPPORT
- */
-export var HAS_MAP_SUPPORT = typeof Map === 'function';
-/**
- * @constant {boolean} HAS_SET_SUPPORT
- */
-
-export var HAS_SET_SUPPORT = typeof Set === 'function';
-/**
- * @constant {boolean} HAS_WEAKSET_SUPPORT
- */
-
-export var HAS_WEAKSET_SUPPORT = typeof WeakSet === 'function';

package/es/index.js

@@ -1,19 +0,0 @@
-// comparator
-import createCustomEqual from './comparator'; // utils
-
-import { createCircularEqual, sameValueZeroEqual } from './utils';
-export { createCustomEqual, sameValueZeroEqual };
-export var circularDeepEqual = createCustomEqual(createCircularEqual());
-export var circularShallowEqual = createCustomEqual(createCircularEqual(sameValueZeroEqual));
-export var deepEqual = createCustomEqual();
-export var shallowEqual = createCustomEqual(function () {
-  return sameValueZeroEqual;
-});
-export default {
-  circularDeep: circularDeepEqual,
-  circularShallow: circularShallowEqual,
-  createCustom: createCustomEqual,
-  deep: deepEqual,
-  sameValueZero: sameValueZeroEqual,
-  shallow: shallowEqual
-};

package/es/utils.js

@@ -1,333 +0,0 @@
-// constants
-import { HAS_WEAKSET_SUPPORT } from './constants';
-var keys = Object.keys;
-/**
- * @function addObjectToCache
- *
- * @description
- * add object to cache if it is indeed an object
- *
- * @param {any} object the object to potentially add to the cache
- * @param {Object|WeakSet} cache the cache to add to
- * @returns {void}
- */
-
-export var addObjectToCache = function addObjectToCache(object, cache) {
-  return object && typeof object === 'object' && cache.add(object);
-};
-/**
- *
- * @param {Array<Array<any>>} pairs the pairs to check in
- * @param {Array<any>} pairToMatch the pair to check if exists
- * @param {function} isEqual the equality comparator
- * @param {any} meta the meta item to pass through
- * @returns {boolean} does the pair exist in the pairs
- */
-
-export var hasPair = function hasPair(pairs, pairToMatch, isEqual, meta) {
-  var pair;
-
-  for (var index = 0; index < pairs.length; index++) {
-    pair = pairs[index];
-
-    if (isEqual(pair[0], pairToMatch[0], meta) && isEqual(pair[1], pairToMatch[1], meta)) {
-      return true;
-    }
-  }
-
-  return false;
-};
-/**
- * @function hasValue
- *
- * @description
- * does the values include the vakye passed
- *
- * @param {Array<any>} values the values to check in
- * @param {any} item the value to locate
- * @param {function} isEqual the equality comparator
- * @param {any} meta the meta item to pass through
- * @returns {boolean} does the value exist in the values
- */
-
-export var hasValue = function hasValue(values, item, isEqual, meta) {
-  for (var index = 0; index < values.length; index++) {
-    if (isEqual(values[index], item, meta)) {
-      return true;
-    }
-  }
-
-  return false;
-};
-/**
- * @function sameValueZeroEqual
- *
- * @description
- * are the objects passed strictly equal or both NaN
- *
- * @param {any} objectA the object to compare against
- * @param {any} objectB the object to test
- * @returns {boolean} are the objects equal by the SameValueZero principle
- */
-
-export var sameValueZeroEqual = function sameValueZeroEqual(objectA, objectB) {
-  return objectA === objectB || objectA !== objectA && objectB !== objectB;
-};
-/**
- * @function isPlainObject
- *
- * @description
- * is the object a plain object
- *
- * @param {any} object the object to test
- * @returns {boolean} is the object a plain object
- */
-
-export var isPlainObject = function isPlainObject(object) {
-  return object.constructor === Object;
-};
-/**
- * @function isPromiseLike
- *
- * @description
- * is the object promise-like (thenable)
- *
- * @param {any} object the object to test
- * @returns {boolean} is the object promise-like
- */
-
-export var isPromiseLike = function isPromiseLike(object) {
-  return typeof object.then === 'function';
-};
-/**
- * @function isReactElement
- *
- * @description
- * is the object passed a react element
- *
- * @param {any} object the object to test
- * @returns {boolean} is the object a react element
- */
-
-export var isReactElement = function isReactElement(object) {
-  return !!(object.$$typeof && object._store);
-};
-/**
- * @function getNewCache
- *
- * @description
- * get a new cache object to prevent circular references
- *
- * @returns {Object|Weakset} the new cache object
- */
-
-export var getNewCache = function getNewCache() {
-  return HAS_WEAKSET_SUPPORT ? new WeakSet() : Object.create({
-    _values: [],
-    add: function add(value) {
-      this._values.push(value);
-    },
-    has: function has(value) {
-      return !!~this._values.indexOf(value);
-    }
-  });
-};
-/**
- * @function createCircularEqual
- *
- * @description
- * create a custom isEqual handler specific to circular objects
- *
- * @param {funtion} [isEqual] the isEqual comparator to use instead of isDeepEqual
- * @returns {function(any, any): boolean}
- */
-
-export var createCircularEqual = function createCircularEqual(isEqual) {
-  return function (isDeepEqual) {
-    var comparator = isEqual || isDeepEqual;
-    return function (objectA, objectB, cache) {
-      if (cache === void 0) {
-        cache = getNewCache();
-      }
-
-      var cacheHasA = cache.has(objectA);
-      var cacheHasB = cache.has(objectB);
-
-      if (cacheHasA || cacheHasB) {
-        return cacheHasA && cacheHasB;
-      }
-
-      addObjectToCache(objectA, cache);
-      addObjectToCache(objectB, cache);
-      return comparator(objectA, objectB, cache);
-    };
-  };
-};
-/**
- * @function toPairs
- *
- * @param {Map} map the map to convert to [key, value] pairs (entries)
- * @returns {Array<Array<*>>} the [key, value] pairs
- */
-
-export var toPairs = function toPairs(map) {
-  var pairs = [];
-  map.forEach(function (value, key) {
-    return pairs.push([key, value]);
-  });
-  return pairs;
-};
-/**
- * @function toValues
- *
- * @param {Set} set the set to convert to values
- * @returns {Array<*>} the values
- */
-
-export var toValues = function toValues(set) {
-  var values = [];
-  set.forEach(function (value) {
-    return values.push(value);
-  });
-  return values;
-};
-/**
- * @function areArraysEqual
- *
- * @description
- * are the arrays equal in value
- *
- * @param {Array<any>} arrayA the array to test
- * @param {Array<any>} arrayB the array to test against
- * @param {function} isEqual the comparator to determine equality
- * @param {any} meta the meta object to pass through
- * @returns {boolean} are the arrays equal
- */
-
-export var areArraysEqual = function areArraysEqual(arrayA, arrayB, isEqual, meta) {
-  if (arrayA.length !== arrayB.length) {
-    return false;
-  }
-
-  for (var index = 0; index < arrayA.length; index++) {
-    if (!isEqual(arrayA[index], arrayB[index], meta)) {
-      return false;
-    }
-  }
-
-  return true;
-};
-/**
- * @function areMapsEqual
- *
- * @description
- * are the maps equal in value
- *
- * @param {Map} mapA the map to test
- * @param {Map} mapB the map to test against
- * @param {function} isEqual the comparator to determine equality
- * @param {any} meta the meta map to pass through
- * @returns {boolean} are the maps equal
- */
-
-export var areMapsEqual = function areMapsEqual(mapA, mapB, isEqual, meta) {
-  if (mapA.size !== mapB.size) {
-    return false;
-  }
-
-  var pairsA = toPairs(mapA);
-  var pairsB = toPairs(mapB);
-
-  for (var index = 0; index < pairsA.length; index++) {
-    if (!hasPair(pairsB, pairsA[index], isEqual, meta) || !hasPair(pairsA, pairsB[index], isEqual, meta)) {
-      return false;
-    }
-  }
-
-  return true;
-};
-/**
- * @function areObjectsEqual
- *
- * @description
- * are the objects equal in value
- *
- * @param {Object} objectA the object to test
- * @param {Object} objectB the object to test against
- * @param {function} isEqual the comparator to determine equality
- * @param {any} meta the meta object to pass through
- * @returns {boolean} are the objects equal
- */
-
-export var areObjectsEqual = function areObjectsEqual(objectA, objectB, isEqual, meta) {
-  var keysA = keys(objectA);
-  var keysB = keys(objectB);
-
-  if (keysA.length !== keysB.length) {
-    return false;
-  }
-
-  var key;
-
-  for (var index = 0; index < keysA.length; index++) {
-    key = keysA[index];
-
-    if (!hasValue(keysB, key, sameValueZeroEqual)) {
-      return false;
-    } // if a react element, ignore the "_owner" key because its not necessary for equality comparisons
-
-
-    if (key === '_owner' && isReactElement(objectA) && isReactElement(objectB)) {
-      continue;
-    }
-
-    if (!isEqual(objectA[key], objectB[key], meta)) {
-      return false;
-    }
-  }
-
-  return true;
-};
-/**
- * @function areRegExpsEqual
- *
- * @description
- * are the regExps equal in value
- *
- * @param {RegExp} regExpA the regExp to test
- * @param {RegExp} regExpB the regExp to test agains
- * @returns {boolean} are the regExps equal
- */
-
-export var areRegExpsEqual = function areRegExpsEqual(regExpA, regExpB) {
-  return regExpA.source === regExpB.source && regExpA.global === regExpB.global && regExpA.ignoreCase === regExpB.ignoreCase && regExpA.multiline === regExpB.multiline && regExpA.unicode === regExpB.unicode && regExpA.sticky === regExpB.sticky && regExpA.lastIndex === regExpB.lastIndex;
-};
-/**
- * @function areSetsEqual
- *
- * @description
- * are the sets equal in value
- *
- * @param {Set} setA the set to test
- * @param {Set} setB the set to test against
- * @param {function} isEqual the comparator to determine equality
- * @param {any} meta the meta set to pass through
- * @returns {boolean} are the sets equal
- */
-
-export var areSetsEqual = function areSetsEqual(setA, setB, isEqual, meta) {
-  if (setA.size !== setB.size) {
-    return false;
-  }
-
-  var valuesA = toValues(setA);
-  var valuesB = toValues(setB);
-
-  for (var index = 0; index < valuesA.length; index++) {
-    if (!hasValue(valuesB, valuesA[index], isEqual, meta) || !hasValue(valuesA, valuesB[index], isEqual, meta)) {
-      return false;
-    }
-  }
-
-  return true;
-};

package/es-to-mjs.js

@@ -1,14 +0,0 @@
-const fs = require('fs-extra');
-const path = require('path');
-
-const ES_DIRECTORY = path.join(__dirname, 'es');
-const MJS_DIRECTORY = path.join(__dirname, 'mjs');
-
-fs.readdirSync(ES_DIRECTORY).forEach((file) => {
-  const fullPathJsFilename = path.resolve(ES_DIRECTORY, file);
-  const fullPathMjsFilename = path.resolve(MJS_DIRECTORY, `${file.slice(0, -3)}.mjs`);
-
-  fs.copySync(fullPathJsFilename, fullPathMjsFilename);
-
-  console.log(`es/${file} -> mjs/${file.slice(0, -3)}.mjs`);
-});

package/lib/comparator.js

@@ -1,94 +0,0 @@
-"use strict";
-
-exports.__esModule = true;
-exports["default"] = void 0;
-
-var _constants = require("./constants");
-
-var _utils = require("./utils");
-
-// constants
-// utils
-var isArray = Array.isArray;
-
-var createComparator = function createComparator(createIsEqual) {
-  // eslint-disable-next-line no-use-before-define
-  var isEqual = typeof createIsEqual === 'function' ? createIsEqual(comparator) : comparator;
-  /**
-   * @function comparator
-   *
-   * @description
-   * compare the value of the two objects and return true if they are equivalent in values
-   *
-   * @param {any} objectA the object to test against
-   * @param {any} objectB the object to test
-   * @param {any} [meta] an optional meta object that is passed through to all equality test calls
-   * @returns {boolean} are objectA and objectB equivalent in value
-   */
-
-  function comparator(objectA, objectB, meta) {
-    if ((0, _utils.sameValueZeroEqual)(objectA, objectB)) {
-      return true;
-    }
-
-    var typeOfA = typeof objectA;
-
-    if (typeOfA !== typeof objectB || typeOfA !== 'object' || !objectA || !objectB) {
-      return false;
-    }
-
-    if ((0, _utils.isPlainObject)(objectA) && (0, _utils.isPlainObject)(objectB)) {
-      return (0, _utils.areObjectsEqual)(objectA, objectB, isEqual, meta);
-    }
-
-    var arrayA = isArray(objectA);
-    var arrayB = isArray(objectB);
-
-    if (arrayA || arrayB) {
-      return arrayA === arrayB && (0, _utils.areArraysEqual)(objectA, objectB, isEqual, meta);
-    }
-
-    var dateA = objectA instanceof Date;
-    var dateB = objectB instanceof Date;
-
-    if (dateA || dateB) {
-      return dateA === dateB && (0, _utils.sameValueZeroEqual)(objectA.getTime(), objectB.getTime());
-    }
-
-    var regexpA = objectA instanceof RegExp;
-    var regexpB = objectB instanceof RegExp;
-
-    if (regexpA || regexpB) {
-      return regexpA === regexpB && (0, _utils.areRegExpsEqual)(objectA, objectB);
-    }
-
-    if ((0, _utils.isPromiseLike)(objectA) || (0, _utils.isPromiseLike)(objectB)) {
-      return objectA === objectB;
-    }
-
-    if (_constants.HAS_MAP_SUPPORT) {
-      var mapA = objectA instanceof Map;
-      var mapB = objectB instanceof Map;
-
-      if (mapA || mapB) {
-        return mapA === mapB && (0, _utils.areMapsEqual)(objectA, objectB, isEqual, meta);
-      }
-    }
-
-    if (_constants.HAS_SET_SUPPORT) {
-      var setA = objectA instanceof Set;
-      var setB = objectB instanceof Set;
-
-      if (setA || setB) {
-        return setA === setB && (0, _utils.areSetsEqual)(objectA, objectB, isEqual, meta);
-      }
-    }
-
-    return (0, _utils.areObjectsEqual)(objectA, objectB, isEqual, meta);
-  }
-
-  return comparator;
-};
-
-var _default = createComparator;
-exports["default"] = _default;