@alexlit/lint-kit 166.0.1 → 167.0.0

package/packages/config-eslint/node_modules/eslint/lib/rules/func-style.js

@@ -1,221 +0,0 @@
-/**
- * @fileoverview Rule to enforce a particular function style
- * @author Nicholas C. Zakas
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		dialects: ["javascript", "typescript"],
-		language: "javascript",
-		type: "suggestion",
-
-		defaultOptions: [
-			"expression",
-			{
-				allowArrowFunctions: false,
-				allowTypeAnnotation: false,
-				overrides: {},
-			},
-		],
-
-		docs: {
-			description:
-				"Enforce the consistent use of either `function` declarations or expressions assigned to variables",
-			recommended: false,
-			frozen: true,
-			url: "https://eslint.org/docs/latest/rules/func-style",
-		},
-
-		schema: [
-			{
-				enum: ["declaration", "expression"],
-			},
-			{
-				type: "object",
-				properties: {
-					allowArrowFunctions: {
-						type: "boolean",
-					},
-					allowTypeAnnotation: {
-						type: "boolean",
-					},
-					overrides: {
-						type: "object",
-						properties: {
-							namedExports: {
-								enum: ["declaration", "expression", "ignore"],
-							},
-						},
-						additionalProperties: false,
-					},
-				},
-				additionalProperties: false,
-			},
-		],
-
-		messages: {
-			expression: "Expected a function expression.",
-			declaration: "Expected a function declaration.",
-		},
-	},
-
-	create(context) {
-		const [style, { allowArrowFunctions, allowTypeAnnotation, overrides }] =
-			context.options;
-		const enforceDeclarations = style === "declaration";
-		const { namedExports: exportFunctionStyle } = overrides;
-		const stack = [];
-
-		/**
-		 * Checks if a function declaration is part of an overloaded function
-		 * @param {ASTNode} node The function declaration node to check
-		 * @returns {boolean} True if the function is overloaded
-		 */
-		function isOverloadedFunction(node) {
-			const functionName = node.id.name;
-
-			if (node.parent.type === "ExportNamedDeclaration") {
-				return node.parent.parent.body.some(
-					member =>
-						member.type === "ExportNamedDeclaration" &&
-						member.declaration?.type === "TSDeclareFunction" &&
-						member.declaration.id.name === functionName,
-				);
-			}
-
-			if (node.parent.type === "SwitchCase") {
-				return node.parent.parent.cases.some(switchCase =>
-					switchCase.consequent.some(
-						member =>
-							member.type === "TSDeclareFunction" &&
-							member.id.name === functionName,
-					),
-				);
-			}
-
-			return (
-				Array.isArray(node.parent.body) &&
-				node.parent.body.some(
-					member =>
-						member.type === "TSDeclareFunction" &&
-						member.id.name === functionName,
-				)
-			);
-		}
-
-		const nodesToCheck = {
-			FunctionDeclaration(node) {
-				stack.push(false);
-
-				if (
-					!enforceDeclarations &&
-					node.parent.type !== "ExportDefaultDeclaration" &&
-					(typeof exportFunctionStyle === "undefined" ||
-						node.parent.type !== "ExportNamedDeclaration") &&
-					!isOverloadedFunction(node)
-				) {
-					context.report({ node, messageId: "expression" });
-				}
-
-				if (
-					node.parent.type === "ExportNamedDeclaration" &&
-					exportFunctionStyle === "expression" &&
-					!isOverloadedFunction(node)
-				) {
-					context.report({ node, messageId: "expression" });
-				}
-			},
-			"FunctionDeclaration:exit"() {
-				stack.pop();
-			},
-
-			FunctionExpression(node) {
-				stack.push(false);
-
-				if (
-					enforceDeclarations &&
-					node.parent.type === "VariableDeclarator" &&
-					(typeof exportFunctionStyle === "undefined" ||
-						node.parent.parent.parent.type !==
-							"ExportNamedDeclaration") &&
-					!(allowTypeAnnotation && node.parent.id.typeAnnotation)
-				) {
-					context.report({
-						node: node.parent,
-						messageId: "declaration",
-					});
-				}
-
-				if (
-					node.parent.type === "VariableDeclarator" &&
-					node.parent.parent.parent.type ===
-						"ExportNamedDeclaration" &&
-					exportFunctionStyle === "declaration" &&
-					!(allowTypeAnnotation && node.parent.id.typeAnnotation)
-				) {
-					context.report({
-						node: node.parent,
-						messageId: "declaration",
-					});
-				}
-			},
-			"FunctionExpression:exit"() {
-				stack.pop();
-			},
-
-			"ThisExpression, Super"() {
-				if (stack.length > 0) {
-					stack[stack.length - 1] = true;
-				}
-			},
-		};
-
-		if (!allowArrowFunctions) {
-			nodesToCheck.ArrowFunctionExpression = function () {
-				stack.push(false);
-			};
-
-			nodesToCheck["ArrowFunctionExpression:exit"] = function (node) {
-				const hasThisOrSuperExpr = stack.pop();
-
-				if (
-					!hasThisOrSuperExpr &&
-					node.parent.type === "VariableDeclarator"
-				) {
-					if (
-						enforceDeclarations &&
-						(typeof exportFunctionStyle === "undefined" ||
-							node.parent.parent.parent.type !==
-								"ExportNamedDeclaration") &&
-						!(allowTypeAnnotation && node.parent.id.typeAnnotation)
-					) {
-						context.report({
-							node: node.parent,
-							messageId: "declaration",
-						});
-					}
-
-					if (
-						node.parent.parent.parent.type ===
-							"ExportNamedDeclaration" &&
-						exportFunctionStyle === "declaration" &&
-						!(allowTypeAnnotation && node.parent.id.typeAnnotation)
-					) {
-						context.report({
-							node: node.parent,
-							messageId: "declaration",
-						});
-					}
-				}
-			};
-		}
-
-		return nodesToCheck;
-	},
-};

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

@@ -1,166 +0,0 @@
-/**
- * @fileoverview Rule to enforce line breaks between arguments of a function call
- * @author Alexey Gonchar <https://github.com/finico>
- * @deprecated in ESLint v8.53.0
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// 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-call-argument-newline",
-						url: "https://eslint.style/rules/function-call-argument-newline",
-					},
-				},
-			],
-		},
-		type: "layout",
-
-		docs: {
-			description:
-				"Enforce line breaks between arguments of a function call",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/function-call-argument-newline",
-		},
-
-		fixable: "whitespace",
-
-		schema: [
-			{
-				enum: ["always", "never", "consistent"],
-			},
-		],
-
-		messages: {
-			unexpectedLineBreak: "There should be no line break here.",
-			missingLineBreak:
-				"There should be a line break after this argument.",
-		},
-	},
-
-	create(context) {
-		const sourceCode = context.sourceCode;
-
-		const checkers = {
-			unexpected: {
-				messageId: "unexpectedLineBreak",
-				check: (prevToken, currentToken) =>
-					prevToken.loc.end.line !== currentToken.loc.start.line,
-				createFix: (token, tokenBefore) => fixer =>
-					fixer.replaceTextRange(
-						[tokenBefore.range[1], token.range[0]],
-						" ",
-					),
-			},
-			missing: {
-				messageId: "missingLineBreak",
-				check: (prevToken, currentToken) =>
-					prevToken.loc.end.line === currentToken.loc.start.line,
-				createFix: (token, tokenBefore) => fixer =>
-					fixer.replaceTextRange(
-						[tokenBefore.range[1], token.range[0]],
-						"\n",
-					),
-			},
-		};
-
-		/**
-		 * Check all arguments for line breaks in the CallExpression
-		 * @param {CallExpression} node node to evaluate
-		 * @param {{ messageId: string, check: Function }} checker selected checker
-		 * @returns {void}
-		 * @private
-		 */
-		function checkArguments(node, checker) {
-			for (let i = 1; i < node.arguments.length; i++) {
-				const prevArgToken = sourceCode.getLastToken(
-					node.arguments[i - 1],
-				);
-				const currentArgToken = sourceCode.getFirstToken(
-					node.arguments[i],
-				);
-
-				if (checker.check(prevArgToken, currentArgToken)) {
-					const tokenBefore = sourceCode.getTokenBefore(
-						currentArgToken,
-						{ includeComments: true },
-					);
-
-					const hasLineCommentBefore = tokenBefore.type === "Line";
-
-					context.report({
-						node,
-						loc: {
-							start: tokenBefore.loc.end,
-							end: currentArgToken.loc.start,
-						},
-						messageId: checker.messageId,
-						fix: hasLineCommentBefore
-							? null
-							: checker.createFix(currentArgToken, tokenBefore),
-					});
-				}
-			}
-		}
-
-		/**
-		 * Check if open space is present in a function name
-		 * @param {CallExpression} node node to evaluate
-		 * @returns {void}
-		 * @private
-		 */
-		function check(node) {
-			if (node.arguments.length < 2) {
-				return;
-			}
-
-			const option = context.options[0] || "always";
-
-			if (option === "never") {
-				checkArguments(node, checkers.unexpected);
-			} else if (option === "always") {
-				checkArguments(node, checkers.missing);
-			} else if (option === "consistent") {
-				const firstArgToken = sourceCode.getLastToken(
-					node.arguments[0],
-				);
-				const secondArgToken = sourceCode.getFirstToken(
-					node.arguments[1],
-				);
-
-				if (
-					firstArgToken.loc.end.line === secondArgToken.loc.start.line
-				) {
-					checkArguments(node, checkers.unexpected);
-				} else {
-					checkArguments(node, checkers.missing);
-				}
-			}
-		}
-
-		return {
-			CallExpression: check,
-			NewExpression: check,
-		};
-	},
-};