@alexlit/lint-kit 183.0.0 → 183.2.0

package/packages/config-eslint/node_modules/eslint/lib/rules/id-length.js

@@ -1,217 +0,0 @@
-/**
- * @fileoverview Rule that warns when identifier names are shorter or longer
- * than the values provided in configuration.
- * @author Burak Yigit Kaya aka BYK
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const { getGraphemeCount } = require("../shared/string-utils");
-const {
-	getModuleExportName,
-	isImportAttributeKey,
-} = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-
-		defaultOptions: [
-			{
-				exceptionPatterns: [],
-				exceptions: [],
-				min: 2,
-				properties: "always",
-			},
-		],
-
-		docs: {
-			description: "Enforce minimum and maximum identifier lengths",
-			recommended: false,
-			frozen: true,
-			url: "https://eslint.org/docs/latest/rules/id-length",
-		},
-
-		schema: [
-			{
-				type: "object",
-				properties: {
-					min: {
-						type: "integer",
-					},
-					max: {
-						type: "integer",
-					},
-					exceptions: {
-						type: "array",
-						uniqueItems: true,
-						items: {
-							type: "string",
-						},
-					},
-					exceptionPatterns: {
-						type: "array",
-						uniqueItems: true,
-						items: {
-							type: "string",
-						},
-					},
-					properties: {
-						enum: ["always", "never"],
-					},
-				},
-				additionalProperties: false,
-			},
-		],
-		messages: {
-			tooShort: "Identifier name '{{name}}' is too short (< {{min}}).",
-			tooShortPrivate:
-				"Identifier name '#{{name}}' is too short (< {{min}}).",
-			tooLong: "Identifier name '{{name}}' is too long (> {{max}}).",
-			tooLongPrivate:
-				"Identifier name #'{{name}}' is too long (> {{max}}).",
-		},
-	},
-
-	create(context) {
-		const [options] = context.options;
-		const { max: maxLength = Infinity, min: minLength } = options;
-		const properties = options.properties !== "never";
-		const exceptions = new Set(options.exceptions);
-		const exceptionPatterns = options.exceptionPatterns.map(
-			pattern => new RegExp(pattern, "u"),
-		);
-		const reportedNodes = new Set();
-
-		/**
-		 * Checks if a string matches the provided exception patterns
-		 * @param {string} name The string to check.
-		 * @returns {boolean} if the string is a match
-		 * @private
-		 */
-		function matchesExceptionPattern(name) {
-			return exceptionPatterns.some(pattern => pattern.test(name));
-		}
-
-		const SUPPORTED_EXPRESSIONS = {
-			MemberExpression:
-				properties &&
-				function (parent) {
-					return (
-						!parent.computed &&
-						// regular property assignment
-						((parent.parent.left === parent &&
-							parent.parent.type === "AssignmentExpression") ||
-							// or the last identifier in an ObjectPattern destructuring
-							(parent.parent.type === "Property" &&
-								parent.parent.value === parent &&
-								parent.parent.parent.type === "ObjectPattern" &&
-								parent.parent.parent.parent.left ===
-									parent.parent.parent))
-					);
-				},
-			AssignmentPattern(parent, node) {
-				return parent.left === node;
-			},
-			VariableDeclarator(parent, node) {
-				return parent.id === node;
-			},
-			Property(parent, node) {
-				if (parent.parent.type === "ObjectPattern") {
-					const isKeyAndValueSame =
-						parent.value.name === parent.key.name;
-
-					return (
-						(!isKeyAndValueSame && parent.value === node) ||
-						(isKeyAndValueSame && parent.key === node && properties)
-					);
-				}
-				return (
-					properties &&
-					!isImportAttributeKey(node) &&
-					!parent.computed &&
-					parent.key.name === node.name
-				);
-			},
-			ImportSpecifier(parent, node) {
-				return (
-					parent.local === node &&
-					getModuleExportName(parent.imported) !==
-						getModuleExportName(parent.local)
-				);
-			},
-			ImportDefaultSpecifier: true,
-			ImportNamespaceSpecifier: true,
-			RestElement: true,
-			FunctionExpression: true,
-			ArrowFunctionExpression: true,
-			ClassDeclaration: true,
-			FunctionDeclaration: true,
-			MethodDefinition: true,
-			PropertyDefinition: true,
-			CatchClause: true,
-			ArrayPattern: true,
-		};
-
-		return {
-			[["Identifier", "PrivateIdentifier"]](node) {
-				const name = node.name;
-				const parent = node.parent;
-
-				const nameLength = getGraphemeCount(name);
-
-				const isShort = nameLength < minLength;
-				const isLong = nameLength > maxLength;
-
-				if (
-					!(isShort || isLong) ||
-					exceptions.has(name) ||
-					matchesExceptionPattern(name)
-				) {
-					return; // Nothing to report
-				}
-
-				const isValidExpression = SUPPORTED_EXPRESSIONS[parent.type];
-
-				/*
-				 * We used the range instead of the node because it's possible
-				 * for the same identifier to be represented by two different
-				 * nodes, with the most clear example being shorthand properties:
-				 * { foo }
-				 * In this case, "foo" is represented by one node for the name
-				 * and one for the value. The only way to know they are the same
-				 * is to look at the range.
-				 */
-				if (
-					isValidExpression &&
-					!reportedNodes.has(node.range.toString()) &&
-					(isValidExpression === true ||
-						isValidExpression(parent, node))
-				) {
-					reportedNodes.add(node.range.toString());
-
-					let messageId = isShort ? "tooShort" : "tooLong";
-
-					if (node.type === "PrivateIdentifier") {
-						messageId += "Private";
-					}
-
-					context.report({
-						node,
-						messageId,
-						data: { name, min: minLength, max: maxLength },
-					});
-				}
-			},
-		};
-	},
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/id-match.js

@@ -1,363 +0,0 @@
-/**
- * @fileoverview Rule to flag non-matching identifiers
- * @author Matthieu Larcher
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-
-		defaultOptions: [
-			"^.+$",
-			{
-				classFields: false,
-				ignoreDestructuring: false,
-				onlyDeclarations: false,
-				properties: false,
-			},
-		],
-
-		docs: {
-			description:
-				"Require identifiers to match a specified regular expression",
-			recommended: false,
-			frozen: true,
-			url: "https://eslint.org/docs/latest/rules/id-match",
-		},
-
-		schema: [
-			{
-				type: "string",
-			},
-			{
-				type: "object",
-				properties: {
-					properties: {
-						type: "boolean",
-					},
-					classFields: {
-						type: "boolean",
-					},
-					onlyDeclarations: {
-						type: "boolean",
-					},
-					ignoreDestructuring: {
-						type: "boolean",
-					},
-				},
-				additionalProperties: false,
-			},
-		],
-		messages: {
-			notMatch:
-				"Identifier '{{name}}' does not match the pattern '{{pattern}}'.",
-			notMatchPrivate:
-				"Identifier '#{{name}}' does not match the pattern '{{pattern}}'.",
-		},
-	},
-
-	create(context) {
-		//--------------------------------------------------------------------------
-		// Options
-		//--------------------------------------------------------------------------
-		const [
-			pattern,
-			{
-				classFields: checkClassFields,
-				ignoreDestructuring,
-				onlyDeclarations,
-				properties: checkProperties,
-			},
-		] = context.options;
-		const regexp = new RegExp(pattern, "u");
-
-		const sourceCode = context.sourceCode;
-		let globalScope;
-
-		//--------------------------------------------------------------------------
-		// Helpers
-		//--------------------------------------------------------------------------
-
-		// contains reported nodes to avoid reporting twice on destructuring with shorthand notation
-		const reportedNodes = new Set();
-		const ALLOWED_PARENT_TYPES = new Set([
-			"CallExpression",
-			"NewExpression",
-		]);
-		const DECLARATION_TYPES = new Set([
-			"FunctionDeclaration",
-			"VariableDeclarator",
-		]);
-		const IMPORT_TYPES = new Set([
-			"ImportSpecifier",
-			"ImportNamespaceSpecifier",
-			"ImportDefaultSpecifier",
-		]);
-
-		/**
-		 * Checks whether the given node represents a reference to a global variable that is not declared in the source code.
-		 * These identifiers will be allowed, as it is assumed that user has no control over the names of external global variables.
-		 * @param {ASTNode} node `Identifier` node to check.
-		 * @returns {boolean} `true` if the node is a reference to a global variable.
-		 */
-		function isReferenceToGlobalVariable(node) {
-			const variable = globalScope.set.get(node.name);
-
-			return (
-				variable &&
-				variable.defs.length === 0 &&
-				variable.references.some(ref => ref.identifier === node)
-			);
-		}
-
-		/**
-		 * Checks if a string matches the provided pattern
-		 * @param {string} name The string to check.
-		 * @returns {boolean} if the string is a match
-		 * @private
-		 */
-		function isInvalid(name) {
-			return !regexp.test(name);
-		}
-
-		/**
-		 * Checks if a parent of a node is an ObjectPattern.
-		 * @param {ASTNode} node The node to check.
-		 * @returns {boolean} if the node is inside an ObjectPattern
-		 * @private
-		 */
-		function isInsideObjectPattern(node) {
-			let { parent } = node;
-
-			while (parent) {
-				if (parent.type === "ObjectPattern") {
-					return true;
-				}
-
-				parent = parent.parent;
-			}
-
-			return false;
-		}
-
-		/**
-		 * Verifies if we should report an error or not based on the effective
-		 * parent node and the identifier name.
-		 * @param {ASTNode} effectiveParent The effective parent node of the node to be reported
-		 * @param {string} name The identifier name of the identifier node
-		 * @returns {boolean} whether an error should be reported or not
-		 */
-		function shouldReport(effectiveParent, name) {
-			return (
-				(!onlyDeclarations ||
-					DECLARATION_TYPES.has(effectiveParent.type)) &&
-				!ALLOWED_PARENT_TYPES.has(effectiveParent.type) &&
-				isInvalid(name)
-			);
-		}
-
-		/**
-		 * Reports an AST node as a rule violation.
-		 * @param {ASTNode} node The node to report.
-		 * @returns {void}
-		 * @private
-		 */
-		function report(node) {
-			/*
-			 * We used the range instead of the node because it's possible
-			 * for the same identifier to be represented by two different
-			 * nodes, with the most clear example being shorthand properties:
-			 * { foo }
-			 * In this case, "foo" is represented by one node for the name
-			 * and one for the value. The only way to know they are the same
-			 * is to look at the range.
-			 */
-			if (!reportedNodes.has(node.range.toString())) {
-				const messageId =
-					node.type === "PrivateIdentifier"
-						? "notMatchPrivate"
-						: "notMatch";
-
-				context.report({
-					node,
-					messageId,
-					data: {
-						name: node.name,
-						pattern,
-					},
-				});
-				reportedNodes.add(node.range.toString());
-			}
-		}
-
-		return {
-			Program(node) {
-				globalScope = sourceCode.getScope(node);
-			},
-
-			Identifier(node) {
-				const name = node.name,
-					parent = node.parent,
-					effectiveParent =
-						parent.type === "MemberExpression"
-							? parent.parent
-							: parent;
-
-				if (
-					isReferenceToGlobalVariable(node) ||
-					astUtils.isImportAttributeKey(node)
-				) {
-					return;
-				}
-
-				if (parent.type === "MemberExpression") {
-					if (!checkProperties) {
-						return;
-					}
-
-					// Always check object names
-					if (
-						parent.object.type === "Identifier" &&
-						parent.object.name === name
-					) {
-						if (isInvalid(name)) {
-							report(node);
-						}
-
-						// Report AssignmentExpressions left side's assigned variable id
-					} else if (
-						effectiveParent.type === "AssignmentExpression" &&
-						effectiveParent.left.type === "MemberExpression" &&
-						effectiveParent.left.property.name === node.name
-					) {
-						if (isInvalid(name)) {
-							report(node);
-						}
-
-						// Report AssignmentExpressions only if they are the left side of the assignment
-					} else if (
-						effectiveParent.type === "AssignmentExpression" &&
-						effectiveParent.right.type !== "MemberExpression"
-					) {
-						if (isInvalid(name)) {
-							report(node);
-						}
-					}
-
-					// For https://github.com/eslint/eslint/issues/15123
-				} else if (
-					parent.type === "Property" &&
-					parent.parent.type === "ObjectExpression" &&
-					parent.key === node &&
-					!parent.computed
-				) {
-					if (checkProperties && isInvalid(name)) {
-						report(node);
-					}
-
-					/*
-					 * Properties have their own rules, and
-					 * AssignmentPattern nodes can be treated like Properties:
-					 * e.g.: const { no_camelcased = false } = bar;
-					 */
-				} else if (
-					parent.type === "Property" ||
-					parent.type === "AssignmentPattern"
-				) {
-					if (
-						parent.parent &&
-						parent.parent.type === "ObjectPattern"
-					) {
-						if (
-							!ignoreDestructuring &&
-							parent.shorthand &&
-							parent.value.left &&
-							isInvalid(name)
-						) {
-							report(node);
-						}
-
-						const assignmentKeyEqualsValue =
-							parent.key.name === parent.value.name;
-
-						// prevent checking righthand side of destructured object
-						if (!assignmentKeyEqualsValue && parent.key === node) {
-							return;
-						}
-
-						const valueIsInvalid =
-							parent.value.name && isInvalid(name);
-
-						// ignore destructuring if the option is set, unless a new identifier is created
-						if (
-							valueIsInvalid &&
-							!(assignmentKeyEqualsValue && ignoreDestructuring)
-						) {
-							report(node);
-						}
-					}
-
-					// never check properties or always ignore destructuring
-					if (
-						(!checkProperties && !parent.computed) ||
-						(ignoreDestructuring && isInsideObjectPattern(node))
-					) {
-						return;
-					}
-
-					// don't check right hand side of AssignmentExpression to prevent duplicate warnings
-					if (
-						parent.right !== node &&
-						shouldReport(effectiveParent, name)
-					) {
-						report(node);
-					}
-
-					// Check if it's an import specifier
-				} else if (IMPORT_TYPES.has(parent.type)) {
-					// Report only if the local imported identifier is invalid
-					if (
-						parent.local &&
-						parent.local.name === node.name &&
-						isInvalid(name)
-					) {
-						report(node);
-					}
-				} else if (parent.type === "PropertyDefinition") {
-					if (checkClassFields && isInvalid(name)) {
-						report(node);
-					}
-
-					// Report anything that is invalid that isn't a CallExpression
-				} else if (shouldReport(effectiveParent, name)) {
-					report(node);
-				}
-			},
-
-			PrivateIdentifier(node) {
-				const isClassField = node.parent.type === "PropertyDefinition";
-
-				if (isClassField && !checkClassFields) {
-					return;
-				}
-
-				if (isInvalid(node.name)) {
-					report(node);
-				}
-			},
-		};
-	},
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/implicit-arrow-linebreak.js

@@ -1,125 +0,0 @@
-/**
- * @fileoverview enforce the location of arrow function bodies
- * @author Sharmila Jesupaul
- * @deprecated in ESLint v8.53.0
- */
-"use strict";
-
-const { isCommentToken, isNotOpeningParenToken } = 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: "implicit-arrow-linebreak",
-						url: "https://eslint.style/rules/implicit-arrow-linebreak",
-					},
-				},
-			],
-		},
-		type: "layout",
-
-		docs: {
-			description: "Enforce the location of arrow function bodies",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/implicit-arrow-linebreak",
-		},
-
-		fixable: "whitespace",
-
-		schema: [
-			{
-				enum: ["beside", "below"],
-			},
-		],
-		messages: {
-			expected: "Expected a linebreak before this expression.",
-			unexpected: "Expected no linebreak before this expression.",
-		},
-	},
-
-	create(context) {
-		const sourceCode = context.sourceCode;
-		const option = context.options[0] || "beside";
-
-		/**
-		 * Validates the location of an arrow function body
-		 * @param {ASTNode} node The arrow function body
-		 * @returns {void}
-		 */
-		function validateExpression(node) {
-			if (node.body.type === "BlockStatement") {
-				return;
-			}
-
-			const arrowToken = sourceCode.getTokenBefore(
-				node.body,
-				isNotOpeningParenToken,
-			);
-			const firstTokenOfBody = sourceCode.getTokenAfter(arrowToken);
-
-			if (
-				arrowToken.loc.end.line === firstTokenOfBody.loc.start.line &&
-				option === "below"
-			) {
-				context.report({
-					node: firstTokenOfBody,
-					messageId: "expected",
-					fix: fixer =>
-						fixer.insertTextBefore(firstTokenOfBody, "\n"),
-				});
-			} else if (
-				arrowToken.loc.end.line !== firstTokenOfBody.loc.start.line &&
-				option === "beside"
-			) {
-				context.report({
-					node: firstTokenOfBody,
-					messageId: "unexpected",
-					fix(fixer) {
-						if (
-							sourceCode.getFirstTokenBetween(
-								arrowToken,
-								firstTokenOfBody,
-								{
-									includeComments: true,
-									filter: isCommentToken,
-								},
-							)
-						) {
-							return null;
-						}
-
-						return fixer.replaceTextRange(
-							[arrowToken.range[1], firstTokenOfBody.range[0]],
-							" ",
-						);
-					},
-				});
-			}
-		}
-
-		//----------------------------------------------------------------------
-		// Public
-		//----------------------------------------------------------------------
-		return {
-			ArrowFunctionExpression: node => validateExpression(node),
-		};
-	},
-};