@alexlit/lint-kit 166.0.1 → 167.0.0

package/packages/config-eslint/node_modules/eslint/lib/rules/max-lines-per-function.js

@@ -1,238 +0,0 @@
-/**
- * @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/packages/config-eslint/node_modules/eslint/lib/rules/max-lines.js

@@ -1,189 +0,0 @@
-/**
- * @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/packages/config-eslint/node_modules/eslint/lib/rules/max-nested-callbacks.js

@@ -1,115 +0,0 @@
-/**
- * @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/packages/config-eslint/node_modules/eslint/lib/rules/max-params.js

@@ -1,129 +0,0 @@
-/**
- * @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`.",
-							},
-						},
-						additionalProperties: false,
-					},
-				],
-			},
-		],
-		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 countVoidThis = false;
-
-		if (typeof option === "object") {
-			if (
-				Object.hasOwn(option, "maximum") ||
-				Object.hasOwn(option, "max")
-			) {
-				numParams = option.maximum || option.max;
-			}
-			countVoidThis = option.countVoidThis;
-		}
-		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 hasVoidThisParam =
-				node.params.length > 0 &&
-				node.params[0].type === "Identifier" &&
-				node.params[0].name === "this" &&
-				node.params[0].typeAnnotation?.typeAnnotation.type ===
-					"TSVoidKeyword";
-
-			const effectiveParamCount =
-				hasVoidThisParam && !countVoidThis
-					? node.params.length - 1
-					: node.params.length;
-
-			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,
-		};
-	},
-};