eslint 8.43.0 → 8.45.0

package/lib/rules/utils/ast-utils.js

@@ -9,6 +9,7 @@
 // Requirements
 //------------------------------------------------------------------------------
 
+const { KEYS: eslintVisitorKeys } = require("eslint-visitor-keys");
 const esutils = require("esutils");
 const espree = require("espree");
 const escapeRegExp = require("escape-string-regexp");
@@ -1005,6 +1006,15 @@ function isTopLevelExpressionStatement(node) {
 
 }
 
+/**
+ * Check whether the given node is a part of a directive prologue or not.
+ * @param {ASTNode} node The node to check.
+ * @returns {boolean} `true` if the node is a part of directive prologue.
+ */
+function isDirective(node) {
+    return node.type === "ExpressionStatement" && typeof node.directive === "string";
+}
+
 //------------------------------------------------------------------------------
 // Public Interface
 //------------------------------------------------------------------------------
@@ -1461,7 +1471,16 @@ module.exports = {
                 return 19;
 
             default:
-                return 20;
+                if (node.type in eslintVisitorKeys) {
+                    return 20;
+                }
+
+                /*
+                 * if the node is not a standard node that we know about, then assume it has the lowest precedence
+                 * this will mean that rules will wrap unknown nodes in parentheses where applicable instead of
+                 * unwrapping them and potentially changing the meaning of the code or introducing a syntax error.
+                 */
+                return -1;
         }
     },
 
@@ -2123,6 +2142,15 @@ module.exports = {
         return OCTAL_OR_NON_OCTAL_DECIMAL_ESCAPE_PATTERN.test(rawString);
     },
 
+    /**
+     * Determines whether the given node is a template literal without expressions.
+     * @param {ASTNode} node Node to check.
+     * @returns {boolean} True if the node is a template literal without expressions.
+     */
+    isStaticTemplateLiteral(node) {
+        return node.type === "TemplateLiteral" && node.expressions.length === 0;
+    },
+
     isReferenceToGlobalVariable,
     isLogicalExpression,
     isCoalesceExpression,
@@ -2139,5 +2167,6 @@ module.exports = {
     getSwitchCaseColonToken,
     getModuleExportName,
     isConstant,
-    isTopLevelExpressionStatement
+    isTopLevelExpressionStatement,
+    isDirective
 };

package/lib/rules/valid-typeof.js

@@ -4,6 +4,12 @@
  */
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -88,7 +94,7 @@ module.exports = {
                     if (parent.type === "BinaryExpression" && OPERATORS.has(parent.operator)) {
                         const sibling = parent.left === node ? parent.right : parent.left;
 
-                        if (sibling.type === "Literal" || sibling.type === "TemplateLiteral" && !sibling.expressions.length) {
+                        if (sibling.type === "Literal" || astUtils.isStaticTemplateLiteral(sibling)) {
                             const value = sibling.type === "Literal" ? sibling.value : sibling.quasis[0].value.cooked;
 
                             if (!VALID_TYPES.has(value)) {

package/lib/rules/yoda.js

@@ -58,22 +58,13 @@ function isNegativeNumericLiteral(node) {
     );
 }
 
-/**
- * Determines whether a node is a Template Literal which can be determined statically.
- * @param {ASTNode} node Node to test
- * @returns {boolean} True if the node is a Template Literal without expression.
- */
-function isStaticTemplateLiteral(node) {
-    return node.type === "TemplateLiteral" && node.expressions.length === 0;
-}
-
 /**
  * Determines whether a non-Literal node should be treated as a single Literal node.
  * @param {ASTNode} node Node to test
  * @returns {boolean} True if the node should be treated as a single Literal node.
  */
 function looksLikeLiteral(node) {
-    return isNegativeNumericLiteral(node) || isStaticTemplateLiteral(node);
+    return isNegativeNumericLiteral(node) || astUtils.isStaticTemplateLiteral(node);
 }
 
 /**
@@ -100,7 +91,7 @@ function getNormalizedLiteral(node) {
         };
     }
 
-    if (isStaticTemplateLiteral(node)) {
+    if (astUtils.isStaticTemplateLiteral(node)) {
         return {
             type: "Literal",
             value: node.quasis[0].value.cooked,

package/lib/shared/types.js

@@ -21,7 +21,7 @@ module.exports = {};
 /**
  * @typedef {Object} ParserOptions
  * @property {EcmaFeatures} [ecmaFeatures] The optional features.
- * @property {3|5|6|7|8|9|10|11|12|13|14|2015|2016|2017|2018|2019|2020|2021|2022|2023} [ecmaVersion] The ECMAScript version (or revision number).
+ * @property {3|5|6|7|8|9|10|11|12|13|14|15|2015|2016|2017|2018|2019|2020|2021|2022|2023|2024} [ecmaVersion] The ECMAScript version (or revision number).
  * @property {"script"|"module"} [sourceType] The source code type.
  * @property {boolean} [allowReserved] Allowing the use of reserved words as identifiers in ES3.
  */

package/lib/unsupported-api.js

@@ -14,6 +14,7 @@
 const { FileEnumerator } = require("./cli-engine/file-enumerator");
 const { FlatESLint, shouldUseFlatConfig } = require("./eslint/flat-eslint");
 const FlatRuleTester = require("./rule-tester/flat-rule-tester");
+const { ESLint } = require("./eslint/eslint");
 
 //-----------------------------------------------------------------------------
 // Exports
@@ -24,5 +25,6 @@ module.exports = {
     FlatESLint,
     shouldUseFlatConfig,
     FlatRuleTester,
-    FileEnumerator
+    FileEnumerator,
+    LegacyESLint: ESLint
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint",
-  "version": "8.43.0",
+  "version": "8.45.0",
   "author": "Nicholas C. Zakas <nicholas+npm@nczconsulting.com>",
   "description": "An AST-based pattern checker for JavaScript.",
   "bin": {
@@ -62,8 +62,8 @@
   "dependencies": {
     "@eslint-community/eslint-utils": "^4.2.0",
     "@eslint-community/regexpp": "^4.4.0",
-    "@eslint/eslintrc": "^2.0.3",
-    "@eslint/js": "8.43.0",
+    "@eslint/eslintrc": "^2.1.0",
+    "@eslint/js": "8.44.0",
     "@humanwhocodes/config-array": "^0.11.10",
     "@humanwhocodes/module-importer": "^1.0.1",
     "@nodelib/fs.walk": "^1.2.8",
@@ -75,7 +75,7 @@
     "escape-string-regexp": "^4.0.0",
     "eslint-scope": "^7.2.0",
     "eslint-visitor-keys": "^3.4.1",
-    "espree": "^9.5.2",
+    "espree": "^9.6.0",
     "esquery": "^1.4.2",
     "esutils": "^2.0.2",
     "fast-deep-equal": "^3.1.3",
@@ -85,7 +85,6 @@
     "globals": "^13.19.0",
     "graphemer": "^1.4.0",
     "ignore": "^5.2.0",
-    "import-fresh": "^3.0.0",
     "imurmurhash": "^0.1.4",
     "is-glob": "^4.0.0",
     "is-path-inside": "^3.0.3",
@@ -95,9 +94,8 @@
     "lodash.merge": "^4.6.2",
     "minimatch": "^3.1.2",
     "natural-compare": "^1.4.0",
-    "optionator": "^0.9.1",
+    "optionator": "^0.9.3",
     "strip-ansi": "^6.0.1",
-    "strip-json-comments": "^3.1.0",
     "text-table": "^0.2.0"
   },
   "devDependencies": {
@@ -115,8 +113,8 @@
     "eslint-plugin-eslint-comments": "^3.2.0",
     "eslint-plugin-eslint-plugin": "^5.1.0",
     "eslint-plugin-internal-rules": "file:tools/internal-rules",
-    "eslint-plugin-jsdoc": "^38.1.6",
-    "eslint-plugin-n": "^15.2.4",
+    "eslint-plugin-jsdoc": "^46.2.5",
+    "eslint-plugin-n": "^16.0.0",
     "eslint-plugin-unicorn": "^42.0.0",
     "eslint-release": "^3.2.0",
     "eslump": "^3.0.0",
@@ -153,10 +151,9 @@
     "puppeteer": "^13.7.0",
     "recast": "^0.20.4",
     "regenerator-runtime": "^0.13.2",
-    "semver": "^7.3.5",
+    "semver": "^7.5.3",
     "shelljs": "^0.8.2",
     "sinon": "^11.0.0",
-    "temp": "^0.9.0",
     "webpack": "^5.23.0",
     "webpack-cli": "^4.5.0",
     "yorkie": "^2.0.0"