es-check 9.6.0-1 → 9.6.0

package/README.md

@@ -80,7 +80,7 @@ Modern JavaScript builds assume proper transpilation via tools like Babel. ES Ch
 
 ## What features does ES Check check for?
 
-ES Check validates syntax by default. Add `--checkFeatures` for ES version-specific feature checking. View supported [features](./lib/helpers/detectFeatures/constants/es-features/).
+ES Check validates syntax by default. Add `--checkFeatures` for ES version-specific feature checking. View supported [features](./lib/constants/es-features/).
 
 ---
 
@@ -118,7 +118,7 @@ Usage: index [options] [ecmaVersion] [files...]
 
 Arguments:
   ecmaVersion                         ecmaVersion to check files against. Can be: es3, es4, es5, es6/es2015, es7/es2016, es8/es2017, es9/es2018, es10/es2019, es11/es2020, es12/es2021,
-                                      es13/es2022, es14/es2023
+                                      es13/es2022, es14/es2023, es15/es2024, es16/es2025
   files                               a glob of files to to test the EcmaScript version against
 
 ```
@@ -142,6 +142,7 @@ Here's a comprehensive list of all available options:
 | `--silent`                    | Silent mode: does not output anything, giving no indication of success or failure other than the exit code (default: false) |
 | `--checkFeatures`             | Check for actual ES version specific features (default: false)                                                              |
 | `--checkForPolyfills`         | Consider polyfills when checking features (only works with --checkFeatures) (default: false)                                |
+| `--ignorePolyfillable [lib]`  | Ignore polyfillable features; optionally specify library (e.g., `core-js`) to limit scope                                   |
 | `--ignore <features>`         | Comma-separated list of features to ignore, e.g., "ErrorCause,TopLevelAwait"                                                |
 | `--ignoreFile <path>`         | Path to JSON file containing features to ignore                                                                             |
 | `--allowList <features>`      | Comma-separated list of features to allow even in lower ES versions, e.g., "const,let"                                      |
@@ -309,6 +310,7 @@ Here's an example of what an `.escheckrc` file will look like:
   "looseGlobMatching": false,
   "checkFeatures": true,
   "checkForPolyfills": true,
+  "ignorePolyfillable": "core-js",
   "ignore": ["ErrorCause", "TopLevelAwait"],
   "allowList": ["ArrayToSorted", "ObjectHasOwn"],
   "checkBrowser": false,
@@ -320,22 +322,23 @@ Here's an example of what an `.escheckrc` file will look like:
 
 ### Configuration Options
 
-| Option              | Type            | Description                                                        |
-| ------------------- | --------------- | ------------------------------------------------------------------ |
-| `ecmaVersion`       | String          | ECMAScript version to check against (e.g., "es5", "es6", "es2020") |
-| `files`             | String or Array | Files or glob patterns to check                                    |
-| `module`            | Boolean         | Whether to parse files as ES modules                               |
-| `not`               | Array           | Files or glob patterns to exclude                                  |
-| `allowHashBang`     | Boolean         | Whether to allow hash bang in files                                |
-| `looseGlobMatching` | Boolean         | Whether to ignore missing files in globs                           |
-| `checkFeatures`     | Boolean         | Whether to check for ES version specific features                  |
-| `checkForPolyfills` | Boolean         | Whether to consider polyfills when checking features               |
-| `ignore`            | Array           | Features to ignore when checking                                   |
-| `allowList`         | Array           | Features to allow even in lower ES versions                        |
-| `checkBrowser`      | Boolean         | Whether to use browserslist configuration to determine ES version  |
-| `browserslistQuery` | String          | Custom browserslist query to use                                   |
-| `browserslistPath`  | String          | Path to custom browserslist configuration                          |
-| `browserslistEnv`   | String          | Browserslist environment to use                                    |
+| Option               | Type            | Description                                                                          |
+| -------------------- | --------------- | ------------------------------------------------------------------------------------ |
+| `ecmaVersion`        | String          | ECMAScript version to check against (e.g., "es5", "es6", "es2020")                   |
+| `files`              | String or Array | Files or glob patterns to check                                                      |
+| `module`             | Boolean         | Whether to parse files as ES modules                                                 |
+| `not`                | Array           | Files or glob patterns to exclude                                                    |
+| `allowHashBang`      | Boolean         | Whether to allow hash bang in files                                                  |
+| `looseGlobMatching`  | Boolean         | Whether to ignore missing files in globs                                             |
+| `checkFeatures`      | Boolean         | Whether to check for ES version specific features                                    |
+| `checkForPolyfills`  | Boolean         | Whether to consider polyfills when checking features                                 |
+| `ignorePolyfillable` | Boolean/String  | Ignore polyfillable features; set to library name (e.g., `"core-js"`) to limit scope |
+| `ignore`             | Array           | Features to ignore when checking                                                     |
+| `allowList`          | Array           | Features to allow even in lower ES versions                                          |
+| `checkBrowser`       | Boolean         | Whether to use browserslist configuration to determine ES version                    |
+| `browserslistQuery`  | String          | Custom browserslist query to use                                                     |
+| `browserslistPath`   | String          | Path to custom browserslist configuration                                            |
+| `browserslistEnv`    | String          | Browserslist environment to use                                                      |
 
 ### Multiple Configurations
 
@@ -443,7 +446,23 @@ ES Check provides three ways to handle polyfilled features:
    es-check es2022 './dist/**/*.js' --checkFeatures --allowList="ArrayToSorted,ObjectHasOwn"
    ```
 
-3. **--ignore**: Completely ignore specific features during checking
+3. **--ignorePolyfillable**: Ignore all features that can be polyfilled (or limit to a specific library)
+
+   ```sh
+   # Ignore all polyfillable features
+   es-check es2017 './dist/**/*.js' --checkFeatures --ignorePolyfillable
+
+   # Ignore only features polyfillable by core-js
+   es-check es2017 './dist/**/*.js' --checkFeatures --ignorePolyfillable=core-js
+   ```
+
+4. **--allowList**: Explicitly specify features to allow regardless of ES version
+
+   ```sh
+   es-check es2022 './dist/**/*.js' --checkFeatures --allowList="ArrayToSorted,ObjectHasOwn"
+   ```
+
+5. **--ignore**: Completely ignore specific features during checking
    ```sh
    es-check es2022 './dist/**/*.js' --checkFeatures --ignore="ArrayToSorted,ObjectHasOwn"
    ```
@@ -451,6 +470,7 @@ ES Check provides three ways to handle polyfilled features:
 #### When to use each option:
 
 - Use `--checkForPolyfills` when you have a standard polyfill setup (like core-js) and want automatic detection
+- Use `--ignorePolyfillable` when you know polyfills are provided externally and don't want to flag polyfillable features
 - Use `--allowList` when you have custom polyfills or want to be explicit about which features are allowed
 - Use `--ignore` as a temporary solution when you're working on fixes
 
@@ -584,7 +604,11 @@ flowchart LR
     E -->|No| F[Success]
     G --> G1{Features<br/>Valid?}
     G1 -->|Pass| H{--checkForPolyfills?}
-    G1 -->|Fail| D
+    G1 -->|Fail| L{--ignorePolyfillable?}
+    L -->|Yes| M{Feature<br/>Polyfillable?}
+    L -->|No| D
+    M -->|Yes| F
+    M -->|No| D
     H -->|Yes| I{Polyfills<br/>Detected?}
     H -->|No| F
     I -->|Yes| F
@@ -693,9 +717,9 @@ To update ES version support:
 
 To update ES feature detection:
 
-- Add features to [version-specific files](./lib/helpers/detectFeatures/constants/es-features/) (e.g., `6.js` for ES6 features)
-- Update [polyfill patterns](./lib/helpers/detectFeatures/constants/polyfills.js) if needed
-- Feature detection uses [acorn walk](https://github.com/acornjs/acorn/blob/master/acorn-walk/README.md)
+- Add features to [version-specific files](./lib/constants/es-features/) (e.g., `6.js` for ES6 features)
+- Update [polyfill patterns](./lib/constants/es-features/polyfills.js) if needed
+- Feature detection uses AST traversal via [Acorn](https://github.com/acornjs/acorn/)
 
 Tests are located in `tests/unit/` and mirror the `lib/` structure. Please add tests for new features!
 

package/lib/check-runner/utils.js

@@ -329,7 +329,11 @@ function processFullAST(
       esVersion,
       parseSourceType,
       ignoreList,
-      { ast, checkForPolyfills: config.checkForPolyfills },
+      {
+        ast,
+        checkForPolyfills: config.checkForPolyfills,
+        ignorePolyfillable: config.ignorePolyfillable,
+      },
     );
     foundFeatures = result.foundFeatures;
     unsupportedFeatures = result.unsupportedFeatures;

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

@@ -47,6 +47,7 @@ const ES13_FEATURES = {
       nodeType: "CallExpression",
       property: "at",
       excludeCallerTypes: ["ObjectExpression"],
+      requireNumericArg: true,
     },
   },
   ObjectHasOwn: {

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

@@ -15,57 +15,57 @@ const POLYFILL_PATTERNS = [
 const IMPORT_PATTERNS = [
   {
     pattern:
-      /(?:from\s+|require\s*\(\s*)['"]core-js\/modules\/es\.array\.to-sorted['"]/,
+      /(?:from\s+|require\s*\(\s*|import\s+)['"]core-js\/modules\/es\.array\.to-sorted['"]/,
     feature: "ArrayToSorted",
   },
   {
     pattern:
-      /(?:from\s+|require\s*\(\s*)['"]core-js\/modules\/es\.array\.find-last['"]/,
+      /(?:from\s+|require\s*\(\s*|import\s+)['"]core-js\/modules\/es\.array\.find-last['"]/,
     feature: "ArrayFindLast",
   },
   {
     pattern:
-      /(?:from\s+|require\s*\(\s*)['"]core-js\/modules\/es\.array\.find-last-index['"]/,
+      /(?:from\s+|require\s*\(\s*|import\s+)['"]core-js\/modules\/es\.array\.find-last-index['"]/,
     feature: "ArrayFindLastIndex",
   },
   {
     pattern:
-      /(?:from\s+|require\s*\(\s*)['"]core-js\/modules\/es\.array\.at['"]/,
+      /(?:from\s+|require\s*\(\s*|import\s+)['"]core-js\/modules\/es\.array\.at['"]/,
     feature: "ArrayAt",
   },
   {
     pattern:
-      /(?:from\s+|require\s*\(\s*)['"]core-js\/modules\/es\.string\.replace-all['"]/,
+      /(?:from\s+|require\s*\(\s*|import\s+)['"]core-js\/modules\/es\.string\.replace-all['"]/,
     feature: "StringReplaceAll",
   },
   {
     pattern:
-      /(?:from\s+|require\s*\(\s*)['"]core-js\/modules\/es\.string\.match-all['"]/,
+      /(?:from\s+|require\s*\(\s*|import\s+)['"]core-js\/modules\/es\.string\.match-all['"]/,
     feature: "StringMatchAll",
   },
   {
     pattern:
-      /(?:from\s+|require\s*\(\s*)['"]core-js\/modules\/es\.string\.at['"]/,
+      /(?:from\s+|require\s*\(\s*|import\s+)['"]core-js\/modules\/es\.string\.at['"]/,
     feature: "StringAt",
   },
   {
     pattern:
-      /(?:from\s+|require\s*\(\s*)['"]core-js\/modules\/es\.object\.has-own['"]/,
+      /(?:from\s+|require\s*\(\s*|import\s+)['"]core-js\/modules\/es\.object\.has-own['"]/,
     feature: "ObjectHasOwn",
   },
   {
     pattern:
-      /(?:from\s+|require\s*\(\s*)['"]core-js\/modules\/es\.promise\.any['"]/,
+      /(?:from\s+|require\s*\(\s*|import\s+)['"]core-js\/modules\/es\.promise\.any['"]/,
     feature: "PromiseAny",
   },
   {
     pattern:
-      /(?:from\s+|require\s*\(\s*)['"]core-js\/modules\/es\.regexp\.exec['"]/,
+      /(?:from\s+|require\s*\(\s*|import\s+)['"]core-js\/modules\/es\.regexp\.exec['"]/,
     feature: "RegExpExec",
   },
   {
     pattern:
-      /(?:from\s+|require\s*\(\s*)['"]core-js\/modules\/es\.global-this['"]/,
+      /(?:from\s+|require\s*\(\s*|import\s+)['"]core-js\/modules\/es\.global-this['"]/,
     feature: "GlobalThis",
   },
 ];

package/lib/detectFeatures.js

@@ -63,7 +63,7 @@ const detectFeatures = (
   ignoreList = new Set(),
   options = {},
 ) => {
-  const { checkForPolyfills, ast } = options;
+  const { checkForPolyfills, ast, ignorePolyfillable } = options;
 
   if (!ast) {
     const error = new Error("AST is required for feature detection");
@@ -76,13 +76,18 @@ const detectFeatures = (
 
   const foundFeatures = detectFeaturesFromAST(ast);
 
+  const polyfillableSet = ignorePolyfillable
+    ? getPolyfillableFeatures(ignorePolyfillable)
+    : null;
+
   const unsupportedFeatures = Object.entries(ES_FEATURES)
     .filter(
       ([name, { minVersion }]) =>
         foundFeatures[name] &&
         minVersion > ecmaVersion &&
         !ignoreList.has(name) &&
-        !(checkForPolyfills && polyfills.has(name)),
+        !(checkForPolyfills && polyfills.has(name)) &&
+        !(polyfillableSet && polyfillableSet.has(name)),
     )
     .map(([name]) => name);
 

package/lib/helpers/ast.js

@@ -13,6 +13,25 @@ function hasOptionsCause(node) {
   );
 }
 
+function hasNumericArgument(node) {
+  const args = node.arguments;
+  const hasArgs = args && args.length === 1;
+  if (!hasArgs) return false;
+
+  const arg = args[0];
+  const isNumericLiteral =
+    arg.type === "Literal" && typeof arg.value === "number";
+
+  const isUnaryExpression = arg.type === "UnaryExpression";
+  const isNegationOperator = arg.operator === "-";
+  const hasNumericLiteralArgument =
+    arg.argument?.type === "Literal" && typeof arg.argument.value === "number";
+  const isNegativeNumeric =
+    isUnaryExpression && isNegationOperator && hasNumericLiteralArgument;
+
+  return isNumericLiteral || isNegativeNumeric;
+}
+
 function checkMap(node, astInfo) {
   const callee = node.callee;
   const calleeObject = callee?.object;
@@ -60,6 +79,9 @@ function checkMap(node, astInfo) {
   const hasExcludedCallerType =
     astInfo.excludeCallerTypes?.includes(callerType);
 
+  const hasNumericArgMismatch =
+    astInfo.requireNumericArg && !hasNumericArgument(node);
+
   const hasMismatch =
     hasKindMismatch ||
     hasOperatorMismatch ||
@@ -70,7 +92,8 @@ function checkMap(node, astInfo) {
     hasPropertyWithExclusion ||
     hasObjectAndPropertyMismatch ||
     hasOptionsCauseMismatch ||
-    hasExcludedCallerType;
+    hasExcludedCallerType ||
+    hasNumericArgMismatch;
 
   if (hasMismatch) return false;
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "es-check",
-  "version": "9.6.0-1",
+  "version": "9.6.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",