@alexlit/lint-kit 164.15.0 → 165.0.0

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

@@ -0,0 +1,101 @@
+/**
+ * @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

@@ -0,0 +1,84 @@
+/**
+ * @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

@@ -0,0 +1,85 @@
+/**
+ * @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

@@ -0,0 +1,383 @@
+/**
+ * @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,
+		};
+	},
+};