compare-anything 0.3.3 → 0.3.7

package/README.md

@@ -1,5 +1,8 @@
 # Compare anything 🛰
 
+<a href="https://www.npmjs.com/package/compare-anything"><img src="https://img.shields.io/npm/v/compare-anything.svg" alt="Total Downloads"></a>
+<a href="https://www.npmjs.com/package/compare-anything"><img src="https://img.shields.io/npm/dw/compare-anything.svg" alt="Latest Stable Version"></a>
+
 ```
 npm i compare-anything
 ```

package/dist/index.cjs

@@ -0,0 +1,113 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var isWhat = require('is-what');
+var filterAnything = require('filter-anything');
+
+function compareObjectsBasedOn(propKeys, objects) {
+    const baseProps = propKeys;
+    const baseObject = objects[0];
+    const differentPropsSet = objects.reduce((carry, object, index) => {
+        if (index === 0)
+            return carry;
+        for (const prop of baseProps) {
+            if (object[prop] !== baseObject[prop])
+                carry.add(prop);
+        }
+        return carry;
+    }, new Set());
+    const differentProps = [...differentPropsSet];
+    const differentPropsPicked = objects.map((object) => filterAnything.pick(object, differentProps));
+    return {
+        differentProps,
+        differentPropsPicked,
+        equal: differentProps.length === 0,
+    };
+}
+
+function compareObjectArraysBasedOn(propKeys, objectArrays) {
+    const firstArray = objectArrays[0];
+    const comparison = {
+        perIndex: [],
+        equal: true,
+    };
+    firstArray.forEach((object, index) => {
+        const objectsToCompare = objectArrays.map((arr) => arr[index]);
+        const compared = compareObjectsBasedOn(propKeys, objectsToCompare);
+        if (!compared.equal)
+            comparison.equal = false;
+        comparison.perIndex.push(compared);
+    });
+    return comparison;
+}
+
+function compareObjectProps(...params) {
+    const propsSet = new Set();
+    const res = {
+        props: [],
+        presentInAll: {},
+        presentIn: {},
+        perProp: {},
+    };
+    params.forEach((object, index) => {
+        if (!isWhat.isAnyObject(object)) {
+            throw new Error("'compareObjectProps' can only compare objects");
+        }
+        Object.keys(object).forEach((prop) => {
+            propsSet.add(prop);
+            if (!(prop in res.presentIn))
+                res.presentIn[prop] = [];
+            res.presentIn[prop].push(index);
+            if (!(prop in res.perProp))
+                res.perProp[prop] = [];
+            res.perProp[prop].push(object);
+        });
+    });
+    const paramCount = params.length;
+    res.presentInAll = Object.keys(res.presentIn).reduce((carry, prop) => {
+        const propCount = res.presentIn[prop].length;
+        carry[prop] = propCount === paramCount;
+        return carry;
+    }, {});
+    res.props = Array.from(propsSet);
+    return res;
+}
+function compareArrays(...params) {
+    const valuesSet = new Set();
+    const res = {
+        values: [],
+        infoPerValue: {},
+        presentInAll: [],
+    };
+    const getEmptyArray = () => params.map(() => undefined);
+    params.forEach((array, paramIndex) => {
+        if (!isWhat.isArray(array))
+            throw new Error("'compareArrays' can only compare arrays");
+        array.forEach((val, valIndex) => {
+            valuesSet.add(val);
+            const parsedVal = isWhat.isNumber(val) || isWhat.isString(val) ? String(val) : JSON.stringify(val);
+            if (!(parsedVal in res.infoPerValue)) {
+                res.infoPerValue[parsedVal] = {
+                    indexPerArray: getEmptyArray(),
+                    presentInAll: false,
+                };
+            }
+            res.infoPerValue[parsedVal].indexPerArray[paramIndex] = valIndex;
+        });
+    });
+    Object.entries(res.infoPerValue).forEach(([parsedVal, info]) => {
+        const isInAllArrays = info.indexPerArray.every((index) => isWhat.isNumber(index) && index >= 0) &&
+            info.indexPerArray.length === params.length;
+        info.presentInAll = isInAllArrays;
+        if (isInAllArrays)
+            res.presentInAll.push(parsedVal);
+    });
+    res.values = Array.from(valuesSet);
+    return res;
+}
+
+exports.compareArrays = compareArrays;
+exports.compareObjectArraysBasedOn = compareObjectArraysBasedOn;
+exports.compareObjectProps = compareObjectProps;
+exports.compareObjectsBasedOn = compareObjectsBasedOn;

package/dist/index.es.js

@@ -0,0 +1,106 @@
+import { isAnyObject, isArray, isNumber, isString } from 'is-what';
+import { pick } from 'filter-anything';
+
+function compareObjectsBasedOn(propKeys, objects) {
+    const baseProps = propKeys;
+    const baseObject = objects[0];
+    const differentPropsSet = objects.reduce((carry, object, index) => {
+        if (index === 0)
+            return carry;
+        for (const prop of baseProps) {
+            if (object[prop] !== baseObject[prop])
+                carry.add(prop);
+        }
+        return carry;
+    }, new Set());
+    const differentProps = [...differentPropsSet];
+    const differentPropsPicked = objects.map((object) => pick(object, differentProps));
+    return {
+        differentProps,
+        differentPropsPicked,
+        equal: differentProps.length === 0,
+    };
+}
+
+function compareObjectArraysBasedOn(propKeys, objectArrays) {
+    const firstArray = objectArrays[0];
+    const comparison = {
+        perIndex: [],
+        equal: true,
+    };
+    firstArray.forEach((object, index) => {
+        const objectsToCompare = objectArrays.map((arr) => arr[index]);
+        const compared = compareObjectsBasedOn(propKeys, objectsToCompare);
+        if (!compared.equal)
+            comparison.equal = false;
+        comparison.perIndex.push(compared);
+    });
+    return comparison;
+}
+
+function compareObjectProps(...params) {
+    const propsSet = new Set();
+    const res = {
+        props: [],
+        presentInAll: {},
+        presentIn: {},
+        perProp: {},
+    };
+    params.forEach((object, index) => {
+        if (!isAnyObject(object)) {
+            throw new Error("'compareObjectProps' can only compare objects");
+        }
+        Object.keys(object).forEach((prop) => {
+            propsSet.add(prop);
+            if (!(prop in res.presentIn))
+                res.presentIn[prop] = [];
+            res.presentIn[prop].push(index);
+            if (!(prop in res.perProp))
+                res.perProp[prop] = [];
+            res.perProp[prop].push(object);
+        });
+    });
+    const paramCount = params.length;
+    res.presentInAll = Object.keys(res.presentIn).reduce((carry, prop) => {
+        const propCount = res.presentIn[prop].length;
+        carry[prop] = propCount === paramCount;
+        return carry;
+    }, {});
+    res.props = Array.from(propsSet);
+    return res;
+}
+function compareArrays(...params) {
+    const valuesSet = new Set();
+    const res = {
+        values: [],
+        infoPerValue: {},
+        presentInAll: [],
+    };
+    const getEmptyArray = () => params.map(() => undefined);
+    params.forEach((array, paramIndex) => {
+        if (!isArray(array))
+            throw new Error("'compareArrays' can only compare arrays");
+        array.forEach((val, valIndex) => {
+            valuesSet.add(val);
+            const parsedVal = isNumber(val) || isString(val) ? String(val) : JSON.stringify(val);
+            if (!(parsedVal in res.infoPerValue)) {
+                res.infoPerValue[parsedVal] = {
+                    indexPerArray: getEmptyArray(),
+                    presentInAll: false,
+                };
+            }
+            res.infoPerValue[parsedVal].indexPerArray[paramIndex] = valIndex;
+        });
+    });
+    Object.entries(res.infoPerValue).forEach(([parsedVal, info]) => {
+        const isInAllArrays = info.indexPerArray.every((index) => isNumber(index) && index >= 0) &&
+            info.indexPerArray.length === params.length;
+        info.presentInAll = isInAllArrays;
+        if (isInAllArrays)
+            res.presentInAll.push(parsedVal);
+    });
+    res.values = Array.from(valuesSet);
+    return res;
+}
+
+export { compareArrays, compareObjectArraysBasedOn, compareObjectProps, compareObjectsBasedOn };

package/{types → dist/types}/compareObjectArraysBasedOn.d.ts

@@ -1,7 +1,6 @@
 import { ComparisonObjects } from './compareObjectsBasedOn';
-import { PlainObject } from './types';
 export declare type ComparisonObjectArrays<ObjectType> = {
     perIndex: ComparisonObjects<ObjectType>[];
     equal: boolean;
 };
-export declare function compareObjectArraysBasedOn<ObjectType extends PlainObject | any = PlainObject>(propKeys: (keyof ObjectType)[], objectArrays: [[ObjectType, ...any[]], ...any[]]): ComparisonObjectArrays<ObjectType>;
+export declare function compareObjectArraysBasedOn<ObjectType extends Record<string, any> | any = Record<string, any>>(propKeys: (keyof ObjectType)[], objectArrays: [[ObjectType, ...any[]], ...any[]]): ComparisonObjectArrays<ObjectType>;

package/{types → dist/types}/compareObjectsBasedOn.d.ts

@@ -1,7 +1,6 @@
-import { PlainObject } from './types';
 export declare type ComparisonObjects<ObjectType> = {
     differentProps: (keyof ObjectType)[];
     differentPropsPicked: Partial<ObjectType>[];
     equal: boolean;
 };
-export declare function compareObjectsBasedOn<ObjectType extends PlainObject | any = PlainObject>(propKeys: (keyof ObjectType)[], objects: [ObjectType, ...any[]]): ComparisonObjects<ObjectType>;
+export declare function compareObjectsBasedOn<ObjectType extends Record<string, any> | any = Record<string, any>>(propKeys: (keyof ObjectType)[], objects: [ObjectType, ...any[]]): ComparisonObjects<ObjectType>;

package/{types → dist/types}/index.d.ts

@@ -1,27 +1,24 @@
 export { compareObjectsBasedOn } from './compareObjectsBasedOn';
 export { compareObjectArraysBasedOn } from './compareObjectArraysBasedOn';
-declare type plainObject = {
-    [key: string]: any;
-};
-export declare function compareObjectProps(...params: plainObject[]): {
+export declare function compareObjectProps(...params: Record<string, any>[]): {
     props: string[];
     presentInAll: {
-        [prop: string]: boolean;
+        [key in string]: boolean;
     };
     perProp: {
-        [prop: string]: plainObject;
+        [key in string]: Record<string, any>;
     };
     presentIn: {
-        [prop: string]: number[];
+        [key in string]: number[];
     };
 };
 export declare function compareArrays(...params: any[][]): {
     values: any[];
     infoPerValue: {
-        [prop: string]: {
+        [key in string]: {
             indexPerArray: (number | undefined)[];
             presentInAll: boolean;
         };
     };
-    presentInAll: any[];
+    presentInAll: string[];
 };

package/package.json

@@ -1,37 +1,54 @@
 {
   "name": "compare-anything",
   "sideEffects": false,
-  "version": "0.3.3",
+  "type": "module",
+  "version": "0.3.7",
   "description": "Compares objects and arrays and tells you which props or values are duplicates, and which are only present once.",
-  "main": "dist/index.cjs.js",
-  "module": "dist/index.esm.js",
-  "typings": "types/index.d.ts",
+  "module": "./dist/index.es.js",
+  "main": "./dist/index.cjs",
+  "types": "./dist/types/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.es.js",
+      "require": "./dist/index.cjs",
+      "types": "./dist/types/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=12.13",
+    "npm": ">=7"
+  },
   "repository": "https://github.com/mesqueeb/compare-anything",
   "author": "Luca Ban - Mesqueeb",
+  "funding": "https://github.com/sponsors/mesqueeb",
   "license": "MIT",
   "scripts": {
-    "test": "ava",
-    "lint": "eslint . --ext .js,.jsx,.ts,.tsx",
-    "rollup": "rollup -c build/rollup.js",
-    "build": "npm run lint && npm run rollup && npm run test"
+    "test": "vitest run",
+    "lint": "tsc --noEmit && eslint ./src --ext .ts",
+    "build": "rollup -c ./scripts/build.js",
+    "release": "npm run lint && del dist && npm run build && np"
   },
   "dependencies": {
-    "filter-anything": "^2.1.5",
-    "is-what": "^3.11.2"
+    "filter-anything": "^2.2.1",
+    "is-what": "^4.1.1"
   },
   "devDependencies": {
-    "@typescript-eslint/eslint-plugin": "^2.34.0",
-    "@typescript-eslint/parser": "^2.34.0",
-    "ava": "^3.13.0",
-    "eslint": "^6.8.0",
-    "eslint-config-prettier": "^6.13.0",
-    "eslint-plugin-tree-shaking": "^1.8.0",
-    "flatten-anything": "^2.0.3",
-    "rollup": "^2.32.0",
-    "rollup-plugin-typescript2": "^0.28.0",
-    "tsconfig-paths": "^3.9.0",
-    "ts-node": "^8.10.2",
-    "typescript": "^3.9.7"
+    "@typescript-eslint/eslint-plugin": "^5.10.1",
+    "@typescript-eslint/parser": "^5.10.1",
+    "del-cli": "^4.0.1",
+    "eslint": "^8.7.0",
+    "eslint-config-prettier": "^8.3.0",
+    "eslint-plugin-tree-shaking": "^1.10.0",
+    "flatten-anything": "^2.0.4",
+    "np": "^7.6.0",
+    "prettier": "^2.5.1",
+    "rollup": "^2.66.0",
+    "rollup-plugin-typescript2": "^0.31.1",
+    "typescript": "^4.5.5",
+    "vitest": "^0.2.1"
   },
   "keywords": [
     "typescript",
@@ -49,13 +66,35 @@
     "url": "https://github.com/mesqueeb/compare-anything/issues"
   },
   "homepage": "https://github.com/mesqueeb/compare-anything#readme",
-  "ava": {
-    "extensions": [
-      "ts"
+  "np": {
+    "yarn": false,
+    "branch": "production"
+  },
+  "eslintConfig": {
+    "ignorePatterns": [
+      "node_modules",
+      "dist",
+      "scripts",
+      "test"
+    ],
+    "root": true,
+    "parser": "@typescript-eslint/parser",
+    "plugins": [
+      "@typescript-eslint",
+      "tree-shaking"
+    ],
+    "extends": [
+      "eslint:recommended",
+      "plugin:@typescript-eslint/eslint-recommended",
+      "plugin:@typescript-eslint/recommended",
+      "prettier"
     ],
-    "require": [
-      "tsconfig-paths/register",
-      "ts-node/register"
-    ]
+    "rules": {
+      "@typescript-eslint/no-empty-function": "off",
+      "@typescript-eslint/no-explicit-any": "off",
+      "@typescript-eslint/ban-ts-ignore": "off",
+      "tree-shaking/no-side-effects-in-initialization": "error",
+      "@typescript-eslint/ban-ts-comment": "off"
+    }
   }
 }

package/.eslintignore

@@ -1,10 +0,0 @@
-# don't ever lint node_modules
-node_modules
-# don't lint build output (make sure it's set to your correct build folder name)
-dist
-# don't lint nyc coverage output
-coverage
-
-test
-
-.eslintrc.js

package/.eslintrc.js

@@ -1,17 +0,0 @@
-// npm i -D @typescript-eslint/eslint-plugin @typescript-eslint/parser eslint eslint-config-prettier eslint-plugin-tree-shaking
-module.exports = {
-  root: true,
-  parser: '@typescript-eslint/parser',
-  plugins: ['@typescript-eslint', 'tree-shaking'],
-  extends: [
-    'eslint:recommended',
-    'plugin:@typescript-eslint/eslint-recommended',
-    'plugin:@typescript-eslint/recommended',
-    'prettier/@typescript-eslint',
-  ],
-  rules: {
-    '@typescript-eslint/no-explicit-any': 'off',
-    '@typescript-eslint/ban-ts-ignore': 'off',
-    'tree-shaking/no-side-effects-in-initialization': 'error',
-  },
-}

package/.github/FUNDING.yml

@@ -1,12 +0,0 @@
-# These are supported funding model platforms
-
-github: mesqueeb
-patreon: # Replace with a single Patreon username
-open_collective: # Replace with a single Open Collective username
-ko_fi: # Replace with a single Ko-fi username
-tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
-community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
-liberapay: # Replace with a single Liberapay username
-issuehunt: # Replace with a single IssueHunt username
-otechie: # Replace with a single Otechie username
-custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']

package/build/rollup.js

@@ -1,64 +0,0 @@
-/* eslint-disable */
-
-// npm install rollup-plugin-typescript2 typescript --save-dev
-import typescript from 'rollup-plugin-typescript2'
-// import { terser } from 'rollup-plugin-terser'
-// import resolve from 'rollup-plugin-node-resolve'
-
-// ------------------------------------------------------------------------------------------
-// formats
-// ------------------------------------------------------------------------------------------
-// amd – Asynchronous Module Definition, used with module loaders like RequireJS
-// cjs – CommonJS, suitable for Node and Browserify/Webpack
-// esm – Keep the bundle as an ES module file
-// iife – A self-executing function, suitable for inclusion as a <script> tag. (If you want to create a bundle for your application, you probably want to use this, because it leads to smaller file sizes.)
-// umd – Universal Module Definition, works as amd, cjs and iife all in one
-// system – Native format of the SystemJS loader
-
-// ------------------------------------------------------------------------------------------
-// setup
-// ------------------------------------------------------------------------------------------
-const pkg = require('../package.json')
-const name = pkg.name
-const className = name.replace(/(^\w|-\w)/g, c =>
-  c.replace('-', '').toUpperCase()
-)
-const external = Object.keys(pkg.dependencies || [])
-const plugins = [
-  typescript({
-    useTsconfigDeclarationDir: true,
-    tsconfigOverride: { exclude: ['test/**/*'] }
-  })
-]
-
-// ------------------------------------------------------------------------------------------
-// Builds
-// ------------------------------------------------------------------------------------------
-function defaults (config) {
-  // defaults
-  const defaults = {
-    plugins,
-    external
-  }
-  // defaults.output
-  config.output = config.output.map(output => {
-    return Object.assign(
-      {
-        sourcemap: false,
-        name: className
-      },
-      output
-    )
-  })
-  return Object.assign(defaults, config)
-}
-
-export default [
-  defaults({
-    input: 'src/index.ts',
-    output: [
-      { file: 'dist/index.cjs.js', format: 'cjs' },
-      { file: 'dist/index.esm.js', format: 'esm' }
-    ]
-  })
-]

package/dist/index.cjs.js

@@ -1,185 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var isWhat = require('is-what');
-var filterAnything = require('filter-anything');
-
-/*! *****************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-
-function __values(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-}
-
-function __read(o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-}
-
-function __spread() {
-    for (var ar = [], i = 0; i < arguments.length; i++)
-        ar = ar.concat(__read(arguments[i]));
-    return ar;
-}
-
-function compareObjectsBasedOn(propKeys, objects) {
-    var baseProps = propKeys;
-    var baseObject = objects[0];
-    var differentPropsSet = objects.reduce(function (carry, object, index) {
-        var e_1, _a;
-        if (index === 0)
-            return carry;
-        try {
-            for (var baseProps_1 = __values(baseProps), baseProps_1_1 = baseProps_1.next(); !baseProps_1_1.done; baseProps_1_1 = baseProps_1.next()) {
-                var prop = baseProps_1_1.value;
-                if (object[prop] !== baseObject[prop])
-                    carry.add(prop);
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (baseProps_1_1 && !baseProps_1_1.done && (_a = baseProps_1.return)) _a.call(baseProps_1);
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
-        return carry;
-    }, new Set());
-    var differentProps = __spread(differentPropsSet);
-    var differentPropsPicked = objects.map(function (object) {
-        return filterAnything.pick(object, differentProps);
-    });
-    return {
-        differentProps: differentProps,
-        differentPropsPicked: differentPropsPicked,
-        equal: differentProps.length === 0
-    };
-}
-
-function compareObjectArraysBasedOn(propKeys, objectArrays) {
-    var firstArray = objectArrays[0];
-    var comparison = {
-        perIndex: [],
-        equal: true
-    };
-    firstArray.forEach(function (object, index) {
-        var objectsToCompare = objectArrays.map(function (arr) { return arr[index]; });
-        var compared = compareObjectsBasedOn(propKeys, objectsToCompare);
-        if (!compared.equal)
-            comparison.equal = false;
-        comparison.perIndex.push(compared);
-    });
-    return comparison;
-}
-
-function compareObjectProps() {
-    var params = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        params[_i] = arguments[_i];
-    }
-    var propsSet = new Set();
-    var res = {
-        props: null,
-        presentInAll: null,
-        presentIn: {},
-        perProp: {}
-    };
-    params.forEach(function (object, index) {
-        if (!isWhat.isAnyObject(object)) {
-            throw new Error("'compareObjectProps' can only compare objects");
-        }
-        Object.keys(object).forEach(function (prop) {
-            propsSet.add(prop);
-            if (!(prop in res.presentIn))
-                res.presentIn[prop] = [];
-            res.presentIn[prop].push(index);
-            if (!(prop in res.perProp))
-                res.perProp[prop] = [];
-            res.perProp[prop].push(object);
-        });
-    });
-    var paramCount = params.length;
-    res.presentInAll = Object.keys(res.presentIn).reduce(function (carry, prop) {
-        var propCount = res.presentIn[prop].length;
-        carry[prop] = propCount === paramCount;
-        return carry;
-    }, {});
-    res.props = Array.from(propsSet);
-    return res;
-}
-function compareArrays() {
-    var params = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        params[_i] = arguments[_i];
-    }
-    var valuesSet = new Set();
-    var res = {
-        values: null,
-        infoPerValue: {},
-        presentInAll: []
-    };
-    var getEmptyArray = function () { return params.map(function () { return undefined; }); };
-    params.forEach(function (array, paramIndex) {
-        if (!isWhat.isArray(array))
-            throw new Error("'compareArrays' can only compare arrays");
-        array.forEach(function (val, valIndex) {
-            valuesSet.add(val);
-            var parsedVal = isWhat.isNumber(val) || isWhat.isString(val) ? String(val) : JSON.stringify(val);
-            if (!(parsedVal in res.infoPerValue)) {
-                res.infoPerValue[parsedVal] = {
-                    indexPerArray: getEmptyArray(),
-                    presentInAll: false
-                };
-            }
-            res.infoPerValue[parsedVal].indexPerArray[paramIndex] = valIndex;
-        });
-    });
-    Object.entries(res.infoPerValue).forEach(function (_a) {
-        var _b = __read(_a, 2), parsedVal = _b[0], info = _b[1];
-        var isInAllArrays = info.indexPerArray.every(function (index) { return isWhat.isNumber(index) && index >= 0; }) &&
-            info.indexPerArray.length === params.length;
-        info.presentInAll = isInAllArrays;
-        if (isInAllArrays)
-            res.presentInAll.push(parsedVal);
-    });
-    res.values = Array.from(valuesSet);
-    return res;
-}
-
-exports.compareArrays = compareArrays;
-exports.compareObjectArraysBasedOn = compareObjectArraysBasedOn;
-exports.compareObjectProps = compareObjectProps;
-exports.compareObjectsBasedOn = compareObjectsBasedOn;

package/dist/index.esm.js

@@ -1,178 +0,0 @@
-import { isAnyObject, isArray, isNumber, isString } from 'is-what';
-import { pick } from 'filter-anything';
-
-/*! *****************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-
-function __values(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-}
-
-function __read(o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-}
-
-function __spread() {
-    for (var ar = [], i = 0; i < arguments.length; i++)
-        ar = ar.concat(__read(arguments[i]));
-    return ar;
-}
-
-function compareObjectsBasedOn(propKeys, objects) {
-    var baseProps = propKeys;
-    var baseObject = objects[0];
-    var differentPropsSet = objects.reduce(function (carry, object, index) {
-        var e_1, _a;
-        if (index === 0)
-            return carry;
-        try {
-            for (var baseProps_1 = __values(baseProps), baseProps_1_1 = baseProps_1.next(); !baseProps_1_1.done; baseProps_1_1 = baseProps_1.next()) {
-                var prop = baseProps_1_1.value;
-                if (object[prop] !== baseObject[prop])
-                    carry.add(prop);
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (baseProps_1_1 && !baseProps_1_1.done && (_a = baseProps_1.return)) _a.call(baseProps_1);
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
-        return carry;
-    }, new Set());
-    var differentProps = __spread(differentPropsSet);
-    var differentPropsPicked = objects.map(function (object) {
-        return pick(object, differentProps);
-    });
-    return {
-        differentProps: differentProps,
-        differentPropsPicked: differentPropsPicked,
-        equal: differentProps.length === 0
-    };
-}
-
-function compareObjectArraysBasedOn(propKeys, objectArrays) {
-    var firstArray = objectArrays[0];
-    var comparison = {
-        perIndex: [],
-        equal: true
-    };
-    firstArray.forEach(function (object, index) {
-        var objectsToCompare = objectArrays.map(function (arr) { return arr[index]; });
-        var compared = compareObjectsBasedOn(propKeys, objectsToCompare);
-        if (!compared.equal)
-            comparison.equal = false;
-        comparison.perIndex.push(compared);
-    });
-    return comparison;
-}
-
-function compareObjectProps() {
-    var params = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        params[_i] = arguments[_i];
-    }
-    var propsSet = new Set();
-    var res = {
-        props: null,
-        presentInAll: null,
-        presentIn: {},
-        perProp: {}
-    };
-    params.forEach(function (object, index) {
-        if (!isAnyObject(object)) {
-            throw new Error("'compareObjectProps' can only compare objects");
-        }
-        Object.keys(object).forEach(function (prop) {
-            propsSet.add(prop);
-            if (!(prop in res.presentIn))
-                res.presentIn[prop] = [];
-            res.presentIn[prop].push(index);
-            if (!(prop in res.perProp))
-                res.perProp[prop] = [];
-            res.perProp[prop].push(object);
-        });
-    });
-    var paramCount = params.length;
-    res.presentInAll = Object.keys(res.presentIn).reduce(function (carry, prop) {
-        var propCount = res.presentIn[prop].length;
-        carry[prop] = propCount === paramCount;
-        return carry;
-    }, {});
-    res.props = Array.from(propsSet);
-    return res;
-}
-function compareArrays() {
-    var params = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        params[_i] = arguments[_i];
-    }
-    var valuesSet = new Set();
-    var res = {
-        values: null,
-        infoPerValue: {},
-        presentInAll: []
-    };
-    var getEmptyArray = function () { return params.map(function () { return undefined; }); };
-    params.forEach(function (array, paramIndex) {
-        if (!isArray(array))
-            throw new Error("'compareArrays' can only compare arrays");
-        array.forEach(function (val, valIndex) {
-            valuesSet.add(val);
-            var parsedVal = isNumber(val) || isString(val) ? String(val) : JSON.stringify(val);
-            if (!(parsedVal in res.infoPerValue)) {
-                res.infoPerValue[parsedVal] = {
-                    indexPerArray: getEmptyArray(),
-                    presentInAll: false
-                };
-            }
-            res.infoPerValue[parsedVal].indexPerArray[paramIndex] = valIndex;
-        });
-    });
-    Object.entries(res.infoPerValue).forEach(function (_a) {
-        var _b = __read(_a, 2), parsedVal = _b[0], info = _b[1];
-        var isInAllArrays = info.indexPerArray.every(function (index) { return isNumber(index) && index >= 0; }) &&
-            info.indexPerArray.length === params.length;
-        info.presentInAll = isInAllArrays;
-        if (isInAllArrays)
-            res.presentInAll.push(parsedVal);
-    });
-    res.values = Array.from(valuesSet);
-    return res;
-}
-
-export { compareArrays, compareObjectArraysBasedOn, compareObjectProps, compareObjectsBasedOn };

package/src/compareObjectArraysBasedOn.ts

@@ -1,30 +0,0 @@
-import {
-  ComparisonObjects,
-  compareObjectsBasedOn
-} from './compareObjectsBasedOn'
-import { PlainObject } from './types'
-
-export type ComparisonObjectArrays<ObjectType> = {
-  perIndex: ComparisonObjects<ObjectType>[]
-  equal: boolean
-}
-
-export function compareObjectArraysBasedOn<
-  ObjectType extends PlainObject | any = PlainObject
-> (
-  propKeys: (keyof ObjectType)[],
-  objectArrays: [[ObjectType, ...any[]], ...any[]]
-): ComparisonObjectArrays<ObjectType> {
-  const firstArray = objectArrays[0]
-  const comparison: ComparisonObjectArrays<ObjectType> = {
-    perIndex: [],
-    equal: true
-  }
-  firstArray.forEach((object, index) => {
-    const objectsToCompare = objectArrays.map(arr => arr[index])
-    const compared = compareObjectsBasedOn(propKeys, objectsToCompare as any)
-    if (!compared.equal) comparison.equal = false
-    comparison.perIndex.push(compared)
-  })
-  return comparison
-}

package/src/compareObjectsBasedOn.ts

@@ -1,38 +0,0 @@
-import { pick } from 'filter-anything'
-import { PlainObject } from './types'
-
-export type ComparisonObjects<ObjectType> = {
-  differentProps: (keyof ObjectType)[]
-  differentPropsPicked: Partial<ObjectType>[]
-  equal: boolean
-}
-
-export function compareObjectsBasedOn<
-  ObjectType extends PlainObject | any = PlainObject
-> (
-  propKeys: (keyof ObjectType)[],
-  objects: [ObjectType, ...any[]]
-): ComparisonObjects<ObjectType> {
-  type PropKeys = keyof ObjectType
-  const baseProps = propKeys
-  const baseObject = objects[0]
-  const differentPropsSet: Set<PropKeys> = objects.reduce(
-    (carry, object, index) => {
-      if (index === 0) return carry
-      for (const prop of baseProps) {
-        if (object[prop] !== baseObject[prop]) carry.add(prop)
-      }
-      return carry
-    },
-    new Set() as Set<PropKeys>
-  )
-  const differentProps = [...differentPropsSet]
-  const differentPropsPicked = objects.map(object =>
-    pick(object, differentProps as string[])
-  ) as Partial<ObjectType>[]
-  return {
-    differentProps,
-    differentPropsPicked,
-    equal: differentProps.length === 0
-  }
-}

package/src/index.ts

@@ -1,98 +0,0 @@
-import { isAnyObject, isArray, isString, isNumber } from 'is-what'
-
-export { compareObjectsBasedOn } from './compareObjectsBasedOn'
-export { compareObjectArraysBasedOn } from './compareObjectArraysBasedOn'
-
-type plainObject = { [key: string]: any }
-
-export function compareObjectProps (
-  ...params: plainObject[]
-): {
-  props: string[]
-  presentInAll: { [prop: string]: boolean }
-  perProp: { [prop: string]: plainObject }
-  presentIn: { [prop: string]: number[] }
-} {
-  const propsSet = new Set()
-  const res = {
-    props: null,
-    presentInAll: null,
-    presentIn: {},
-    perProp: {}
-  }
-  params.forEach((object, index) => {
-    if (!isAnyObject(object)) {
-      throw new Error("'compareObjectProps' can only compare objects")
-    }
-    Object.keys(object).forEach(prop => {
-      propsSet.add(prop)
-      if (!(prop in res.presentIn)) res.presentIn[prop] = []
-      res.presentIn[prop].push(index)
-      if (!(prop in res.perProp)) res.perProp[prop] = []
-      res.perProp[prop].push(object)
-    })
-  })
-  const paramCount = params.length
-  res.presentInAll = Object.keys(res.presentIn).reduce((carry, prop) => {
-    const propCount = res.presentIn[prop].length
-    carry[prop] = propCount === paramCount
-    return carry
-  }, {})
-  res.props = Array.from(propsSet)
-  return res
-}
-
-export function compareArrays (
-  ...params: any[][]
-): {
-  values: any[]
-  infoPerValue: {
-    [prop: string]: {
-      indexPerArray: (number | undefined)[]
-      presentInAll: boolean
-    }
-  }
-  presentInAll: any[]
-} {
-  const valuesSet = new Set()
-  const res: {
-    values: null | any[]
-    infoPerValue: {
-      [val: string]: {
-        indexPerArray: (number | undefined)[]
-        presentInAll: boolean
-      }
-    }
-    presentInAll: string[]
-  } = {
-    values: null,
-    infoPerValue: {},
-    presentInAll: []
-  }
-  const getEmptyArray = (): undefined[] => params.map(() => undefined)
-  params.forEach((array, paramIndex) => {
-    if (!isArray(array))
-      throw new Error("'compareArrays' can only compare arrays")
-    array.forEach((val, valIndex) => {
-      valuesSet.add(val)
-      const parsedVal =
-        isNumber(val) || isString(val) ? String(val) : JSON.stringify(val)
-      if (!(parsedVal in res.infoPerValue)) {
-        res.infoPerValue[parsedVal] = {
-          indexPerArray: getEmptyArray(),
-          presentInAll: false
-        }
-      }
-      res.infoPerValue[parsedVal].indexPerArray[paramIndex] = valIndex
-    })
-  })
-  Object.entries(res.infoPerValue).forEach(([parsedVal, info]) => {
-    const isInAllArrays =
-      info.indexPerArray.every(index => isNumber(index) && index >= 0) &&
-      info.indexPerArray.length === params.length
-    info.presentInAll = isInAllArrays
-    if (isInAllArrays) res.presentInAll.push(parsedVal)
-  })
-  res.values = Array.from(valuesSet)
-  return res
-}

package/src/types.ts

@@ -1,4 +0,0 @@
-export type PlainObject = {
-  [prop: string]: any
-  [prop: number]: never
-}

package/test/compareObjectsBasedOn.ts

@@ -1,21 +0,0 @@
-// @ts-check
-import test from 'ava'
-import { compareObjectsBasedOn } from '../src'
-
-test('compareObjectsBasedOn', t => {
-  const base = { a: 1, b: true, c: 'CC' }
-  const check = { d: 1 }
-  const result = compareObjectsBasedOn(['a', 'b'], [base, check])
-  t.deepEqual(result.differentProps, ['a', 'b'])
-  t.deepEqual(result.differentPropsPicked, [{ a: 1, b: true }, {}])
-  t.deepEqual(result.equal, false)
-})
-
-test('compareObjectsBasedOn - ok', t => {
-  const base = { a: 1, b: true, c: 'CC' }
-  const check = { a: 1, c: 'CC', d: 1 }
-  const result = compareObjectsBasedOn(['a', 'c'], [base, check])
-  t.deepEqual(result.differentProps, [])
-  t.deepEqual(result.differentPropsPicked, [{}, {}])
-  t.deepEqual(result.equal, true)
-})

package/test/index.ts

@@ -1,95 +0,0 @@
-import test from 'ava'
-import { flatten } from 'flatten-anything'
-import { compareObjectProps, compareArrays } from '../src/index'
-
-test('compareObjectProps', t => {
-  let res, objectA, objectB
-  objectA = { a: '', b: '', c: '', d: '' }
-  objectB = { b: '', c: '', e: '', f: '' }
-
-  res = compareObjectProps(objectA, objectB)
-  t.deepEqual(res, {
-    props: ['a', 'b', 'c', 'd', 'e', 'f'],
-    presentInAll: { a: false, b: true, c: true, d: false, e: false, f: false },
-    presentIn: { a: [0], b: [0, 1], c: [0, 1], d: [0], e: [1], f: [1] },
-    perProp: {
-      a: [objectA],
-      b: [objectA, objectB],
-      c: [objectA, objectB],
-      d: [objectA],
-      e: [objectB],
-      f: [objectB]
-    }
-  })
-})
-
-test('compareObjectProps 3 or more', t => {
-  let res, objectA, objectB, objectC, objectD
-  objectA = { a: '', b: '', c: '', d: '' }
-  objectB = { b: '', c: '', e: '', f: '' }
-  objectC = { b: '1', e: '', d: '' }
-  objectD = { b: '2', c: '', a: '', f: '' }
-
-  res = compareObjectProps(objectA, objectB, objectC, objectD)
-  t.deepEqual(res, {
-    props: ['a', 'b', 'c', 'd', 'e', 'f'],
-    presentInAll: { a: false, b: true, c: false, d: false, e: false, f: false },
-    presentIn: {
-      a: [0, 3],
-      b: [0, 1, 2, 3],
-      c: [0, 1, 3],
-      d: [0, 2],
-      e: [1, 2],
-      f: [1, 3]
-    },
-    perProp: {
-      a: [objectA, objectD],
-      b: [objectA, objectB, objectC, objectD],
-      c: [objectA, objectB, objectD],
-      d: [objectA, objectC],
-      e: [objectB, objectC],
-      f: [objectB, objectD]
-    }
-  })
-})
-
-test('compareObjectProps flat', t => {
-  let res
-  const objectA = { nested: { a: '🃏️', b: '🎴' } }
-  const objectB = { nested: { a: '🃏', c: '🀄️' } }
-  const flatA = flatten(objectA)
-  // →　{'nested.a': '🃏️', 'nested.b': '🎴'}
-  const flatB = flatten(objectB)
-  // →　{'nested.a': '🃏️', 'nested.c': '🀄️'}
-  res = compareObjectProps(flatA, flatB)
-  t.deepEqual(res, {
-    props: ['nested.a', 'nested.b', 'nested.c'],
-    presentInAll: { 'nested.a': true, 'nested.b': false, 'nested.c': false },
-    presentIn: { 'nested.a': [0, 1], 'nested.b': [0], 'nested.c': [1] },
-    perProp: {
-      'nested.a': [flatA, flatB],
-      'nested.b': [flatA],
-      'nested.c': [flatB]
-    }
-  })
-})
-
-test('compareArrays', t => {
-  let res, arrayA, arrayB
-  arrayA = ['a', 'b', 'c', 'd']
-  arrayB = ['b', 'c', 'e', 'f']
-
-  res = compareArrays(arrayA, arrayB)
-  t.deepEqual(res, {
-    values: ['a', 'b', 'c', 'd', 'e', 'f'],
-    infoPerValue: {
-      a: { indexPerArray: [0, undefined], presentInAll: false },
-      b: { indexPerArray: [1, 0], presentInAll: true },
-      c: { indexPerArray: [2, 1], presentInAll: true },
-      d: { indexPerArray: [3, undefined], presentInAll: false },
-      e: { indexPerArray: [undefined, 2], presentInAll: false },
-      f: { indexPerArray: [undefined, 3], presentInAll: false }
-    },
-    presentInAll: ['b', 'c']
-  })
-})

package/tsconfig.json

@@ -1,15 +0,0 @@
-{
-  "compilerOptions": {
-    "baseUrl": ".",
-    "downlevelIteration": true,
-    "outDir": "./dist",
-    "declaration": true,
-    "declarationDir": "./types/",
-    "target": "es5",
-    "lib": ["es5", "es2015", "es2016", "es2017", "dom"]
-  },
-  "include": [
-    "src/**/*",
-    "test/**/*"
-  ]
-}

package/types/types.d.ts

@@ -1,4 +0,0 @@
-export declare type PlainObject = {
-    [prop: string]: any;
-    [prop: number]: never;
-};