eslint 8.57.1 → 9.39.1

package/lib/rules/no-multi-str.js

@@ -15,51 +15,53 @@ const astUtils = require("./utils/ast-utils");
 // Rule Definition
 //------------------------------------------------------------------------------
 
-/** @type {import('../shared/types').Rule} */
+/** @type {import('../types').Rule.RuleModule} */
 module.exports = {
-    meta: {
-        type: "suggestion",
+	meta: {
+		type: "suggestion",
 
-        docs: {
-            description: "Disallow multiline strings",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/no-multi-str"
-        },
+		docs: {
+			description: "Disallow multiline strings",
+			recommended: false,
+			frozen: true,
+			url: "https://eslint.org/docs/latest/rules/no-multi-str",
+		},
 
-        schema: [],
+		schema: [],
 
-        messages: {
-            multilineString: "Multiline support is limited to browsers supporting ES5 only."
-        }
-    },
+		messages: {
+			multilineString:
+				"Multiline support is limited to browsers supporting ES5 only.",
+		},
+	},
 
-    create(context) {
+	create(context) {
+		/**
+		 * Determines if a given node is part of JSX syntax.
+		 * @param {ASTNode} node The node to check.
+		 * @returns {boolean} True if the node is a JSX node, false if not.
+		 * @private
+		 */
+		function isJSXElement(node) {
+			return node.type.indexOf("JSX") === 0;
+		}
 
-        /**
-         * Determines if a given node is part of JSX syntax.
-         * @param {ASTNode} node The node to check.
-         * @returns {boolean} True if the node is a JSX node, false if not.
-         * @private
-         */
-        function isJSXElement(node) {
-            return node.type.indexOf("JSX") === 0;
-        }
+		//--------------------------------------------------------------------------
+		// Public API
+		//--------------------------------------------------------------------------
 
-        //--------------------------------------------------------------------------
-        // Public API
-        //--------------------------------------------------------------------------
-
-        return {
-
-            Literal(node) {
-                if (astUtils.LINEBREAK_MATCHER.test(node.raw) && !isJSXElement(node.parent)) {
-                    context.report({
-                        node,
-                        messageId: "multilineString"
-                    });
-                }
-            }
-        };
-
-    }
+		return {
+			Literal(node) {
+				if (
+					astUtils.LINEBREAK_MATCHER.test(node.raw) &&
+					!isJSXElement(node.parent)
+				) {
+					context.report({
+						node,
+						messageId: "multilineString",
+					});
+				}
+			},
+		};
+	},
 };

package/lib/rules/no-multiple-empty-lines.js

@@ -10,145 +10,201 @@
 // Rule Definition
 //------------------------------------------------------------------------------
 
-/** @type {import('../shared/types').Rule} */
+/** @type {import('../types').Rule.RuleModule} */
 module.exports = {
-    meta: {
-        deprecated: true,
-        replacedBy: [],
-        type: "layout",
-
-        docs: {
-            description: "Disallow multiple empty lines",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/no-multiple-empty-lines"
-        },
-
-        fixable: "whitespace",
-
-        schema: [
-            {
-                type: "object",
-                properties: {
-                    max: {
-                        type: "integer",
-                        minimum: 0
-                    },
-                    maxEOF: {
-                        type: "integer",
-                        minimum: 0
-                    },
-                    maxBOF: {
-                        type: "integer",
-                        minimum: 0
-                    }
-                },
-                required: ["max"],
-                additionalProperties: false
-            }
-        ],
-
-        messages: {
-            blankBeginningOfFile: "Too many blank lines at the beginning of file. Max of {{max}} allowed.",
-            blankEndOfFile: "Too many blank lines at the end of file. Max of {{max}} allowed.",
-            consecutiveBlank: "More than {{max}} blank {{pluralizedLines}} not allowed."
-        }
-    },
-
-    create(context) {
-
-        // Use options.max or 2 as default
-        let max = 2,
-            maxEOF = max,
-            maxBOF = max;
-
-        if (context.options.length) {
-            max = context.options[0].max;
-            maxEOF = typeof context.options[0].maxEOF !== "undefined" ? context.options[0].maxEOF : max;
-            maxBOF = typeof context.options[0].maxBOF !== "undefined" ? context.options[0].maxBOF : max;
-        }
-
-        const sourceCode = context.sourceCode;
-
-        // Swallow the final newline, as some editors add it automatically and we don't want it to cause an issue
-        const allLines = sourceCode.lines[sourceCode.lines.length - 1] === "" ? sourceCode.lines.slice(0, -1) : sourceCode.lines;
-        const templateLiteralLines = new Set();
-
-        //--------------------------------------------------------------------------
-        // Public
-        //--------------------------------------------------------------------------
-
-        return {
-            TemplateLiteral(node) {
-                node.quasis.forEach(literalPart => {
-
-                    // Empty lines have a semantic meaning if they're inside template literals. Don't count these as empty lines.
-                    for (let ignoredLine = literalPart.loc.start.line; ignoredLine < literalPart.loc.end.line; ignoredLine++) {
-                        templateLiteralLines.add(ignoredLine);
-                    }
-                });
-            },
-            "Program:exit"(node) {
-                return allLines
-
-                    // Given a list of lines, first get a list of line numbers that are non-empty.
-                    .reduce((nonEmptyLineNumbers, line, index) => {
-                        if (line.trim() || templateLiteralLines.has(index + 1)) {
-                            nonEmptyLineNumbers.push(index + 1);
-                        }
-                        return nonEmptyLineNumbers;
-                    }, [])
-
-                    // Add a value at the end to allow trailing empty lines to be checked.
-                    .concat(allLines.length + 1)
-
-                    // Given two line numbers of non-empty lines, report the lines between if the difference is too large.
-                    .reduce((lastLineNumber, lineNumber) => {
-                        let messageId, maxAllowed;
-
-                        if (lastLineNumber === 0) {
-                            messageId = "blankBeginningOfFile";
-                            maxAllowed = maxBOF;
-                        } else if (lineNumber === allLines.length + 1) {
-                            messageId = "blankEndOfFile";
-                            maxAllowed = maxEOF;
-                        } else {
-                            messageId = "consecutiveBlank";
-                            maxAllowed = max;
-                        }
-
-                        if (lineNumber - lastLineNumber - 1 > maxAllowed) {
-                            context.report({
-                                node,
-                                loc: {
-                                    start: { line: lastLineNumber + maxAllowed + 1, column: 0 },
-                                    end: { line: lineNumber, column: 0 }
-                                },
-                                messageId,
-                                data: {
-                                    max: maxAllowed,
-                                    pluralizedLines: maxAllowed === 1 ? "line" : "lines"
-                                },
-                                fix(fixer) {
-                                    const rangeStart = sourceCode.getIndexFromLoc({ line: lastLineNumber + 1, column: 0 });
-
-                                    /*
-                                     * The end of the removal range is usually the start index of the next line.
-                                     * However, at the end of the file there is no next line, so the end of the
-                                     * range is just the length of the text.
-                                     */
-                                    const lineNumberAfterRemovedLines = lineNumber - maxAllowed;
-                                    const rangeEnd = lineNumberAfterRemovedLines <= allLines.length
-                                        ? sourceCode.getIndexFromLoc({ line: lineNumberAfterRemovedLines, column: 0 })
-                                        : sourceCode.text.length;
-
-                                    return fixer.removeRange([rangeStart, rangeEnd]);
-                                }
-                            });
-                        }
-
-                        return lineNumber;
-                    }, 0);
-            }
-        };
-    }
+	meta: {
+		deprecated: {
+			message: "Formatting rules are being moved out of ESLint core.",
+			url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/",
+			deprecatedSince: "8.53.0",
+			availableUntil: "11.0.0",
+			replacedBy: [
+				{
+					message:
+						"ESLint Stylistic now maintains deprecated stylistic core rules.",
+					url: "https://eslint.style/guide/migration",
+					plugin: {
+						name: "@stylistic/eslint-plugin",
+						url: "https://eslint.style",
+					},
+					rule: {
+						name: "no-multiple-empty-lines",
+						url: "https://eslint.style/rules/no-multiple-empty-lines",
+					},
+				},
+			],
+		},
+		type: "layout",
+
+		docs: {
+			description: "Disallow multiple empty lines",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/no-multiple-empty-lines",
+		},
+
+		fixable: "whitespace",
+
+		schema: [
+			{
+				type: "object",
+				properties: {
+					max: {
+						type: "integer",
+						minimum: 0,
+					},
+					maxEOF: {
+						type: "integer",
+						minimum: 0,
+					},
+					maxBOF: {
+						type: "integer",
+						minimum: 0,
+					},
+				},
+				required: ["max"],
+				additionalProperties: false,
+			},
+		],
+
+		messages: {
+			blankBeginningOfFile:
+				"Too many blank lines at the beginning of file. Max of {{max}} allowed.",
+			blankEndOfFile:
+				"Too many blank lines at the end of file. Max of {{max}} allowed.",
+			consecutiveBlank:
+				"More than {{max}} blank {{pluralizedLines}} not allowed.",
+		},
+	},
+
+	create(context) {
+		// Use options.max or 2 as default
+		let max = 2,
+			maxEOF = max,
+			maxBOF = max;
+
+		if (context.options.length) {
+			max = context.options[0].max;
+			maxEOF =
+				typeof context.options[0].maxEOF !== "undefined"
+					? context.options[0].maxEOF
+					: max;
+			maxBOF =
+				typeof context.options[0].maxBOF !== "undefined"
+					? context.options[0].maxBOF
+					: max;
+		}
+
+		const sourceCode = context.sourceCode;
+
+		// Swallow the final newline, as some editors add it automatically and we don't want it to cause an issue
+		const allLines =
+			sourceCode.lines.at(-1) === ""
+				? sourceCode.lines.slice(0, -1)
+				: sourceCode.lines;
+		const templateLiteralLines = new Set();
+
+		//--------------------------------------------------------------------------
+		// Public
+		//--------------------------------------------------------------------------
+
+		return {
+			TemplateLiteral(node) {
+				node.quasis.forEach(literalPart => {
+					// Empty lines have a semantic meaning if they're inside template literals. Don't count these as empty lines.
+					for (
+						let ignoredLine = literalPart.loc.start.line;
+						ignoredLine < literalPart.loc.end.line;
+						ignoredLine++
+					) {
+						templateLiteralLines.add(ignoredLine);
+					}
+				});
+			},
+			"Program:exit"(node) {
+				return (
+					allLines
+
+						// Given a list of lines, first get a list of line numbers that are non-empty.
+						.reduce((nonEmptyLineNumbers, line, index) => {
+							if (
+								line.trim() ||
+								templateLiteralLines.has(index + 1)
+							) {
+								nonEmptyLineNumbers.push(index + 1);
+							}
+							return nonEmptyLineNumbers;
+						}, [])
+
+						// Add a value at the end to allow trailing empty lines to be checked.
+						.concat(allLines.length + 1)
+
+						// Given two line numbers of non-empty lines, report the lines between if the difference is too large.
+						.reduce((lastLineNumber, lineNumber) => {
+							let messageId, maxAllowed;
+
+							if (lastLineNumber === 0) {
+								messageId = "blankBeginningOfFile";
+								maxAllowed = maxBOF;
+							} else if (lineNumber === allLines.length + 1) {
+								messageId = "blankEndOfFile";
+								maxAllowed = maxEOF;
+							} else {
+								messageId = "consecutiveBlank";
+								maxAllowed = max;
+							}
+
+							if (lineNumber - lastLineNumber - 1 > maxAllowed) {
+								context.report({
+									node,
+									loc: {
+										start: {
+											line:
+												lastLineNumber + maxAllowed + 1,
+											column: 0,
+										},
+										end: { line: lineNumber, column: 0 },
+									},
+									messageId,
+									data: {
+										max: maxAllowed,
+										pluralizedLines:
+											maxAllowed === 1 ? "line" : "lines",
+									},
+									fix(fixer) {
+										const rangeStart =
+											sourceCode.getIndexFromLoc({
+												line: lastLineNumber + 1,
+												column: 0,
+											});
+
+										/*
+										 * The end of the removal range is usually the start index of the next line.
+										 * However, at the end of the file there is no next line, so the end of the
+										 * range is just the length of the text.
+										 */
+										const lineNumberAfterRemovedLines =
+											lineNumber - maxAllowed;
+										const rangeEnd =
+											lineNumberAfterRemovedLines <=
+											allLines.length
+												? sourceCode.getIndexFromLoc({
+														line: lineNumberAfterRemovedLines,
+														column: 0,
+													})
+												: sourceCode.text.length;
+
+										return fixer.removeRange([
+											rangeStart,
+											rangeEnd,
+										]);
+									},
+								});
+							}
+
+							return lineNumber;
+						}, 0)
+				);
+			},
+		};
+	},
 };

package/lib/rules/no-native-reassign.js

@@ -10,89 +10,105 @@
 // Rule Definition
 //------------------------------------------------------------------------------
 
-/** @type {import('../shared/types').Rule} */
+/** @type {import('../types').Rule.RuleModule} */
 module.exports = {
-    meta: {
-        type: "suggestion",
+	meta: {
+		type: "suggestion",
 
-        docs: {
-            description: "Disallow assignments to native objects or read-only global variables",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/no-native-reassign"
-        },
+		docs: {
+			description:
+				"Disallow assignments to native objects or read-only global variables",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/no-native-reassign",
+		},
 
-        deprecated: true,
+		deprecated: {
+			message: "Renamed rule.",
+			url: "https://eslint.org/blog/2016/08/eslint-v3.3.0-released/#deprecated-rules",
+			deprecatedSince: "3.3.0",
+			availableUntil: "11.0.0",
+			replacedBy: [
+				{
+					rule: {
+						name: "no-global-assign",
+						url: "https://eslint.org/docs/rules/no-global-assign",
+					},
+				},
+			],
+		},
 
-        replacedBy: ["no-global-assign"],
+		schema: [
+			{
+				type: "object",
+				properties: {
+					exceptions: {
+						type: "array",
+						items: { type: "string" },
+						uniqueItems: true,
+					},
+				},
+				additionalProperties: false,
+			},
+		],
 
-        schema: [
-            {
-                type: "object",
-                properties: {
-                    exceptions: {
-                        type: "array",
-                        items: { type: "string" },
-                        uniqueItems: true
-                    }
-                },
-                additionalProperties: false
-            }
-        ],
+		messages: {
+			nativeReassign:
+				"Read-only global '{{name}}' should not be modified.",
+		},
+	},
 
-        messages: {
-            nativeReassign: "Read-only global '{{name}}' should not be modified."
-        }
-    },
+	create(context) {
+		const config = context.options[0];
+		const exceptions = (config && config.exceptions) || [];
+		const sourceCode = context.sourceCode;
 
-    create(context) {
-        const config = context.options[0];
-        const exceptions = (config && config.exceptions) || [];
-        const sourceCode = context.sourceCode;
+		/**
+		 * Reports write references.
+		 * @param {Reference} reference A reference to check.
+		 * @param {number} index The index of the reference in the references.
+		 * @param {Reference[]} references The array that the reference belongs to.
+		 * @returns {void}
+		 */
+		function checkReference(reference, index, references) {
+			const identifier = reference.identifier;
 
-        /**
-         * Reports write references.
-         * @param {Reference} reference A reference to check.
-         * @param {int} index The index of the reference in the references.
-         * @param {Reference[]} references The array that the reference belongs to.
-         * @returns {void}
-         */
-        function checkReference(reference, index, references) {
-            const identifier = reference.identifier;
+			if (
+				reference.init === false &&
+				reference.isWrite() &&
+				/*
+				 * Destructuring assignments can have multiple default value,
+				 * so possibly there are multiple writeable references for the same identifier.
+				 */
+				(index === 0 || references[index - 1].identifier !== identifier)
+			) {
+				context.report({
+					node: identifier,
+					messageId: "nativeReassign",
+					data: identifier,
+				});
+			}
+		}
 
-            if (reference.init === false &&
-                reference.isWrite() &&
+		/**
+		 * Reports write references if a given variable is read-only builtin.
+		 * @param {Variable} variable A variable to check.
+		 * @returns {void}
+		 */
+		function checkVariable(variable) {
+			if (
+				variable.writeable === false &&
+				!exceptions.includes(variable.name)
+			) {
+				variable.references.forEach(checkReference);
+			}
+		}
 
-                /*
-                 * Destructuring assignments can have multiple default value,
-                 * so possibly there are multiple writeable references for the same identifier.
-                 */
-                (index === 0 || references[index - 1].identifier !== identifier)
-            ) {
-                context.report({
-                    node: identifier,
-                    messageId: "nativeReassign",
-                    data: identifier
-                });
-            }
-        }
+		return {
+			Program(node) {
+				const globalScope = sourceCode.getScope(node);
 
-        /**
-         * Reports write references if a given variable is read-only builtin.
-         * @param {Variable} variable A variable to check.
-         * @returns {void}
-         */
-        function checkVariable(variable) {
-            if (variable.writeable === false && !exceptions.includes(variable.name)) {
-                variable.references.forEach(checkReference);
-            }
-        }
-
-        return {
-            Program(node) {
-                const globalScope = sourceCode.getScope(node);
-
-                globalScope.variables.forEach(checkVariable);
-            }
-        };
-    }
+				globalScope.variables.forEach(checkVariable);
+			},
+		};
+	},
 };