es-check 9.6.4 → 9.7.2

package/lib/cli/handler.js

@@ -1,63 +1,65 @@
 const fs = require("fs");
 const { loadConfig } = require("../config");
 const { runChecks } = require("../check-runner");
-const {
-  createLogger,
-  generateBashCompletion,
-  generateZshCompletion,
-} = require("../helpers");
+const { createLogger, generateBashCompletion, generateZshCompletion } = require("../helpers");
 const { JS_VERSIONS } = require("../constants/versions");
 const { SUPPORTED_SHELLS, COMPLETION_OPTIONS } = require("./constants");
 
+function valueOrDefault(value, defaultValue) {
+  if (value !== undefined) return value;
+  return defaultValue;
+}
+
+function parseCommaList(value) {
+  return value
+    .split(",")
+    .map((item) => item.trim())
+    .filter(Boolean);
+}
+
+function parseOptionList(value, defaultValue) {
+  if (!value) return defaultValue;
+  return parseCommaList(value);
+}
+
+function resolveCacheOption(options, baseConfig) {
+  if (options.noCache) return false;
+  return valueOrDefault(baseConfig.cache, true);
+}
+
 function buildConfig(ecmaVersionArg, filesArg, options, baseConfig) {
   const ignoreFilePath = options.ignoreFile || options["ignore-file"];
-
-  const config = {
-    ...baseConfig,
+  const ignore = valueOrDefault(options.ignore, baseConfig.ignore);
+  const ignoreFile = valueOrDefault(ignoreFilePath, baseConfig.ignoreFile);
+  const not = parseOptionList(options.not, baseConfig.not);
+  const allowList = valueOrDefault(options.allowList, baseConfig.allowList);
+  const browserslistQuery = valueOrDefault(options.browserslistQuery, baseConfig.browserslistQuery);
+  const browserslistPath = valueOrDefault(options.browserslistPath, baseConfig.browserslistPath);
+  const browserslistEnv = valueOrDefault(options.browserslistEnv, baseConfig.browserslistEnv);
+  const batchSize = valueOrDefault(options.batchSize, baseConfig.batchSize);
+  const cache = resolveCacheOption(options, baseConfig);
+  const light = valueOrDefault(options.light, baseConfig.light);
+
+  const config = Object.assign({}, baseConfig, {
     module: options.module,
     allowHashBang: options.allowHashBang || options["allow-hash-bang"],
     typescript: options.typescript || options.ts,
     checkFeatures: options.checkFeatures,
     checkForPolyfills: options.checkForPolyfills,
     ignorePolyfillable: options.ignorePolyfillable,
-    ignore: options.ignore !== undefined ? options.ignore : baseConfig.ignore,
-    ignoreFile:
-      ignoreFilePath !== undefined ? ignoreFilePath : baseConfig.ignoreFile,
-    not: options.not
-      ? options.not
-          .split(",")
-          .map((n) => n.trim())
-          .filter(Boolean)
-      : baseConfig.not,
+    ignore,
+    ignoreFile,
+    not,
     looseGlobMatching: options.looseGlobMatching,
-    allowList:
-      options.allowList !== undefined
-        ? options.allowList
-        : baseConfig.allowList,
+    allowList,
     checkBrowser: options.checkBrowser,
-    browserslistQuery:
-      options.browserslistQuery !== undefined
-        ? options.browserslistQuery
-        : baseConfig.browserslistQuery,
-    browserslistPath:
-      options.browserslistPath !== undefined
-        ? options.browserslistPath
-        : baseConfig.browserslistPath,
-    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,
-  };
+    browserslistQuery,
+    browserslistPath,
+    browserslistEnv,
+    batchSize,
+    cache,
+    light,
+  });
 
   const hasEcmaVersion = ecmaVersionArg !== undefined;
   if (hasEcmaVersion) {
@@ -66,16 +68,14 @@ function buildConfig(ecmaVersionArg, filesArg, options, baseConfig) {
 
   const hasFilesArg = filesArg?.length > 0;
   const hasFilesOption = options.files !== undefined;
+  const shouldUseFilesOption = !hasFilesArg && hasFilesOption;
 
   if (hasFilesArg) {
     config.files = filesArg;
   }
 
-  if (!hasFilesArg && hasFilesOption) {
-    config.files = options.files
-      .split(",")
-      .map((f) => f.trim())
-      .filter(Boolean);
+  if (shouldUseFilesOption) {
+    config.files = parseCommaList(options.files);
   }
 
   return config;
@@ -88,9 +88,7 @@ function warnAboutIgnoreFile(ignoreFilePath, logger) {
   const shouldWarn = hasIgnoreFile && !ignoreFileExists && isWarn;
 
   if (shouldWarn) {
-    logger.warn(
-      `Warning: Ignore file '${ignoreFilePath}' does not exist or is not accessible`,
-    );
+    logger.warn(`Warning: Ignore file '${ignoreFilePath}' does not exist or is not accessible`);
   }
 }
 
@@ -99,51 +97,40 @@ async function handleMainCommand(ecmaVersionArg, filesArg, options) {
 
   const hasBothFilesInputs = filesArg?.length > 0 && options.files;
   if (hasBothFilesInputs) {
-    logger.error(
-      "Cannot pass in both [files...] argument and --files flag at the same time!",
-    );
+    logger.error("Cannot pass in both [files...] argument and --files flag at the same time!");
     process.exit(1);
   }
 
   const validEcmaVersionValues = new Set(JS_VERSIONS);
   const isCheckBrowser = options.checkBrowser;
   const hasEcmaVersion = ecmaVersionArg !== undefined;
-  const isInvalidEcmaVersion =
-    hasEcmaVersion && !validEcmaVersionValues.has(ecmaVersionArg);
+  const isInvalidEcmaVersion = hasEcmaVersion && !validEcmaVersionValues.has(ecmaVersionArg);
   const shouldTreatAsFile = isCheckBrowser && isInvalidEcmaVersion;
 
   let adjustedEcmaVersion = ecmaVersionArg;
   let adjustedFiles = filesArg;
 
   if (shouldTreatAsFile) {
-    adjustedFiles = [ecmaVersionArg, ...filesArg];
+    adjustedFiles = [ecmaVersionArg].concat(filesArg);
     adjustedEcmaVersion = "checkBrowser";
   }
 
   const configs = await loadConfig(options.config);
   const baseConfig = configs[0] || {};
 
-  const hasCommandLineArgs =
-    adjustedEcmaVersion || adjustedFiles?.length || options.files;
+  const hasCommandLineArgs = adjustedEcmaVersion || adjustedFiles?.length || options.files;
 
   if (hasCommandLineArgs) {
     const ignoreFilePath = options.ignoreFile || options["ignore-file"];
     warnAboutIgnoreFile(ignoreFilePath, logger);
 
-    const singleConfig = buildConfig(
-      adjustedEcmaVersion,
-      adjustedFiles,
-      options,
-      baseConfig,
-    );
+    const singleConfig = buildConfig(adjustedEcmaVersion, adjustedFiles, options, baseConfig);
     return runChecks([singleConfig], logger);
   }
 
   const hasNoConfigs = configs.length === 0;
   if (hasNoConfigs) {
-    logger.error(
-      "No configuration found. Please provide command line arguments or a config file.",
-    );
+    logger.error("No configuration found. Please provide command line arguments or a config file.");
     process.exit(1);
   }
 
@@ -165,16 +152,19 @@ function handleCompletionCommand(shell) {
   const commands = ["completion"];
   const options = COMPLETION_OPTIONS;
 
+  const completionScript = getCompletionScript(shell, commands, options);
+
+  logger.info(completionScript);
+}
+
+function getCompletionScript(shell, commands, options) {
   const isBash = shell === "bash";
-  const isZsh = shell === "zsh";
+  if (isBash) return generateBashCompletion("es-check", commands, options);
 
-  const completionScript = isBash
-    ? generateBashCompletion("es-check", commands, options)
-    : isZsh
-      ? generateZshCompletion("es-check", commands, options)
-      : null;
+  const isZsh = shell === "zsh";
+  if (isZsh) return generateZshCompletion("es-check", commands, options);
 
-  logger.info(completionScript);
+  return null;
 }
 
 module.exports = {

package/lib/cli/parser.js

@@ -19,10 +19,17 @@ const BOOLEAN_FLAGS = new Set([
   "version",
 ]);
 
+function createBooleanOptions(flags) {
+  return flags.split("").reduce((nextOptions, flag) => {
+    nextOptions[flag] = true;
+    return nextOptions;
+  }, {});
+}
+
 function parseArgs(argv) {
   const args = argv.slice(2);
   const options = {};
-  const positional = [];
+  let positional = [];
 
   let i = 0;
   const hasMoreArgs = () => i < args.length;
@@ -34,12 +41,13 @@ function parseArgs(argv) {
     const isShortOption = arg.startsWith("-") && !arg.startsWith("--");
 
     if (isLongOption) {
-      const hasEquals = arg.includes("=");
+      const optionParts = arg.slice(2).split("=");
+      const hasEquals = optionParts.length > 1;
       if (hasEquals) {
-        const [key, ...valueParts] = arg.slice(2).split("=");
+        const [key, ...valueParts] = optionParts;
         options[key] = valueParts.join("=");
       } else {
-        const key = arg.slice(2);
+        const key = optionParts[0];
         const isBooleanFlag = BOOLEAN_FLAGS.has(key);
 
         if (isBooleanFlag) {
@@ -61,16 +69,12 @@ function parseArgs(argv) {
       const flags = arg.slice(1);
       const lastFlag = flags[flags.length - 1];
       const otherFlags = flags.slice(0, -1);
-
-      for (const flag of otherFlags) {
-        options[flag] = true;
-      }
+      Object.assign(options, createBooleanOptions(otherFlags));
 
       const nextArg = args[i + 1];
       const hasNextArg = nextArg !== undefined;
       const isBooleanFlag = BOOLEAN_FLAGS.has(lastFlag);
-      const nextIsValue =
-        hasNextArg && !nextArg.startsWith("-") && !isBooleanFlag;
+      const nextIsValue = hasNextArg && !nextArg.startsWith("-") && !isBooleanFlag;
 
       if (nextIsValue) {
         options[lastFlag] = nextArg;
@@ -79,7 +83,7 @@ function parseArgs(argv) {
         options[lastFlag] = true;
       }
     } else {
-      positional.push(arg);
+      positional = positional.concat(arg);
     }
 
     i++;
@@ -97,7 +101,7 @@ USAGE:
   es-check completion [shell]
 
 ARGUMENTS:
-  ecmaVersion    ES version to check (es3, es5, es6, es2015-es2025, or checkBrowser)
+  ecmaVersion    ES version to check (es3, es5, es6, es2015-es2026, or checkBrowser)
   files          Glob patterns of files to check
 
 OPTIONS:

package/lib/cli/utils.js

@@ -1,5 +1,9 @@
 const fs = require("fs");
 
+function appendError(allErrors, error) {
+  allErrors[allErrors.length] = error;
+}
+
 function parseIgnoreList(options) {
   if (!options) {
     return new Set();
@@ -58,7 +62,8 @@ function parseIgnoreList(options) {
 
     if (Array.isArray(ignoreConfig.features)) {
       ignoreConfig.features.forEach((feature) => {
-        if (feature && typeof feature === "string") {
+        const isStringFeature = feature && typeof feature === "string";
+        if (isStringFeature) {
           ignoreList.add(feature.trim());
         }
       });
@@ -74,7 +79,6 @@ function generateBashCompletion(cmdName, commands, options) {
   const cmdsStr = commands.join(" ");
   const optsStr = options.map((opt) => "--" + opt).join(" ");
 
-  /* eslint-disable no-useless-escape */
   return `
 # es-check bash completion script
 # Install by adding to ~/.bashrc:
@@ -88,22 +92,22 @@ _${cmdName.replace(/-/g, "_")}_completion() {
 
   cmds="${cmdsStr}"
   opts="${optsStr}"
-  es_versions="es3 es5 es6 es2015 es7 es2016 es8 es2017 es9 es2018 es10 es2019 es11 es2020 es12 es2021 es13 es2022 es14 es2023 es15 es2024 es16 es2025"
+  es_versions="es3 es5 es6 es2015 es7 es2016 es8 es2017 es9 es2018 es10 es2019 es11 es2020 es12 es2021 es13 es2022 es14 es2023 es15 es2024 es16 es2025 es17 es2026"
 
-  case "\$prev" in
+  case "$prev" in
     ${cmdName})
-      COMPREPLY=( \$(compgen -W "\$es_versions \$cmds \$opts" -- "\$cur") )
+      COMPREPLY=( $(compgen -W "$es_versions $cmds $opts" -- "$cur") )
       return 0
       ;;
     completion)
-      COMPREPLY=( \$(compgen -W "bash zsh" -- "\$cur") )
+      COMPREPLY=( $(compgen -W "bash zsh" -- "$cur") )
       return 0
       ;;
     *)
-      if [[ "\$cur" == -* ]]; then
-        COMPREPLY=( \$(compgen -W "\$opts" -- "\$cur") )
+      if [[ "$cur" == -* ]]; then
+        COMPREPLY=( $(compgen -W "$opts" -- "$cur") )
       else
-        COMPREPLY=( \$(compgen -f -- "\$cur") )
+        COMPREPLY=( $(compgen -f -- "$cur") )
       fi
       return 0
       ;;
@@ -112,16 +116,11 @@ _${cmdName.replace(/-/g, "_")}_completion() {
 
 complete -F _${cmdName.replace(/-/g, "_")}_completion ${cmdName}
 `;
-  /* eslint-enable no-useless-escape */
 }
 
 function generateZshCompletion(cmdName, commands, options) {
-  const optionsStr = options
-    .map((opt) => `"--${opt}[Option description]"`)
-    .join("\n    ");
-  const commandsStr = commands
-    .map((cmd) => `"${cmd}:Command description"`)
-    .join("\n    ");
+  const optionsStr = options.map((opt) => `"--${opt}[Option description]"`).join("\n    ");
+  const commandsStr = commands.map((cmd) => `"${cmd}:Command description"`).join("\n    ");
 
   return `
 #compdef ${cmdName}
@@ -154,6 +153,8 @@ _${cmdName.replace(/-/g, "_")}() {
     "es2024:ECMAScript 2024"
     "es16:ECMAScript 2025"
     "es2025:ECMAScript 2025"
+    "es17:ECMAScript 2026"
+    "es2026:ECMAScript 2026"
   )
 
   commands=(
@@ -186,8 +187,9 @@ function determineInvocationType(loggerOrOptions) {
   }
 
   const hasLoggerMethods = loggerOrOptions.info || loggerOrOptions.error;
+  const isOptionsObject = typeof loggerOrOptions === "object" && !hasLoggerMethods;
 
-  if (typeof loggerOrOptions === "object" && !hasLoggerMethods) {
+  if (isOptionsObject) {
     return { isNodeAPI: true, logger: loggerOrOptions.logger || null };
   }
 
@@ -195,13 +197,7 @@ function determineInvocationType(loggerOrOptions) {
 }
 
 function handleESVersionError(options) {
-  const {
-    errorMessage,
-    logger,
-    isNodeAPI,
-    allErrors,
-    file = "config",
-  } = options;
+  const { errorMessage, logger, isNodeAPI, allErrors, file = "config" } = options;
 
   if (logger) {
     logger.error(errorMessage);
@@ -211,7 +207,7 @@ function handleESVersionError(options) {
     process.exit(1);
     return { shouldContinue: false, hasErrors: true };
   } else {
-    allErrors.push({
+    appendError(allErrors, {
       err: new Error(errorMessage),
       file,
     });

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

@@ -19,7 +19,7 @@ const ES15_FEATURES = {
     minVersion: 15,
     example: "/pattern/v",
     astInfo: {
-      nodeType: "RegExpLiteral",
+      nodeType: "Literal",
       flags: "v",
     },
   },
@@ -59,6 +59,22 @@ const ES15_FEATURES = {
       property: "waitAsync",
     },
   },
+  ArrayBufferTransfer: {
+    minVersion: 15,
+    example: "buffer.transfer(newByteLength)",
+    astInfo: {
+      nodeType: "CallExpression",
+      property: "transfer",
+    },
+  },
+  ArrayBufferTransferToFixedLength: {
+    minVersion: 15,
+    example: "buffer.transferToFixedLength(newByteLength)",
+    astInfo: {
+      nodeType: "CallExpression",
+      property: "transferToFixedLength",
+    },
+  },
 };
 
 module.exports = { ES15_FEATURES };

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

@@ -29,6 +29,15 @@ const ES16_FEATURES = {
       property: "try",
     },
   },
+  IntlDurationFormat: {
+    minVersion: 16,
+    example: "new Intl.DurationFormat('en')",
+    astInfo: {
+      nodeType: "NewExpression",
+      object: "Intl",
+      property: "DurationFormat",
+    },
+  },
   DuplicateNamedCaptureGroups: {
     minVersion: 16,
     example: "/(?<name>a)|(?<name>b)/",
@@ -117,6 +126,31 @@ const ES16_FEATURES = {
       property: "escape",
     },
   },
+  MathF16Round: {
+    minVersion: 16,
+    example: "Math.f16round(value)",
+    astInfo: {
+      nodeType: "CallExpression",
+      object: "Math",
+      property: "f16round",
+    },
+  },
+  DataViewGetFloat16: {
+    minVersion: 16,
+    example: "view.getFloat16(byteOffset)",
+    astInfo: {
+      nodeType: "CallExpression",
+      property: "getFloat16",
+    },
+  },
+  DataViewSetFloat16: {
+    minVersion: 16,
+    example: "view.setFloat16(byteOffset, value)",
+    astInfo: {
+      nodeType: "CallExpression",
+      property: "setFloat16",
+    },
+  },
 };
 
 module.exports = { ES16_FEATURES };

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

@@ -17,29 +17,108 @@ const ES17_FEATURES = {
       property: "isError",
     },
   },
-  ArrayBufferTransfer: {
+  MapGetOrInsert: {
     minVersion: 17,
-    example: "buffer.transfer(newByteLength)",
+    example: "map.getOrInsert(key, value)",
     astInfo: {
       nodeType: "CallExpression",
-      property: "transfer",
+      property: "getOrInsert",
+      requireMapReceiver: true,
     },
   },
-  ArrayBufferTransferToFixedLength: {
+  MapGetOrInsertComputed: {
     minVersion: 17,
-    example: "buffer.transferToFixedLength(newByteLength)",
+    example: "map.getOrInsertComputed(key, fn)",
     astInfo: {
       nodeType: "CallExpression",
-      property: "transferToFixedLength",
+      property: "getOrInsertComputed",
+      requireMapReceiver: true,
     },
   },
-  IntlDurationFormat: {
+  IteratorConcat: {
     minVersion: 17,
-    example: "new Intl.DurationFormat('en')",
+    example: "Iterator.concat(first, second)",
     astInfo: {
-      nodeType: "NewExpression",
-      object: "Intl",
-      property: "DurationFormat",
+      nodeType: "CallExpression",
+      object: "Iterator",
+      property: "concat",
+    },
+  },
+  JSONRawJSON: {
+    minVersion: 17,
+    example: "JSON.rawJSON(text)",
+    astInfo: {
+      nodeType: "CallExpression",
+      object: "JSON",
+      property: "rawJSON",
+    },
+  },
+  JSONIsRawJSON: {
+    minVersion: 17,
+    example: "JSON.isRawJSON(value)",
+    astInfo: {
+      nodeType: "CallExpression",
+      object: "JSON",
+      property: "isRawJSON",
+    },
+  },
+  MathSumPrecise: {
+    minVersion: 17,
+    example: "Math.sumPrecise(values)",
+    astInfo: {
+      nodeType: "CallExpression",
+      object: "Math",
+      property: "sumPrecise",
+    },
+  },
+  Uint8ArrayFromBase64: {
+    minVersion: 17,
+    example: "Uint8Array.fromBase64(text)",
+    astInfo: {
+      nodeType: "CallExpression",
+      object: "Uint8Array",
+      property: "fromBase64",
+    },
+  },
+  Uint8ArrayFromHex: {
+    minVersion: 17,
+    example: "Uint8Array.fromHex(text)",
+    astInfo: {
+      nodeType: "CallExpression",
+      object: "Uint8Array",
+      property: "fromHex",
+    },
+  },
+  Uint8ArrayToBase64: {
+    minVersion: 17,
+    example: "bytes.toBase64()",
+    astInfo: {
+      nodeType: "CallExpression",
+      property: "toBase64",
+    },
+  },
+  Uint8ArrayToHex: {
+    minVersion: 17,
+    example: "bytes.toHex()",
+    astInfo: {
+      nodeType: "CallExpression",
+      property: "toHex",
+    },
+  },
+  Uint8ArraySetFromBase64: {
+    minVersion: 17,
+    example: "bytes.setFromBase64(text)",
+    astInfo: {
+      nodeType: "CallExpression",
+      property: "setFromBase64",
+    },
+  },
+  Uint8ArraySetFromHex: {
+    minVersion: 17,
+    example: "bytes.setFromHex(text)",
+    astInfo: {
+      nodeType: "CallExpression",
+      property: "setFromHex",
     },
   },
 };

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

@@ -11,7 +11,8 @@ const ES9_FEATURES = {
     minVersion: 9,
     example: "for await (const x of asyncIterable) {}",
     astInfo: {
-      nodeType: "ForAwaitStatement",
+      nodeType: "ForOfStatement",
+      await: true,
     },
   },
   PromiseFinally: {

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

@@ -0,0 +1,71 @@
+const ES_GLOBAL_MIN_VERSION = {
+  AggregateError: 12,
+  Array: 5,
+  ArrayBuffer: 6,
+  Atomics: 8,
+  BigInt: 11,
+  BigInt64Array: 11,
+  BigUint64Array: 11,
+  Boolean: 5,
+  DataView: 6,
+  Date: 5,
+  Error: 5,
+  EvalError: 5,
+  FinalizationRegistry: 12,
+  Float16Array: 16,
+  Float32Array: 6,
+  Float64Array: 6,
+  Function: 5,
+  Infinity: 5,
+  Int16Array: 6,
+  Int32Array: 6,
+  Int8Array: 6,
+  Intl: 6,
+  Iterator: 16,
+  JSON: 5,
+  Map: 6,
+  Math: 5,
+  NaN: 5,
+  Number: 5,
+  Object: 5,
+  Promise: 6,
+  Proxy: 6,
+  RangeError: 5,
+  ReferenceError: 5,
+  Reflect: 6,
+  RegExp: 5,
+  Set: 6,
+  SharedArrayBuffer: 8,
+  String: 5,
+  Symbol: 6,
+  SyntaxError: 5,
+  TypeError: 5,
+  URIError: 5,
+  Uint16Array: 6,
+  Uint32Array: 6,
+  Uint8Array: 6,
+  Uint8ClampedArray: 6,
+  WeakMap: 6,
+  WeakRef: 12,
+  WeakSet: 6,
+  decodeURI: 5,
+  decodeURIComponent: 5,
+  encodeURI: 5,
+  encodeURIComponent: 5,
+  escape: 5,
+  eval: 5,
+  globalThis: 11,
+  isFinite: 5,
+  isNaN: 5,
+  parseFloat: 5,
+  parseInt: 5,
+  undefined: 5,
+  unescape: 5,
+};
+
+const ES_GLOBALS_SOURCE = "https://github.com/sindresorhus/globals/blob/main/globals.json";
+
+module.exports = {
+  ES_GLOBAL_MIN_VERSION,
+  ES_GLOBALS_SOURCE,
+};