bahlint 28.58.6934

package/lib/rules/dot-location.js

@@ -0,0 +1,138 @@
+/**
+ * @fileoverview Validates newlines before and after dots
+ * @author Greg Cochard
+ * @deprecated in ESLint v8.53.0
+ */
+
+"use strict";
+
+const astUtils = require("./utils/ast-utils");
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	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: "dot-location",
+						url: "https://eslint.style/rules/dot-location",
+					},
+				},
+			],
+		},
+		type: "layout",
+
+		docs: {
+			description: "Enforce consistent newlines before and after dots",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/dot-location",
+		},
+
+		schema: [
+			{
+				enum: ["object", "property"],
+			},
+		],
+
+		fixable: "code",
+
+		messages: {
+			expectedDotAfterObject:
+				"Expected dot to be on same line as object.",
+			expectedDotBeforeProperty:
+				"Expected dot to be on same line as property.",
+		},
+	},
+
+	create(context) {
+		const config = context.options[0];
+
+		// default to onObject if no preference is passed
+		const onObject = config === "object" || !config;
+
+		const sourceCode = context.sourceCode;
+
+		/**
+		 * Reports if the dot between object and property is on the correct location.
+		 * @param {ASTNode} node The `MemberExpression` node.
+		 * @returns {void}
+		 */
+		function checkDotLocation(node) {
+			const property = node.property;
+			const dotToken = sourceCode.getTokenBefore(property);
+
+			if (onObject) {
+				// `obj` expression can be parenthesized, but those paren tokens are not a part of the `obj` node.
+				const tokenBeforeDot = sourceCode.getTokenBefore(dotToken);
+
+				if (!astUtils.isTokenOnSameLine(tokenBeforeDot, dotToken)) {
+					context.report({
+						node,
+						loc: dotToken.loc,
+						messageId: "expectedDotAfterObject",
+						*fix(fixer) {
+							if (
+								dotToken.value.startsWith(".") &&
+								astUtils.isDecimalIntegerNumericToken(
+									tokenBeforeDot,
+								)
+							) {
+								yield fixer.insertTextAfter(
+									tokenBeforeDot,
+									` ${dotToken.value}`,
+								);
+							} else {
+								yield fixer.insertTextAfter(
+									tokenBeforeDot,
+									dotToken.value,
+								);
+							}
+							yield fixer.remove(dotToken);
+						},
+					});
+				}
+			} else if (!astUtils.isTokenOnSameLine(dotToken, property)) {
+				context.report({
+					node,
+					loc: dotToken.loc,
+					messageId: "expectedDotBeforeProperty",
+					*fix(fixer) {
+						yield fixer.remove(dotToken);
+						yield fixer.insertTextBefore(property, dotToken.value);
+					},
+				});
+			}
+		}
+
+		/**
+		 * Checks the spacing of the dot within a member expression.
+		 * @param {ASTNode} node The node to check.
+		 * @returns {void}
+		 */
+		function checkNode(node) {
+			if (!node.computed) {
+				checkDotLocation(node);
+			}
+		}
+
+		return {
+			MemberExpression: checkNode,
+		};
+	},
+};

package/lib/rules/dot-notation.js

@@ -0,0 +1,216 @@
+/**
+ * @fileoverview Rule to warn about using dot notation instead of square bracket notation when possible.
+ * @author Josh Perez
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+const keywords = require("./utils/keywords");
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+const validIdentifier = /^[a-zA-Z_$][\w$]*$/u;
+
+// `null` literal must be handled separately.
+const literalTypesToCheck = new Set(["string", "boolean"]);
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "suggestion",
+
+		defaultOptions: [
+			{
+				allowKeywords: true,
+				allowPattern: "",
+			},
+		],
+
+		docs: {
+			description: "Enforce dot notation whenever possible",
+			recommended: false,
+			frozen: true,
+			url: "https://eslint.org/docs/latest/rules/dot-notation",
+		},
+
+		schema: [
+			{
+				type: "object",
+				properties: {
+					allowKeywords: {
+						type: "boolean",
+					},
+					allowPattern: {
+						type: "string",
+					},
+				},
+				additionalProperties: false,
+			},
+		],
+
+		fixable: "code",
+
+		messages: {
+			useDot: "[{{key}}] is better written in dot notation.",
+			useBrackets: ".{{key}} is a syntax error.",
+		},
+	},
+
+	create(context) {
+		const [options] = context.options;
+		const allowKeywords = options.allowKeywords;
+		const sourceCode = context.sourceCode;
+
+		let allowPattern;
+
+		if (options.allowPattern) {
+			allowPattern = new RegExp(options.allowPattern, "u");
+		}
+
+		/**
+		 * Check if the property is valid dot notation
+		 * @param {ASTNode} node The dot notation node
+		 * @param {string|boolean|null} value Value which is to be checked
+		 * @returns {void}
+		 */
+		function checkComputedProperty(node, value) {
+			if (
+				validIdentifier.test(value) &&
+				(allowKeywords || !keywords.includes(String(value))) &&
+				!(allowPattern && allowPattern.test(value))
+			) {
+				const formattedValue =
+					node.property.type === "Literal"
+						? JSON.stringify(value)
+						: `\`${value}\``;
+
+				context.report({
+					node: node.property,
+					messageId: "useDot",
+					data: {
+						key: formattedValue,
+					},
+					*fix(fixer) {
+						const leftBracket = sourceCode.getTokenAfter(
+							node.object,
+							astUtils.isOpeningBracketToken,
+						);
+						const rightBracket = sourceCode.getLastToken(node);
+						const nextToken = sourceCode.getTokenAfter(node);
+
+						// Don't perform any fixes if there are comments inside the brackets.
+						if (
+							sourceCode.commentsExistBetween(
+								leftBracket,
+								rightBracket,
+							)
+						) {
+							return;
+						}
+
+						// Replace the brackets by an identifier.
+						if (!node.optional) {
+							yield fixer.insertTextBefore(
+								leftBracket,
+								astUtils.isDecimalInteger(node.object)
+									? " ."
+									: ".",
+							);
+						}
+						yield fixer.replaceTextRange(
+							[leftBracket.range[0], rightBracket.range[1]],
+							String(value),
+						);
+
+						// Insert a space after the property if it will be connected to the next token.
+						if (
+							nextToken &&
+							rightBracket.range[1] === nextToken.range[0] &&
+							!astUtils.canTokensBeAdjacent(
+								String(value),
+								nextToken,
+							)
+						) {
+							yield fixer.insertTextAfter(node, " ");
+						}
+					},
+				});
+			}
+		}
+
+		return {
+			MemberExpression(node) {
+				if (
+					node.computed &&
+					node.property.type === "Literal" &&
+					(literalTypesToCheck.has(typeof node.property.value) ||
+						astUtils.isNullLiteral(node.property))
+				) {
+					checkComputedProperty(node, node.property.value);
+				}
+				if (
+					node.computed &&
+					astUtils.isStaticTemplateLiteral(node.property)
+				) {
+					checkComputedProperty(
+						node,
+						node.property.quasis[0].value.cooked,
+					);
+				}
+				if (
+					!allowKeywords &&
+					!node.computed &&
+					node.property.type === "Identifier" &&
+					keywords.includes(String(node.property.name))
+				) {
+					context.report({
+						node: node.property,
+						messageId: "useBrackets",
+						data: {
+							key: node.property.name,
+						},
+						*fix(fixer) {
+							const dotToken = sourceCode.getTokenBefore(
+								node.property,
+							);
+
+							// A statement that starts with `let[` is parsed as a destructuring variable declaration, not a MemberExpression.
+							if (
+								node.object.type === "Identifier" &&
+								node.object.name === "let" &&
+								!node.optional
+							) {
+								return;
+							}
+
+							// Don't perform any fixes if there are comments between the dot and the property name.
+							if (
+								sourceCode.commentsExistBetween(
+									dotToken,
+									node.property,
+								)
+							) {
+								return;
+							}
+
+							// Replace the identifier to brackets.
+							if (!node.optional) {
+								yield fixer.remove(dotToken);
+							}
+							yield fixer.replaceText(
+								node.property,
+								`["${node.property.name}"]`,
+							);
+						},
+					});
+				}
+			},
+		};
+	},
+};

package/lib/rules/eol-last.js

@@ -0,0 +1,135 @@
+/**
+ * @fileoverview Require or disallow newline at the end of files
+ * @author Nodeca Team <https://github.com/nodeca>
+ * @deprecated in ESLint v8.53.0
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	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: "eol-last",
+						url: "https://eslint.style/rules/eol-last",
+					},
+				},
+			],
+		},
+		type: "layout",
+
+		docs: {
+			description: "Require or disallow newline at the end of files",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/eol-last",
+		},
+
+		fixable: "whitespace",
+
+		schema: [
+			{
+				enum: ["always", "never", "unix", "windows"],
+			},
+		],
+
+		messages: {
+			missing: "Newline required at end of file but not found.",
+			unexpected: "Newline not allowed at end of file.",
+		},
+	},
+	create(context) {
+		//--------------------------------------------------------------------------
+		// Public
+		//--------------------------------------------------------------------------
+
+		return {
+			Program: function checkBadEOF(node) {
+				const sourceCode = context.sourceCode,
+					src = sourceCode.getText(),
+					lastLine = sourceCode.lines.at(-1),
+					location = {
+						column: lastLine.length,
+						line: sourceCode.lines.length,
+					},
+					LF = "\n",
+					CRLF = `\r${LF}`,
+					endsWithNewline = src.endsWith(LF);
+
+				/*
+				 * Empty source is always valid: No content in file so we don't
+				 * need to lint for a newline on the last line of content.
+				 */
+				if (!src.length) {
+					return;
+				}
+
+				let mode = context.options[0] || "always",
+					appendCRLF = false;
+
+				if (mode === "unix") {
+					// `"unix"` should behave exactly as `"always"`
+					mode = "always";
+				}
+				if (mode === "windows") {
+					// `"windows"` should behave exactly as `"always"`, but append CRLF in the fixer for backwards compatibility
+					mode = "always";
+					appendCRLF = true;
+				}
+				if (mode === "always" && !endsWithNewline) {
+					// File is not newline-terminated, but should be
+					context.report({
+						node,
+						loc: location,
+						messageId: "missing",
+						fix(fixer) {
+							return fixer.insertTextAfterRange(
+								[0, src.length],
+								appendCRLF ? CRLF : LF,
+							);
+						},
+					});
+				} else if (mode === "never" && endsWithNewline) {
+					const secondLastLine = sourceCode.lines.at(-2);
+
+					// File is newline-terminated, but shouldn't be
+					context.report({
+						node,
+						loc: {
+							start: {
+								line: sourceCode.lines.length - 1,
+								column: secondLastLine.length,
+							},
+							end: { line: sourceCode.lines.length, column: 0 },
+						},
+						messageId: "unexpected",
+						fix(fixer) {
+							const finalEOLs = /(?:\r?\n)+$/u,
+								match = finalEOLs.exec(sourceCode.text),
+								start = match.index,
+								end = sourceCode.text.length;
+
+							return fixer.replaceTextRange([start, end], "");
+						},
+					});
+				}
+			},
+		};
+	},
+};

package/lib/rules/eqeqeq.js

@@ -0,0 +1,210 @@
+/**
+ * @fileoverview Rule to flag statements that use != and == instead of !== and ===
+ * @author Nicholas C. Zakas
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "suggestion",
+		hasSuggestions: true,
+
+		docs: {
+			description: "Require the use of `===` and `!==`",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/eqeqeq",
+		},
+
+		schema: {
+			anyOf: [
+				{
+					type: "array",
+					items: [
+						{
+							enum: ["always"],
+						},
+						{
+							type: "object",
+							properties: {
+								null: {
+									enum: ["always", "never", "ignore"],
+								},
+							},
+							additionalProperties: false,
+						},
+					],
+					additionalItems: false,
+				},
+				{
+					type: "array",
+					items: [
+						{
+							enum: ["smart", "allow-null"],
+						},
+					],
+					additionalItems: false,
+				},
+			],
+		},
+
+		fixable: "code",
+
+		messages: {
+			unexpected:
+				"Expected '{{expectedOperator}}' and instead saw '{{actualOperator}}'.",
+			replaceOperator:
+				"Use '{{expectedOperator}}' instead of '{{actualOperator}}'.",
+		},
+	},
+
+	create(context) {
+		const config = context.options[0] || "always";
+		const options = context.options[1] || {};
+		const sourceCode = context.sourceCode;
+
+		const nullOption =
+			config === "always" ? options.null || "always" : "ignore";
+		const enforceRuleForNull = nullOption === "always";
+		const enforceInverseRuleForNull = nullOption === "never";
+
+		/**
+		 * Checks if an expression is a typeof expression
+		 * @param {ASTNode} node The node to check
+		 * @returns {boolean} if the node is a typeof expression
+		 */
+		function isTypeOf(node) {
+			return (
+				node.type === "UnaryExpression" && node.operator === "typeof"
+			);
+		}
+
+		/**
+		 * Checks if either operand of a binary expression is a typeof operation
+		 * @param {ASTNode} node The node to check
+		 * @returns {boolean} if one of the operands is typeof
+		 * @private
+		 */
+		function isTypeOfBinary(node) {
+			return isTypeOf(node.left) || isTypeOf(node.right);
+		}
+
+		/**
+		 * Checks if operands are literals of the same type (via typeof)
+		 * @param {ASTNode} node The node to check
+		 * @returns {boolean} if operands are of same type
+		 * @private
+		 */
+		function areLiteralsAndSameType(node) {
+			return (
+				node.left.type === "Literal" &&
+				node.right.type === "Literal" &&
+				typeof node.left.value === typeof node.right.value
+			);
+		}
+
+		/**
+		 * Checks if one of the operands is a literal null
+		 * @param {ASTNode} node The node to check
+		 * @returns {boolean} if operands are null
+		 * @private
+		 */
+		function isNullCheck(node) {
+			return (
+				astUtils.isNullLiteral(node.right) ||
+				astUtils.isNullLiteral(node.left)
+			);
+		}
+
+		/**
+		 * Reports a message for this rule.
+		 * @param {ASTNode} node The binary expression node that was checked
+		 * @param {string} expectedOperator The operator that was expected (either '==', '!=', '===', or '!==')
+		 * @returns {void}
+		 * @private
+		 */
+		function report(node, expectedOperator) {
+			const operatorToken = sourceCode.getFirstTokenBetween(
+				node.left,
+				node.right,
+				token => token.value === node.operator,
+			);
+
+			const commonReportParams = {
+				node,
+				loc: operatorToken.loc,
+				messageId: "unexpected",
+				data: { expectedOperator, actualOperator: node.operator },
+			};
+
+			if (isTypeOfBinary(node) || areLiteralsAndSameType(node)) {
+				context.report({
+					...commonReportParams,
+					fix(fixer) {
+						return fixer.replaceText(
+							operatorToken,
+							expectedOperator,
+						);
+					},
+				});
+			} else {
+				context.report({
+					...commonReportParams,
+					suggest: [
+						{
+							messageId: "replaceOperator",
+							data: {
+								expectedOperator,
+								actualOperator: node.operator,
+							},
+							fix: fixer =>
+								fixer.replaceText(
+									operatorToken,
+									expectedOperator,
+								),
+						},
+					],
+				});
+			}
+		}
+
+		return {
+			BinaryExpression(node) {
+				const isNull = isNullCheck(node);
+
+				if (node.operator !== "==" && node.operator !== "!=") {
+					if (enforceInverseRuleForNull && isNull) {
+						report(node, node.operator.slice(0, -1));
+					}
+					return;
+				}
+
+				if (
+					config === "smart" &&
+					(isTypeOfBinary(node) ||
+						areLiteralsAndSameType(node) ||
+						isNull)
+				) {
+					return;
+				}
+
+				if (!enforceRuleForNull && isNull) {
+					return;
+				}
+
+				report(node, `${node.operator}=`);
+			},
+		};
+	},
+};