es-check 9.4.7 → 9.5.0

package/README.md

@@ -671,7 +671,7 @@ Tested on lodash, axios, react, moment, express, and chalk. See [benchmarks](./t
 
 ## Contributing
 
-ES Check has only 4 core dependencies: [acorn](https://github.com/ternjs/acorn/) for JavaScript parsing, [fast-brake](https://github.com/stackblitz/fast-brake) for lightweight feature detection, [fast-glob](https://github.com/mrmlnc/fast-glob) for file globbing, and [browserslist](https://github.com/browserslist/browserslist) for browser targeting.
+ES Check has only 3 core dependencies: [acorn](https://github.com/ternjs/acorn/) for JavaScript parsing, [fast-glob](https://github.com/mrmlnc/fast-glob) for file globbing, and [browserslist](https://github.com/browserslist/browserslist) for browser targeting.
 
 The CLI, logging, and source map support are implemented with custom lightweight solutions using Node.js built-ins to minimize dependencies. To contribute, file an [issue](https://github.com/yowainwright/es-check/issues) or submit a pull request.
 

package/lib/check-runner/utils.js

@@ -285,28 +285,6 @@ function filterIgnoredFiles(files, pathsToIgnore, globOpts) {
   });
 }
 
-function processLightMode(code, ecmaVersion, config, file, isDebug, logger) {
-  const { parseLightMode } = require("../helpers");
-  const { error: parseError } = parseLightMode(
-    code,
-    ecmaVersion,
-    config.module,
-    config.allowHashBang,
-    file,
-  );
-
-  const hasParseError = parseError !== null;
-  const shouldDebugError = hasParseError && isDebug;
-
-  if (shouldDebugError) {
-    logger.debug(
-      `ES-Check: failed to parse file: ${file} \n - error: ${parseError.err}`,
-    );
-  }
-
-  return parseError;
-}
-
 function processFullAST(
   code,
   acornOpts,
@@ -425,12 +403,6 @@ function createFileProcessor(config, options) {
       logger.debug(`ES-Check: checking ${file}`);
     }
 
-    const isLightMode = config.light;
-
-    if (isLightMode) {
-      return processLightMode(code, ecmaVersion, config, file, isDebug, logger);
-    }
-
     return processFullAST(
       code,
       acornOpts,

package/lib/constants/es-features/15.js

@@ -0,0 +1,64 @@
+const ES15_FEATURES = {
+  StringIsWellFormed: {
+    minVersion: 15,
+    example: "str.isWellFormed()",
+    astInfo: {
+      nodeType: "CallExpression",
+      property: "isWellFormed",
+    },
+  },
+  StringToWellFormed: {
+    minVersion: 15,
+    example: "str.toWellFormed()",
+    astInfo: {
+      nodeType: "CallExpression",
+      property: "toWellFormed",
+    },
+  },
+  RegExpUnicodeSetFlag: {
+    minVersion: 15,
+    example: "/pattern/v",
+    astInfo: {
+      nodeType: "RegExpLiteral",
+      flags: "v",
+    },
+  },
+  PromiseWithResolvers: {
+    minVersion: 15,
+    example: "Promise.withResolvers()",
+    astInfo: {
+      nodeType: "CallExpression",
+      object: "Promise",
+      property: "withResolvers",
+    },
+  },
+  ObjectGroupBy: {
+    minVersion: 15,
+    example: "Object.groupBy(array, fn)",
+    astInfo: {
+      nodeType: "CallExpression",
+      object: "Object",
+      property: "groupBy",
+    },
+  },
+  MapGroupBy: {
+    minVersion: 15,
+    example: "Map.groupBy(array, fn)",
+    astInfo: {
+      nodeType: "CallExpression",
+      object: "Map",
+      property: "groupBy",
+    },
+  },
+  AtomicsWaitAsync: {
+    minVersion: 15,
+    example: "Atomics.waitAsync(typedArray, index, value)",
+    astInfo: {
+      nodeType: "CallExpression",
+      object: "Atomics",
+      property: "waitAsync",
+    },
+  },
+};
+
+module.exports = { ES15_FEATURES };

package/lib/constants/es-features/16.js

@@ -0,0 +1,115 @@
+const ES16_FEATURES = {
+  ArrayPrototypeGroup: {
+    minVersion: 16,
+    superseded: true,
+    supersededBy: "ObjectGroupBy",
+    example: "arr.group(x => x.category)",
+    astInfo: {
+      nodeType: "CallExpression",
+      property: "group",
+      excludeObjects: ["console"],
+    },
+  },
+  ArrayPrototypeGroupToMap: {
+    minVersion: 16,
+    superseded: true,
+    supersededBy: "MapGroupBy",
+    example: "arr.groupToMap(x => x.category)",
+    astInfo: {
+      nodeType: "CallExpression",
+      property: "groupToMap",
+    },
+  },
+  PromiseTry: {
+    minVersion: 16,
+    example: "Promise.try(() => syncOrAsyncFunction())",
+    astInfo: {
+      nodeType: "CallExpression",
+      object: "Promise",
+      property: "try",
+    },
+  },
+  DuplicateNamedCaptureGroups: {
+    minVersion: 16,
+    example: "/(?<name>a)|(?<name>b)/",
+    astInfo: {
+      nodeType: "RegExpLiteral",
+      duplicateNamedGroups: true,
+    },
+  },
+  SetUnion: {
+    minVersion: 16,
+    example: "set1.union(set2)",
+    astInfo: {
+      nodeType: "CallExpression",
+      property: "union",
+    },
+  },
+  SetIntersection: {
+    minVersion: 16,
+    example: "set1.intersection(set2)",
+    astInfo: {
+      nodeType: "CallExpression",
+      property: "intersection",
+    },
+  },
+  SetDifference: {
+    minVersion: 16,
+    example: "set1.difference(set2)",
+    astInfo: {
+      nodeType: "CallExpression",
+      property: "difference",
+    },
+  },
+  SetSymmetricDifference: {
+    minVersion: 16,
+    example: "set1.symmetricDifference(set2)",
+    astInfo: {
+      nodeType: "CallExpression",
+      property: "symmetricDifference",
+    },
+  },
+  SetIsSubsetOf: {
+    minVersion: 16,
+    example: "set1.isSubsetOf(set2)",
+    astInfo: {
+      nodeType: "CallExpression",
+      property: "isSubsetOf",
+    },
+  },
+  SetIsSupersetOf: {
+    minVersion: 16,
+    example: "set1.isSupersetOf(set2)",
+    astInfo: {
+      nodeType: "CallExpression",
+      property: "isSupersetOf",
+    },
+  },
+  SetIsDisjointFrom: {
+    minVersion: 16,
+    example: "set1.isDisjointFrom(set2)",
+    astInfo: {
+      nodeType: "CallExpression",
+      property: "isDisjointFrom",
+    },
+  },
+  Float16Array: {
+    minVersion: 16,
+    example: "new Float16Array()",
+    astInfo: {
+      nodeType: "NewExpression",
+      callee: "Float16Array",
+    },
+  },
+  RegExpEscape: {
+    minVersion: 16,
+    example: "RegExp.escape(str)",
+    astInfo: {
+      nodeType: "CallExpression",
+      object: "RegExp",
+      property: "escape",
+    },
+  },
+};
+
+module.exports = { ES16_FEATURES };

package/lib/constants/es-features/index.js

@@ -1,10 +1,34 @@
-const { ES_FEATURES } = require("./es-features");
+const { ES6_FEATURES } = require("./6");
+const { ES7_FEATURES } = require("./7");
+const { ES8_FEATURES } = require("./8");
+const { ES9_FEATURES } = require("./9");
+const { ES10_FEATURES } = require("./10");
+const { ES11_FEATURES } = require("./11");
+const { ES12_FEATURES } = require("./12");
+const { ES13_FEATURES } = require("./13");
+const { ES14_FEATURES } = require("./14");
+const { ES15_FEATURES } = require("./15");
+const { ES16_FEATURES } = require("./16");
 const {
   POLYFILL_PATTERNS,
   IMPORT_PATTERNS,
   FEATURE_TO_POLYFILL_MAP,
 } = require("./polyfills");
 
+const ES_FEATURES = {
+  ...ES6_FEATURES,
+  ...ES7_FEATURES,
+  ...ES8_FEATURES,
+  ...ES9_FEATURES,
+  ...ES10_FEATURES,
+  ...ES11_FEATURES,
+  ...ES12_FEATURES,
+  ...ES13_FEATURES,
+  ...ES14_FEATURES,
+  ...ES15_FEATURES,
+  ...ES16_FEATURES,
+};
+
 module.exports = {
   ES_FEATURES,
   POLYFILL_PATTERNS,

package/lib/detectFeatures.js

@@ -1,19 +1,11 @@
-const { fastBrakeSync } = require("fast-brake/sync");
 const {
   ES_FEATURES,
   POLYFILL_PATTERNS,
   IMPORT_PATTERNS,
   FEATURE_TO_POLYFILL_MAP,
 } = require("./constants");
-const esversionPlugin = require("fast-brake/plugins/esversion");
+const { detectFeaturesFromAST } = require("./helpers/astDetector");
 
-const fastbrake = fastBrakeSync({ plugins: [esversionPlugin.default] });
-
-/**
- * Detects polyfills in the code and adds them to the polyfills Set
- * @param {string} code - The source code to check
- * @param {Set} polyfills - Set to store detected polyfills
- */
 const detectPolyfills = (
   code,
   polyfills,
@@ -35,54 +27,6 @@ const detectPolyfills = (
   }
 };
 
-const featureNameMap = {
-  let_const: ["let", "const"],
-  arrow_functions: "ArrowFunctions",
-  template_literals: "TemplateLiterals",
-  destructuring: "Destructuring",
-  classes: "class",
-  extends: "extends",
-  spread_rest: ["RestSpread", "ArraySpread"],
-  default_parameters: "DefaultParams",
-  default_params: "DefaultParams",
-  for_of: "ForOf",
-  import: "import",
-  export: "export",
-  import_export: ["import", "export"],
-  async_await: "AsyncAwait",
-  generators: "Generators",
-  promise: "Promise",
-  promise_resolve: "PromiseResolve",
-  promise_reject: "PromiseReject",
-  promise_any: "PromiseAny",
-  promise_allSettled: "PromiseAllSettled",
-  map: "Map",
-  set: "Set",
-  weakmap: "WeakMap",
-  weakset: "WeakSet",
-  symbol: "Symbol",
-  proxy: "Proxy",
-  reflect: "Reflect",
-  weakref: "WeakRef",
-  finalization_registry: "FinalizationRegistry",
-  exponentiation: "ExponentOperator",
-  object_spread: "ObjectSpread",
-  rest_spread_properties: "ObjectSpread",
-  optional_catch: "OptionalCatchBinding",
-  bigint: "BigInt",
-  nullish_coalescing: "NullishCoalescing",
-  optional_chaining: "OptionalChaining",
-  private_fields: "PrivateClassFields",
-  logical_assignment: "LogicalAssignment",
-  numeric_separators: "NumericSeparators",
-  class_fields: "ClassFields",
-  top_level_await: "TopLevelAwait",
-  globalThis: "globalThis",
-  array_at: "ArrayPrototypeAt",
-  object_hasOwn: "ObjectHasOwn",
-  string_replaceAll: "StringReplaceAll",
-};
-
 const detectFeatures = (
   code,
   ecmaVersion,
@@ -92,56 +36,26 @@ const detectFeatures = (
 ) => {
   const { checkForPolyfills, ast } = options;
 
-  const polyfills = new Set();
-  if (checkForPolyfills) detectPolyfills(code, polyfills);
-
-  let detectedFeatures;
-
-  if (ast) {
-    detectedFeatures = [];
-  } else {
-    try {
-      detectedFeatures = fastbrake.detect(code);
-    } catch (err) {
-      const error = new Error(`Failed to parse code: ${err.message}`);
-      error.type = "ES-Check";
-      throw error;
-    }
+  if (!ast) {
+    const error = new Error("AST is required for feature detection");
+    error.type = "ES-Check";
+    throw error;
   }
 
-  const foundFeatures = Object.keys(ES_FEATURES).reduce((acc, f) => {
-    acc[f] = false;
-    return acc;
-  }, {});
-
-  detectedFeatures.forEach((feature) => {
-    const mapped = featureNameMap[feature.name];
-
-    if (mapped) {
-      if (Array.isArray(mapped)) {
-        mapped.forEach((name) => {
-          if (ES_FEATURES[name]) {
-            foundFeatures[name] = true;
-          }
-        });
-      } else if (ES_FEATURES[mapped]) {
-        foundFeatures[mapped] = true;
-      }
-    }
-  });
+  const polyfills = new Set();
+  if (checkForPolyfills) detectPolyfills(code, polyfills);
 
-  const unsupportedFeatures = [];
-  Object.entries(ES_FEATURES).forEach(([featureName, { minVersion }]) => {
-    const isPolyfilled = checkForPolyfills && polyfills.has(featureName);
-    if (
-      foundFeatures[featureName] &&
-      minVersion > ecmaVersion &&
-      !ignoreList.has(featureName) &&
-      !isPolyfilled
-    ) {
-      unsupportedFeatures.push(featureName);
-    }
-  });
+  const foundFeatures = detectFeaturesFromAST(ast);
+
+  const unsupportedFeatures = Object.entries(ES_FEATURES)
+    .filter(
+      ([name, { minVersion }]) =>
+        foundFeatures[name] &&
+        minVersion > ecmaVersion &&
+        !ignoreList.has(name) &&
+        !(checkForPolyfills && polyfills.has(name)),
+    )
+    .map(([name]) => name);
 
   if (unsupportedFeatures.length > 0) {
     const error = new Error(

package/lib/helpers/astDetector.js

@@ -0,0 +1,144 @@
+const { ES_FEATURES } = require("../constants");
+const { checkMap } = require("./ast");
+
+const CHILD_KEYS = [
+  "body",
+  "declarations",
+  "expression",
+  "left",
+  "right",
+  "argument",
+  "arguments",
+  "callee",
+  "object",
+  "property",
+  "properties",
+  "elements",
+  "params",
+  "id",
+  "init",
+  "test",
+  "consequent",
+  "alternate",
+  "cases",
+  "discriminant",
+  "block",
+  "handler",
+  "finalizer",
+  "source",
+  "specifiers",
+  "declaration",
+  "exported",
+  "imported",
+  "local",
+  "key",
+  "value",
+  "superClass",
+];
+
+function normalizeNodeType(nodeType) {
+  if (nodeType === "ExportDeclaration") {
+    return [
+      "ExportNamedDeclaration",
+      "ExportDefaultDeclaration",
+      "ExportAllDeclaration",
+    ];
+  }
+  if (nodeType === "BigIntLiteral") {
+    return ["Literal"];
+  }
+  return [nodeType];
+}
+
+function buildFeatureIndex(features) {
+  const index = {};
+  for (const [name, { astInfo }] of Object.entries(features)) {
+    if (!astInfo?.nodeType) continue;
+    const types = normalizeNodeType(astInfo.nodeType);
+    for (const t of types) {
+      (index[t] ||= []).push({ name, astInfo });
+    }
+  }
+  return index;
+}
+
+const featuresByNodeType = buildFeatureIndex(ES_FEATURES);
+
+function matchesFeature(node, astInfo) {
+  if (astInfo.childType) {
+    return node.elements?.some((el) => el?.type === astInfo.childType) || false;
+  }
+
+  if (astInfo.name && node.type === "Identifier") {
+    return node.name === astInfo.name;
+  }
+
+  if (astInfo.nodeType === "BigIntLiteral") {
+    return node.bigint !== undefined;
+  }
+
+  if (astInfo.kind && node.kind !== astInfo.kind) {
+    return false;
+  }
+
+  if (astInfo.operator && node.operator !== astInfo.operator) {
+    return false;
+  }
+
+  if (astInfo.property === "superClass") {
+    return node.superClass !== null;
+  }
+
+  if (node.type === "CallExpression" || node.type === "NewExpression") {
+    return checkMap(node, astInfo);
+  }
+
+  return true;
+}
+
+function detectFeaturesFromAST(ast) {
+  const foundFeatures = Object.create(null);
+  for (const key of Object.keys(ES_FEATURES)) {
+    foundFeatures[key] = false;
+  }
+
+  const remaining = new Set(Object.keys(ES_FEATURES));
+  const stack = [ast];
+
+  while (stack.length > 0 && remaining.size > 0) {
+    const node = stack.pop();
+    if (!node || typeof node !== "object") continue;
+
+    const candidates = featuresByNodeType[node.type];
+    if (candidates) {
+      for (const { name, astInfo } of candidates) {
+        if (!remaining.has(name)) continue;
+        if (matchesFeature(node, astInfo)) {
+          foundFeatures[name] = true;
+          remaining.delete(name);
+        }
+      }
+    }
+
+    for (const key of CHILD_KEYS) {
+      const child = node[key];
+      if (!child) continue;
+      if (Array.isArray(child)) {
+        for (let i = child.length - 1; i >= 0; i--) {
+          if (child[i]) stack.push(child[i]);
+        }
+      } else if (child.type) {
+        stack.push(child);
+      }
+    }
+  }
+
+  return foundFeatures;
+}
+
+module.exports = {
+  normalizeNodeType,
+  buildFeatureIndex,
+  matchesFeature,
+  detectFeaturesFromAST,
+};

package/lib/helpers/index.js

@@ -1,6 +1,7 @@
 const logger = require("./logger");
 const parsers = require("./parsers");
 const ast = require("./ast");
+const astDetector = require("./astDetector");
 const files = require("./files");
 const cli = require("../cli/utils");
 const sourcemap = require("./sourcemap");
@@ -12,6 +13,7 @@ module.exports = Object.assign(
   logger,
   parsers,
   ast,
+  astDetector,
   files,
   cli,
   sourcemap,

package/lib/helpers/parsers.js

@@ -1,13 +1,3 @@
-const { fastBrakeSync } = require("fast-brake/sync");
-const esversionPlugin = require("fast-brake/plugins/esversion");
-const { ECMA_VERSION_MAP } = require("../constants/versions");
-
-const fastbrake = fastBrakeSync({ plugins: [esversionPlugin.default] });
-
-function getTargetVersion(ecmaVersion) {
-  return ECMA_VERSION_MAP[ecmaVersion] || "es5";
-}
-
 function parseCode(code, acornOpts, acorn, file) {
   try {
     const ast = acorn.parse(code, acornOpts);
@@ -30,46 +20,6 @@ function parseCode(code, acornOpts, acorn, file) {
   }
 }
 
-function parseLightMode(code, ecmaVersion, isModule, allowHashBang, file) {
-  const targetVersion = getTargetVersion(ecmaVersion);
-
-  const codeToCheck =
-    allowHashBang && code.startsWith("#!")
-      ? code.slice(code.indexOf("\n") + 1)
-      : code;
-
-  try {
-    const isCompatible = fastbrake.check(codeToCheck, {
-      target: targetVersion,
-      sourceType: isModule ? "module" : "script",
-    });
-
-    if (!isCompatible) {
-      return {
-        error: {
-          err: new Error(
-            `Code contains features incompatible with ${targetVersion}`,
-          ),
-          stack: "",
-          file,
-        },
-      };
-    }
-
-    return { error: null };
-  } catch (err) {
-    return {
-      error: {
-        err: new Error(`Failed to check code in light mode: ${err.message}`),
-        stack: err.stack || "",
-        file,
-      },
-    };
-  }
-}
-
 module.exports = {
-  getTargetVersion,
   parseCode,
-  parseLightMode,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "es-check",
-  "version": "9.4.7",
+  "version": "9.5.0",
   "description": "Checks the ECMAScript version of .js glob against a specified version of ECMAScript with a shell command",
   "main": "lib/index.js",
   "license": "MIT",
@@ -17,8 +17,6 @@
     "es-check": "lib/cli/index.js"
   },
   "scripts": {
-    "commit": "git-cz",
-    "commit-msg": "commitlint --edit $1",
     "dev": "pnpm site:dev",
     "lint": "oxlint lib",
     "lint:ci": "oxlint lib --quiet",
@@ -52,11 +50,9 @@
     "url": "https://github.com/yowainwright/es-check/issues"
   },
   "homepage": "https://github.com/yowainwright/es-check#readme",
+  "website": "https://jeffry.in/es-check",
   "devDependencies": {
-    "@commitlint/cli": "20.1.0",
-    "@commitlint/config-conventional": "^20.0.0",
     "codependence": "^0.3.1",
-    "commitizen": "4.3.1",
     "oxlint": "^1.29.0",
     "pastoralist": "1.8.2",
     "prettier": "3.6.2",
@@ -65,7 +61,6 @@
   "dependencies": {
     "acorn": "8.15.0",
     "browserslist": "^4.28.0",
-    "fast-brake": "^0.1.6",
     "fast-glob": "^3.3.3"
   },
   "engines": {
@@ -90,18 +85,6 @@
     "test js version",
     "test ecmascript version"
   ],
-  "commitlint": {
-    "extends": [
-      "@commitlint/config-conventional"
-    ],
-    "rules": {
-      "header-max-length": [
-        2,
-        "always",
-        120
-      ]
-    }
-  },
   "release-it": {
     "git": {
       "commitMessage": "chore: release v${version}",

package/lib/constants/es-features/es-features/15.js

@@ -1,28 +0,0 @@
-const ES15_FEATURES = {
-  StringIsWellFormed: {
-    minVersion: 15,
-    example: "str.isWellFormed()",
-    astInfo: {
-      nodeType: "CallExpression",
-      property: "isWellFormed",
-    },
-  },
-  StringToWellFormed: {
-    minVersion: 15,
-    example: "str.toWellFormed()",
-    astInfo: {
-      nodeType: "CallExpression",
-      property: "toWellFormed",
-    },
-  },
-  RegExpUnicodeSetFlag: {
-    minVersion: 15,
-    example: "/pattern/v",
-    astInfo: {
-      nodeType: "RegExpLiteral",
-      flags: "v",
-    },
-  },
-};
-
-module.exports = { ES15_FEATURES };

package/lib/constants/es-features/es-features/16.js

@@ -1,39 +0,0 @@
-const ES16_FEATURES = {
-  ArrayGroup: {
-    minVersion: 16,
-    example: "arr.group(x => x.category)",
-    astInfo: {
-      nodeType: "CallExpression",
-      property: "group",
-      excludeObjects: ["console"],
-    },
-  },
-  ArrayGroupToMap: {
-    minVersion: 16,
-    example: "arr.groupToMap(x => x.category)",
-    astInfo: {
-      nodeType: "CallExpression",
-      property: "groupToMap",
-      excludeObjects: ["console"],
-    },
-  },
-  PromiseTry: {
-    minVersion: 16,
-    example: "Promise.try(() => syncOrAsyncFunction())",
-    astInfo: {
-      nodeType: "CallExpression",
-      object: "Promise",
-      property: "try",
-    },
-  },
-  DuplicateNamedCaptureGroups: {
-    minVersion: 16,
-    example: "/(?<name>a)|(?<name>b)/",
-    astInfo: {
-      nodeType: "RegExpLiteral",
-      duplicateNamedGroups: true,
-    },
-  },
-};
-
-module.exports = { ES16_FEATURES };

package/lib/constants/es-features/es-features/index.js

@@ -1,27 +0,0 @@
-const { ES6_FEATURES } = require("./6");
-const { ES7_FEATURES } = require("./7");
-const { ES8_FEATURES } = require("./8");
-const { ES9_FEATURES } = require("./9");
-const { ES10_FEATURES } = require("./10");
-const { ES11_FEATURES } = require("./11");
-const { ES12_FEATURES } = require("./12");
-const { ES13_FEATURES } = require("./13");
-const { ES14_FEATURES } = require("./14");
-const { ES15_FEATURES } = require("./15");
-const { ES16_FEATURES } = require("./16");
-
-const ES_FEATURES = {
-  ...ES6_FEATURES,
-  ...ES7_FEATURES,
-  ...ES8_FEATURES,
-  ...ES9_FEATURES,
-  ...ES10_FEATURES,
-  ...ES11_FEATURES,
-  ...ES12_FEATURES,
-  ...ES13_FEATURES,
-  ...ES14_FEATURES,
-  ...ES15_FEATURES,
-  ...ES16_FEATURES,
-};
-
-module.exports = { ES_FEATURES };