ast-compare 3.0.3 → 3.0.7

package/CHANGELOG.md

@@ -3,26 +3,6 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
-## 3.0.3 (2021-11-02)
-
-### Bug Fixes
-
-- bump TS and separate ESLint plugins away from this monorepo ([b1ebce1](https://github.com/codsen/codsen/commit/b1ebce1637d8c41c2d848fc24b0ba4058865bd5d))
-
-### Features
-
-- migrate to ES Modules ([c579dff](https://github.com/codsen/codsen/commit/c579dff3b23205e383035ca10ddcec671e35d0fe))
-
-### BREAKING CHANGES
-
-- programs now are in ES Modules and won't work with Common JS require()
-
-## 3.0.1 (2021-09-13)
-
-### Bug Fixes
-
-- bump TS and separate ESLint plugins away from this monorepo ([2e07d42](https://github.com/codsen/codsen/commit/2e07d424222b6ffedf5fb45c83ad453627ec2904))
-
 ## 3.0.0 (2021-09-09)
 
 ### Features

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2010-%YEAR% Roy Revelt and other contributors
+Copyright (c) 2010-2021 Roy Revelt and other contributors
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

package/dist/ast-compare.esm.js

@@ -1,7 +1,7 @@
 /**
  * @name ast-compare
  * @fileoverview Compare anything: AST, objects, arrays, strings and nested thereof
- * @version 3.0.3
+ * @version 3.0.7
  * @author Roy Revelt, Codsen Ltd
  * @license MIT
  * {@link https://codsen.com/os/ast-compare/}
@@ -14,133 +14,158 @@ import { isMatch } from 'matcher';
 
 /* istanbul ignore next */
 function isBlank(something) {
-  if (isObj(something)) {
-    return !Object.keys(something).length;
-  }
-  if (Array.isArray(something) || typeof something === "string") {
-    return !something.length;
-  }
-  return false;
-}
-function compare(b, s, originalOpts) {
-  let sKeys;
-  let bKeys;
-  let found;
-  let bOffset = 0;
-  const defaults = {
-    hungryForWhitespace: false,
-    matchStrictly: false,
-    verboseWhenMismatches: false,
-    useWildcards: false
-  };
-  const opts = { ...defaults,
-    ...originalOpts
-  };
-  if (opts.hungryForWhitespace && opts.matchStrictly && isObj(b) && empty(b) && isObj(s) && !Object.keys(s).length) {
-    return true;
-  }
-  if ((!opts.hungryForWhitespace || opts.hungryForWhitespace && !empty(b) && empty(s)) && isObj(b) && Object.keys(b).length !== 0 && isObj(s) && Object.keys(s).length === 0 || typeDetect(b) !== typeDetect(s) && (!opts.hungryForWhitespace || opts.hungryForWhitespace && !empty(b))) {
-    return false;
-  }
-  if (typeof b === "string" && typeof s === "string") {
-    if (opts.hungryForWhitespace && empty(b) && empty(s)) {
-      return true;
+    if (isObj(something)) {
+        return !Object.keys(something).length;
     }
-    if (opts.verboseWhenMismatches) {
-      return b === s ? true : `Given string ${s} is not matched! We have ${b} on the other end.`;
+    if (Array.isArray(something) || typeof something === "string") {
+        return !something.length;
     }
-    return opts.useWildcards ? isMatch(b, s, {
-      caseSensitive: true
-    }) : b === s;
-  }
-  if (Array.isArray(b) && Array.isArray(s)) {
-    if (opts.hungryForWhitespace && empty(s) && (!opts.matchStrictly || opts.matchStrictly && b.length === s.length)) {
-      return true;
+    return false;
+}
+function compare(b, s, originalOpts) {
+    let sKeys;
+    let bKeys;
+    let found;
+    let bOffset = 0;
+    const defaults = {
+        hungryForWhitespace: false,
+        matchStrictly: false,
+        verboseWhenMismatches: false,
+        useWildcards: false,
+    };
+    const opts = { ...defaults, ...originalOpts };
+    if (opts.hungryForWhitespace &&
+        opts.matchStrictly &&
+        isObj(b) &&
+        empty(b) &&
+        isObj(s) &&
+        !Object.keys(s).length) {
+        return true;
     }
-    if (!opts.hungryForWhitespace && s.length > b.length || opts.matchStrictly && s.length !== b.length) {
-      if (!opts.verboseWhenMismatches) {
+    if (((!opts.hungryForWhitespace ||
+        (opts.hungryForWhitespace && !empty(b) && empty(s))) &&
+        isObj(b) &&
+        Object.keys(b).length !== 0 &&
+        isObj(s) &&
+        Object.keys(s).length === 0) ||
+        (typeDetect(b) !== typeDetect(s) &&
+            (!opts.hungryForWhitespace || (opts.hungryForWhitespace && !empty(b))))) {
         return false;
-      }
-      return `The length of a given array, ${JSON.stringify(s, null, 4)} is ${s.length} but the length of an array on the other end, ${JSON.stringify(b, null, 4)} is ${b.length}`;
-    }
-    if (s.length === 0) {
-      if (b.length === 0) {
-        return true;
-      }
-      if (opts.verboseWhenMismatches) {
-        return `The given array has no elements, but the array on the other end, ${JSON.stringify(b, null, 4)} does have some`;
-      }
-      return false;
     }
-    for (let i = 0, sLen = s.length; i < sLen; i++) {
-      found = false;
-      for (let j = bOffset, bLen = b.length; j < bLen; j++) {
-        bOffset += 1;
-        if (compare(b[j], s[i], opts) === true) {
-          found = true;
-          break;
+    if (typeof b === "string" && typeof s === "string") {
+        if (opts.hungryForWhitespace && empty(b) && empty(s)) {
+            return true;
         }
-      }
-      if (!found) {
-        if (!opts.verboseWhenMismatches) {
-          return false;
+        if (opts.verboseWhenMismatches) {
+            return b === s
+                ? true
+                : `Given string ${s} is not matched! We have ${b} on the other end.`;
         }
-        return `The given array ${JSON.stringify(s, null, 4)} is not a subset of an array on the other end, ${JSON.stringify(b, null, 4)}`;
-      }
+        return opts.useWildcards ? isMatch(b, s, { caseSensitive: true }) : b === s;
     }
-  } else if (isObj(b) && isObj(s)) {
-    sKeys = new Set(Object.keys(s));
-    bKeys = new Set(Object.keys(b));
-    if (opts.matchStrictly && sKeys.size !== bKeys.size) {
-      if (!opts.verboseWhenMismatches) {
-        return false;
-      }
-      const uniqueKeysOnS = new Set([...sKeys].filter(x => !bKeys.has(x)));
-      const sMessage = uniqueKeysOnS.size ? ` First object has unique keys: ${JSON.stringify(uniqueKeysOnS, null, 4)}.` : "";
-      const uniqueKeysOnB = new Set([...bKeys].filter(x => !sKeys.has(x)));
-      const bMessage = uniqueKeysOnB.size ? ` Second object has unique keys:
-        ${JSON.stringify(uniqueKeysOnB, null, 4)}.` : "";
-      return `When matching strictly, we found that both objects have different amount of keys.${sMessage}${bMessage}`;
-    }
-    for (const sKey of sKeys) {
-      if (!Object.prototype.hasOwnProperty.call(b, sKey)) {
-        if (!opts.useWildcards || opts.useWildcards && !sKey.includes("*")) {
-          if (!opts.verboseWhenMismatches) {
-            return false;
-          }
-          return `The given object has key "${sKey}" which the other-one does not have.`;
+    if (Array.isArray(b) && Array.isArray(s)) {
+        if (opts.hungryForWhitespace &&
+            empty(s) &&
+            (!opts.matchStrictly || (opts.matchStrictly && b.length === s.length))) {
+            return true;
         }
-        if (Object.keys(b).some(bKey => isMatch(bKey, sKey, {
-          caseSensitive: true
-        }))) {
-          return true;
+        if ((!opts.hungryForWhitespace && s.length > b.length) ||
+            (opts.matchStrictly && s.length !== b.length)) {
+            if (!opts.verboseWhenMismatches) {
+                return false;
+            }
+            return `The length of a given array, ${JSON.stringify(s, null, 4)} is ${s.length} but the length of an array on the other end, ${JSON.stringify(b, null, 4)} is ${b.length}`;
         }
-        if (!opts.verboseWhenMismatches) {
-          return false;
-        }
-        return `The given object has key "${sKey}" which the other-one does not have.`;
-      }
-      if (b[sKey] != null && typeDetect(b[sKey]) !== typeDetect(s[sKey])) {
-        if (!(empty(b[sKey]) && empty(s[sKey]) && opts.hungryForWhitespace)) {
-          if (!opts.verboseWhenMismatches) {
+        if (s.length === 0) {
+            if (b.length === 0) {
+                return true;
+            }
+            if (opts.verboseWhenMismatches) {
+                return `The given array has no elements, but the array on the other end, ${JSON.stringify(b, null, 4)} does have some`;
+            }
             return false;
-          }
-          return `The given key ${sKey} is of a different type on both objects. On the first-one, it's ${typeDetect(s[sKey])}, on the second-one, it's ${typeDetect(b[sKey])}`;
         }
-      } else if (compare(b[sKey], s[sKey], opts) !== true) {
-        if (!opts.verboseWhenMismatches) {
-          return false;
+        for (let i = 0, sLen = s.length; i < sLen; i++) {
+            found = false;
+            for (let j = bOffset, bLen = b.length; j < bLen; j++) {
+                bOffset += 1;
+                if (compare(b[j], s[i], opts) === true) {
+                    found = true;
+                    break;
+                }
+            }
+            if (!found) {
+                if (!opts.verboseWhenMismatches) {
+                    return false;
+                }
+                return `The given array ${JSON.stringify(s, null, 4)} is not a subset of an array on the other end, ${JSON.stringify(b, null, 4)}`;
+            }
         }
-        return `The given piece ${JSON.stringify(s[sKey], null, 4)} and ${JSON.stringify(b[sKey], null, 4)} don't match.`;
-      }
     }
-  } else {
-    if (opts.hungryForWhitespace && empty(b) && empty(s) && (!opts.matchStrictly || opts.matchStrictly && isBlank(s))) {
-      return true;
+    else if (isObj(b) && isObj(s)) {
+        sKeys = new Set(Object.keys(s));
+        bKeys = new Set(Object.keys(b));
+        if (opts.matchStrictly && sKeys.size !== bKeys.size) {
+            if (!opts.verboseWhenMismatches) {
+                return false;
+            }
+            const uniqueKeysOnS = new Set([...sKeys].filter((x) => !bKeys.has(x)));
+            const sMessage = uniqueKeysOnS.size
+                ? ` First object has unique keys: ${JSON.stringify(uniqueKeysOnS, null, 4)}.`
+                : "";
+            const uniqueKeysOnB = new Set([...bKeys].filter((x) => !sKeys.has(x)));
+            const bMessage = uniqueKeysOnB.size
+                ? ` Second object has unique keys:
+        ${JSON.stringify(uniqueKeysOnB, null, 4)}.`
+                : "";
+            return `When matching strictly, we found that both objects have different amount of keys.${sMessage}${bMessage}`;
+        }
+        for (const sKey of sKeys) {
+            if (!Object.prototype.hasOwnProperty.call(b, sKey)) {
+                if (!opts.useWildcards || (opts.useWildcards && !sKey.includes("*"))) {
+                    if (!opts.verboseWhenMismatches) {
+                        return false;
+                    }
+                    return `The given object has key "${sKey}" which the other-one does not have.`;
+                }
+                if (Object.keys(b).some((bKey) => isMatch(bKey, sKey, { caseSensitive: true }))) {
+                    return true;
+                }
+                if (!opts.verboseWhenMismatches) {
+                    return false;
+                }
+                return `The given object has key "${sKey}" which the other-one does not have.`;
+            }
+            if (b[sKey] != null &&
+                typeDetect(b[sKey]) !==
+                    typeDetect(s[sKey])) {
+                if (!(empty(b[sKey]) &&
+                    empty(s[sKey]) &&
+                    opts.hungryForWhitespace)) {
+                    if (!opts.verboseWhenMismatches) {
+                        return false;
+                    }
+                    return `The given key ${sKey} is of a different type on both objects. On the first-one, it's ${typeDetect(s[sKey])}, on the second-one, it's ${typeDetect(b[sKey])}`;
+                }
+            }
+            else if (compare(b[sKey], s[sKey], opts) !== true) {
+                if (!opts.verboseWhenMismatches) {
+                    return false;
+                }
+                return `The given piece ${JSON.stringify(s[sKey], null, 4)} and ${JSON.stringify(b[sKey], null, 4)} don't match.`;
+            }
+        }
+    }
+    else {
+        if (opts.hungryForWhitespace &&
+            empty(b) &&
+            empty(s) &&
+            (!opts.matchStrictly || (opts.matchStrictly && isBlank(s)))) {
+            return true;
+        }
+        return b === s;
     }
-    return b === s;
-  }
-  return true;
+    return true;
 }
 
 export { compare };

package/dist/ast-compare.umd.js

@@ -1,7 +1,7 @@
 /**
  * @name ast-compare
  * @fileoverview Compare anything: AST, objects, arrays, strings and nested thereof
- * @version 3.0.3
+ * @version 3.0.7
  * @author Roy Revelt, Codsen Ltd
  * @license MIT
  * {@link https://codsen.com/os/ast-compare/}
@@ -11,7 +11,7 @@
 /**
  * @name ast-monkey-util
  * @fileoverview Utility library of AST helper functions
- * @version 2.0.3
+ * @version 2.0.7
  * @author Roy Revelt, Codsen Ltd
  * @license MIT
  * {@link https://codsen.com/os/ast-monkey-util/}
@@ -19,7 +19,7 @@
 /**
  * @name ast-monkey-traverse
  * @fileoverview Utility library to traverse AST
- * @version 3.0.3
+ * @version 3.0.7
  * @author Roy Revelt, Codsen Ltd
  * @license MIT
  * {@link https://codsen.com/os/ast-monkey-traverse/}
@@ -27,7 +27,7 @@
 /**
  * @name ast-contains-only-empty-space
  * @fileoverview Does AST contain only empty space?
- * @version 3.0.3
+ * @version 3.0.7
  * @author Roy Revelt, Codsen Ltd
  * @license MIT
  * {@link https://codsen.com/os/ast-contains-only-empty-space/}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ast-compare",
-  "version": "3.0.3",
+  "version": "3.0.7",
   "description": "Compare anything: AST, objects, arrays, strings and nested thereof",
   "keywords": [
     "array",
@@ -41,13 +41,12 @@
   "types": "types/index.d.ts",
   "scripts": {
     "build": "rollup -c",
-    "ci_test": "npm run build && npm run format && tap --no-only --reporter=silent --output-file=testStats.md && npm run clean_cov",
-    "clean_cov": "../../scripts/leaveCoverageTotalOnly.js",
+    "build:esbuild": "node '../../scripts/esbuild.js'",
+    "build:esbuild:dev": "cross-env MODE=dev node '../../scripts/esbuild.js'",
+    "ci_test": "npm run build && npm run format && tap --no-only --reporter=silent",
     "clean_types": "../../scripts/cleanTypes.js",
     "dev": "rollup -c --dev",
     "devunittest": "npm run dev && tap --only -R 'base'",
-    "esbuild": "node '../../scripts/esbuild.js'",
-    "esbuild_dev": "cross-env MODE=dev node '../../scripts/esbuild.js'",
     "format": "npm run lect && npm run prettier && npm run lint",
     "lect": "lect",
     "lint": "../../node_modules/eslint/bin/eslint.js . --ext .js --ext .ts --fix --config \"../../.eslintrc.json\" --quiet",
@@ -56,17 +55,14 @@
     "republish": "npm publish || :",
     "tap": "tap",
     "pretest": "npm run build",
-    "test": "npm run lint && npm run unittest && npm run test:examples && npm run clean_cov && npm run format",
+    "test": "npm run test:ci && npm run perf",
+    "test:ci": "npm run unittest && npm run test:examples && npm run format",
     "test:examples": "../../scripts/test-examples.js && npm run lect && npm run prettier",
     "tsc": "tsc",
-    "unittest": "tap --no-only --output-file=testStats.md --reporter=terse && tsc -p tsconfig.json --noEmit && npm run clean_cov && npm run perf"
+    "unittest": "tap --no-only --reporter=terse && tsc -p tsconfig.json --noEmit"
   },
   "tap": {
     "check-coverage": false,
-    "coverage-report": [
-      "json-summary",
-      "text"
-    ],
     "node-arg": [
       "--no-warnings",
       "--experimental-loader",
@@ -90,8 +86,8 @@
     }
   },
   "dependencies": {
-    "@babel/runtime": "^7.16.0",
-    "ast-contains-only-empty-space": "^3.0.3",
+    "@babel/runtime": "^7.16.3",
+    "ast-contains-only-empty-space": "^3.0.7",
     "lodash.isplainobject": "^4.0.6",
     "matcher": "^5.0.0",
     "type-detect": "^4.0.8"
@@ -105,8 +101,8 @@
     "@babel/plugin-proposal-nullish-coalescing-operator": "^7.16.0",
     "@babel/plugin-proposal-object-rest-spread": "^7.16.0",
     "@babel/plugin-proposal-optional-chaining": "^7.16.0",
-    "@babel/plugin-transform-runtime": "^7.16.0",
-    "@babel/preset-env": "^7.16.0",
+    "@babel/plugin-transform-runtime": "^7.16.4",
+    "@babel/preset-env": "^7.16.4",
     "@babel/preset-typescript": "^7.16.0",
     "@babel/register": "^7.16.0",
     "@istanbuljs/esm-loader-hook": "^0.1.2",
@@ -116,27 +112,27 @@
     "@rollup/plugin-strip": "^2.1.0",
     "@rollup/plugin-typescript": "^8.3.0",
     "@types/lodash.isplainobject": "^4.0.6",
-    "@types/node": "^16.11.6",
+    "@types/node": "^16.11.10",
     "@types/tap": "^15.0.5",
     "@types/type-detect": "^4.0.1",
-    "@typescript-eslint/eslint-plugin": "^5.2.0",
-    "@typescript-eslint/parser": "^5.2.0",
-    "core-js": "^3.19.0",
+    "@typescript-eslint/eslint-plugin": "^5.5.0",
+    "@typescript-eslint/parser": "^5.5.0",
+    "core-js": "^3.19.2",
     "cross-env": "^7.0.3",
-    "eslint": "^8.1.0",
-    "lect": "^0.18.3",
-    "rollup": "^2.59.0",
+    "eslint": "^8.3.0",
+    "lect": "^0.18.7",
+    "rollup": "^2.60.1",
     "rollup-plugin-ascii": "^0.0.3",
     "rollup-plugin-banner": "^0.2.1",
     "rollup-plugin-cleanup": "^3.2.1",
-    "rollup-plugin-dts": "^4.0.0",
+    "rollup-plugin-dts": "^4.0.1",
     "rollup-plugin-terser": "^7.0.2",
-    "tap": "^15.0.10",
+    "tap": "^15.1.5",
     "tslib": "^2.3.1",
-    "type-fest": "^2.5.2",
-    "typescript": "^4.4.4"
+    "type-fest": "^2.6.0",
+    "typescript": "^4.5.2"
   },
   "engines": {
-    "node": ">=12"
+    "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
   }
 }