@alexlit/lint-kit 166.1.0 → 167.0.0

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

@@ -1,497 +0,0 @@
-/**
- * @fileoverview Rule to check for max length on a line.
- * @author Matt DuVall <http://www.mattduvall.com>
- * @deprecated in ESLint v8.53.0
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Constants
-//------------------------------------------------------------------------------
-
-const OPTIONS_SCHEMA = {
-	type: "object",
-	properties: {
-		code: {
-			type: "integer",
-			minimum: 0,
-		},
-		comments: {
-			type: "integer",
-			minimum: 0,
-		},
-		tabWidth: {
-			type: "integer",
-			minimum: 0,
-		},
-		ignorePattern: {
-			type: "string",
-		},
-		ignoreComments: {
-			type: "boolean",
-		},
-		ignoreStrings: {
-			type: "boolean",
-		},
-		ignoreUrls: {
-			type: "boolean",
-		},
-		ignoreTemplateLiterals: {
-			type: "boolean",
-		},
-		ignoreRegExpLiterals: {
-			type: "boolean",
-		},
-		ignoreTrailingComments: {
-			type: "boolean",
-		},
-	},
-	additionalProperties: false,
-};
-
-const OPTIONS_OR_INTEGER_SCHEMA = {
-	anyOf: [
-		OPTIONS_SCHEMA,
-		{
-			type: "integer",
-			minimum: 0,
-		},
-	],
-};
-
-//------------------------------------------------------------------------------
-// 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-len",
-						url: "https://eslint.style/rules/max-len",
-					},
-				},
-			],
-		},
-		type: "layout",
-
-		docs: {
-			description: "Enforce a maximum line length",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/max-len",
-		},
-
-		schema: [
-			OPTIONS_OR_INTEGER_SCHEMA,
-			OPTIONS_OR_INTEGER_SCHEMA,
-			OPTIONS_SCHEMA,
-		],
-		messages: {
-			max: "This line has a length of {{lineLength}}. Maximum allowed is {{maxLength}}.",
-			maxComment:
-				"This line has a comment length of {{lineLength}}. Maximum allowed is {{maxCommentLength}}.",
-		},
-	},
-
-	create(context) {
-		/*
-		 * Inspired by http://tools.ietf.org/html/rfc3986#appendix-B, however:
-		 * - They're matching an entire string that we know is a URI
-		 * - We're matching part of a string where we think there *might* be a URL
-		 * - We're only concerned about URLs, as picking out any URI would cause
-		 *   too many false positives
-		 * - We don't care about matching the entire URL, any small segment is fine
-		 */
-		const URL_REGEXP = /[^:/?#]:\/\/[^?#]/u;
-
-		const sourceCode = context.sourceCode;
-
-		/**
-		 * Computes the length of a line that may contain tabs. The width of each
-		 * tab will be the number of spaces to the next tab stop.
-		 * @param {string} line The line.
-		 * @param {number} tabWidth The width of each tab stop in spaces.
-		 * @returns {number} The computed line length.
-		 * @private
-		 */
-		function computeLineLength(line, tabWidth) {
-			let extraCharacterCount = 0;
-
-			line.replace(/\t/gu, (match, offset) => {
-				const totalOffset = offset + extraCharacterCount,
-					previousTabStopOffset = tabWidth
-						? totalOffset % tabWidth
-						: 0,
-					spaceCount = tabWidth - previousTabStopOffset;
-
-				extraCharacterCount += spaceCount - 1; // -1 for the replaced tab
-			});
-			return Array.from(line).length + extraCharacterCount;
-		}
-
-		// The options object must be the last option specified…
-		const options = Object.assign({}, context.options.at(-1));
-
-		// …but max code length…
-		if (typeof context.options[0] === "number") {
-			options.code = context.options[0];
-		}
-
-		// …and tabWidth can be optionally specified directly as integers.
-		if (typeof context.options[1] === "number") {
-			options.tabWidth = context.options[1];
-		}
-
-		const maxLength = typeof options.code === "number" ? options.code : 80,
-			tabWidth =
-				typeof options.tabWidth === "number" ? options.tabWidth : 4,
-			ignoreComments = !!options.ignoreComments,
-			ignoreStrings = !!options.ignoreStrings,
-			ignoreTemplateLiterals = !!options.ignoreTemplateLiterals,
-			ignoreRegExpLiterals = !!options.ignoreRegExpLiterals,
-			ignoreTrailingComments =
-				!!options.ignoreTrailingComments || !!options.ignoreComments,
-			ignoreUrls = !!options.ignoreUrls,
-			maxCommentLength = options.comments;
-		let ignorePattern = options.ignorePattern || null;
-
-		if (ignorePattern) {
-			ignorePattern = new RegExp(ignorePattern, "u");
-		}
-
-		//--------------------------------------------------------------------------
-		// Helpers
-		//--------------------------------------------------------------------------
-
-		/**
-		 * Tells if a given comment is trailing: it starts on the current line and
-		 * extends to or past the end of the current line.
-		 * @param {string} line The source line we want to check for a trailing comment on
-		 * @param {number} lineNumber The one-indexed line number for line
-		 * @param {ASTNode} comment The comment to inspect
-		 * @returns {boolean} If the comment is trailing on the given line
-		 */
-		function isTrailingComment(line, lineNumber, comment) {
-			return (
-				comment &&
-				comment.loc.start.line === lineNumber &&
-				lineNumber <= comment.loc.end.line &&
-				(comment.loc.end.line > lineNumber ||
-					comment.loc.end.column === line.length)
-			);
-		}
-
-		/**
-		 * 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 = !line
-					.slice(0, comment.loc.start.column)
-					.trim();
-
-			return (
-				comment &&
-				(start.line < lineNumber ||
-					(start.line === lineNumber && isFirstTokenOnLine)) &&
-				(end.line > lineNumber ||
-					(end.line === lineNumber && end.column === line.length))
-			);
-		}
-
-		/**
-		 * Check if a node is a JSXEmptyExpression contained in a single line JSXExpressionContainer.
-		 * @param {ASTNode} node A node to check.
-		 * @returns {boolean} True if the node is a JSXEmptyExpression contained in a single line JSXExpressionContainer.
-		 */
-		function isJSXEmptyExpressionInSingleLineContainer(node) {
-			if (
-				!node ||
-				!node.parent ||
-				node.type !== "JSXEmptyExpression" ||
-				node.parent.type !== "JSXExpressionContainer"
-			) {
-				return false;
-			}
-
-			const parent = node.parent;
-
-			return parent.loc.start.line === parent.loc.end.line;
-		}
-
-		/**
-		 * Gets the line after the comment and any remaining trailing whitespace is
-		 * stripped.
-		 * @param {string} line The source line with a trailing comment
-		 * @param {ASTNode} comment The comment to remove
-		 * @returns {string} Line without comment and trailing whitespace
-		 */
-		function stripTrailingComment(line, comment) {
-			// loc.column is zero-indexed
-			return line.slice(0, comment.loc.start.column).replace(/\s+$/u, "");
-		}
-
-		/**
-		 * Ensure that an array exists at [key] on `object`, and add `value` to it.
-		 * @param {Object} object the object to mutate
-		 * @param {string} key the object's key
-		 * @param {any} value the value to add
-		 * @returns {void}
-		 * @private
-		 */
-		function ensureArrayAndPush(object, key, value) {
-			if (!Array.isArray(object[key])) {
-				object[key] = [];
-			}
-			object[key].push(value);
-		}
-
-		/**
-		 * Retrieves an array containing all strings (" or ') in the source code.
-		 * @returns {ASTNode[]} An array of string nodes.
-		 */
-		function getAllStrings() {
-			return sourceCode.ast.tokens.filter(
-				token =>
-					token.type === "String" ||
-					(token.type === "JSXText" &&
-						sourceCode.getNodeByRangeIndex(token.range[0] - 1)
-							.type === "JSXAttribute"),
-			);
-		}
-
-		/**
-		 * Retrieves an array containing all template literals in the source code.
-		 * @returns {ASTNode[]} An array of template literal nodes.
-		 */
-		function getAllTemplateLiterals() {
-			return sourceCode.ast.tokens.filter(
-				token => token.type === "Template",
-			);
-		}
-
-		/**
-		 * Retrieves an array containing all RegExp literals in the source code.
-		 * @returns {ASTNode[]} An array of RegExp literal nodes.
-		 */
-		function getAllRegExpLiterals() {
-			return sourceCode.ast.tokens.filter(
-				token => token.type === "RegularExpression",
-			);
-		}
-
-		/**
-		 *
-		 * reduce an array of AST nodes by line number, both start and end.
-		 * @param {ASTNode[]} arr array of AST nodes
-		 * @returns {Object} accululated AST nodes
-		 */
-		function groupArrayByLineNumber(arr) {
-			const obj = {};
-
-			for (let i = 0; i < arr.length; i++) {
-				const node = arr[i];
-
-				for (let j = node.loc.start.line; j <= node.loc.end.line; ++j) {
-					ensureArrayAndPush(obj, j, node);
-				}
-			}
-			return obj;
-		}
-
-		/**
-		 * Returns an array of all comments in the source code.
-		 * If the element in the array is a JSXEmptyExpression contained with a single line JSXExpressionContainer,
-		 * the element is changed with JSXExpressionContainer node.
-		 * @returns {ASTNode[]} An array of comment nodes
-		 */
-		function getAllComments() {
-			const comments = [];
-
-			sourceCode.getAllComments().forEach(commentNode => {
-				const containingNode = sourceCode.getNodeByRangeIndex(
-					commentNode.range[0],
-				);
-
-				if (isJSXEmptyExpressionInSingleLineContainer(containingNode)) {
-					// push a unique node only
-					if (comments.at(-1) !== containingNode.parent) {
-						comments.push(containingNode.parent);
-					}
-				} else {
-					comments.push(commentNode);
-				}
-			});
-
-			return comments;
-		}
-
-		/**
-		 * Check the program for max length
-		 * @param {ASTNode} node Node to examine
-		 * @returns {void}
-		 * @private
-		 */
-		function checkProgramForMaxLength(node) {
-			// split (honors line-ending)
-			const lines = sourceCode.lines,
-				// list of comments to ignore
-				comments =
-					ignoreComments || maxCommentLength || ignoreTrailingComments
-						? getAllComments()
-						: [];
-
-			// we iterate over comments in parallel with the lines
-			let commentsIndex = 0;
-
-			const strings = getAllStrings();
-			const stringsByLine = groupArrayByLineNumber(strings);
-
-			const templateLiterals = getAllTemplateLiterals();
-			const templateLiteralsByLine =
-				groupArrayByLineNumber(templateLiterals);
-
-			const regExpLiterals = getAllRegExpLiterals();
-			const regExpLiteralsByLine = groupArrayByLineNumber(regExpLiterals);
-
-			lines.forEach((line, i) => {
-				// i is zero-indexed, line numbers are one-indexed
-				const lineNumber = i + 1;
-
-				/*
-				 * if we're checking comment length; we need to know whether this
-				 * line is a comment
-				 */
-				let lineIsComment = false;
-				let textToMeasure;
-
-				/*
-				 * We can short-circuit the comment checks if we're already out of
-				 * comments to check.
-				 */
-				if (commentsIndex < comments.length) {
-					let comment;
-
-					// iterate over comments until we find one past the current line
-					do {
-						comment = comments[++commentsIndex];
-					} while (comment && comment.loc.start.line <= lineNumber);
-
-					// and step back by one
-					comment = comments[--commentsIndex];
-
-					if (isFullLineComment(line, lineNumber, comment)) {
-						lineIsComment = true;
-						textToMeasure = line;
-					} else if (
-						ignoreTrailingComments &&
-						isTrailingComment(line, lineNumber, comment)
-					) {
-						textToMeasure = stripTrailingComment(line, comment);
-
-						// ignore multiple trailing comments in the same line
-						let lastIndex = commentsIndex;
-
-						while (
-							isTrailingComment(
-								textToMeasure,
-								lineNumber,
-								comments[--lastIndex],
-							)
-						) {
-							textToMeasure = stripTrailingComment(
-								textToMeasure,
-								comments[lastIndex],
-							);
-						}
-					} else {
-						textToMeasure = line;
-					}
-				} else {
-					textToMeasure = line;
-				}
-				if (
-					(ignorePattern && ignorePattern.test(textToMeasure)) ||
-					(ignoreUrls && URL_REGEXP.test(textToMeasure)) ||
-					(ignoreStrings && stringsByLine[lineNumber]) ||
-					(ignoreTemplateLiterals &&
-						templateLiteralsByLine[lineNumber]) ||
-					(ignoreRegExpLiterals && regExpLiteralsByLine[lineNumber])
-				) {
-					// ignore this line
-					return;
-				}
-
-				const lineLength = computeLineLength(textToMeasure, tabWidth);
-				const commentLengthApplies = lineIsComment && maxCommentLength;
-
-				if (lineIsComment && ignoreComments) {
-					return;
-				}
-
-				const loc = {
-					start: {
-						line: lineNumber,
-						column: 0,
-					},
-					end: {
-						line: lineNumber,
-						column: textToMeasure.length,
-					},
-				};
-
-				if (commentLengthApplies) {
-					if (lineLength > maxCommentLength) {
-						context.report({
-							node,
-							loc,
-							messageId: "maxComment",
-							data: {
-								lineLength,
-								maxCommentLength,
-							},
-						});
-					}
-				} else if (lineLength > maxLength) {
-					context.report({
-						node,
-						loc,
-						messageId: "max",
-						data: {
-							lineLength,
-							maxLength,
-						},
-					});
-				}
-			});
-		}
-
-		//--------------------------------------------------------------------------
-		// Public API
-		//--------------------------------------------------------------------------
-
-		return {
-			Program: checkProgramForMaxLength,
-		};
-	},
-};