@alexlit/lint-kit 166.0.1 → 167.0.0

package/packages/config-eslint/node_modules/eslint/lib/rules/space-before-blocks.js

@@ -1,232 +0,0 @@
-/**
- * @fileoverview A rule to ensure whitespace before blocks.
- * @author Mathias Schreck <https://github.com/lo1tuma>
- * @deprecated in ESLint v8.53.0
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-/**
- * Checks whether the given node represents the body of a function.
- * @param {ASTNode} node the node to check.
- * @returns {boolean} `true` if the node is function body.
- */
-function isFunctionBody(node) {
-	const parent = node.parent;
-
-	return (
-		node.type === "BlockStatement" &&
-		astUtils.isFunction(parent) &&
-		parent.body === node
-	);
-}
-
-//------------------------------------------------------------------------------
-// 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: "space-before-blocks",
-						url: "https://eslint.style/rules/space-before-blocks",
-					},
-				},
-			],
-		},
-		type: "layout",
-
-		docs: {
-			description: "Enforce consistent spacing before blocks",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/space-before-blocks",
-		},
-
-		fixable: "whitespace",
-
-		schema: [
-			{
-				oneOf: [
-					{
-						enum: ["always", "never"],
-					},
-					{
-						type: "object",
-						properties: {
-							keywords: {
-								enum: ["always", "never", "off"],
-							},
-							functions: {
-								enum: ["always", "never", "off"],
-							},
-							classes: {
-								enum: ["always", "never", "off"],
-							},
-						},
-						additionalProperties: false,
-					},
-				],
-			},
-		],
-
-		messages: {
-			unexpectedSpace: "Unexpected space before opening brace.",
-			missingSpace: "Missing space before opening brace.",
-		},
-	},
-
-	create(context) {
-		const config = context.options[0],
-			sourceCode = context.sourceCode;
-		let alwaysFunctions = true,
-			alwaysKeywords = true,
-			alwaysClasses = true,
-			neverFunctions = false,
-			neverKeywords = false,
-			neverClasses = false;
-
-		if (typeof config === "object") {
-			alwaysFunctions = config.functions === "always";
-			alwaysKeywords = config.keywords === "always";
-			alwaysClasses = config.classes === "always";
-			neverFunctions = config.functions === "never";
-			neverKeywords = config.keywords === "never";
-			neverClasses = config.classes === "never";
-		} else if (config === "never") {
-			alwaysFunctions = false;
-			alwaysKeywords = false;
-			alwaysClasses = false;
-			neverFunctions = true;
-			neverKeywords = true;
-			neverClasses = true;
-		}
-
-		/**
-		 * Checks whether the spacing before the given block is already controlled by another rule:
-		 * - `arrow-spacing` checks spaces after `=>`.
-		 * - `keyword-spacing` checks spaces after keywords in certain contexts.
-		 * - `switch-colon-spacing` checks spaces after `:` of switch cases.
-		 * @param {Token} precedingToken first token before the block.
-		 * @param {ASTNode|Token} node `BlockStatement` node or `{` token of a `SwitchStatement` node.
-		 * @returns {boolean} `true` if requiring or disallowing spaces before the given block could produce conflicts with other rules.
-		 */
-		function isConflicted(precedingToken, node) {
-			return (
-				astUtils.isArrowToken(precedingToken) ||
-				(astUtils.isKeywordToken(precedingToken) &&
-					!isFunctionBody(node)) ||
-				(astUtils.isColonToken(precedingToken) &&
-					node.parent &&
-					node.parent.type === "SwitchCase" &&
-					precedingToken ===
-						astUtils.getSwitchCaseColonToken(
-							node.parent,
-							sourceCode,
-						))
-			);
-		}
-
-		/**
-		 * Checks the given BlockStatement node has a preceding space if it doesn’t start on a new line.
-		 * @param {ASTNode|Token} node The AST node of a BlockStatement.
-		 * @returns {void} undefined.
-		 */
-		function checkPrecedingSpace(node) {
-			const precedingToken = sourceCode.getTokenBefore(node);
-
-			if (
-				precedingToken &&
-				!isConflicted(precedingToken, node) &&
-				astUtils.isTokenOnSameLine(precedingToken, node)
-			) {
-				const hasSpace = sourceCode.isSpaceBetweenTokens(
-					precedingToken,
-					node,
-				);
-				let requireSpace;
-				let requireNoSpace;
-
-				if (isFunctionBody(node)) {
-					requireSpace = alwaysFunctions;
-					requireNoSpace = neverFunctions;
-				} else if (node.type === "ClassBody") {
-					requireSpace = alwaysClasses;
-					requireNoSpace = neverClasses;
-				} else {
-					requireSpace = alwaysKeywords;
-					requireNoSpace = neverKeywords;
-				}
-
-				if (requireSpace && !hasSpace) {
-					context.report({
-						node,
-						messageId: "missingSpace",
-						fix(fixer) {
-							return fixer.insertTextBefore(node, " ");
-						},
-					});
-				} else if (requireNoSpace && hasSpace) {
-					context.report({
-						node,
-						messageId: "unexpectedSpace",
-						fix(fixer) {
-							return fixer.removeRange([
-								precedingToken.range[1],
-								node.range[0],
-							]);
-						},
-					});
-				}
-			}
-		}
-
-		/**
-		 * Checks if the CaseBlock of an given SwitchStatement node has a preceding space.
-		 * @param {ASTNode} node The node of a SwitchStatement.
-		 * @returns {void} undefined.
-		 */
-		function checkSpaceBeforeCaseBlock(node) {
-			const cases = node.cases;
-			let openingBrace;
-
-			if (cases.length > 0) {
-				openingBrace = sourceCode.getTokenBefore(cases[0]);
-			} else {
-				openingBrace = sourceCode.getLastToken(node, 1);
-			}
-
-			checkPrecedingSpace(openingBrace);
-		}
-
-		return {
-			BlockStatement: checkPrecedingSpace,
-			ClassBody: checkPrecedingSpace,
-			SwitchStatement: checkSpaceBeforeCaseBlock,
-		};
-	},
-};

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

@@ -1,205 +0,0 @@
-/**
- * @fileoverview Rule to validate spacing before function paren.
- * @author Mathias Schreck <https://github.com/lo1tuma>
- * @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: "space-before-function-paren",
-						url: "https://eslint.style/rules/space-before-function-paren",
-					},
-				},
-			],
-		},
-		type: "layout",
-
-		docs: {
-			description:
-				"Enforce consistent spacing before `function` definition opening parenthesis",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/space-before-function-paren",
-		},
-
-		fixable: "whitespace",
-
-		schema: [
-			{
-				oneOf: [
-					{
-						enum: ["always", "never"],
-					},
-					{
-						type: "object",
-						properties: {
-							anonymous: {
-								enum: ["always", "never", "ignore"],
-							},
-							named: {
-								enum: ["always", "never", "ignore"],
-							},
-							asyncArrow: {
-								enum: ["always", "never", "ignore"],
-							},
-						},
-						additionalProperties: false,
-					},
-				],
-			},
-		],
-
-		messages: {
-			unexpectedSpace: "Unexpected space before function parentheses.",
-			missingSpace: "Missing space before function parentheses.",
-		},
-	},
-
-	create(context) {
-		const sourceCode = context.sourceCode;
-		const baseConfig =
-			typeof context.options[0] === "string"
-				? context.options[0]
-				: "always";
-		const overrideConfig =
-			typeof context.options[0] === "object" ? context.options[0] : {};
-
-		/**
-		 * Determines whether a function has a name.
-		 * @param {ASTNode} node The function node.
-		 * @returns {boolean} Whether the function has a name.
-		 */
-		function isNamedFunction(node) {
-			if (node.id) {
-				return true;
-			}
-
-			const parent = node.parent;
-
-			return (
-				parent.type === "MethodDefinition" ||
-				(parent.type === "Property" &&
-					(parent.kind === "get" ||
-						parent.kind === "set" ||
-						parent.method))
-			);
-		}
-
-		/**
-		 * Gets the config for a given function
-		 * @param {ASTNode} node The function node
-		 * @returns {string} "always", "never", or "ignore"
-		 */
-		function getConfigForFunction(node) {
-			if (node.type === "ArrowFunctionExpression") {
-				// Always ignore non-async functions and arrow functions without parens, e.g. async foo => bar
-				if (
-					node.async &&
-					astUtils.isOpeningParenToken(
-						sourceCode.getFirstToken(node, { skip: 1 }),
-					)
-				) {
-					return overrideConfig.asyncArrow || baseConfig;
-				}
-			} else if (isNamedFunction(node)) {
-				return overrideConfig.named || baseConfig;
-
-				// `generator-star-spacing` should warn anonymous generators. E.g. `function* () {}`
-			} else if (!node.generator) {
-				return overrideConfig.anonymous || baseConfig;
-			}
-
-			return "ignore";
-		}
-
-		/**
-		 * Checks the parens of a function node
-		 * @param {ASTNode} node A function node
-		 * @returns {void}
-		 */
-		function checkFunction(node) {
-			const functionConfig = getConfigForFunction(node);
-
-			if (functionConfig === "ignore") {
-				return;
-			}
-
-			const rightToken = sourceCode.getFirstToken(
-				node,
-				astUtils.isOpeningParenToken,
-			);
-			const leftToken = sourceCode.getTokenBefore(rightToken);
-			const hasSpacing = sourceCode.isSpaceBetweenTokens(
-				leftToken,
-				rightToken,
-			);
-
-			if (hasSpacing && functionConfig === "never") {
-				context.report({
-					node,
-					loc: {
-						start: leftToken.loc.end,
-						end: rightToken.loc.start,
-					},
-					messageId: "unexpectedSpace",
-					fix(fixer) {
-						const comments =
-							sourceCode.getCommentsBefore(rightToken);
-
-						// Don't fix anything if there's a single line comment between the left and the right token
-						if (comments.some(comment => comment.type === "Line")) {
-							return null;
-						}
-						return fixer.replaceTextRange(
-							[leftToken.range[1], rightToken.range[0]],
-							comments.reduce(
-								(text, comment) =>
-									text + sourceCode.getText(comment),
-								"",
-							),
-						);
-					},
-				});
-			} else if (!hasSpacing && functionConfig === "always") {
-				context.report({
-					node,
-					loc: rightToken.loc,
-					messageId: "missingSpace",
-					fix: fixer => fixer.insertTextAfter(leftToken, " "),
-				});
-			}
-		}
-
-		return {
-			ArrowFunctionExpression: checkFunction,
-			FunctionDeclaration: checkFunction,
-			FunctionExpression: checkFunction,
-		};
-	},
-};