bahlint 28.58.6934

package/lib/rules/arrow-spacing.js

@@ -0,0 +1,188 @@
+/**
+ * @fileoverview Rule to define spacing before/after arrow function's arrow.
+ * @author Jxck
+ * @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: "arrow-spacing",
+						url: "https://eslint.style/rules/arrow-spacing",
+					},
+				},
+			],
+		},
+		type: "layout",
+
+		docs: {
+			description:
+				"Enforce consistent spacing before and after the arrow in arrow functions",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/arrow-spacing",
+		},
+
+		fixable: "whitespace",
+
+		schema: [
+			{
+				type: "object",
+				properties: {
+					before: {
+						type: "boolean",
+						default: true,
+					},
+					after: {
+						type: "boolean",
+						default: true,
+					},
+				},
+				additionalProperties: false,
+			},
+		],
+
+		messages: {
+			expectedBefore: "Missing space before =>.",
+			unexpectedBefore: "Unexpected space before =>.",
+
+			expectedAfter: "Missing space after =>.",
+			unexpectedAfter: "Unexpected space after =>.",
+		},
+	},
+
+	create(context) {
+		// merge rules with default
+		const rule = Object.assign({}, context.options[0]);
+
+		rule.before = rule.before !== false;
+		rule.after = rule.after !== false;
+
+		const sourceCode = context.sourceCode;
+
+		/**
+		 * Get tokens of arrow(`=>`) and before/after arrow.
+		 * @param {ASTNode} node The arrow function node.
+		 * @returns {Object} Tokens of arrow and before/after arrow.
+		 */
+		function getTokens(node) {
+			const arrow = sourceCode.getTokenBefore(
+				node.body,
+				astUtils.isArrowToken,
+			);
+
+			return {
+				before: sourceCode.getTokenBefore(arrow),
+				arrow,
+				after: sourceCode.getTokenAfter(arrow),
+			};
+		}
+
+		/**
+		 * Count spaces before/after arrow(`=>`) token.
+		 * @param {Object} tokens Tokens before/after arrow.
+		 * @returns {Object} count of space before/after arrow.
+		 */
+		function countSpaces(tokens) {
+			const before = tokens.arrow.range[0] - tokens.before.range[1];
+			const after = tokens.after.range[0] - tokens.arrow.range[1];
+
+			return { before, after };
+		}
+
+		/**
+		 * Determines whether space(s) before after arrow(`=>`) is satisfy rule.
+		 * if before/after value is `true`, there should be space(s).
+		 * if before/after value is `false`, there should be no space.
+		 * @param {ASTNode} node The arrow function node.
+		 * @returns {void}
+		 */
+		function spaces(node) {
+			const tokens = getTokens(node);
+			const countSpace = countSpaces(tokens);
+
+			if (rule.before) {
+				// should be space(s) before arrow
+				if (countSpace.before === 0) {
+					context.report({
+						node: tokens.before,
+						messageId: "expectedBefore",
+						fix(fixer) {
+							return fixer.insertTextBefore(tokens.arrow, " ");
+						},
+					});
+				}
+			} else {
+				// should be no space before arrow
+				if (countSpace.before > 0) {
+					context.report({
+						node: tokens.before,
+						messageId: "unexpectedBefore",
+						fix(fixer) {
+							return fixer.removeRange([
+								tokens.before.range[1],
+								tokens.arrow.range[0],
+							]);
+						},
+					});
+				}
+			}
+
+			if (rule.after) {
+				// should be space(s) after arrow
+				if (countSpace.after === 0) {
+					context.report({
+						node: tokens.after,
+						messageId: "expectedAfter",
+						fix(fixer) {
+							return fixer.insertTextAfter(tokens.arrow, " ");
+						},
+					});
+				}
+			} else {
+				// should be no space after arrow
+				if (countSpace.after > 0) {
+					context.report({
+						node: tokens.after,
+						messageId: "unexpectedAfter",
+						fix(fixer) {
+							return fixer.removeRange([
+								tokens.arrow.range[1],
+								tokens.after.range[0],
+							]);
+						},
+					});
+				}
+			}
+		}
+
+		return {
+			ArrowFunctionExpression: spaces,
+		};
+	},
+};

package/lib/rules/block-scoped-var.js

@@ -0,0 +1,137 @@
+/**
+ * @fileoverview Rule to check for "block scoped" variables by binding context
+ * @author Matt DuVall <http://www.mattduvall.com>
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "suggestion",
+
+		docs: {
+			description:
+				"Enforce the use of variables within the scope they are defined",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/block-scoped-var",
+		},
+
+		schema: [],
+
+		messages: {
+			outOfScope:
+				"'{{name}}' declared on line {{definitionLine}} column {{definitionColumn}} is used outside of binding context.",
+		},
+	},
+
+	create(context) {
+		let stack = [];
+		const sourceCode = context.sourceCode;
+
+		/**
+		 * Makes a block scope.
+		 * @param {ASTNode} node A node of a scope.
+		 * @returns {void}
+		 */
+		function enterScope(node) {
+			stack.push(node.range);
+		}
+
+		/**
+		 * Pops the last block scope.
+		 * @returns {void}
+		 */
+		function exitScope() {
+			stack.pop();
+		}
+
+		/**
+		 * Reports a given reference.
+		 * @param {eslint-scope.Reference} reference A reference to report.
+		 * @param {eslint-scope.Definition} definition A definition for which to report reference.
+		 * @returns {void}
+		 */
+		function report(reference, definition) {
+			const identifier = reference.identifier;
+			const definitionPosition = definition.name.loc.start;
+
+			context.report({
+				node: identifier,
+				messageId: "outOfScope",
+				data: {
+					name: identifier.name,
+					definitionLine: definitionPosition.line,
+					definitionColumn: definitionPosition.column + 1,
+				},
+			});
+		}
+
+		/**
+		 * Finds and reports references which are outside of valid scopes.
+		 * @param {ASTNode} node A node to get variables.
+		 * @returns {void}
+		 */
+		function checkForVariables(node) {
+			if (node.kind !== "var") {
+				return;
+			}
+
+			// Defines a predicate to check whether or not a given reference is outside of valid scope.
+			const scopeRange = stack.at(-1);
+
+			/**
+			 * Check if a reference is out of scope
+			 * @param {ASTNode} reference node to examine
+			 * @returns {boolean} True is its outside the scope
+			 * @private
+			 */
+			function isOutsideOfScope(reference) {
+				const idRange = reference.identifier.range;
+
+				return idRange[0] < scopeRange[0] || idRange[1] > scopeRange[1];
+			}
+
+			// Gets declared variables, and checks its references.
+			const variables = sourceCode.getDeclaredVariables(node);
+
+			for (let i = 0; i < variables.length; ++i) {
+				// Reports.
+				variables[i].references.filter(isOutsideOfScope).forEach(ref =>
+					report(
+						ref,
+						variables[i].defs.find(def => def.parent === node),
+					),
+				);
+			}
+		}
+
+		return {
+			Program(node) {
+				stack = [node.range];
+			},
+
+			// Manages scopes.
+			BlockStatement: enterScope,
+			"BlockStatement:exit": exitScope,
+			ForStatement: enterScope,
+			"ForStatement:exit": exitScope,
+			ForInStatement: enterScope,
+			"ForInStatement:exit": exitScope,
+			ForOfStatement: enterScope,
+			"ForOfStatement:exit": exitScope,
+			SwitchStatement: enterScope,
+			"SwitchStatement:exit": exitScope,
+			CatchClause: enterScope,
+			"CatchClause:exit": exitScope,
+			StaticBlock: enterScope,
+			"StaticBlock:exit": exitScope,
+
+			// Finds and reports references which are outside of valid scope.
+			VariableDeclaration: checkForVariables,
+		};
+	},
+};

package/lib/rules/block-spacing.js

@@ -0,0 +1,202 @@
+/**
+ * @fileoverview A rule to disallow or enforce spaces inside of single line blocks.
+ * @author Toru Nagashima
+ * @deprecated in ESLint v8.53.0
+ */
+
+"use strict";
+
+const util = 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: "block-spacing",
+						url: "https://eslint.style/rules/block-spacing",
+					},
+				},
+			],
+		},
+		type: "layout",
+
+		docs: {
+			description:
+				"Disallow or enforce spaces inside of blocks after opening block and before closing block",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/block-spacing",
+		},
+
+		fixable: "whitespace",
+
+		schema: [{ enum: ["always", "never"] }],
+
+		messages: {
+			missing: "Requires a space {{location}} '{{token}}'.",
+			extra: "Unexpected space(s) {{location}} '{{token}}'.",
+		},
+	},
+
+	create(context) {
+		const always = context.options[0] !== "never",
+			messageId = always ? "missing" : "extra",
+			sourceCode = context.sourceCode;
+
+		/**
+		 * Gets the open brace token from a given node.
+		 * @param {ASTNode} node A BlockStatement/StaticBlock/SwitchStatement node to get.
+		 * @returns {Token} The token of the open brace.
+		 */
+		function getOpenBrace(node) {
+			if (node.type === "SwitchStatement") {
+				if (node.cases.length > 0) {
+					return sourceCode.getTokenBefore(node.cases[0]);
+				}
+				return sourceCode.getLastToken(node, 1);
+			}
+
+			if (node.type === "StaticBlock") {
+				return sourceCode.getFirstToken(node, { skip: 1 }); // skip the `static` token
+			}
+
+			// "BlockStatement"
+			return sourceCode.getFirstToken(node);
+		}
+
+		/**
+		 * Checks whether or not:
+		 *   - given tokens are on same line.
+		 *   - there is/isn't a space between given tokens.
+		 * @param {Token} left A token to check.
+		 * @param {Token} right The token which is next to `left`.
+		 * @returns {boolean}
+		 *    When the option is `"always"`, `true` if there are one or more spaces between given tokens.
+		 *    When the option is `"never"`, `true` if there are not any spaces between given tokens.
+		 *    If given tokens are not on same line, it's always `true`.
+		 */
+		function isValid(left, right) {
+			return (
+				!util.isTokenOnSameLine(left, right) ||
+				sourceCode.isSpaceBetween(left, right) === always
+			);
+		}
+
+		/**
+		 * Checks and reports invalid spacing style inside braces.
+		 * @param {ASTNode} node A BlockStatement/StaticBlock/SwitchStatement node to check.
+		 * @returns {void}
+		 */
+		function checkSpacingInsideBraces(node) {
+			// Gets braces and the first/last token of content.
+			const openBrace = getOpenBrace(node);
+			const closeBrace = sourceCode.getLastToken(node);
+			const firstToken = sourceCode.getTokenAfter(openBrace, {
+				includeComments: true,
+			});
+			const lastToken = sourceCode.getTokenBefore(closeBrace, {
+				includeComments: true,
+			});
+
+			// Skip if the node is invalid or empty.
+			if (
+				openBrace.type !== "Punctuator" ||
+				openBrace.value !== "{" ||
+				closeBrace.type !== "Punctuator" ||
+				closeBrace.value !== "}" ||
+				firstToken === closeBrace
+			) {
+				return;
+			}
+
+			// Skip line comments for option never
+			if (!always && firstToken.type === "Line") {
+				return;
+			}
+
+			// Check.
+			if (!isValid(openBrace, firstToken)) {
+				let loc = openBrace.loc;
+
+				if (messageId === "extra") {
+					loc = {
+						start: openBrace.loc.end,
+						end: firstToken.loc.start,
+					};
+				}
+
+				context.report({
+					node,
+					loc,
+					messageId,
+					data: {
+						location: "after",
+						token: openBrace.value,
+					},
+					fix(fixer) {
+						if (always) {
+							return fixer.insertTextBefore(firstToken, " ");
+						}
+
+						return fixer.removeRange([
+							openBrace.range[1],
+							firstToken.range[0],
+						]);
+					},
+				});
+			}
+			if (!isValid(lastToken, closeBrace)) {
+				let loc = closeBrace.loc;
+
+				if (messageId === "extra") {
+					loc = {
+						start: lastToken.loc.end,
+						end: closeBrace.loc.start,
+					};
+				}
+				context.report({
+					node,
+					loc,
+					messageId,
+					data: {
+						location: "before",
+						token: closeBrace.value,
+					},
+					fix(fixer) {
+						if (always) {
+							return fixer.insertTextAfter(lastToken, " ");
+						}
+
+						return fixer.removeRange([
+							lastToken.range[1],
+							closeBrace.range[0],
+						]);
+					},
+				});
+			}
+		}
+
+		return {
+			BlockStatement: checkSpacingInsideBraces,
+			StaticBlock: checkSpacingInsideBraces,
+			SwitchStatement: checkSpacingInsideBraces,
+		};
+	},
+};