@alexlit/lint-kit 166.1.0 → 167.0.0

package/packages/config-eslint/node_modules/eslint/lib/rules/no-undef-init.js

@@ -1,101 +0,0 @@
-/**
- * @fileoverview Rule to flag when initializing to undefined
- * @author Ilya Volodin
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-const CONSTANT_BINDINGS = new Set(["const", "using", "await using"]);
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-
-		docs: {
-			description: "Disallow initializing variables to `undefined`",
-			recommended: false,
-			frozen: true,
-			url: "https://eslint.org/docs/latest/rules/no-undef-init",
-		},
-
-		schema: [],
-		fixable: "code",
-
-		messages: {
-			unnecessaryUndefinedInit:
-				"It's not necessary to initialize '{{name}}' to undefined.",
-		},
-	},
-
-	create(context) {
-		const sourceCode = context.sourceCode;
-
-		return {
-			VariableDeclarator(node) {
-				const name = sourceCode.getText(node.id),
-					init = node.init && node.init.name,
-					scope = sourceCode.getScope(node),
-					undefinedVar = astUtils.getVariableByName(
-						scope,
-						"undefined",
-					),
-					shadowed = undefinedVar && undefinedVar.defs.length > 0,
-					lastToken = sourceCode.getLastToken(node);
-
-				if (
-					init === "undefined" &&
-					!CONSTANT_BINDINGS.has(node.parent.kind) &&
-					!shadowed
-				) {
-					context.report({
-						node,
-						messageId: "unnecessaryUndefinedInit",
-						data: { name },
-						fix(fixer) {
-							if (node.parent.kind === "var") {
-								return null;
-							}
-
-							if (
-								node.id.type === "ArrayPattern" ||
-								node.id.type === "ObjectPattern"
-							) {
-								// Don't fix destructuring assignment to `undefined`.
-								return null;
-							}
-
-							if (
-								sourceCode.commentsExistBetween(
-									node.id,
-									lastToken,
-								)
-							) {
-								return null;
-							}
-
-							return fixer.removeRange([
-								node.id.range[1],
-								node.range[1],
-							]);
-						},
-					});
-				}
-			},
-		};
-	},
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/no-undef.js

@@ -1,84 +0,0 @@
-/**
- * @fileoverview Rule to flag references to undeclared variables.
- * @author Mark Macdonald
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-/**
- * Checks if the given node is the argument of a typeof operator.
- * @param {ASTNode} node The AST node being checked.
- * @returns {boolean} Whether or not the node is the argument of a typeof operator.
- */
-function hasTypeOfOperator(node) {
-	const parent = node.parent;
-
-	return parent.type === "UnaryExpression" && parent.operator === "typeof";
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "problem",
-
-		defaultOptions: [
-			{
-				typeof: false,
-			},
-		],
-
-		docs: {
-			description:
-				"Disallow the use of undeclared variables unless mentioned in `/*global */` comments",
-			recommended: true,
-			url: "https://eslint.org/docs/latest/rules/no-undef",
-		},
-
-		schema: [
-			{
-				type: "object",
-				properties: {
-					typeof: {
-						type: "boolean",
-					},
-				},
-				additionalProperties: false,
-			},
-		],
-		messages: {
-			undef: "'{{name}}' is not defined.",
-		},
-	},
-
-	create(context) {
-		const [{ typeof: considerTypeOf }] = context.options;
-		const sourceCode = context.sourceCode;
-
-		return {
-			"Program:exit"(node) {
-				const globalScope = sourceCode.getScope(node);
-
-				globalScope.through.forEach(ref => {
-					const identifier = ref.identifier;
-
-					if (!considerTypeOf && hasTypeOfOperator(identifier)) {
-						return;
-					}
-
-					context.report({
-						node: identifier,
-						messageId: "undef",
-						data: identifier,
-					});
-				});
-			},
-		};
-	},
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/no-undefined.js

@@ -1,85 +0,0 @@
-/**
- * @fileoverview Rule to flag references to the undefined variable.
- * @author Michael Ficarra
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-
-		docs: {
-			description: "Disallow the use of `undefined` as an identifier",
-			recommended: false,
-			frozen: true,
-			url: "https://eslint.org/docs/latest/rules/no-undefined",
-		},
-
-		schema: [],
-
-		messages: {
-			unexpectedUndefined: "Unexpected use of undefined.",
-		},
-	},
-
-	create(context) {
-		const sourceCode = context.sourceCode;
-
-		/**
-		 * Report an invalid "undefined" identifier node.
-		 * @param {ASTNode} node The node to report.
-		 * @returns {void}
-		 */
-		function report(node) {
-			context.report({
-				node,
-				messageId: "unexpectedUndefined",
-			});
-		}
-
-		/**
-		 * Checks the given scope for references to `undefined` and reports
-		 * all references found.
-		 * @param {eslint-scope.Scope} scope The scope to check.
-		 * @returns {void}
-		 */
-		function checkScope(scope) {
-			const undefinedVar = scope.set.get("undefined");
-
-			if (!undefinedVar) {
-				return;
-			}
-
-			const references = undefinedVar.references;
-
-			const defs = undefinedVar.defs;
-
-			// Report non-initializing references (those are covered in defs below)
-			references
-				.filter(ref => !ref.init)
-				.forEach(ref => report(ref.identifier));
-
-			defs.forEach(def => report(def.name));
-		}
-
-		return {
-			"Program:exit"(node) {
-				const globalScope = sourceCode.getScope(node);
-
-				const stack = [globalScope];
-
-				while (stack.length) {
-					const scope = stack.pop();
-
-					stack.push(...scope.childScopes);
-					checkScope(scope);
-				}
-			},
-		};
-	},
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/no-underscore-dangle.js

@@ -1,383 +0,0 @@
-/**
- * @fileoverview Rule to flag dangling underscores in variable declarations.
- * @author Matt DuVall <http://www.mattduvall.com>
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-
-		defaultOptions: [
-			{
-				allow: [],
-				allowAfterSuper: false,
-				allowAfterThis: false,
-				allowAfterThisConstructor: false,
-				allowFunctionParams: true,
-				allowInArrayDestructuring: true,
-				allowInObjectDestructuring: true,
-				enforceInClassFields: false,
-				enforceInMethodNames: false,
-			},
-		],
-
-		docs: {
-			description: "Disallow dangling underscores in identifiers",
-			recommended: false,
-			frozen: true,
-			url: "https://eslint.org/docs/latest/rules/no-underscore-dangle",
-		},
-
-		schema: [
-			{
-				type: "object",
-				properties: {
-					allow: {
-						type: "array",
-						items: {
-							type: "string",
-						},
-					},
-					allowAfterThis: {
-						type: "boolean",
-					},
-					allowAfterSuper: {
-						type: "boolean",
-					},
-					allowAfterThisConstructor: {
-						type: "boolean",
-					},
-					enforceInMethodNames: {
-						type: "boolean",
-					},
-					allowFunctionParams: {
-						type: "boolean",
-					},
-					enforceInClassFields: {
-						type: "boolean",
-					},
-					allowInArrayDestructuring: {
-						type: "boolean",
-					},
-					allowInObjectDestructuring: {
-						type: "boolean",
-					},
-				},
-				additionalProperties: false,
-			},
-		],
-
-		messages: {
-			unexpectedUnderscore:
-				"Unexpected dangling '_' in '{{identifier}}'.",
-		},
-	},
-
-	create(context) {
-		const [
-			{
-				allow,
-				allowAfterSuper,
-				allowAfterThis,
-				allowAfterThisConstructor,
-				allowFunctionParams,
-				allowInArrayDestructuring,
-				allowInObjectDestructuring,
-				enforceInClassFields,
-				enforceInMethodNames,
-			},
-		] = context.options;
-		const sourceCode = context.sourceCode;
-
-		//-------------------------------------------------------------------------
-		// Helpers
-		//-------------------------------------------------------------------------
-
-		/**
-		 * Check if identifier is present inside the allowed option
-		 * @param {string} identifier name of the node
-		 * @returns {boolean} true if its is present
-		 * @private
-		 */
-		function isAllowed(identifier) {
-			return allow.includes(identifier);
-		}
-
-		/**
-		 * Check if identifier has a dangling underscore
-		 * @param {string} identifier name of the node
-		 * @returns {boolean} true if its is present
-		 * @private
-		 */
-		function hasDanglingUnderscore(identifier) {
-			const len = identifier.length;
-
-			return (
-				identifier !== "_" &&
-				(identifier[0] === "_" || identifier[len - 1] === "_")
-			);
-		}
-
-		/**
-		 * Check if identifier is a special case member expression
-		 * @param {string} identifier name of the node
-		 * @returns {boolean} true if its is a special case
-		 * @private
-		 */
-		function isSpecialCaseIdentifierForMemberExpression(identifier) {
-			return identifier === "__proto__";
-		}
-
-		/**
-		 * Check if identifier is a special case variable expression
-		 * @param {string} identifier name of the node
-		 * @returns {boolean} true if its is a special case
-		 * @private
-		 */
-		function isSpecialCaseIdentifierInVariableExpression(identifier) {
-			// Checks for the underscore library usage here
-			return identifier === "_";
-		}
-
-		/**
-		 * Check if a node is a member reference of this.constructor
-		 * @param {ASTNode} node node to evaluate
-		 * @returns {boolean} true if it is a reference on this.constructor
-		 * @private
-		 */
-		function isThisConstructorReference(node) {
-			return (
-				node.object.type === "MemberExpression" &&
-				node.object.property.name === "constructor" &&
-				node.object.object.type === "ThisExpression"
-			);
-		}
-
-		/**
-		 * Check if function parameter has a dangling underscore.
-		 * @param {ASTNode} node function node to evaluate
-		 * @returns {void}
-		 * @private
-		 */
-		function checkForDanglingUnderscoreInFunctionParameters(node) {
-			if (!allowFunctionParams) {
-				node.params.forEach(param => {
-					const { type } = param;
-					let nodeToCheck;
-
-					if (type === "RestElement") {
-						nodeToCheck = param.argument;
-					} else if (type === "AssignmentPattern") {
-						nodeToCheck = param.left;
-					} else {
-						nodeToCheck = param;
-					}
-
-					if (nodeToCheck.type === "Identifier") {
-						const identifier = nodeToCheck.name;
-
-						if (
-							hasDanglingUnderscore(identifier) &&
-							!isAllowed(identifier)
-						) {
-							context.report({
-								node: param,
-								messageId: "unexpectedUnderscore",
-								data: {
-									identifier,
-								},
-							});
-						}
-					}
-				});
-			}
-		}
-
-		/**
-		 * Check if function has a dangling underscore
-		 * @param {ASTNode} node node to evaluate
-		 * @returns {void}
-		 * @private
-		 */
-		function checkForDanglingUnderscoreInFunction(node) {
-			if (node.type === "FunctionDeclaration" && node.id) {
-				const identifier = node.id.name;
-
-				if (
-					typeof identifier !== "undefined" &&
-					hasDanglingUnderscore(identifier) &&
-					!isAllowed(identifier)
-				) {
-					context.report({
-						node,
-						messageId: "unexpectedUnderscore",
-						data: {
-							identifier,
-						},
-					});
-				}
-			}
-			checkForDanglingUnderscoreInFunctionParameters(node);
-		}
-
-		/**
-		 * Check if variable expression has a dangling underscore
-		 * @param {ASTNode} node node to evaluate
-		 * @returns {void}
-		 * @private
-		 */
-		function checkForDanglingUnderscoreInVariableExpression(node) {
-			sourceCode.getDeclaredVariables(node).forEach(variable => {
-				const definition = variable.defs.find(def => def.node === node);
-				const identifierNode = definition.name;
-				const identifier = identifierNode.name;
-				let parent = identifierNode.parent;
-
-				while (
-					![
-						"VariableDeclarator",
-						"ArrayPattern",
-						"ObjectPattern",
-					].includes(parent.type)
-				) {
-					parent = parent.parent;
-				}
-
-				if (
-					hasDanglingUnderscore(identifier) &&
-					!isSpecialCaseIdentifierInVariableExpression(identifier) &&
-					!isAllowed(identifier) &&
-					!(
-						allowInArrayDestructuring &&
-						parent.type === "ArrayPattern"
-					) &&
-					!(
-						allowInObjectDestructuring &&
-						parent.type === "ObjectPattern"
-					)
-				) {
-					context.report({
-						node,
-						messageId: "unexpectedUnderscore",
-						data: {
-							identifier,
-						},
-					});
-				}
-			});
-		}
-
-		/**
-		 * Check if member expression has a dangling underscore
-		 * @param {ASTNode} node node to evaluate
-		 * @returns {void}
-		 * @private
-		 */
-		function checkForDanglingUnderscoreInMemberExpression(node) {
-			const identifier = node.property.name,
-				isMemberOfThis = node.object.type === "ThisExpression",
-				isMemberOfSuper = node.object.type === "Super",
-				isMemberOfThisConstructor = isThisConstructorReference(node);
-
-			if (
-				typeof identifier !== "undefined" &&
-				hasDanglingUnderscore(identifier) &&
-				!(isMemberOfThis && allowAfterThis) &&
-				!(isMemberOfSuper && allowAfterSuper) &&
-				!(isMemberOfThisConstructor && allowAfterThisConstructor) &&
-				!isSpecialCaseIdentifierForMemberExpression(identifier) &&
-				!isAllowed(identifier)
-			) {
-				context.report({
-					node,
-					messageId: "unexpectedUnderscore",
-					data: {
-						identifier,
-					},
-				});
-			}
-		}
-
-		/**
-		 * Check if method declaration or method property has a dangling underscore
-		 * @param {ASTNode} node node to evaluate
-		 * @returns {void}
-		 * @private
-		 */
-		function checkForDanglingUnderscoreInMethod(node) {
-			const identifier = node.key.name;
-			const isMethod =
-				node.type === "MethodDefinition" ||
-				(node.type === "Property" && node.method);
-
-			if (
-				typeof identifier !== "undefined" &&
-				enforceInMethodNames &&
-				isMethod &&
-				hasDanglingUnderscore(identifier) &&
-				!isAllowed(identifier)
-			) {
-				context.report({
-					node,
-					messageId: "unexpectedUnderscore",
-					data: {
-						identifier:
-							node.key.type === "PrivateIdentifier"
-								? `#${identifier}`
-								: identifier,
-					},
-				});
-			}
-		}
-
-		/**
-		 * Check if a class field has a dangling underscore
-		 * @param {ASTNode} node node to evaluate
-		 * @returns {void}
-		 * @private
-		 */
-		function checkForDanglingUnderscoreInClassField(node) {
-			const identifier = node.key.name;
-
-			if (
-				typeof identifier !== "undefined" &&
-				hasDanglingUnderscore(identifier) &&
-				enforceInClassFields &&
-				!isAllowed(identifier)
-			) {
-				context.report({
-					node,
-					messageId: "unexpectedUnderscore",
-					data: {
-						identifier:
-							node.key.type === "PrivateIdentifier"
-								? `#${identifier}`
-								: identifier,
-					},
-				});
-			}
-		}
-
-		//--------------------------------------------------------------------------
-		// Public API
-		//--------------------------------------------------------------------------
-
-		return {
-			FunctionDeclaration: checkForDanglingUnderscoreInFunction,
-			VariableDeclarator: checkForDanglingUnderscoreInVariableExpression,
-			MemberExpression: checkForDanglingUnderscoreInMemberExpression,
-			MethodDefinition: checkForDanglingUnderscoreInMethod,
-			PropertyDefinition: checkForDanglingUnderscoreInClassField,
-			Property: checkForDanglingUnderscoreInMethod,
-			FunctionExpression: checkForDanglingUnderscoreInFunction,
-			ArrowFunctionExpression: checkForDanglingUnderscoreInFunction,
-		};
-	},
-};