@alexlit/lint-kit 166.1.0 → 167.0.0

package/packages/config-eslint/node_modules/eslint/lib/rules/max-statements-per-line.js

@@ -1,224 +0,0 @@
-/**
- * @fileoverview Specify the maximum number of statements allowed per line.
- * @author Kenneth Williams
- * @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: "max-statements-per-line",
-						url: "https://eslint.style/rules/max-statements-per-line",
-					},
-				},
-			],
-		},
-		type: "layout",
-
-		docs: {
-			description:
-				"Enforce a maximum number of statements allowed per line",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/max-statements-per-line",
-		},
-
-		schema: [
-			{
-				type: "object",
-				properties: {
-					max: {
-						type: "integer",
-						minimum: 1,
-						default: 1,
-					},
-				},
-				additionalProperties: false,
-			},
-		],
-		messages: {
-			exceed: "This line has {{numberOfStatementsOnThisLine}} {{statements}}. Maximum allowed is {{maxStatementsPerLine}}.",
-		},
-	},
-
-	create(context) {
-		const sourceCode = context.sourceCode,
-			options = context.options[0] || {},
-			maxStatementsPerLine =
-				typeof options.max !== "undefined" ? options.max : 1;
-
-		let lastStatementLine = 0,
-			numberOfStatementsOnThisLine = 0,
-			firstExtraStatement;
-
-		//--------------------------------------------------------------------------
-		// Helpers
-		//--------------------------------------------------------------------------
-
-		const SINGLE_CHILD_ALLOWED =
-			/^(?:(?:DoWhile|For|ForIn|ForOf|If|Labeled|While)Statement|Export(?:Default|Named)Declaration)$/u;
-
-		/**
-		 * Reports with the first extra statement, and clears it.
-		 * @returns {void}
-		 */
-		function reportFirstExtraStatementAndClear() {
-			if (firstExtraStatement) {
-				context.report({
-					node: firstExtraStatement,
-					messageId: "exceed",
-					data: {
-						numberOfStatementsOnThisLine,
-						maxStatementsPerLine,
-						statements:
-							numberOfStatementsOnThisLine === 1
-								? "statement"
-								: "statements",
-					},
-				});
-			}
-			firstExtraStatement = null;
-		}
-
-		/**
-		 * Gets the actual last token of a given node.
-		 * @param {ASTNode} node A node to get. This is a node except EmptyStatement.
-		 * @returns {Token} The actual last token.
-		 */
-		function getActualLastToken(node) {
-			return sourceCode.getLastToken(node, astUtils.isNotSemicolonToken);
-		}
-
-		/**
-		 * Addresses a given node.
-		 * It updates the state of this rule, then reports the node if the node violated this rule.
-		 * @param {ASTNode} node A node to check.
-		 * @returns {void}
-		 */
-		function enterStatement(node) {
-			const line = node.loc.start.line;
-
-			/*
-			 * Skip to allow non-block statements if this is direct child of control statements.
-			 * `if (a) foo();` is counted as 1.
-			 * But `if (a) foo(); else foo();` should be counted as 2.
-			 */
-			if (
-				SINGLE_CHILD_ALLOWED.test(node.parent.type) &&
-				node.parent.alternate !== node
-			) {
-				return;
-			}
-
-			// Update state.
-			if (line === lastStatementLine) {
-				numberOfStatementsOnThisLine += 1;
-			} else {
-				reportFirstExtraStatementAndClear();
-				numberOfStatementsOnThisLine = 1;
-				lastStatementLine = line;
-			}
-
-			// Reports if the node violated this rule.
-			if (numberOfStatementsOnThisLine === maxStatementsPerLine + 1) {
-				firstExtraStatement = firstExtraStatement || node;
-			}
-		}
-
-		/**
-		 * Updates the state of this rule with the end line of leaving node to check with the next statement.
-		 * @param {ASTNode} node A node to check.
-		 * @returns {void}
-		 */
-		function leaveStatement(node) {
-			const line = getActualLastToken(node).loc.end.line;
-
-			// Update state.
-			if (line !== lastStatementLine) {
-				reportFirstExtraStatementAndClear();
-				numberOfStatementsOnThisLine = 1;
-				lastStatementLine = line;
-			}
-		}
-
-		//--------------------------------------------------------------------------
-		// Public API
-		//--------------------------------------------------------------------------
-
-		return {
-			BreakStatement: enterStatement,
-			ClassDeclaration: enterStatement,
-			ContinueStatement: enterStatement,
-			DebuggerStatement: enterStatement,
-			DoWhileStatement: enterStatement,
-			ExpressionStatement: enterStatement,
-			ForInStatement: enterStatement,
-			ForOfStatement: enterStatement,
-			ForStatement: enterStatement,
-			FunctionDeclaration: enterStatement,
-			IfStatement: enterStatement,
-			ImportDeclaration: enterStatement,
-			LabeledStatement: enterStatement,
-			ReturnStatement: enterStatement,
-			SwitchStatement: enterStatement,
-			ThrowStatement: enterStatement,
-			TryStatement: enterStatement,
-			VariableDeclaration: enterStatement,
-			WhileStatement: enterStatement,
-			WithStatement: enterStatement,
-			ExportNamedDeclaration: enterStatement,
-			ExportDefaultDeclaration: enterStatement,
-			ExportAllDeclaration: enterStatement,
-
-			"BreakStatement:exit": leaveStatement,
-			"ClassDeclaration:exit": leaveStatement,
-			"ContinueStatement:exit": leaveStatement,
-			"DebuggerStatement:exit": leaveStatement,
-			"DoWhileStatement:exit": leaveStatement,
-			"ExpressionStatement:exit": leaveStatement,
-			"ForInStatement:exit": leaveStatement,
-			"ForOfStatement:exit": leaveStatement,
-			"ForStatement:exit": leaveStatement,
-			"FunctionDeclaration:exit": leaveStatement,
-			"IfStatement:exit": leaveStatement,
-			"ImportDeclaration:exit": leaveStatement,
-			"LabeledStatement:exit": leaveStatement,
-			"ReturnStatement:exit": leaveStatement,
-			"SwitchStatement:exit": leaveStatement,
-			"ThrowStatement:exit": leaveStatement,
-			"TryStatement:exit": leaveStatement,
-			"VariableDeclaration:exit": leaveStatement,
-			"WhileStatement:exit": leaveStatement,
-			"WithStatement:exit": leaveStatement,
-			"ExportNamedDeclaration:exit": leaveStatement,
-			"ExportDefaultDeclaration:exit": leaveStatement,
-			"ExportAllDeclaration:exit": leaveStatement,
-			"Program:exit": reportFirstExtraStatementAndClear,
-		};
-	},
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/max-statements.js

@@ -1,188 +0,0 @@
-/**
- * @fileoverview A rule to set the maximum number of statements in a function.
- * @author Ian Christian Myers
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-const { upperCaseFirst } = require("../shared/string-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-
-		docs: {
-			description:
-				"Enforce a maximum number of statements allowed in function blocks",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/max-statements",
-		},
-
-		schema: [
-			{
-				oneOf: [
-					{
-						type: "integer",
-						minimum: 0,
-					},
-					{
-						type: "object",
-						properties: {
-							maximum: {
-								type: "integer",
-								minimum: 0,
-							},
-							max: {
-								type: "integer",
-								minimum: 0,
-							},
-						},
-						additionalProperties: false,
-					},
-				],
-			},
-			{
-				type: "object",
-				properties: {
-					ignoreTopLevelFunctions: {
-						type: "boolean",
-					},
-				},
-				additionalProperties: false,
-			},
-		],
-		messages: {
-			exceed: "{{name}} has too many statements ({{count}}). Maximum allowed is {{max}}.",
-		},
-	},
-
-	create(context) {
-		//--------------------------------------------------------------------------
-		// Helpers
-		//--------------------------------------------------------------------------
-
-		const functionStack = [],
-			option = context.options[0],
-			ignoreTopLevelFunctions =
-				(context.options[1] &&
-					context.options[1].ignoreTopLevelFunctions) ||
-				false,
-			topLevelFunctions = [];
-		let maxStatements = 10;
-
-		if (
-			typeof option === "object" &&
-			(Object.hasOwn(option, "maximum") || Object.hasOwn(option, "max"))
-		) {
-			maxStatements = option.maximum || option.max;
-		} else if (typeof option === "number") {
-			maxStatements = option;
-		}
-
-		/**
-		 * Reports a node if it has too many statements
-		 * @param {ASTNode} node node to evaluate
-		 * @param {number} count Number of statements in node
-		 * @param {number} max Maximum number of statements allowed
-		 * @returns {void}
-		 * @private
-		 */
-		function reportIfTooManyStatements(node, count, max) {
-			if (count > max) {
-				const name = upperCaseFirst(
-					astUtils.getFunctionNameWithKind(node),
-				);
-
-				context.report({
-					node,
-					messageId: "exceed",
-					data: { name, count, max },
-				});
-			}
-		}
-
-		/**
-		 * When parsing a new function, store it in our function stack
-		 * @returns {void}
-		 * @private
-		 */
-		function startFunction() {
-			functionStack.push(0);
-		}
-
-		/**
-		 * Evaluate the node at the end of function
-		 * @param {ASTNode} node node to evaluate
-		 * @returns {void}
-		 * @private
-		 */
-		function endFunction(node) {
-			const count = functionStack.pop();
-
-			/*
-			 * This rule does not apply to class static blocks, but we have to track them so
-			 * that statements in them do not count as statements in the enclosing function.
-			 */
-			if (node.type === "StaticBlock") {
-				return;
-			}
-
-			if (ignoreTopLevelFunctions && functionStack.length === 0) {
-				topLevelFunctions.push({ node, count });
-			} else {
-				reportIfTooManyStatements(node, count, maxStatements);
-			}
-		}
-
-		/**
-		 * Increment the count of the functions
-		 * @param {ASTNode} node node to evaluate
-		 * @returns {void}
-		 * @private
-		 */
-		function countStatements(node) {
-			functionStack[functionStack.length - 1] += node.body.length;
-		}
-
-		//--------------------------------------------------------------------------
-		// Public API
-		//--------------------------------------------------------------------------
-
-		return {
-			FunctionDeclaration: startFunction,
-			FunctionExpression: startFunction,
-			ArrowFunctionExpression: startFunction,
-			StaticBlock: startFunction,
-
-			BlockStatement: countStatements,
-
-			"FunctionDeclaration:exit": endFunction,
-			"FunctionExpression:exit": endFunction,
-			"ArrowFunctionExpression:exit": endFunction,
-			"StaticBlock:exit": endFunction,
-
-			"Program:exit"() {
-				if (topLevelFunctions.length === 1) {
-					return;
-				}
-
-				topLevelFunctions.forEach(element => {
-					const count = element.count;
-					const node = element.node;
-
-					reportIfTooManyStatements(node, count, maxStatements);
-				});
-			},
-		};
-	},
-};