@alexlit/lint-kit 166.1.0 → 167.0.0

package/packages/config-eslint/node_modules/eslint/lib/rules/newline-after-var.js

@@ -1,307 +0,0 @@
-/**
- * @fileoverview Rule to check empty newline after "var" statement
- * @author Gopal Venkatesan
- * @deprecated in ESLint v4.0.0
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "layout",
-
-		docs: {
-			description:
-				"Require or disallow an empty line after variable declarations",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/newline-after-var",
-		},
-		schema: [
-			{
-				enum: ["never", "always"],
-			},
-		],
-		fixable: "whitespace",
-		messages: {
-			expected: "Expected blank line after variable declarations.",
-			unexpected: "Unexpected blank line after variable declarations.",
-		},
-
-		deprecated: {
-			message: "The rule was replaced with a more general rule.",
-			url: "https://eslint.org/blog/2017/06/eslint-v4.0.0-released/",
-			deprecatedSince: "4.0.0",
-			availableUntil: "11.0.0",
-			replacedBy: [
-				{
-					message: "The new rule moved to a plugin.",
-					url: "https://eslint.org/docs/latest/rules/padding-line-between-statements#examples",
-					plugin: {
-						name: "@stylistic/eslint-plugin",
-						url: "https://eslint.style",
-					},
-					rule: {
-						name: "padding-line-between-statements",
-						url: "https://eslint.style/rules/padding-line-between-statements",
-					},
-				},
-			],
-		},
-	},
-
-	create(context) {
-		const sourceCode = context.sourceCode;
-
-		// Default `mode` to "always".
-		const mode = context.options[0] === "never" ? "never" : "always";
-
-		// Cache starting and ending line numbers of comments for faster lookup
-		const commentEndLine = sourceCode
-			.getAllComments()
-			.reduce((result, token) => {
-				result[token.loc.start.line] = token.loc.end.line;
-				return result;
-			}, {});
-
-		//--------------------------------------------------------------------------
-		// Helpers
-		//--------------------------------------------------------------------------
-
-		/**
-		 * Gets a token from the given node to compare line to the next statement.
-		 *
-		 * In general, the token is the last token of the node. However, the token is the second last token if the following conditions satisfy.
-		 *
-		 * - The last token is semicolon.
-		 * - The semicolon is on a different line from the previous token of the semicolon.
-		 *
-		 * This behavior would address semicolon-less style code. e.g.:
-		 *
-		 *     var foo = 1
-		 *
-		 *     ;(a || b).doSomething()
-		 * @param {ASTNode} node The node to get.
-		 * @returns {Token} The token to compare line to the next statement.
-		 */
-		function getLastToken(node) {
-			const lastToken = sourceCode.getLastToken(node);
-
-			if (lastToken.type === "Punctuator" && lastToken.value === ";") {
-				const prevToken = sourceCode.getTokenBefore(lastToken);
-
-				if (prevToken.loc.end.line !== lastToken.loc.start.line) {
-					return prevToken;
-				}
-			}
-
-			return lastToken;
-		}
-
-		/**
-		 * Determine if provided keyword is a variable declaration
-		 * @private
-		 * @param {string} keyword keyword to test
-		 * @returns {boolean} True if `keyword` is a type of var
-		 */
-		function isVar(keyword) {
-			return (
-				keyword === "var" || keyword === "let" || keyword === "const"
-			);
-		}
-
-		/**
-		 * Determine if provided keyword is a variant of for specifiers
-		 * @private
-		 * @param {string} keyword keyword to test
-		 * @returns {boolean} True if `keyword` is a variant of for specifier
-		 */
-		function isForTypeSpecifier(keyword) {
-			return (
-				keyword === "ForStatement" ||
-				keyword === "ForInStatement" ||
-				keyword === "ForOfStatement"
-			);
-		}
-
-		/**
-		 * Determine if provided keyword is an export specifiers
-		 * @private
-		 * @param {string} nodeType nodeType to test
-		 * @returns {boolean} True if `nodeType` is an export specifier
-		 */
-		function isExportSpecifier(nodeType) {
-			return (
-				nodeType === "ExportNamedDeclaration" ||
-				nodeType === "ExportSpecifier" ||
-				nodeType === "ExportDefaultDeclaration" ||
-				nodeType === "ExportAllDeclaration"
-			);
-		}
-
-		/**
-		 * Determine if provided node is the last of their parent block.
-		 * @private
-		 * @param {ASTNode} node node to test
-		 * @returns {boolean} True if `node` is last of their parent block.
-		 */
-		function isLastNode(node) {
-			const token = sourceCode.getTokenAfter(node);
-
-			return (
-				!token || (token.type === "Punctuator" && token.value === "}")
-			);
-		}
-
-		/**
-		 * Gets the last line of a group of consecutive comments
-		 * @param {number} commentStartLine The starting line of the group
-		 * @returns {number} The number of the last comment line of the group
-		 */
-		function getLastCommentLineOfBlock(commentStartLine) {
-			const currentCommentEnd = commentEndLine[commentStartLine];
-
-			return commentEndLine[currentCommentEnd + 1]
-				? getLastCommentLineOfBlock(currentCommentEnd + 1)
-				: currentCommentEnd;
-		}
-
-		/**
-		 * Determine if a token starts more than one line after a comment ends
-		 * @param {token} token The token being checked
-		 * @param {integer} commentStartLine The line number on which the comment starts
-		 * @returns {boolean} True if `token` does not start immediately after a comment
-		 */
-		function hasBlankLineAfterComment(token, commentStartLine) {
-			return (
-				token.loc.start.line >
-				getLastCommentLineOfBlock(commentStartLine) + 1
-			);
-		}
-
-		/**
-		 * Checks that a blank line exists after a variable declaration when mode is
-		 * set to "always", or checks that there is no blank line when mode is set
-		 * to "never"
-		 * @private
-		 * @param {ASTNode} node `VariableDeclaration` node to test
-		 * @returns {void}
-		 */
-		function checkForBlankLine(node) {
-			/*
-			 * lastToken is the last token on the node's line. It will usually also be the last token of the node, but it will
-			 * sometimes be second-last if there is a semicolon on a different line.
-			 */
-			const lastToken = getLastToken(node),
-				/*
-				 * If lastToken is the last token of the node, nextToken should be the token after the node. Otherwise, nextToken
-				 * is the last token of the node.
-				 */
-				nextToken =
-					lastToken === sourceCode.getLastToken(node)
-						? sourceCode.getTokenAfter(node)
-						: sourceCode.getLastToken(node),
-				nextLineNum = lastToken.loc.end.line + 1;
-
-			// Ignore if there is no following statement
-			if (!nextToken) {
-				return;
-			}
-
-			// Ignore if parent of node is a for variant
-			if (isForTypeSpecifier(node.parent.type)) {
-				return;
-			}
-
-			// Ignore if parent of node is an export specifier
-			if (isExportSpecifier(node.parent.type)) {
-				return;
-			}
-
-			/*
-			 * Some coding styles use multiple `var` statements, so do nothing if
-			 * the next token is a `var` statement.
-			 */
-			if (nextToken.type === "Keyword" && isVar(nextToken.value)) {
-				return;
-			}
-
-			// Ignore if it is last statement in a block
-			if (isLastNode(node)) {
-				return;
-			}
-
-			// Next statement is not a `var`...
-			const noNextLineToken = nextToken.loc.start.line > nextLineNum;
-			const hasNextLineComment =
-				typeof commentEndLine[nextLineNum] !== "undefined";
-
-			if (mode === "never" && noNextLineToken && !hasNextLineComment) {
-				context.report({
-					node,
-					messageId: "unexpected",
-					fix(fixer) {
-						const linesBetween = sourceCode
-							.getText()
-							.slice(lastToken.range[1], nextToken.range[0])
-							.split(astUtils.LINEBREAK_MATCHER);
-
-						return fixer.replaceTextRange(
-							[lastToken.range[1], nextToken.range[0]],
-							`${linesBetween.slice(0, -1).join("")}\n${linesBetween.at(-1)}`,
-						);
-					},
-				});
-			}
-
-			// Token on the next line, or comment without blank line
-			if (
-				mode === "always" &&
-				(!noNextLineToken ||
-					(hasNextLineComment &&
-						!hasBlankLineAfterComment(nextToken, nextLineNum)))
-			) {
-				context.report({
-					node,
-					messageId: "expected",
-					fix(fixer) {
-						if (
-							(noNextLineToken
-								? getLastCommentLineOfBlock(nextLineNum)
-								: lastToken.loc.end.line) ===
-							nextToken.loc.start.line
-						) {
-							return fixer.insertTextBefore(nextToken, "\n\n");
-						}
-
-						return fixer.insertTextBeforeRange(
-							[
-								nextToken.range[0] - nextToken.loc.start.column,
-								nextToken.range[1],
-							],
-							"\n",
-						);
-					},
-				});
-			}
-		}
-
-		//--------------------------------------------------------------------------
-		// Public
-		//--------------------------------------------------------------------------
-
-		return {
-			VariableDeclaration: checkForBlankLine,
-		};
-	},
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/newline-before-return.js

@@ -1,242 +0,0 @@
-/**
- * @fileoverview Rule to require newlines before `return` statement
- * @author Kai Cataldo
- * @deprecated in ESLint v4.0.0
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "layout",
-
-		docs: {
-			description: "Require an empty line before `return` statements",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/newline-before-return",
-		},
-
-		fixable: "whitespace",
-		schema: [],
-		messages: {
-			expected: "Expected newline before return statement.",
-		},
-
-		deprecated: {
-			message: "The rule was replaced with a more general rule.",
-			url: "https://eslint.org/blog/2017/06/eslint-v4.0.0-released/",
-			deprecatedSince: "4.0.0",
-			availableUntil: "11.0.0",
-			replacedBy: [
-				{
-					message: "The new rule moved to a plugin.",
-					url: "https://eslint.org/docs/latest/rules/padding-line-between-statements#examples",
-					plugin: {
-						name: "@stylistic/eslint-plugin",
-						url: "https://eslint.style",
-					},
-					rule: {
-						name: "padding-line-between-statements",
-						url: "https://eslint.style/rules/padding-line-between-statements",
-					},
-				},
-			],
-		},
-	},
-
-	create(context) {
-		const sourceCode = context.sourceCode;
-
-		//--------------------------------------------------------------------------
-		// Helpers
-		//--------------------------------------------------------------------------
-
-		/**
-		 * Tests whether node is preceded by supplied tokens
-		 * @param {ASTNode} node node to check
-		 * @param {Array} testTokens array of tokens to test against
-		 * @returns {boolean} Whether or not the node is preceded by one of the supplied tokens
-		 * @private
-		 */
-		function isPrecededByTokens(node, testTokens) {
-			const tokenBefore = sourceCode.getTokenBefore(node);
-
-			return testTokens.includes(tokenBefore.value);
-		}
-
-		/**
-		 * Checks whether node is the first node after statement or in block
-		 * @param {ASTNode} node node to check
-		 * @returns {boolean} Whether or not the node is the first node after statement or in block
-		 * @private
-		 */
-		function isFirstNode(node) {
-			const parentType = node.parent.type;
-
-			if (node.parent.body) {
-				return Array.isArray(node.parent.body)
-					? node.parent.body[0] === node
-					: node.parent.body === node;
-			}
-
-			if (parentType === "IfStatement") {
-				return isPrecededByTokens(node, ["else", ")"]);
-			}
-			if (parentType === "DoWhileStatement") {
-				return isPrecededByTokens(node, ["do"]);
-			}
-			if (parentType === "SwitchCase") {
-				return isPrecededByTokens(node, [":"]);
-			}
-			return isPrecededByTokens(node, [")"]);
-		}
-
-		/**
-		 * Returns the number of lines of comments that precede the node
-		 * @param {ASTNode} node node to check for overlapping comments
-		 * @param {number} lineNumTokenBefore line number of previous token, to check for overlapping comments
-		 * @returns {number} Number of lines of comments that precede the node
-		 * @private
-		 */
-		function calcCommentLines(node, lineNumTokenBefore) {
-			const comments = sourceCode.getCommentsBefore(node);
-			let numLinesComments = 0;
-
-			if (!comments.length) {
-				return numLinesComments;
-			}
-
-			comments.forEach(comment => {
-				numLinesComments++;
-
-				if (comment.type === "Block") {
-					numLinesComments +=
-						comment.loc.end.line - comment.loc.start.line;
-				}
-
-				// avoid counting lines with inline comments twice
-				if (comment.loc.start.line === lineNumTokenBefore) {
-					numLinesComments--;
-				}
-
-				if (comment.loc.end.line === node.loc.start.line) {
-					numLinesComments--;
-				}
-			});
-
-			return numLinesComments;
-		}
-
-		/**
-		 * Returns the line number of the token before the node that is passed in as an argument
-		 * @param {ASTNode} node The node to use as the start of the calculation
-		 * @returns {number} Line number of the token before `node`
-		 * @private
-		 */
-		function getLineNumberOfTokenBefore(node) {
-			const tokenBefore = sourceCode.getTokenBefore(node);
-			let lineNumTokenBefore;
-
-			/**
-			 * Global return (at the beginning of a script) is a special case.
-			 * If there is no token before `return`, then we expect no line
-			 * break before the return. Comments are allowed to occupy lines
-			 * before the global return, just no blank lines.
-			 * Setting lineNumTokenBefore to zero in that case results in the
-			 * desired behavior.
-			 */
-			if (tokenBefore) {
-				lineNumTokenBefore = tokenBefore.loc.end.line;
-			} else {
-				lineNumTokenBefore = 0; // global return at beginning of script
-			}
-
-			return lineNumTokenBefore;
-		}
-
-		/**
-		 * Checks whether node is preceded by a newline
-		 * @param {ASTNode} node node to check
-		 * @returns {boolean} Whether or not the node is preceded by a newline
-		 * @private
-		 */
-		function hasNewlineBefore(node) {
-			const lineNumNode = node.loc.start.line;
-			const lineNumTokenBefore = getLineNumberOfTokenBefore(node);
-			const commentLines = calcCommentLines(node, lineNumTokenBefore);
-
-			return lineNumNode - lineNumTokenBefore - commentLines > 1;
-		}
-
-		/**
-		 * Checks whether it is safe to apply a fix to a given return statement.
-		 *
-		 * The fix is not considered safe if the given return statement has leading comments,
-		 * as we cannot safely determine if the newline should be added before or after the comments.
-		 * For more information, see: https://github.com/eslint/eslint/issues/5958#issuecomment-222767211
-		 * @param {ASTNode} node The return statement node to check.
-		 * @returns {boolean} `true` if it can fix the node.
-		 * @private
-		 */
-		function canFix(node) {
-			const leadingComments = sourceCode.getCommentsBefore(node);
-			const lastLeadingComment = leadingComments.at(-1);
-			const tokenBefore = sourceCode.getTokenBefore(node);
-
-			if (leadingComments.length === 0) {
-				return true;
-			}
-
-			/*
-			 * if the last leading comment ends in the same line as the previous token and
-			 * does not share a line with the `return` node, we can consider it safe to fix.
-			 * Example:
-			 * function a() {
-			 *     var b; //comment
-			 *     return;
-			 * }
-			 */
-			if (
-				lastLeadingComment.loc.end.line === tokenBefore.loc.end.line &&
-				lastLeadingComment.loc.end.line !== node.loc.start.line
-			) {
-				return true;
-			}
-
-			return false;
-		}
-
-		//--------------------------------------------------------------------------
-		// Public
-		//--------------------------------------------------------------------------
-
-		return {
-			ReturnStatement(node) {
-				if (!isFirstNode(node) && !hasNewlineBefore(node)) {
-					context.report({
-						node,
-						messageId: "expected",
-						fix(fixer) {
-							if (canFix(node)) {
-								const tokenBefore =
-									sourceCode.getTokenBefore(node);
-								const newlines =
-									node.loc.start.line ===
-									tokenBefore.loc.end.line
-										? "\n\n"
-										: "\n";
-
-								return fixer.insertTextBefore(node, newlines);
-							}
-							return null;
-						},
-					});
-				}
-			},
-		};
-	},
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/newline-per-chained-call.js

@@ -1,159 +0,0 @@
-/**
- * @fileoverview Rule to ensure newline per method call when chaining calls
- * @author Rajendra Patil
- * @author Burak Yigit Kaya
- * @deprecated in ESLint v8.53.0
- */
-
-"use strict";
-
-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: "newline-per-chained-call",
-						url: "https://eslint.style/rules/newline-per-chained-call",
-					},
-				},
-			],
-		},
-		type: "layout",
-
-		docs: {
-			description: "Require a newline after each call in a method chain",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/newline-per-chained-call",
-		},
-
-		fixable: "whitespace",
-
-		schema: [
-			{
-				type: "object",
-				properties: {
-					ignoreChainWithDepth: {
-						type: "integer",
-						minimum: 1,
-						maximum: 10,
-						default: 2,
-					},
-				},
-				additionalProperties: false,
-			},
-		],
-		messages: {
-			expected: "Expected line break before `{{callee}}`.",
-		},
-	},
-
-	create(context) {
-		const options = context.options[0] || {},
-			ignoreChainWithDepth = options.ignoreChainWithDepth || 2;
-
-		const sourceCode = context.sourceCode;
-
-		/**
-		 * Get the prefix of a given MemberExpression node.
-		 * If the MemberExpression node is a computed value it returns a
-		 * left bracket. If not it returns a period.
-		 * @param {ASTNode} node A MemberExpression node to get
-		 * @returns {string} The prefix of the node.
-		 */
-		function getPrefix(node) {
-			if (node.computed) {
-				if (node.optional) {
-					return "?.[";
-				}
-				return "[";
-			}
-			if (node.optional) {
-				return "?.";
-			}
-			return ".";
-		}
-
-		/**
-		 * Gets the property text of a given MemberExpression node.
-		 * If the text is multiline, this returns only the first line.
-		 * @param {ASTNode} node A MemberExpression node to get.
-		 * @returns {string} The property text of the node.
-		 */
-		function getPropertyText(node) {
-			const prefix = getPrefix(node);
-			const lines = sourceCode
-				.getText(node.property)
-				.split(astUtils.LINEBREAK_MATCHER);
-			const suffix = node.computed && lines.length === 1 ? "]" : "";
-
-			return prefix + lines[0] + suffix;
-		}
-
-		return {
-			"CallExpression:exit"(node) {
-				const callee = astUtils.skipChainExpression(node.callee);
-
-				if (callee.type !== "MemberExpression") {
-					return;
-				}
-
-				let parent = astUtils.skipChainExpression(callee.object);
-				let depth = 1;
-
-				while (parent && parent.callee) {
-					depth += 1;
-					parent = astUtils.skipChainExpression(
-						astUtils.skipChainExpression(parent.callee).object,
-					);
-				}
-
-				if (
-					depth > ignoreChainWithDepth &&
-					astUtils.isTokenOnSameLine(callee.object, callee.property)
-				) {
-					const firstTokenAfterObject = sourceCode.getTokenAfter(
-						callee.object,
-						astUtils.isNotClosingParenToken,
-					);
-
-					context.report({
-						node: callee.property,
-						loc: {
-							start: firstTokenAfterObject.loc.start,
-							end: callee.loc.end,
-						},
-						messageId: "expected",
-						data: {
-							callee: getPropertyText(callee),
-						},
-						fix(fixer) {
-							return fixer.insertTextBefore(
-								firstTokenAfterObject,
-								"\n",
-							);
-						},
-					});
-				}
-			},
-		};
-	},
-};