bahlint 28.58.6934

package/lib/rules/max-lines-per-function.js

@@ -0,0 +1,238 @@
+/**
+ * @fileoverview A rule to set the maximum number of line of code in a function.
+ * @author Pete Ward <peteward44@gmail.com>
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+const { upperCaseFirst } = require("../shared/string-utils");
+
+//------------------------------------------------------------------------------
+// Constants
+//------------------------------------------------------------------------------
+
+const OPTIONS_SCHEMA = {
+	type: "object",
+	properties: {
+		max: {
+			type: "integer",
+			minimum: 0,
+		},
+		skipComments: {
+			type: "boolean",
+		},
+		skipBlankLines: {
+			type: "boolean",
+		},
+		IIFEs: {
+			type: "boolean",
+		},
+	},
+	additionalProperties: false,
+};
+
+const OPTIONS_OR_INTEGER_SCHEMA = {
+	oneOf: [
+		OPTIONS_SCHEMA,
+		{
+			type: "integer",
+			minimum: 1,
+		},
+	],
+};
+
+/**
+ * Given a list of comment nodes, return a map with numeric keys (source code line numbers) and comment token values.
+ * @param {Array} comments An array of comment nodes.
+ * @returns {Map<string, Node>} A map with numeric keys (source code line numbers) and comment token values.
+ */
+function getCommentLineNumbers(comments) {
+	const map = new Map();
+
+	comments.forEach(comment => {
+		for (let i = comment.loc.start.line; i <= comment.loc.end.line; i++) {
+			map.set(i, comment);
+		}
+	});
+	return map;
+}
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "suggestion",
+
+		docs: {
+			description:
+				"Enforce a maximum number of lines of code in a function",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/max-lines-per-function",
+		},
+
+		schema: [OPTIONS_OR_INTEGER_SCHEMA],
+		messages: {
+			exceed: "{{name}} has too many lines ({{lineCount}}). Maximum allowed is {{maxLines}}.",
+		},
+	},
+
+	create(context) {
+		const sourceCode = context.sourceCode;
+		const lines = sourceCode.lines;
+
+		const option = context.options[0];
+		let maxLines = 50;
+		let skipComments = false;
+		let skipBlankLines = false;
+		let IIFEs = false;
+
+		if (typeof option === "object") {
+			maxLines = typeof option.max === "number" ? option.max : 50;
+			skipComments = !!option.skipComments;
+			skipBlankLines = !!option.skipBlankLines;
+			IIFEs = !!option.IIFEs;
+		} else if (typeof option === "number") {
+			maxLines = option;
+		}
+
+		const commentLineNumbers = getCommentLineNumbers(
+			sourceCode.getAllComments(),
+		);
+
+		//--------------------------------------------------------------------------
+		// Helpers
+		//--------------------------------------------------------------------------
+
+		/**
+		 * Tells if a comment encompasses the entire line.
+		 * @param {string} line The source line with a trailing comment
+		 * @param {number} lineNumber The one-indexed line number this is on
+		 * @param {ASTNode} comment The comment to remove
+		 * @returns {boolean} If the comment covers the entire line
+		 */
+		function isFullLineComment(line, lineNumber, comment) {
+			const start = comment.loc.start,
+				end = comment.loc.end,
+				isFirstTokenOnLine =
+					start.line === lineNumber &&
+					!line.slice(0, start.column).trim(),
+				isLastTokenOnLine =
+					end.line === lineNumber && !line.slice(end.column).trim();
+
+			return (
+				comment &&
+				(start.line < lineNumber || isFirstTokenOnLine) &&
+				(end.line > lineNumber || isLastTokenOnLine)
+			);
+		}
+
+		/**
+		 * Identifies is a node is a FunctionExpression which is part of an IIFE
+		 * @param {ASTNode} node Node to test
+		 * @returns {boolean} True if it's an IIFE
+		 */
+		function isIIFE(node) {
+			return (
+				(node.type === "FunctionExpression" ||
+					node.type === "ArrowFunctionExpression") &&
+				node.parent &&
+				node.parent.type === "CallExpression" &&
+				node.parent.callee === node
+			);
+		}
+
+		/**
+		 * Identifies is a node is a FunctionExpression which is embedded within a MethodDefinition or Property
+		 * @param {ASTNode} node Node to test
+		 * @returns {boolean} True if it's a FunctionExpression embedded within a MethodDefinition or Property
+		 */
+		function isEmbedded(node) {
+			if (!node.parent) {
+				return false;
+			}
+			if (node !== node.parent.value) {
+				return false;
+			}
+			if (node.parent.type === "MethodDefinition") {
+				return true;
+			}
+			if (node.parent.type === "Property") {
+				return (
+					node.parent.method === true ||
+					node.parent.kind === "get" ||
+					node.parent.kind === "set"
+				);
+			}
+			return false;
+		}
+
+		/**
+		 * Count the lines in the function
+		 * @param {ASTNode} funcNode Function AST node
+		 * @returns {void}
+		 * @private
+		 */
+		function processFunction(funcNode) {
+			const node = isEmbedded(funcNode) ? funcNode.parent : funcNode;
+
+			if (!IIFEs && isIIFE(node)) {
+				return;
+			}
+			let lineCount = 0;
+
+			for (let i = node.loc.start.line - 1; i < node.loc.end.line; ++i) {
+				const line = lines[i];
+
+				if (skipComments) {
+					if (
+						commentLineNumbers.has(i + 1) &&
+						isFullLineComment(
+							line,
+							i + 1,
+							commentLineNumbers.get(i + 1),
+						)
+					) {
+						continue;
+					}
+				}
+
+				if (skipBlankLines) {
+					if (line.match(/^\s*$/u)) {
+						continue;
+					}
+				}
+
+				lineCount++;
+			}
+
+			if (lineCount > maxLines) {
+				const name = upperCaseFirst(
+					astUtils.getFunctionNameWithKind(funcNode),
+				);
+
+				context.report({
+					node,
+					messageId: "exceed",
+					data: { name, lineCount, maxLines },
+				});
+			}
+		}
+
+		//--------------------------------------------------------------------------
+		// Public API
+		//--------------------------------------------------------------------------
+
+		return {
+			FunctionDeclaration: processFunction,
+			FunctionExpression: processFunction,
+			ArrowFunctionExpression: processFunction,
+		};
+	},
+};

package/lib/rules/max-lines.js

@@ -0,0 +1,189 @@
+/**
+ * @fileoverview enforce a maximum file length
+ * @author Alberto Rodríguez
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+/**
+ * Creates an array of numbers from `start` up to, but not including, `end`
+ * @param {number} start The start of the range
+ * @param {number} end The end of the range
+ * @returns {number[]} The range of numbers
+ */
+function range(start, end) {
+	return [...Array(end - start).keys()].map(x => x + start);
+}
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "suggestion",
+
+		docs: {
+			description: "Enforce a maximum number of lines per file",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/max-lines",
+		},
+
+		schema: [
+			{
+				oneOf: [
+					{
+						type: "integer",
+						minimum: 0,
+					},
+					{
+						type: "object",
+						properties: {
+							max: {
+								type: "integer",
+								minimum: 0,
+							},
+							skipComments: {
+								type: "boolean",
+							},
+							skipBlankLines: {
+								type: "boolean",
+							},
+						},
+						additionalProperties: false,
+					},
+				],
+			},
+		],
+		messages: {
+			exceed: "File has too many lines ({{actual}}). Maximum allowed is {{max}}.",
+		},
+	},
+
+	create(context) {
+		const option = context.options[0];
+		let max = 300;
+
+		if (typeof option === "object" && Object.hasOwn(option, "max")) {
+			max = option.max;
+		} else if (typeof option === "number") {
+			max = option;
+		}
+
+		const skipComments = option && option.skipComments;
+		const skipBlankLines = option && option.skipBlankLines;
+
+		const sourceCode = context.sourceCode;
+
+		/**
+		 * Returns whether or not a token is a comment node type
+		 * @param {Token} token The token to check
+		 * @returns {boolean} True if the token is a comment node
+		 */
+		function isCommentNodeType(token) {
+			return token && (token.type === "Block" || token.type === "Line");
+		}
+
+		/**
+		 * Returns the line numbers of a comment that don't have any code on the same line
+		 * @param {Node} comment The comment node to check
+		 * @returns {number[]} The line numbers
+		 */
+		function getLinesWithoutCode(comment) {
+			let start = comment.loc.start.line;
+			let end = comment.loc.end.line;
+
+			let token;
+
+			token = comment;
+			do {
+				token = sourceCode.getTokenBefore(token, {
+					includeComments: true,
+				});
+			} while (isCommentNodeType(token));
+
+			if (token && astUtils.isTokenOnSameLine(token, comment)) {
+				start += 1;
+			}
+
+			token = comment;
+			do {
+				token = sourceCode.getTokenAfter(token, {
+					includeComments: true,
+				});
+			} while (isCommentNodeType(token));
+
+			if (token && astUtils.isTokenOnSameLine(comment, token)) {
+				end -= 1;
+			}
+
+			if (start <= end) {
+				return range(start, end + 1);
+			}
+			return [];
+		}
+
+		return {
+			"Program:exit"() {
+				let lines = sourceCode.lines.map((text, i) => ({
+					lineNumber: i + 1,
+					text,
+				}));
+
+				/*
+				 * If file ends with a linebreak, `sourceCode.lines` will have one extra empty line at the end.
+				 * That isn't a real line, so we shouldn't count it.
+				 */
+				if (lines.length > 1 && lines.at(-1).text === "") {
+					lines.pop();
+				}
+
+				if (skipBlankLines) {
+					lines = lines.filter(l => l.text.trim() !== "");
+				}
+
+				if (skipComments) {
+					const comments = sourceCode.getAllComments();
+
+					const commentLines = new Set(
+						comments.flatMap(getLinesWithoutCode),
+					);
+
+					lines = lines.filter(l => !commentLines.has(l.lineNumber));
+				}
+
+				if (lines.length > max) {
+					const loc = {
+						start: {
+							line: lines[max].lineNumber,
+							column: 0,
+						},
+						end: {
+							line: sourceCode.lines.length,
+							column: sourceCode.lines.at(-1).length,
+						},
+					};
+
+					context.report({
+						loc,
+						messageId: "exceed",
+						data: {
+							max,
+							actual: lines.length,
+						},
+					});
+				}
+			},
+		};
+	},
+};

package/lib/rules/max-nested-callbacks.js

@@ -0,0 +1,115 @@
+/**
+ * @fileoverview Rule to enforce a maximum number of nested callbacks.
+ * @author Ian Christian Myers
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "suggestion",
+
+		docs: {
+			description: "Enforce a maximum depth that callbacks can be nested",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/max-nested-callbacks",
+		},
+
+		schema: [
+			{
+				oneOf: [
+					{
+						type: "integer",
+						minimum: 0,
+					},
+					{
+						type: "object",
+						properties: {
+							maximum: {
+								type: "integer",
+								minimum: 0,
+							},
+							max: {
+								type: "integer",
+								minimum: 0,
+							},
+						},
+						additionalProperties: false,
+					},
+				],
+			},
+		],
+		messages: {
+			exceed: "Too many nested callbacks ({{num}}). Maximum allowed is {{max}}.",
+		},
+	},
+
+	create(context) {
+		//--------------------------------------------------------------------------
+		// Constants
+		//--------------------------------------------------------------------------
+		const option = context.options[0];
+		let THRESHOLD = 10;
+
+		if (
+			typeof option === "object" &&
+			(Object.hasOwn(option, "maximum") || Object.hasOwn(option, "max"))
+		) {
+			THRESHOLD = option.maximum || option.max;
+		} else if (typeof option === "number") {
+			THRESHOLD = option;
+		}
+
+		//--------------------------------------------------------------------------
+		// Helpers
+		//--------------------------------------------------------------------------
+
+		const callbackStack = [];
+
+		/**
+		 * Checks a given function node for too many callbacks.
+		 * @param {ASTNode} node The node to check.
+		 * @returns {void}
+		 * @private
+		 */
+		function checkFunction(node) {
+			const parent = node.parent;
+
+			if (parent.type === "CallExpression") {
+				callbackStack.push(node);
+			}
+
+			if (callbackStack.length > THRESHOLD) {
+				const opts = { num: callbackStack.length, max: THRESHOLD };
+
+				context.report({ node, messageId: "exceed", data: opts });
+			}
+		}
+
+		/**
+		 * Pops the call stack.
+		 * @returns {void}
+		 * @private
+		 */
+		function popStack() {
+			callbackStack.pop();
+		}
+
+		//--------------------------------------------------------------------------
+		// Public API
+		//--------------------------------------------------------------------------
+
+		return {
+			ArrowFunctionExpression: checkFunction,
+			"ArrowFunctionExpression:exit": popStack,
+
+			FunctionExpression: checkFunction,
+			"FunctionExpression:exit": popStack,
+		};
+	},
+};

package/lib/rules/max-params.js

@@ -0,0 +1,148 @@
+/**
+ * @fileoverview Rule to flag when a function has too many parameters
+ * @author Ilya Volodin
+ */
+
+"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",
+		dialects: ["typescript", "javascript"],
+		language: "javascript",
+
+		docs: {
+			description:
+				"Enforce a maximum number of parameters in function definitions",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/max-params",
+		},
+
+		schema: [
+			{
+				oneOf: [
+					{
+						type: "integer",
+						minimum: 0,
+					},
+					{
+						type: "object",
+						properties: {
+							maximum: {
+								type: "integer",
+								minimum: 0,
+							},
+							max: {
+								type: "integer",
+								minimum: 0,
+							},
+							countVoidThis: {
+								type: "boolean",
+								description:
+									"Whether to count a `this` declaration when the type is `void`.",
+							},
+							countThis: {
+								enum: ["never", "except-void", "always"],
+								description:
+									"Whether to count a `this` declaration.",
+							},
+						},
+						additionalProperties: false,
+						not: { required: ["countVoidThis", "countThis"] },
+					},
+				],
+			},
+		],
+		messages: {
+			exceed: "{{name}} has too many parameters ({{count}}). Maximum allowed is {{max}}.",
+		},
+	},
+
+	create(context) {
+		const sourceCode = context.sourceCode;
+		const option = context.options[0];
+		let numParams = 3;
+		let countThis = "except-void";
+
+		if (typeof option === "object") {
+			if (
+				Object.hasOwn(option, "maximum") ||
+				Object.hasOwn(option, "max")
+			) {
+				numParams = option.maximum || option.max;
+			}
+
+			countThis = option.countThis;
+			if (!countThis && Object.hasOwn(option, "countVoidThis")) {
+				countThis = option.countVoidThis ? "always" : "except-void";
+			}
+			countThis ||= "except-void";
+		}
+		if (typeof option === "number") {
+			numParams = option;
+		}
+
+		/**
+		 * Checks a function to see if it has too many parameters.
+		 * @param {ASTNode} node The node to check.
+		 * @returns {void}
+		 * @private
+		 */
+		function checkFunction(node) {
+			const thisParam =
+				node.params.length > 0 &&
+				node.params[0].type === "Identifier" &&
+				node.params[0].name === "this"
+					? node.params[0]
+					: null;
+
+			let effectiveParamCount = node.params.length;
+			if (thisParam) {
+				if (countThis === "never") {
+					effectiveParamCount = node.params.length - 1;
+				} else if (
+					countThis === "except-void" &&
+					thisParam.typeAnnotation?.typeAnnotation.type ===
+						"TSVoidKeyword"
+				) {
+					effectiveParamCount = node.params.length - 1;
+				}
+			}
+
+			if (effectiveParamCount > numParams) {
+				context.report({
+					loc: astUtils.getFunctionHeadLoc(node, sourceCode),
+					node,
+					messageId: "exceed",
+					data: {
+						name: upperCaseFirst(
+							astUtils.getFunctionNameWithKind(node),
+						),
+						count: effectiveParamCount,
+						max: numParams,
+					},
+				});
+			}
+		}
+
+		return {
+			FunctionDeclaration: checkFunction,
+			ArrowFunctionExpression: checkFunction,
+			FunctionExpression: checkFunction,
+			TSDeclareFunction: checkFunction,
+			TSFunctionType: checkFunction,
+		};
+	},
+};