eslint 8.20.0 → 8.23.0

package/lib/rule-tester/flat-rule-tester.js

@@ -4,7 +4,7 @@
  */
 "use strict";
 
-/* eslint-env mocha -- Mocha/Jest wrapper */
+/* globals describe, it -- Mocha globals */
 
 //------------------------------------------------------------------------------
 // Requirements
@@ -480,51 +480,54 @@ class FlatRuleTester {
             ].concat(scenarioErrors).join("\n"));
         }
 
-        const baseConfig = {
-            plugins: {
+        const baseConfig = [
+            {
+                plugins: {
 
-                // copy root plugin over
-                "@": {
+                    // copy root plugin over
+                    "@": {
 
-                    /*
-                     * Parsers are wrapped to detect more errors, so this needs
-                     * to be a new object for each call to run(), otherwise the
-                     * parsers will be wrapped multiple times.
-                     */
-                    parsers: {
-                        ...defaultConfig[0].plugins["@"].parsers
-                    },
+                        /*
+                         * Parsers are wrapped to detect more errors, so this needs
+                         * to be a new object for each call to run(), otherwise the
+                         * parsers will be wrapped multiple times.
+                         */
+                        parsers: {
+                            ...defaultConfig[0].plugins["@"].parsers
+                        },
 
-                    /*
-                     * The rules key on the default plugin is a proxy to lazy-load
-                     * just the rules that are needed. So, don't create a new object
-                     * here, just use the default one to keep that performance
-                     * enhancement.
-                     */
-                    rules: defaultConfig[0].plugins["@"].rules
-                },
-                "rule-to-test": {
-                    rules: {
-                        [ruleName]: Object.assign({}, rule, {
+                        /*
+                         * The rules key on the default plugin is a proxy to lazy-load
+                         * just the rules that are needed. So, don't create a new object
+                         * here, just use the default one to keep that performance
+                         * enhancement.
+                         */
+                        rules: defaultConfig[0].plugins["@"].rules
+                    },
+                    "rule-to-test": {
+                        rules: {
+                            [ruleName]: Object.assign({}, rule, {
 
-                            // Create a wrapper rule that freezes the `context` properties.
-                            create(context) {
-                                freezeDeeply(context.options);
-                                freezeDeeply(context.settings);
-                                freezeDeeply(context.parserOptions);
+                                // Create a wrapper rule that freezes the `context` properties.
+                                create(context) {
+                                    freezeDeeply(context.options);
+                                    freezeDeeply(context.settings);
+                                    freezeDeeply(context.parserOptions);
 
-                                // freezeDeeply(context.languageOptions);
+                                    // freezeDeeply(context.languageOptions);
 
-                                return (typeof rule === "function" ? rule : rule.create)(context);
-                            }
-                        })
+                                    return (typeof rule === "function" ? rule : rule.create)(context);
+                                }
+                            })
+                        }
                     }
+                },
+                languageOptions: {
+                    ...defaultConfig[0].languageOptions
                 }
             },
-            languageOptions: {
-                ...defaultConfig[0].languageOptions
-            }
-        };
+            ...defaultConfig.slice(1)
+        ];
 
         /**
          * Run the rule for the given item

package/lib/rule-tester/rule-tester.js

@@ -4,7 +4,7 @@
  */
 "use strict";
 
-/* eslint-env mocha -- Mocha wrapper */
+/* globals describe, it -- Mocha globals */
 
 /*
  * This is a wrapper around mocha to allow for DRY unittests for eslint
@@ -305,6 +305,36 @@ function getCommentsDeprecation() {
     );
 }
 
+/**
+ * Emit a deprecation warning if function-style format is being used.
+ * @param {string} ruleName Name of the rule.
+ * @returns {void}
+ */
+function emitLegacyRuleAPIWarning(ruleName) {
+    if (!emitLegacyRuleAPIWarning[`warned-${ruleName}`]) {
+        emitLegacyRuleAPIWarning[`warned-${ruleName}`] = true;
+        process.emitWarning(
+            `"${ruleName}" rule is using the deprecated function-style format and will stop working in ESLint v9. Please use object-style format: https://eslint.org/docs/developer-guide/working-with-rules`,
+            "DeprecationWarning"
+        );
+    }
+}
+
+/**
+ * Emit a deprecation warning if rule has options but is missing the "meta.schema" property
+ * @param {string} ruleName Name of the rule.
+ * @returns {void}
+ */
+function emitMissingSchemaWarning(ruleName) {
+    if (!emitMissingSchemaWarning[`warned-${ruleName}`]) {
+        emitMissingSchemaWarning[`warned-${ruleName}`] = true;
+        process.emitWarning(
+            `"${ruleName}" rule has options but is missing the "meta.schema" property and will stop working in ESLint v9. Please add a schema: https://eslint.org/docs/developer-guide/working-with-rules#options-schemas`,
+            "DeprecationWarning"
+        );
+    }
+}
+
 //------------------------------------------------------------------------------
 // Public Interface
 //------------------------------------------------------------------------------
@@ -521,6 +551,9 @@ class RuleTester {
             ].concat(scenarioErrors).join("\n"));
         }
 
+        if (typeof rule === "function") {
+            emitLegacyRuleAPIWarning(ruleName);
+        }
 
         linter.defineRule(ruleName, Object.assign({}, rule, {
 
@@ -578,6 +611,15 @@ class RuleTester {
 
             if (hasOwnProperty(item, "options")) {
                 assert(Array.isArray(item.options), "options must be an array");
+                if (
+                    item.options.length > 0 &&
+                    typeof rule === "object" &&
+                    (
+                        !rule.meta || (rule.meta && (typeof rule.meta.schema === "undefined" || rule.meta.schema === null))
+                    )
+                ) {
+                    emitMissingSchemaWarning(ruleName);
+                }
                 config.rules[ruleName] = [1].concat(item.options);
             } else {
                 config.rules[ruleName] = 1;

package/lib/rules/key-spacing.js

@@ -9,6 +9,9 @@
 //------------------------------------------------------------------------------
 
 const astUtils = require("./utils/ast-utils");
+const GraphemeSplitter = require("grapheme-splitter");
+
+const splitter = new GraphemeSplitter();
 
 //------------------------------------------------------------------------------
 // Helpers
@@ -508,7 +511,7 @@ module.exports = {
             const startToken = sourceCode.getFirstToken(property);
             const endToken = getLastTokenBeforeColon(property.key);
 
-            return endToken.range[1] - startToken.range[0];
+            return splitter.countGraphemes(sourceCode.getText().slice(startToken.range[0], endToken.range[1]));
         }
 
         /**

package/lib/rules/lines-around-comment.js

@@ -231,9 +231,15 @@ module.exports = {
             const parent = getParentNodeOfToken(token);
 
             if (parent && isParentNodeType(parent, nodeType)) {
-                const parentStartNodeOrToken = parent.type === "StaticBlock"
-                    ? sourceCode.getFirstToken(parent, { skip: 1 }) // opening brace of the static block
-                    : parent;
+                let parentStartNodeOrToken = parent;
+
+                if (parent.type === "StaticBlock") {
+                    parentStartNodeOrToken = sourceCode.getFirstToken(parent, { skip: 1 }); // opening brace of the static block
+                } else if (parent.type === "SwitchStatement") {
+                    parentStartNodeOrToken = sourceCode.getTokenAfter(parent.discriminant, {
+                        filter: astUtils.isOpeningBraceToken
+                    }); // opening brace of the switch statement
+                }
 
                 return token.loc.start.line - parentStartNodeOrToken.loc.start.line === 1;
             }
@@ -264,7 +270,8 @@ module.exports = {
                 isCommentAtParentStart(token, "ClassBody") ||
                 isCommentAtParentStart(token, "BlockStatement") ||
                 isCommentAtParentStart(token, "StaticBlock") ||
-                isCommentAtParentStart(token, "SwitchCase")
+                isCommentAtParentStart(token, "SwitchCase") ||
+                isCommentAtParentStart(token, "SwitchStatement")
             );
         }
 

package/lib/rules/no-fallthrough.js

@@ -76,6 +76,10 @@ module.exports = {
                     commentPattern: {
                         type: "string",
                         default: ""
+                    },
+                    allowEmptyCase: {
+                        type: "boolean",
+                        default: false
                     }
                 },
                 additionalProperties: false
@@ -91,6 +95,7 @@ module.exports = {
         const options = context.options[0] || {};
         let currentCodePath = null;
         const sourceCode = context.getSourceCode();
+        const allowEmptyCase = options.allowEmptyCase || false;
 
         /*
          * We need to use leading comments of the next SwitchCase node because
@@ -104,7 +109,6 @@ module.exports = {
         } else {
             fallthroughCommentPattern = DEFAULT_FALLTHROUGH_COMMENT;
         }
-
         return {
             onCodePathStart(codePath) {
                 currentCodePath = codePath;
@@ -119,7 +123,8 @@ module.exports = {
                  * Checks whether or not there is a fallthrough comment.
                  * And reports the previous fallthrough node if that does not exist.
                  */
-                if (fallthroughCase && !hasFallthroughComment(fallthroughCase, node, context, fallthroughCommentPattern)) {
+
+                if (fallthroughCase && (!hasFallthroughComment(fallthroughCase, node, context, fallthroughCommentPattern))) {
                     context.report({
                         messageId: node.test ? "case" : "default",
                         node
@@ -137,7 +142,7 @@ module.exports = {
                  * And allows empty cases and the last case.
                  */
                 if (currentCodePath.currentSegments.some(isReachable) &&
-                    (node.consequent.length > 0 || hasBlankLinesBetween(node, nextToken)) &&
+                    (node.consequent.length > 0 || (!allowEmptyCase && hasBlankLinesBetween(node, nextToken))) &&
                     node.parent.cases[node.parent.cases.length - 1] !== node) {
                     fallthroughCase = node;
                 }

package/lib/rules/no-lone-blocks.js

@@ -91,7 +91,7 @@ module.exports = {
         };
 
         // ES6: report blocks without block-level bindings, or that's only child of another block
-        if (context.parserOptions.ecmaVersion >= 6) {
+        if (context.languageOptions.ecmaVersion >= 2015) {
             ruleDef = {
                 BlockStatement(node) {
                     if (isLoneBlock(node)) {

package/lib/rules/no-warning-comments.js

@@ -37,6 +37,15 @@ module.exports = {
                     },
                     location: {
                         enum: ["start", "anywhere"]
+                    },
+                    decoration: {
+                        type: "array",
+                        items: {
+                            type: "string",
+                            pattern: "^\\S$"
+                        },
+                        minItems: 1,
+                        uniqueItems: true
                     }
                 },
                 additionalProperties: false
@@ -53,6 +62,7 @@ module.exports = {
             configuration = context.options[0] || {},
             warningTerms = configuration.terms || ["todo", "fixme", "xxx"],
             location = configuration.location || "start",
+            decoration = [...configuration.decoration || []].join(""),
             selfConfigRegEx = /\bno-warning-comments\b/u;
 
         /**
@@ -64,6 +74,7 @@ module.exports = {
          */
         function convertToRegExp(term) {
             const escaped = escapeRegExp(term);
+            const escapedDecoration = escapeRegExp(decoration);
 
             /*
              * When matching at the start, ignore leading whitespace, and
@@ -74,18 +85,23 @@ module.exports = {
              *     e.g. terms ["TODO"] matches `//TODO something`
              * $   handles any terms at the end of a comment
              *     e.g. terms ["TODO"] matches `// something TODO`
-             * \s* handles optional leading spaces (for "start" location only)
-             *     e.g. terms ["TODO"] matches `//    TODO something`
              * \b  handles terms preceded/followed by word boundary
              *     e.g. terms: ["!FIX", "FIX!"] matches `// FIX!something` or `// something!FIX`
              *          terms: ["FIX"] matches `// FIX!` or `// !FIX`, but not `// fixed or affix`
+             *
+             * For location start:
+             * [\s]* handles optional leading spaces
+             *     e.g. terms ["TODO"] matches `//    TODO something`
+             * [\s\*]* (where "\*" is the escaped string of decoration)
+             *     handles optional leading spaces or decoration characters (for "start" location only)
+             *     e.g. terms ["TODO"] matches `/**** TODO something ... `
              */
             const wordBoundary = "\\b";
 
             let prefix = "";
 
             if (location === "start") {
-                prefix = "^\\s*";
+                prefix = `^[\\s${escapedDecoration}]*`;
             } else if (/^\w/u.test(term)) {
                 prefix = wordBoundary;
             }
@@ -95,12 +111,15 @@ module.exports = {
 
             /*
              * For location "start", the typical regex is:
-             *   /^\s*ESCAPED_TERM\b/iu.
+             *   /^[\s]*ESCAPED_TERM\b/iu.
+             * Or if decoration characters are specified (e.g. "*"), then any of
+             * those characters may appear in any order at the start:
+             *   /^[\s\*]*ESCAPED_TERM\b/iu.
              *
              * For location "anywhere" the typical regex is
              *   /\bESCAPED_TERM\b/iu
              *
-             * If it starts or ends with non-word character, the prefix and suffix empty, respectively.
+             * If it starts or ends with non-word character, the prefix and suffix are empty, respectively.
              */
             return new RegExp(`${prefix}${escaped}${suffix}`, flags);
         }

package/lib/rules/object-shorthand.js

@@ -78,6 +78,9 @@ module.exports = {
                                 ignoreConstructors: {
                                     type: "boolean"
                                 },
+                                methodsIgnorePattern: {
+                                    type: "string"
+                                },
                                 avoidQuotes: {
                                     type: "boolean"
                                 },
@@ -115,6 +118,9 @@ module.exports = {
 
         const PARAMS = context.options[1] || {};
         const IGNORE_CONSTRUCTORS = PARAMS.ignoreConstructors;
+        const METHODS_IGNORE_PATTERN = PARAMS.methodsIgnorePattern
+            ? new RegExp(PARAMS.methodsIgnorePattern, "u")
+            : null;
         const AVOID_QUOTES = PARAMS.avoidQuotes;
         const AVOID_EXPLICIT_RETURN_ARROWS = !!PARAMS.avoidExplicitReturnArrows;
         const sourceCode = context.getSourceCode();
@@ -457,6 +463,15 @@ module.exports = {
                     if (IGNORE_CONSTRUCTORS && node.key.type === "Identifier" && isConstructor(node.key.name)) {
                         return;
                     }
+
+                    if (METHODS_IGNORE_PATTERN) {
+                        const propertyName = astUtils.getStaticPropertyName(node);
+
+                        if (propertyName !== null && METHODS_IGNORE_PATTERN.test(propertyName)) {
+                            return;
+                        }
+                    }
+
                     if (AVOID_QUOTES && isStringLiteral(node.key)) {
                         return;
                     }

package/lib/rules/sort-keys.js

@@ -105,6 +105,10 @@ module.exports = {
                         type: "integer",
                         minimum: 2,
                         default: 2
+                    },
+                    allowLineSeparatedGroups: {
+                        type: "boolean",
+                        default: false
                     }
                 },
                 additionalProperties: false
@@ -124,17 +128,21 @@ module.exports = {
         const insensitive = options && options.caseSensitive === false;
         const natural = options && options.natural;
         const minKeys = options && options.minKeys;
+        const allowLineSeparatedGroups = options && options.allowLineSeparatedGroups || false;
         const isValidOrder = isValidOrders[
             order + (insensitive ? "I" : "") + (natural ? "N" : "")
         ];
 
         // The stack to save the previous property's name for each object literals.
         let stack = null;
+        const sourceCode = context.getSourceCode();
 
         return {
             ObjectExpression(node) {
                 stack = {
                     upper: stack,
+                    prevNode: null,
+                    prevBlankLine: false,
                     prevName: null,
                     numKeys: node.properties.length
                 };
@@ -159,10 +167,45 @@ module.exports = {
                 const numKeys = stack.numKeys;
                 const thisName = getPropertyName(node);
 
+                // Get tokens between current node and previous node
+                const tokens = stack.prevNode && sourceCode
+                    .getTokensBetween(stack.prevNode, node, { includeComments: true });
+
+                let isBlankLineBetweenNodes = stack.prevBlankLine;
+
+                if (tokens) {
+
+                    // check blank line between tokens
+                    tokens.forEach((token, index) => {
+                        const previousToken = tokens[index - 1];
+
+                        if (previousToken && (token.loc.start.line - previousToken.loc.end.line > 1)) {
+                            isBlankLineBetweenNodes = true;
+                        }
+                    });
+
+                    // check blank line between the current node and the last token
+                    if (!isBlankLineBetweenNodes && (node.loc.start.line - tokens[tokens.length - 1].loc.end.line > 1)) {
+                        isBlankLineBetweenNodes = true;
+                    }
+
+                    // check blank line between the first token and the previous node
+                    if (!isBlankLineBetweenNodes && (tokens[0].loc.start.line - stack.prevNode.loc.end.line > 1)) {
+                        isBlankLineBetweenNodes = true;
+                    }
+                }
+
+                stack.prevNode = node;
+
                 if (thisName !== null) {
                     stack.prevName = thisName;
                 }
 
+                if (allowLineSeparatedGroups && isBlankLineBetweenNodes) {
+                    stack.prevBlankLine = thisName === null;
+                    return;
+                }
+
                 if (prevName === null || thisName === null || numKeys < minKeys) {
                     return;
                 }

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

@@ -1978,7 +1978,7 @@ module.exports = {
             if (comments.length) {
                 const lastComment = comments[comments.length - 1];
 
-                if (lastComment.range[0] > leftToken.range[0]) {
+                if (!leftToken || lastComment.range[0] > leftToken.range[0]) {
                     leftToken = lastComment;
                 }
             }
@@ -1986,7 +1986,13 @@ module.exports = {
             leftToken = leftValue;
         }
 
-        if (leftToken.type === "Shebang") {
+        /*
+         * If a hashbang comment was passed as a token object from SourceCode,
+         * its type will be "Shebang" because of the way ESLint itself handles hashbangs.
+         * If a hashbang comment was passed in a string and then tokenized in this function,
+         * its type will be "Hashbang" because of the way Espree tokenizes hashbangs.
+         */
+        if (leftToken.type === "Shebang" || leftToken.type === "Hashbang") {
             return false;
         }
 
@@ -2007,7 +2013,7 @@ module.exports = {
             if (comments.length) {
                 const firstComment = comments[0];
 
-                if (firstComment.range[0] < rightToken.range[0]) {
+                if (!rightToken || firstComment.range[0] < rightToken.range[0]) {
                     rightToken = firstComment;
                 }
             }

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|2015|2016|2017|2018|2019|2020|2021|2022} [ecmaVersion] The ECMAScript version (or revision number).
+ * @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 {"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

@@ -12,6 +12,8 @@
 //-----------------------------------------------------------------------------
 
 const { FileEnumerator } = require("./cli-engine/file-enumerator");
+const { FlatESLint } = require("./eslint/flat-eslint");
+const FlatRuleTester = require("./rule-tester/flat-rule-tester");
 
 //-----------------------------------------------------------------------------
 // Exports
@@ -19,5 +21,7 @@ const { FileEnumerator } = require("./cli-engine/file-enumerator");
 
 module.exports = {
     builtinRules: require("./rules"),
+    FlatESLint,
+    FlatRuleTester,
     FileEnumerator
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint",
-  "version": "8.20.0",
+  "version": "8.23.0",
   "author": "Nicholas C. Zakas <nicholas+npm@nczconsulting.com>",
   "description": "An AST-based pattern checker for JavaScript.",
   "bin": {
@@ -39,7 +39,8 @@
     "docs/src/rules/*.md": [
       "node tools/fetch-docs-links.js",
       "git add docs/src/_data/further_reading_links.json"
-    ]
+    ],
+    "docs/**/*.svg": "npx svgo -r --multipass"
   },
   "files": [
     "LICENSE",
@@ -54,8 +55,10 @@
   "homepage": "https://eslint.org",
   "bugs": "https://github.com/eslint/eslint/issues/",
   "dependencies": {
-    "@eslint/eslintrc": "^1.3.0",
-    "@humanwhocodes/config-array": "^0.9.2",
+    "@eslint/eslintrc": "^1.3.1",
+    "@humanwhocodes/config-array": "^0.10.4",
+    "@humanwhocodes/gitignore-to-minimatch": "^1.0.2",
+    "@humanwhocodes/module-importer": "^1.0.1",
     "ajv": "^6.10.0",
     "chalk": "^4.0.0",
     "cross-spawn": "^7.0.2",
@@ -65,14 +68,17 @@
     "eslint-scope": "^7.1.1",
     "eslint-utils": "^3.0.0",
     "eslint-visitor-keys": "^3.3.0",
-    "espree": "^9.3.2",
+    "espree": "^9.4.0",
     "esquery": "^1.4.0",
     "esutils": "^2.0.2",
     "fast-deep-equal": "^3.1.3",
     "file-entry-cache": "^6.0.1",
+    "find-up": "^5.0.0",
     "functional-red-black-tree": "^1.0.1",
     "glob-parent": "^6.0.1",
     "globals": "^13.15.0",
+    "globby": "^11.1.0",
+    "grapheme-splitter": "^1.0.4",
     "ignore": "^5.2.0",
     "import-fresh": "^3.0.0",
     "imurmurhash": "^0.1.4",
@@ -87,8 +93,7 @@
     "regexpp": "^3.2.0",
     "strip-ansi": "^6.0.1",
     "strip-json-comments": "^3.1.0",
-    "text-table": "^0.2.0",
-    "v8-compile-cache": "^2.0.3"
+    "text-table": "^0.2.0"
   },
   "devDependencies": {
     "@babel/core": "^7.4.3",
@@ -105,7 +110,7 @@
     "eslint-plugin-eslint-plugin": "^4.4.0",
     "eslint-plugin-internal-rules": "file:tools/internal-rules",
     "eslint-plugin-jsdoc": "^38.1.6",
-    "eslint-plugin-node": "^11.1.0",
+    "eslint-plugin-n": "^15.2.4",
     "eslint-plugin-unicorn": "^42.0.0",
     "eslint-release": "^3.2.0",
     "eslump": "^3.0.0",
@@ -141,7 +146,7 @@
     "pirates": "^4.0.5",
     "progress": "^2.0.3",
     "proxyquire": "^2.0.1",
-    "puppeteer": "^9.1.1",
+    "puppeteer": "^13.7.0",
     "recast": "^0.20.4",
     "regenerator-runtime": "^0.13.2",
     "semver": "^7.3.5",