es-check 9.3.1 → 9.4.0-0

package/README.md

@@ -31,7 +31,7 @@ Ensuring that JavaScript files can pass ES Check is important in a [modular and
 es-check es6 './dist/**/*.js' --checkFeatures
 ```
 
-### `checkBrowser --browserslistQuery='<broswerslist query>'`
+### `checkBrowser --browserslistQuery='<browserslist query>'`
 
 ```sh
 es-check checkBrowser ./dist/**/*.js --browserslistQuery="last 2 versions"
@@ -134,6 +134,7 @@ Here's a comprehensive list of all available options:
 |--------|-------------|
 | `-V, --version` | Output the version number |
 | `--module` | Use ES modules (default: false) |
+| `--light` | Lightweight mode: 2-3x faster checking using pattern matching only (default: false) |
 | `--allowHashBang` | If the code starts with #! treat it as a comment (default: false) |
 | `--files <files>` | A glob of files to test the ECMAScript version against (alias for [files...]) |
 | `--not <files>` | Folder or file names to skip |
@@ -201,6 +202,12 @@ Once enabled, you can use tab completion for:
 es-check es6 './dist/**/*.js' --module
 ```
 
+**Fast checking with light mode (2-3x faster):**
+
+```sh
+es-check es5 './dist/**/*.js' --light
+```
+
 **Checking files with hash bang:**
 
 ```sh

package/detectFeatures.js

@@ -1,7 +1,5 @@
-const acorn = require('acorn');
-const walk = require('acorn-walk');
+const fastBrake = require('fast-brake');
 const { ES_FEATURES, POLYFILL_PATTERNS, IMPORT_PATTERNS } = require('./constants');
-const { checkMap } = require('./utils');
 
 /**
  * Detects polyfills in the code and adds them to the polyfills Set
@@ -28,54 +26,105 @@ 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, sourceType, ignoreList = new Set(), options = {}) => {
-  const { checkForPolyfills, ast: providedAst } = options;
+  const { checkForPolyfills, ast } = options;
 
   const polyfills = new Set();
   if (checkForPolyfills) detectPolyfills(code, polyfills);
 
-  const ast = providedAst || acorn.parse(code, {
-    ecmaVersion: 'latest',
-    sourceType,
-  });
-
-  const allChecks = Object.entries(ES_FEATURES).map(([featureName, { astInfo }]) => ({
-    featureName,
-    nodeType: astInfo.nodeType,
-    astInfo,
-  }));
+  let detectedFeatures = [];
+  
+  if (ast && ast.features) {
+    detectedFeatures = ast.features;
+  } else {
+    try {
+      const detectOptions = {
+        sourceType: sourceType || 'script'
+      };
+      detectedFeatures = fastBrake.detect(code, detectOptions);
+    } catch (err) {
+      const error = new Error(`Failed to parse code: ${err.message}`);
+      error.type = 'ES-Check';
+      throw error;
+    }
+  }
 
   const foundFeatures = Object.keys(ES_FEATURES).reduce((acc, f) => {
     acc[f] = false;
     return acc;
   }, {});
 
-  const universalVisitor = (node) => {
-    allChecks
-      .filter(({ nodeType }) => nodeType === node.type)
-      .forEach(({ featureName, astInfo }) => {
-        const checker = checkMap[node.type] || checkMap.default;
-        if (checker(node, astInfo)) {
-          foundFeatures[featureName] = true;
-        }
-      });
-  };
-
-  const nodeTypes = [...new Set(allChecks.map((c) => c.nodeType))];
-  const visitors = nodeTypes.reduce((acc, nt) => {
-    acc[nt] = universalVisitor;
-    return acc;
-  }, {});
-
-  walk.simple(ast, visitors);
+  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 unsupportedFeatures = Object.entries(ES_FEATURES).reduce((acc = [], [featureName, { minVersion }]) => {
+  const unsupportedFeatures = [];
+  Object.entries(ES_FEATURES).forEach(([featureName, { minVersion }]) => {
     const isPolyfilled = checkForPolyfills && polyfills.has(featureName);
     if (foundFeatures[featureName] && minVersion > ecmaVersion && !ignoreList.has(featureName) && !isPolyfilled) {
-      acc.push(featureName);
+      unsupportedFeatures.push(featureName);
     }
-    return acc;
-  }, []);
+  });
 
   if (unsupportedFeatures.length > 0) {
     const error = new Error(

package/index.js

@@ -100,6 +100,7 @@ program
   .option('--config <path>', 'path to custom .escheckrc config file')
   .option('--batchSize <number>', 'number of files to process concurrently (0 for unlimited)', '0')
   .option('--noCache', 'disable file caching (caching is enabled by default)', false)
+  .option('--light', 'lightweight mode: faster checking with pattern matching only (skips full AST parsing)', false)
 
 async function loadConfig(customConfigPath) {
   const logger = createLogger();
@@ -182,6 +183,7 @@ program
         browserslistEnv: options.browserslistEnv !== undefined ? options.browserslistEnv : baseConfig.browserslistEnv,
         batchSize: options.batchSize !== undefined ? options.batchSize : baseConfig.batchSize,
         cache: options.noCache ? false : (baseConfig.cache !== undefined ? baseConfig.cache : true),
+        light: options.light !== undefined ? options.light : baseConfig.light,
       };
 
       if (ecmaVersionArg !== undefined) {
@@ -236,6 +238,7 @@ async function runChecks(configs, loggerOrOptions) {
     const checkFeatures = config.checkFeatures;
     const checkForPolyfills = config.checkForPolyfills;
     const checkBrowser = config.checkBrowser;
+    const lightMode = config.light;
     const ignoreFilePath = config.ignoreFile || config['ignore-file'];
 
     const ignoreFileExists = ignoreFilePath && fs.existsSync(ignoreFilePath);
@@ -475,10 +478,22 @@ async function runChecks(configs, loggerOrOptions) {
         logger.debug(`ES-Check: checking ${file}`)
       }
 
+      if (lightMode) {
+        const { parseLightMode } = require('./utils');
+        const { error: parseError } = await parseLightMode(code, ecmaVersion, esmodule, allowHashBang, file);
+        if (parseError) {
+          if (isDebug) {
+            logger.debug(`ES-Check: failed to parse file: ${file} \n - error: ${parseError.err}`)
+          }
+          return parseError;
+        }
+        return null;
+      }
+
       const needsFullAST = checkFeatures;
       const parserOptions = needsFullAST ? acornOpts : { ...acornOpts, locations: false, ranges: false, onComment: null };
       
-      const { ast, error: parseError } = parseCode(code, parserOptions, acorn, file);
+      const { ast, error: parseError } = parseCode(code, parserOptions, acorn, file, checkFeatures);
       if (parseError) {
         if (isDebug) {
           logger.debug(`ES-Check: failed to parse file: ${file} \n - error: ${parseError.err}`)
@@ -571,6 +586,8 @@ async function runChecks(configs, loggerOrOptions) {
   
   if (isNodeAPI) {
     return { success: true, errors: [] };
+  } else {
+    process.exit(0);
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "es-check",
-  "version": "9.3.1",
+  "version": "9.4.0-0",
   "description": "Checks the ECMAScript version of .js glob against a specified version of ECMAScript with a shell command",
   "main": "index.js",
   "license": "MIT",
@@ -33,12 +33,14 @@
     "prepare": "husky",
     "prepublishOnly": "pnpm test",
     "release": "release-it --no-git.requireUpstream",
+    "changelog": "node scripts/update-changelog.mjs",
     "report:coverage": "nyc report --reporter=lcov > coverage.lcov && codecov",
     "setup": "pnpm install --reporter=silent",
     "test": "nyc mocha test.js utils.test.js browserslist.test.js polyfillDetector.test.js detectFeatures.test.js --timeout 10s && npm run test:e2e",
-    "test:e2e": "npm run test:e2e:cli && npm run test:e2e:esm",
+    "test:e2e": "npm run test:e2e:cli && npm run test:e2e:esm && npm run test:e2e:package-files",
     "test:e2e:cli": "node e2e/test-cli.js",
     "test:e2e:esm": "node e2e/test-esm-import.mjs",
+    "test:e2e:package-files": "node e2e/test-package-files.mjs",
     "update": "codependence --update",
     "benchmark": "./benchmarks/run-benchmarks.sh",
     "site:dev": "pnpm --filter es-check-docs run dev",
@@ -68,10 +70,11 @@
     "codependence": "^0.3.1",
     "commitizen": "4.3.1",
     "conventional-changelog-cli": "^5.0.0",
-    "eslint": "9.33.0",
+    "eslint": "9.34.0",
     "eslint-config-prettier": "10.1.8",
     "eslint-plugin-es5": "^1.5.0",
     "husky": "9.1.7",
+    "inquirer": "^12.9.1",
     "is-ci": "^3.0.1",
     "mocha": "11.7.1",
     "nyc": "^17.1.0",
@@ -84,6 +87,7 @@
     "acorn-walk": "^8.3.4",
     "browserslist": "^4.23.3",
     "commander": "14.0.0",
+    "fast-brake": "^0.1.1",
     "fast-glob": "^3.3.3",
     "lilconfig": "^3.1.3",
     "source-map": "^0.7.4",
@@ -144,7 +148,7 @@
         "pnpm run lint",
         "pnpm test"
       ],
-      "after:release": "echo Successfully released ${name} v${version} to ${repo.repository}."
+      "after:release": "echo Successfully released ${name} v${version} to ${repo.repository}. && pnpm run changelog"
     }
   },
   "packageManager": "pnpm@10.6.5+sha512.cdf928fca20832cd59ec53826492b7dc25dc524d4370b6b4adbf65803d32efaa6c1c88147c0ae4e8d579a6c9eec715757b50d4fa35eea179d868eada4ed043af"

package/utils.js

@@ -420,51 +420,117 @@ function getFileCacheStats() {
   return fileCache.getStats();
 }
 
+const ECMA_VERSION_MAP = {
+  5: 'es5',
+  6: 'es2015',
+  7: 'es2016',
+  8: 'es2017',
+  9: 'es2018',
+  10: 'es2019',
+  11: 'es2020',
+  12: 'es2021',
+  13: 'es2022',
+  14: 'es2023',
+  15: 'es2024',
+  16: 'es2025',
+  2015: 'es2015',
+  2016: 'es2016',
+  2017: 'es2017',
+  2018: 'es2018',
+  2019: 'es2019',
+  2020: 'es2020',
+  2021: 'es2021',
+  2022: 'es2022',
+  2023: 'es2023',
+  2024: 'es2024',
+  2025: 'es2025'
+};
+
 /**
- * Parse code with acorn and handle errors
+ * Convert ecmaVersion to fast-brake target format
+ * @param {number|string} ecmaVersion - Version from acorn options
+ * @returns {string} Target version for fast-brake
+ */
+function getTargetVersion(ecmaVersion) {
+  return ECMA_VERSION_MAP[ecmaVersion] || 'es5';
+}
+
+/**
+ * Parse code with fast-brake and handle errors
  * @param {string} code - Code to parse
- * @param {Object} acornOpts - Acorn parsing options
- * @param {Object} acorn - Acorn module
+ * @param {Object} acornOpts - Parsing options (for compatibility)
+ * @param {Object} acorn - Module (for compatibility, not used)
  * @param {string} file - File path for error reporting
  * @returns {{ast: Object, error: null} | {ast: null, error: Object}}
  */
-function parseCode(code, acornOpts, acorn, file) {
+const fastBrake = require('fast-brake');
+
+const parseCache = new Map();
+
+function parseCode(code, acornOpts, acorn, file, needsFeatures = false) {
+  const cacheKey = `${file}:${acornOpts.ecmaVersion}:${acornOpts.sourceType}:${needsFeatures}:${code.length}`;
+  
+  if (parseCache.has(cacheKey)) {
+    return parseCache.get(cacheKey);
+  }
+  
   try {
-    const ast = acorn.parse(code, acornOpts);
-    return { ast, error: null };
+    const ecmaVersion = acornOpts.ecmaVersion || 5;
+    const targetVersion = getTargetVersion(ecmaVersion);
+    const sourceType = acornOpts.sourceType || 'script';
+    
+    const codeToCheck = acornOpts.allowHashBang && code.startsWith('#!')
+      ? code.slice(code.indexOf('\n') + 1)
+      : code;
+    
+    const options = { target: targetVersion, sourceType };
+    
+    if (sourceType !== 'module') {
+      const quickCheck = fastBrake.detect(codeToCheck, { sourceType: 'script' });
+      const moduleFeature = quickCheck.find(f => f.name === 'import' || f.name === 'export');
+      
+      if (moduleFeature) {
+        throw new Error(
+          `'${moduleFeature.name}' can only be used in ES modules. Use --module flag to enable module support` +
+          (moduleFeature.line ? ` at line ${moduleFeature.line}` : '')
+        );
+      }
+    }
+    
+    fastBrake.fastBrake(codeToCheck, options);
+    
+    const detectedFeatures = needsFeatures 
+      ? fastBrake.detect(codeToCheck, { sourceType }) 
+      : [];
+    
+    const result = { 
+      ast: { type: 'Program', features: detectedFeatures }, 
+      error: null 
+    };
+    parseCache.set(cacheKey, result);
+    return result;
   } catch (err) {
-    return {
+    const result = {
       ast: null,
-      error: {
-        err,
-        stack: err.stack,
-        file
-      }
+      error: { err, stack: err.stack, file }
     };
+    parseCache.set(cacheKey, result);
+    return result;
   }
 }
 
-/**
- * Determine how runChecks is being invoked (CLI vs Node API)
- * @param {Object|null} loggerOrOptions - Logger or options object passed to runChecks
- * @returns {{isNodeAPI: boolean, logger: Object|null}}
- */
 function determineInvocationType(loggerOrOptions) {
-  let isNodeAPI = false;
-  let logger = null;
-  
   if (!loggerOrOptions) {
-    isNodeAPI = true;
-    logger = null;
-  } else if (typeof loggerOrOptions === 'object' && !loggerOrOptions.info && !loggerOrOptions.error) {
-    isNodeAPI = true;
-    logger = loggerOrOptions.logger || null;
-  } else {
-    isNodeAPI = false;
-    logger = loggerOrOptions;
+    return { isNodeAPI: true, logger: null };
   }
   
-  return { isNodeAPI, logger };
+  const hasLoggerMethods = loggerOrOptions.info || loggerOrOptions.error;
+  
+  if (typeof loggerOrOptions === 'object' && !hasLoggerMethods) {
+    return { isNodeAPI: true, logger: loggerOrOptions.logger || null };
+  }
+  
+  return { isNodeAPI: false, logger: loggerOrOptions };
 }
 
 /**
@@ -515,6 +581,37 @@ function handleESVersionError(options) {
   }
 }
 
+(async () => {
+  try {
+    await fastBrake.check('', { target: 'es5' });
+  } catch (e) {}
+})();
+
+async function parseLightMode(code, ecmaVersion, isModule, allowHashBang, file) {
+  const targetVersion = getTargetVersion(ecmaVersion);
+  
+  const codeToCheck = allowHashBang && code.startsWith('#!')
+    ? code.slice(code.indexOf('\n') + 1)
+    : code;
+  
+  const isCompatible = await 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 };
+}
+
 module.exports = {
   parseIgnoreList,
   checkVarKindMatch,
@@ -530,6 +627,7 @@ module.exports = {
   clearFileCache,
   getFileCacheStats,
   parseCode,
+  parseLightMode,
   determineInvocationType,
   determineLogLevel,
   handleESVersionError