@alexlit/lint-kit 178.0.0 → 180.0.0

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

@@ -1,391 +0,0 @@
-/**
- * @fileoverview Comma style - enforces comma styles of two types: last and first
- * @author Vignesh Anand aka vegetableman
- * @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: "comma-style",
-						url: "https://eslint.style/rules/comma-style",
-					},
-				},
-			],
-		},
-		type: "layout",
-
-		docs: {
-			description: "Enforce consistent comma style",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/comma-style",
-		},
-
-		fixable: "code",
-
-		schema: [
-			{
-				enum: ["first", "last"],
-			},
-			{
-				type: "object",
-				properties: {
-					exceptions: {
-						type: "object",
-						additionalProperties: {
-							type: "boolean",
-						},
-					},
-				},
-				additionalProperties: false,
-			},
-		],
-
-		messages: {
-			unexpectedLineBeforeAndAfterComma:
-				"Bad line breaking before and after ','.",
-			expectedCommaFirst: "',' should be placed first.",
-			expectedCommaLast: "',' should be placed last.",
-		},
-	},
-
-	create(context) {
-		const style = context.options[0] || "last",
-			sourceCode = context.sourceCode;
-		const exceptions = {
-			ArrayPattern: true,
-			ArrowFunctionExpression: true,
-			CallExpression: true,
-			FunctionDeclaration: true,
-			FunctionExpression: true,
-			ImportDeclaration: true,
-			ObjectPattern: true,
-			NewExpression: true,
-		};
-
-		if (
-			context.options.length === 2 &&
-			Object.hasOwn(context.options[1], "exceptions")
-		) {
-			const keys = Object.keys(context.options[1].exceptions);
-
-			for (let i = 0; i < keys.length; i++) {
-				exceptions[keys[i]] = context.options[1].exceptions[keys[i]];
-			}
-		}
-
-		//--------------------------------------------------------------------------
-		// Helpers
-		//--------------------------------------------------------------------------
-
-		/**
-		 * Modified text based on the style
-		 * @param {string} styleType Style type
-		 * @param {string} text Source code text
-		 * @returns {string} modified text
-		 * @private
-		 */
-		function getReplacedText(styleType, text) {
-			switch (styleType) {
-				case "between":
-					return `,${text.replace(astUtils.LINEBREAK_MATCHER, "")}`;
-
-				case "first":
-					return `${text},`;
-
-				case "last":
-					return `,${text}`;
-
-				default:
-					return "";
-			}
-		}
-
-		/**
-		 * Determines the fixer function for a given style.
-		 * @param {string} styleType comma style
-		 * @param {ASTNode} previousItemToken The token to check.
-		 * @param {ASTNode} commaToken The token to check.
-		 * @param {ASTNode} currentItemToken The token to check.
-		 * @returns {Function} Fixer function
-		 * @private
-		 */
-		function getFixerFunction(
-			styleType,
-			previousItemToken,
-			commaToken,
-			currentItemToken,
-		) {
-			const text =
-				sourceCode.text.slice(
-					previousItemToken.range[1],
-					commaToken.range[0],
-				) +
-				sourceCode.text.slice(
-					commaToken.range[1],
-					currentItemToken.range[0],
-				);
-			const range = [
-				previousItemToken.range[1],
-				currentItemToken.range[0],
-			];
-
-			return function (fixer) {
-				return fixer.replaceTextRange(
-					range,
-					getReplacedText(styleType, text),
-				);
-			};
-		}
-
-		/**
-		 * Validates the spacing around single items in lists.
-		 * @param {Token} previousItemToken The last token from the previous item.
-		 * @param {Token} commaToken The token representing the comma.
-		 * @param {Token} currentItemToken The first token of the current item.
-		 * @param {Token} reportItem The item to use when reporting an error.
-		 * @returns {void}
-		 * @private
-		 */
-		function validateCommaItemSpacing(
-			previousItemToken,
-			commaToken,
-			currentItemToken,
-			reportItem,
-		) {
-			// if single line
-			if (
-				astUtils.isTokenOnSameLine(commaToken, currentItemToken) &&
-				astUtils.isTokenOnSameLine(previousItemToken, commaToken)
-			) {
-				// do nothing.
-			} else if (
-				!astUtils.isTokenOnSameLine(commaToken, currentItemToken) &&
-				!astUtils.isTokenOnSameLine(previousItemToken, commaToken)
-			) {
-				const comment = sourceCode.getCommentsAfter(commaToken)[0];
-				const styleType =
-					comment &&
-					comment.type === "Block" &&
-					astUtils.isTokenOnSameLine(commaToken, comment)
-						? style
-						: "between";
-
-				// lone comma
-				context.report({
-					node: reportItem,
-					loc: commaToken.loc,
-					messageId: "unexpectedLineBeforeAndAfterComma",
-					fix: getFixerFunction(
-						styleType,
-						previousItemToken,
-						commaToken,
-						currentItemToken,
-					),
-				});
-			} else if (
-				style === "first" &&
-				!astUtils.isTokenOnSameLine(commaToken, currentItemToken)
-			) {
-				context.report({
-					node: reportItem,
-					loc: commaToken.loc,
-					messageId: "expectedCommaFirst",
-					fix: getFixerFunction(
-						style,
-						previousItemToken,
-						commaToken,
-						currentItemToken,
-					),
-				});
-			} else if (
-				style === "last" &&
-				astUtils.isTokenOnSameLine(commaToken, currentItemToken)
-			) {
-				context.report({
-					node: reportItem,
-					loc: commaToken.loc,
-					messageId: "expectedCommaLast",
-					fix: getFixerFunction(
-						style,
-						previousItemToken,
-						commaToken,
-						currentItemToken,
-					),
-				});
-			}
-		}
-
-		/**
-		 * Checks the comma placement with regards to a declaration/property/element
-		 * @param {ASTNode} node The binary expression node to check
-		 * @param {string} property The property of the node containing child nodes.
-		 * @private
-		 * @returns {void}
-		 */
-		function validateComma(node, property) {
-			const items = node[property],
-				arrayLiteral =
-					node.type === "ArrayExpression" ||
-					node.type === "ArrayPattern";
-
-			if (items.length > 1 || arrayLiteral) {
-				// seed as opening [
-				let previousItemToken = sourceCode.getFirstToken(node);
-
-				items.forEach(item => {
-					const commaToken = item
-							? sourceCode.getTokenBefore(item)
-							: previousItemToken,
-						currentItemToken = item
-							? sourceCode.getFirstToken(item)
-							: sourceCode.getTokenAfter(commaToken),
-						reportItem = item || currentItemToken;
-
-					/*
-					 * This works by comparing three token locations:
-					 * - previousItemToken is the last token of the previous item
-					 * - commaToken is the location of the comma before the current item
-					 * - currentItemToken is the first token of the current item
-					 *
-					 * These values get switched around if item is undefined.
-					 * previousItemToken will refer to the last token not belonging
-					 * to the current item, which could be a comma or an opening
-					 * square bracket. currentItemToken could be a comma.
-					 *
-					 * All comparisons are done based on these tokens directly, so
-					 * they are always valid regardless of an undefined item.
-					 */
-					if (astUtils.isCommaToken(commaToken)) {
-						validateCommaItemSpacing(
-							previousItemToken,
-							commaToken,
-							currentItemToken,
-							reportItem,
-						);
-					}
-
-					if (item) {
-						const tokenAfterItem = sourceCode.getTokenAfter(
-							item,
-							astUtils.isNotClosingParenToken,
-						);
-
-						previousItemToken = tokenAfterItem
-							? sourceCode.getTokenBefore(tokenAfterItem)
-							: sourceCode.ast.tokens.at(-1);
-					} else {
-						previousItemToken = currentItemToken;
-					}
-				});
-
-				/*
-				 * Special case for array literals that have empty last items, such
-				 * as [ 1, 2, ]. These arrays only have two items show up in the
-				 * AST, so we need to look at the token to verify that there's no
-				 * dangling comma.
-				 */
-				if (arrayLiteral) {
-					const lastToken = sourceCode.getLastToken(node),
-						nextToLastToken = sourceCode.getTokenBefore(lastToken);
-
-					if (astUtils.isCommaToken(nextToLastToken)) {
-						validateCommaItemSpacing(
-							sourceCode.getTokenBefore(nextToLastToken),
-							nextToLastToken,
-							lastToken,
-							lastToken,
-						);
-					}
-				}
-			}
-		}
-
-		//--------------------------------------------------------------------------
-		// Public
-		//--------------------------------------------------------------------------
-
-		const nodes = {};
-
-		if (!exceptions.VariableDeclaration) {
-			nodes.VariableDeclaration = function (node) {
-				validateComma(node, "declarations");
-			};
-		}
-		if (!exceptions.ObjectExpression) {
-			nodes.ObjectExpression = function (node) {
-				validateComma(node, "properties");
-			};
-		}
-		if (!exceptions.ObjectPattern) {
-			nodes.ObjectPattern = function (node) {
-				validateComma(node, "properties");
-			};
-		}
-		if (!exceptions.ArrayExpression) {
-			nodes.ArrayExpression = function (node) {
-				validateComma(node, "elements");
-			};
-		}
-		if (!exceptions.ArrayPattern) {
-			nodes.ArrayPattern = function (node) {
-				validateComma(node, "elements");
-			};
-		}
-		if (!exceptions.FunctionDeclaration) {
-			nodes.FunctionDeclaration = function (node) {
-				validateComma(node, "params");
-			};
-		}
-		if (!exceptions.FunctionExpression) {
-			nodes.FunctionExpression = function (node) {
-				validateComma(node, "params");
-			};
-		}
-		if (!exceptions.ArrowFunctionExpression) {
-			nodes.ArrowFunctionExpression = function (node) {
-				validateComma(node, "params");
-			};
-		}
-		if (!exceptions.CallExpression) {
-			nodes.CallExpression = function (node) {
-				validateComma(node, "arguments");
-			};
-		}
-		if (!exceptions.ImportDeclaration) {
-			nodes.ImportDeclaration = function (node) {
-				validateComma(node, "specifiers");
-			};
-		}
-		if (!exceptions.NewExpression) {
-			nodes.NewExpression = function (node) {
-				validateComma(node, "arguments");
-			};
-		}
-
-		return nodes;
-	},
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/complexity.js

@@ -1,201 +0,0 @@
-/**
- * @fileoverview Counts the cyclomatic complexity of each function of the script. See http://en.wikipedia.org/wiki/Cyclomatic_complexity.
- * Counts the number of if, conditional, for, while, try, switch/case,
- * @author Patrick Brosset
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-const { upperCaseFirst } = require("../shared/string-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-const THRESHOLD_DEFAULT = 20;
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-
-		defaultOptions: [THRESHOLD_DEFAULT],
-
-		docs: {
-			description:
-				"Enforce a maximum cyclomatic complexity allowed in a program",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/complexity",
-		},
-
-		schema: [
-			{
-				oneOf: [
-					{
-						type: "integer",
-						minimum: 0,
-					},
-					{
-						type: "object",
-						properties: {
-							maximum: {
-								type: "integer",
-								minimum: 0,
-							},
-							max: {
-								type: "integer",
-								minimum: 0,
-							},
-							variant: {
-								enum: ["classic", "modified"],
-							},
-						},
-						additionalProperties: false,
-					},
-				],
-			},
-		],
-
-		messages: {
-			complex:
-				"{{name}} has a complexity of {{complexity}}. Maximum allowed is {{max}}.",
-		},
-	},
-
-	create(context) {
-		const sourceCode = context.sourceCode;
-		const option = context.options[0];
-		let threshold = THRESHOLD_DEFAULT;
-		let VARIANT = "classic";
-
-		if (typeof option === "object") {
-			if (
-				Object.hasOwn(option, "maximum") ||
-				Object.hasOwn(option, "max")
-			) {
-				threshold = option.maximum || option.max;
-			}
-
-			if (Object.hasOwn(option, "variant")) {
-				VARIANT = option.variant;
-			}
-		} else if (typeof option === "number") {
-			threshold = option;
-		}
-
-		const IS_MODIFIED_COMPLEXITY = VARIANT === "modified";
-
-		//--------------------------------------------------------------------------
-		// Helpers
-		//--------------------------------------------------------------------------
-
-		// Using a stack to store complexity per code path
-		const complexities = [];
-
-		/**
-		 * Increase the complexity of the code path in context
-		 * @returns {void}
-		 * @private
-		 */
-		function increaseComplexity() {
-			complexities[complexities.length - 1]++;
-		}
-
-		//--------------------------------------------------------------------------
-		// Public API
-		//--------------------------------------------------------------------------
-
-		return {
-			onCodePathStart() {
-				// The initial complexity is 1, representing one execution path in the CodePath
-				complexities.push(1);
-			},
-
-			// Each branching in the code adds 1 to the complexity
-			CatchClause: increaseComplexity,
-			ConditionalExpression: increaseComplexity,
-			LogicalExpression: increaseComplexity,
-			ForStatement: increaseComplexity,
-			ForInStatement: increaseComplexity,
-			ForOfStatement: increaseComplexity,
-			IfStatement: increaseComplexity,
-			WhileStatement: increaseComplexity,
-			DoWhileStatement: increaseComplexity,
-			AssignmentPattern: increaseComplexity,
-
-			// Avoid `default`
-			"SwitchCase[test]": () =>
-				IS_MODIFIED_COMPLEXITY || increaseComplexity(),
-			SwitchStatement: () =>
-				IS_MODIFIED_COMPLEXITY && increaseComplexity(),
-
-			// Logical assignment operators have short-circuiting behavior
-			AssignmentExpression(node) {
-				if (astUtils.isLogicalAssignmentOperator(node.operator)) {
-					increaseComplexity();
-				}
-			},
-
-			MemberExpression(node) {
-				if (node.optional === true) {
-					increaseComplexity();
-				}
-			},
-
-			CallExpression(node) {
-				if (node.optional === true) {
-					increaseComplexity();
-				}
-			},
-
-			onCodePathEnd(codePath, node) {
-				const complexity = complexities.pop();
-
-				/*
-				 * This rule only evaluates complexity of functions, so "program" is excluded.
-				 * Class field initializers and class static blocks are implicit functions. Therefore,
-				 * they shouldn't contribute to the enclosing function's complexity, but their
-				 * own complexity should be evaluated.
-				 */
-				if (
-					codePath.origin !== "function" &&
-					codePath.origin !== "class-field-initializer" &&
-					codePath.origin !== "class-static-block"
-				) {
-					return;
-				}
-
-				if (complexity > threshold) {
-					let name;
-					let loc = node.loc;
-
-					if (codePath.origin === "class-field-initializer") {
-						name = "class field initializer";
-					} else if (codePath.origin === "class-static-block") {
-						name = "class static block";
-						loc = sourceCode.getFirstToken(node).loc;
-					} else {
-						name = astUtils.getFunctionNameWithKind(node);
-						loc = astUtils.getFunctionHeadLoc(node, sourceCode);
-					}
-
-					context.report({
-						node,
-						loc,
-						messageId: "complex",
-						data: {
-							name: upperCaseFirst(name),
-							complexity,
-							max: threshold,
-						},
-					});
-				}
-			},
-		};
-	},
-};