@alexlit/lint-kit 175.0.0 → 176.0.0

package/packages/config-eslint/node_modules/eslint/lib/rules/function-paren-newline.js

@@ -1,368 +0,0 @@
-/**
- * @fileoverview enforce consistent line breaks inside function parentheses
- * @author Teddy Katz
- * @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: "function-paren-newline",
-						url: "https://eslint.style/rules/function-paren-newline",
-					},
-				},
-			],
-		},
-		type: "layout",
-
-		docs: {
-			description:
-				"Enforce consistent line breaks inside function parentheses",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/function-paren-newline",
-		},
-
-		fixable: "whitespace",
-
-		schema: [
-			{
-				oneOf: [
-					{
-						enum: [
-							"always",
-							"never",
-							"consistent",
-							"multiline",
-							"multiline-arguments",
-						],
-					},
-					{
-						type: "object",
-						properties: {
-							minItems: {
-								type: "integer",
-								minimum: 0,
-							},
-						},
-						additionalProperties: false,
-					},
-				],
-			},
-		],
-
-		messages: {
-			expectedBefore: "Expected newline before ')'.",
-			expectedAfter: "Expected newline after '('.",
-			expectedBetween: "Expected newline between arguments/params.",
-			unexpectedBefore: "Unexpected newline before ')'.",
-			unexpectedAfter: "Unexpected newline after '('.",
-		},
-	},
-
-	create(context) {
-		const sourceCode = context.sourceCode;
-		const rawOption = context.options[0] || "multiline";
-		const multilineOption = rawOption === "multiline";
-		const multilineArgumentsOption = rawOption === "multiline-arguments";
-		const consistentOption = rawOption === "consistent";
-		let minItems;
-
-		if (typeof rawOption === "object") {
-			minItems = rawOption.minItems;
-		} else if (rawOption === "always") {
-			minItems = 0;
-		} else if (rawOption === "never") {
-			minItems = Infinity;
-		} else {
-			minItems = null;
-		}
-
-		//----------------------------------------------------------------------
-		// Helpers
-		//----------------------------------------------------------------------
-
-		/**
-		 * Determines whether there should be newlines inside function parens
-		 * @param {ASTNode[]} elements The arguments or parameters in the list
-		 * @param {boolean} hasLeftNewline `true` if the left paren has a newline in the current code.
-		 * @returns {boolean} `true` if there should be newlines inside the function parens
-		 */
-		function shouldHaveNewlines(elements, hasLeftNewline) {
-			if (multilineArgumentsOption && elements.length === 1) {
-				return hasLeftNewline;
-			}
-			if (multilineOption || multilineArgumentsOption) {
-				return elements.some(
-					(element, index) =>
-						index !== elements.length - 1 &&
-						element.loc.end.line !==
-							elements[index + 1].loc.start.line,
-				);
-			}
-			if (consistentOption) {
-				return hasLeftNewline;
-			}
-			return elements.length >= minItems;
-		}
-
-		/**
-		 * Validates parens
-		 * @param {Object} parens An object with keys `leftParen` for the left paren token, and `rightParen` for the right paren token
-		 * @param {ASTNode[]} elements The arguments or parameters in the list
-		 * @returns {void}
-		 */
-		function validateParens(parens, elements) {
-			const leftParen = parens.leftParen;
-			const rightParen = parens.rightParen;
-			const tokenAfterLeftParen = sourceCode.getTokenAfter(leftParen);
-			const tokenBeforeRightParen = sourceCode.getTokenBefore(rightParen);
-			const hasLeftNewline = !astUtils.isTokenOnSameLine(
-				leftParen,
-				tokenAfterLeftParen,
-			);
-			const hasRightNewline = !astUtils.isTokenOnSameLine(
-				tokenBeforeRightParen,
-				rightParen,
-			);
-			const needsNewlines = shouldHaveNewlines(elements, hasLeftNewline);
-
-			if (hasLeftNewline && !needsNewlines) {
-				context.report({
-					node: leftParen,
-					messageId: "unexpectedAfter",
-					fix(fixer) {
-						return sourceCode
-							.getText()
-							.slice(
-								leftParen.range[1],
-								tokenAfterLeftParen.range[0],
-							)
-							.trim()
-							? // If there is a comment between the ( and the first element, don't do a fix.
-								null
-							: fixer.removeRange([
-									leftParen.range[1],
-									tokenAfterLeftParen.range[0],
-								]);
-					},
-				});
-			} else if (!hasLeftNewline && needsNewlines) {
-				context.report({
-					node: leftParen,
-					messageId: "expectedAfter",
-					fix: fixer => fixer.insertTextAfter(leftParen, "\n"),
-				});
-			}
-
-			if (hasRightNewline && !needsNewlines) {
-				context.report({
-					node: rightParen,
-					messageId: "unexpectedBefore",
-					fix(fixer) {
-						return sourceCode
-							.getText()
-							.slice(
-								tokenBeforeRightParen.range[1],
-								rightParen.range[0],
-							)
-							.trim()
-							? // If there is a comment between the last element and the ), don't do a fix.
-								null
-							: fixer.removeRange([
-									tokenBeforeRightParen.range[1],
-									rightParen.range[0],
-								]);
-					},
-				});
-			} else if (!hasRightNewline && needsNewlines) {
-				context.report({
-					node: rightParen,
-					messageId: "expectedBefore",
-					fix: fixer => fixer.insertTextBefore(rightParen, "\n"),
-				});
-			}
-		}
-
-		/**
-		 * Validates a list of arguments or parameters
-		 * @param {Object} parens An object with keys `leftParen` for the left paren token, and `rightParen` for the right paren token
-		 * @param {ASTNode[]} elements The arguments or parameters in the list
-		 * @returns {void}
-		 */
-		function validateArguments(parens, elements) {
-			const leftParen = parens.leftParen;
-			const tokenAfterLeftParen = sourceCode.getTokenAfter(leftParen);
-			const hasLeftNewline = !astUtils.isTokenOnSameLine(
-				leftParen,
-				tokenAfterLeftParen,
-			);
-			const needsNewlines = shouldHaveNewlines(elements, hasLeftNewline);
-
-			for (let i = 0; i <= elements.length - 2; i++) {
-				const currentElement = elements[i];
-				const nextElement = elements[i + 1];
-				const hasNewLine =
-					currentElement.loc.end.line !== nextElement.loc.start.line;
-
-				if (!hasNewLine && needsNewlines) {
-					context.report({
-						node: currentElement,
-						messageId: "expectedBetween",
-						fix: fixer => fixer.insertTextBefore(nextElement, "\n"),
-					});
-				}
-			}
-		}
-
-		/**
-		 * Gets the left paren and right paren tokens of a node.
-		 * @param {ASTNode} node The node with parens
-		 * @throws {TypeError} Unexpected node type.
-		 * @returns {Object} An object with keys `leftParen` for the left paren token, and `rightParen` for the right paren token.
-		 * Can also return `null` if an expression has no parens (e.g. a NewExpression with no arguments, or an ArrowFunctionExpression
-		 * with a single parameter)
-		 */
-		function getParenTokens(node) {
-			switch (node.type) {
-				case "NewExpression":
-					if (
-						!node.arguments.length &&
-						!(
-							astUtils.isOpeningParenToken(
-								sourceCode.getLastToken(node, { skip: 1 }),
-							) &&
-							astUtils.isClosingParenToken(
-								sourceCode.getLastToken(node),
-							) &&
-							node.callee.range[1] < node.range[1]
-						)
-					) {
-						// If the NewExpression does not have parens (e.g. `new Foo`), return null.
-						return null;
-					}
-
-				// falls through
-
-				case "CallExpression":
-					return {
-						leftParen: sourceCode.getTokenAfter(
-							node.callee,
-							astUtils.isOpeningParenToken,
-						),
-						rightParen: sourceCode.getLastToken(node),
-					};
-
-				case "FunctionDeclaration":
-				case "FunctionExpression": {
-					const leftParen = sourceCode.getFirstToken(
-						node,
-						astUtils.isOpeningParenToken,
-					);
-					const rightParen = node.params.length
-						? sourceCode.getTokenAfter(
-								node.params.at(-1),
-								astUtils.isClosingParenToken,
-							)
-						: sourceCode.getTokenAfter(leftParen);
-
-					return { leftParen, rightParen };
-				}
-
-				case "ArrowFunctionExpression": {
-					const firstToken = sourceCode.getFirstToken(node, {
-						skip: node.async ? 1 : 0,
-					});
-
-					if (!astUtils.isOpeningParenToken(firstToken)) {
-						// If the ArrowFunctionExpression has a single param without parens, return null.
-						return null;
-					}
-
-					const rightParen = node.params.length
-						? sourceCode.getTokenAfter(
-								node.params.at(-1),
-								astUtils.isClosingParenToken,
-							)
-						: sourceCode.getTokenAfter(firstToken);
-
-					return {
-						leftParen: firstToken,
-						rightParen,
-					};
-				}
-
-				case "ImportExpression": {
-					const leftParen = sourceCode.getFirstToken(node, 1);
-					const rightParen = sourceCode.getLastToken(node);
-
-					return { leftParen, rightParen };
-				}
-
-				default:
-					throw new TypeError(
-						`unexpected node with type ${node.type}`,
-					);
-			}
-		}
-
-		//----------------------------------------------------------------------
-		// Public
-		//----------------------------------------------------------------------
-
-		return {
-			[[
-				"ArrowFunctionExpression",
-				"CallExpression",
-				"FunctionDeclaration",
-				"FunctionExpression",
-				"ImportExpression",
-				"NewExpression",
-			]](node) {
-				const parens = getParenTokens(node);
-				let params;
-
-				if (node.type === "ImportExpression") {
-					params = [node.source];
-				} else if (astUtils.isFunction(node)) {
-					params = node.params;
-				} else {
-					params = node.arguments;
-				}
-
-				if (parens) {
-					validateParens(parens, params);
-
-					if (multilineArgumentsOption) {
-						validateArguments(parens, params);
-					}
-				}
-			},
-		};
-	},
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/generator-star-spacing.js

@@ -1,246 +0,0 @@
-/**
- * @fileoverview Rule to check the spacing around the * in generator functions.
- * @author Jamund Ferguson
- * @deprecated in ESLint v8.53.0
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-const OVERRIDE_SCHEMA = {
-	oneOf: [
-		{
-			enum: ["before", "after", "both", "neither"],
-		},
-		{
-			type: "object",
-			properties: {
-				before: { type: "boolean" },
-				after: { type: "boolean" },
-			},
-			additionalProperties: false,
-		},
-	],
-};
-
-/** @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: "generator-star-spacing",
-						url: "https://eslint.style/rules/generator-star-spacing",
-					},
-				},
-			],
-		},
-		type: "layout",
-
-		docs: {
-			description:
-				"Enforce consistent spacing around `*` operators in generator functions",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/generator-star-spacing",
-		},
-
-		fixable: "whitespace",
-
-		schema: [
-			{
-				oneOf: [
-					{
-						enum: ["before", "after", "both", "neither"],
-					},
-					{
-						type: "object",
-						properties: {
-							before: { type: "boolean" },
-							after: { type: "boolean" },
-							named: OVERRIDE_SCHEMA,
-							anonymous: OVERRIDE_SCHEMA,
-							method: OVERRIDE_SCHEMA,
-						},
-						additionalProperties: false,
-					},
-				],
-			},
-		],
-
-		messages: {
-			missingBefore: "Missing space before *.",
-			missingAfter: "Missing space after *.",
-			unexpectedBefore: "Unexpected space before *.",
-			unexpectedAfter: "Unexpected space after *.",
-		},
-	},
-
-	create(context) {
-		const optionDefinitions = {
-			before: { before: true, after: false },
-			after: { before: false, after: true },
-			both: { before: true, after: true },
-			neither: { before: false, after: false },
-		};
-
-		/**
-		 * Returns resolved option definitions based on an option and defaults
-		 * @param {any} option The option object or string value
-		 * @param {Object} defaults The defaults to use if options are not present
-		 * @returns {Object} the resolved object definition
-		 */
-		function optionToDefinition(option, defaults) {
-			if (!option) {
-				return defaults;
-			}
-
-			return typeof option === "string"
-				? optionDefinitions[option]
-				: Object.assign({}, defaults, option);
-		}
-
-		const modes = (function (option) {
-			const defaults = optionToDefinition(
-				option,
-				optionDefinitions.before,
-			);
-
-			return {
-				named: optionToDefinition(option.named, defaults),
-				anonymous: optionToDefinition(option.anonymous, defaults),
-				method: optionToDefinition(option.method, defaults),
-			};
-		})(context.options[0] || {});
-
-		const sourceCode = context.sourceCode;
-
-		/**
-		 * Checks if the given token is a star token or not.
-		 * @param {Token} token The token to check.
-		 * @returns {boolean} `true` if the token is a star token.
-		 */
-		function isStarToken(token) {
-			return token.value === "*" && token.type === "Punctuator";
-		}
-
-		/**
-		 * Gets the generator star token of the given function node.
-		 * @param {ASTNode} node The function node to get.
-		 * @returns {Token} Found star token.
-		 */
-		function getStarToken(node) {
-			return sourceCode.getFirstToken(
-				node.parent.method || node.parent.type === "MethodDefinition"
-					? node.parent
-					: node,
-				isStarToken,
-			);
-		}
-
-		/**
-		 * capitalize a given string.
-		 * @param {string} str the given string.
-		 * @returns {string} the capitalized string.
-		 */
-		function capitalize(str) {
-			return str[0].toUpperCase() + str.slice(1);
-		}
-
-		/**
-		 * Checks the spacing between two tokens before or after the star token.
-		 * @param {string} kind Either "named", "anonymous", or "method"
-		 * @param {string} side Either "before" or "after".
-		 * @param {Token} leftToken `function` keyword token if side is "before", or
-		 *     star token if side is "after".
-		 * @param {Token} rightToken Star token if side is "before", or identifier
-		 *     token if side is "after".
-		 * @returns {void}
-		 */
-		function checkSpacing(kind, side, leftToken, rightToken) {
-			if (
-				!!(rightToken.range[0] - leftToken.range[1]) !==
-				modes[kind][side]
-			) {
-				const after = leftToken.value === "*";
-				const spaceRequired = modes[kind][side];
-				const node = after ? leftToken : rightToken;
-				const messageId = `${spaceRequired ? "missing" : "unexpected"}${capitalize(side)}`;
-
-				context.report({
-					node,
-					messageId,
-					fix(fixer) {
-						if (spaceRequired) {
-							if (after) {
-								return fixer.insertTextAfter(node, " ");
-							}
-							return fixer.insertTextBefore(node, " ");
-						}
-						return fixer.removeRange([
-							leftToken.range[1],
-							rightToken.range[0],
-						]);
-					},
-				});
-			}
-		}
-
-		/**
-		 * Enforces the spacing around the star if node is a generator function.
-		 * @param {ASTNode} node A function expression or declaration node.
-		 * @returns {void}
-		 */
-		function checkFunction(node) {
-			if (!node.generator) {
-				return;
-			}
-
-			const starToken = getStarToken(node);
-			const prevToken = sourceCode.getTokenBefore(starToken);
-			const nextToken = sourceCode.getTokenAfter(starToken);
-
-			let kind = "named";
-
-			if (
-				node.parent.type === "MethodDefinition" ||
-				(node.parent.type === "Property" && node.parent.method)
-			) {
-				kind = "method";
-			} else if (!node.id) {
-				kind = "anonymous";
-			}
-
-			// Only check before when preceded by `function`|`static` keyword
-			if (
-				!(
-					kind === "method" &&
-					starToken === sourceCode.getFirstToken(node.parent)
-				)
-			) {
-				checkSpacing(kind, "before", prevToken, starToken);
-			}
-
-			checkSpacing(kind, "after", starToken, nextToken);
-		}
-
-		return {
-			FunctionDeclaration: checkFunction,
-			FunctionExpression: checkFunction,
-		};
-	},
-};