bahlint 28.58.6934

package/lib/rules/no-whitespace-before-property.js

@@ -0,0 +1,150 @@
+/**
+ * @fileoverview Rule to disallow whitespace before properties
+ * @author Kai Cataldo
+ * @deprecated in ESLint v8.53.0
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+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: "no-whitespace-before-property",
+						url: "https://eslint.style/rules/no-whitespace-before-property",
+					},
+				},
+			],
+		},
+		type: "layout",
+
+		docs: {
+			description: "Disallow whitespace before properties",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/no-whitespace-before-property",
+		},
+
+		fixable: "whitespace",
+		schema: [],
+
+		messages: {
+			unexpectedWhitespace:
+				"Unexpected whitespace before property {{propName}}.",
+		},
+	},
+
+	create(context) {
+		const sourceCode = context.sourceCode;
+
+		//--------------------------------------------------------------------------
+		// Helpers
+		//--------------------------------------------------------------------------
+
+		/**
+		 * Reports whitespace before property token
+		 * @param {ASTNode} node the node to report in the event of an error
+		 * @param {Token} leftToken the left token
+		 * @param {Token} rightToken the right token
+		 * @returns {void}
+		 * @private
+		 */
+		function reportError(node, leftToken, rightToken) {
+			context.report({
+				node,
+				messageId: "unexpectedWhitespace",
+				data: {
+					propName: sourceCode.getText(node.property),
+				},
+				fix(fixer) {
+					let replacementText = "";
+
+					if (
+						!node.computed &&
+						!node.optional &&
+						astUtils.isDecimalInteger(node.object)
+					) {
+						/*
+						 * If the object is a number literal, fixing it to something like 5.toString() would cause a SyntaxError.
+						 * Don't fix this case.
+						 */
+						return null;
+					}
+
+					// Don't fix if comments exist.
+					if (
+						sourceCode.commentsExistBetween(leftToken, rightToken)
+					) {
+						return null;
+					}
+
+					if (node.optional) {
+						replacementText = "?.";
+					} else if (!node.computed) {
+						replacementText = ".";
+					}
+
+					return fixer.replaceTextRange(
+						[leftToken.range[1], rightToken.range[0]],
+						replacementText,
+					);
+				},
+			});
+		}
+
+		//--------------------------------------------------------------------------
+		// Public
+		//--------------------------------------------------------------------------
+
+		return {
+			MemberExpression(node) {
+				let rightToken;
+				let leftToken;
+
+				if (!astUtils.isTokenOnSameLine(node.object, node.property)) {
+					return;
+				}
+
+				if (node.computed) {
+					rightToken = sourceCode.getTokenBefore(
+						node.property,
+						astUtils.isOpeningBracketToken,
+					);
+					leftToken = sourceCode.getTokenBefore(
+						rightToken,
+						node.optional ? 1 : 0,
+					);
+				} else {
+					rightToken = sourceCode.getFirstToken(node.property);
+					leftToken = sourceCode.getTokenBefore(rightToken, 1);
+				}
+
+				if (sourceCode.isSpaceBetween(leftToken, rightToken)) {
+					reportError(node, leftToken, rightToken);
+				}
+			},
+		};
+	},
+};

package/lib/rules/no-with.js

@@ -0,0 +1,37 @@
+/**
+ * @fileoverview Rule to flag use of with statement
+ * @author Nicholas C. Zakas
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "suggestion",
+
+		docs: {
+			description: "Disallow `with` statements",
+			recommended: true,
+			url: "https://eslint.org/docs/latest/rules/no-with",
+		},
+
+		schema: [],
+
+		messages: {
+			unexpectedWith: "Unexpected use of 'with' statement.",
+		},
+	},
+
+	create(context) {
+		return {
+			WithStatement(node) {
+				context.report({ node, messageId: "unexpectedWith" });
+			},
+		};
+	},
+};

package/lib/rules/nonblock-statement-body-position.js

@@ -0,0 +1,164 @@
+/**
+ * @fileoverview enforce the location of single-line statements
+ * @author Teddy Katz
+ * @deprecated in ESLint v8.53.0
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+const POSITION_SCHEMA = { enum: ["beside", "below", "any"] };
+
+/** @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: "nonblock-statement-body-position",
+						url: "https://eslint.style/rules/nonblock-statement-body-position",
+					},
+				},
+			],
+		},
+		type: "layout",
+
+		docs: {
+			description: "Enforce the location of single-line statements",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/nonblock-statement-body-position",
+		},
+
+		fixable: "whitespace",
+
+		schema: [
+			POSITION_SCHEMA,
+			{
+				properties: {
+					overrides: {
+						properties: {
+							if: POSITION_SCHEMA,
+							else: POSITION_SCHEMA,
+							while: POSITION_SCHEMA,
+							do: POSITION_SCHEMA,
+							for: POSITION_SCHEMA,
+						},
+						additionalProperties: false,
+					},
+				},
+				additionalProperties: false,
+			},
+		],
+
+		messages: {
+			expectNoLinebreak: "Expected no linebreak before this statement.",
+			expectLinebreak: "Expected a linebreak before this statement.",
+		},
+	},
+
+	create(context) {
+		const sourceCode = context.sourceCode;
+
+		//----------------------------------------------------------------------
+		// Helpers
+		//----------------------------------------------------------------------
+
+		/**
+		 * Gets the applicable preference for a particular keyword
+		 * @param {string} keywordName The name of a keyword, e.g. 'if'
+		 * @returns {string} The applicable option for the keyword, e.g. 'beside'
+		 */
+		function getOption(keywordName) {
+			return (
+				(context.options[1] &&
+					context.options[1].overrides &&
+					context.options[1].overrides[keywordName]) ||
+				context.options[0] ||
+				"beside"
+			);
+		}
+
+		/**
+		 * Validates the location of a single-line statement
+		 * @param {ASTNode} node The single-line statement
+		 * @param {string} keywordName The applicable keyword name for the single-line statement
+		 * @returns {void}
+		 */
+		function validateStatement(node, keywordName) {
+			const option = getOption(keywordName);
+
+			if (node.type === "BlockStatement" || option === "any") {
+				return;
+			}
+
+			const tokenBefore = sourceCode.getTokenBefore(node);
+
+			if (
+				tokenBefore.loc.end.line === node.loc.start.line &&
+				option === "below"
+			) {
+				context.report({
+					node,
+					messageId: "expectLinebreak",
+					fix: fixer => fixer.insertTextBefore(node, "\n"),
+				});
+			} else if (
+				tokenBefore.loc.end.line !== node.loc.start.line &&
+				option === "beside"
+			) {
+				context.report({
+					node,
+					messageId: "expectNoLinebreak",
+					fix(fixer) {
+						if (
+							sourceCode
+								.getText()
+								.slice(tokenBefore.range[1], node.range[0])
+								.trim()
+						) {
+							return null;
+						}
+						return fixer.replaceTextRange(
+							[tokenBefore.range[1], node.range[0]],
+							" ",
+						);
+					},
+				});
+			}
+		}
+
+		//----------------------------------------------------------------------
+		// Public
+		//----------------------------------------------------------------------
+
+		return {
+			IfStatement(node) {
+				validateStatement(node.consequent, "if");
+
+				// Check the `else` node, but don't check 'else if' statements.
+				if (node.alternate && node.alternate.type !== "IfStatement") {
+					validateStatement(node.alternate, "else");
+				}
+			},
+			WhileStatement: node => validateStatement(node.body, "while"),
+			DoWhileStatement: node => validateStatement(node.body, "do"),
+			ForStatement: node => validateStatement(node.body, "for"),
+			ForInStatement: node => validateStatement(node.body, "for"),
+			ForOfStatement: node => validateStatement(node.body, "for"),
+		};
+	},
+};