@alexlit/lint-kit 164.15.0 → 165.0.0

package/packages/config-eslint/node_modules/eslint/lib/rules/func-name-matching.js

@@ -0,0 +1,338 @@
+/**
+ * @fileoverview Rule to require function names to match the name of the variable or property to which they are assigned.
+ * @author Annie Zhang, Pavel Strashkin
+ */
+
+"use strict";
+
+//--------------------------------------------------------------------------
+// Requirements
+//--------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+const esutils = require("esutils");
+
+//--------------------------------------------------------------------------
+// Helpers
+//--------------------------------------------------------------------------
+
+/**
+ * Determines if a pattern is `module.exports` or `module["exports"]`
+ * @param {ASTNode} pattern The left side of the AssignmentExpression
+ * @returns {boolean} True if the pattern is `module.exports` or `module["exports"]`
+ */
+function isModuleExports(pattern) {
+	if (
+		pattern.type === "MemberExpression" &&
+		pattern.object.type === "Identifier" &&
+		pattern.object.name === "module"
+	) {
+		// module.exports
+		if (
+			pattern.property.type === "Identifier" &&
+			pattern.property.name === "exports"
+		) {
+			return true;
+		}
+
+		// module["exports"]
+		if (
+			pattern.property.type === "Literal" &&
+			pattern.property.value === "exports"
+		) {
+			return true;
+		}
+	}
+	return false;
+}
+
+/**
+ * Determines if a string name is a valid identifier
+ * @param {string} name The string to be checked
+ * @param {number} ecmaVersion The ECMAScript version if specified in the parserOptions config
+ * @returns {boolean} True if the string is a valid identifier
+ */
+function isIdentifier(name, ecmaVersion) {
+	if (ecmaVersion >= 2015) {
+		return esutils.keyword.isIdentifierES6(name);
+	}
+	return esutils.keyword.isIdentifierES5(name);
+}
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+const alwaysOrNever = { enum: ["always", "never"] };
+const optionsObject = {
+	type: "object",
+	properties: {
+		considerPropertyDescriptor: {
+			type: "boolean",
+		},
+		includeCommonJSModuleExports: {
+			type: "boolean",
+		},
+	},
+	additionalProperties: false,
+};
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "suggestion",
+
+		docs: {
+			description:
+				"Require function names to match the name of the variable or property to which they are assigned",
+			recommended: false,
+			frozen: true,
+			url: "https://eslint.org/docs/latest/rules/func-name-matching",
+		},
+
+		schema: {
+			anyOf: [
+				{
+					type: "array",
+					additionalItems: false,
+					items: [alwaysOrNever, optionsObject],
+				},
+				{
+					type: "array",
+					additionalItems: false,
+					items: [optionsObject],
+				},
+			],
+		},
+
+		messages: {
+			matchProperty:
+				"Function name `{{funcName}}` should match property name `{{name}}`.",
+			matchVariable:
+				"Function name `{{funcName}}` should match variable name `{{name}}`.",
+			notMatchProperty:
+				"Function name `{{funcName}}` should not match property name `{{name}}`.",
+			notMatchVariable:
+				"Function name `{{funcName}}` should not match variable name `{{name}}`.",
+		},
+	},
+
+	create(context) {
+		const options =
+			(typeof context.options[0] === "object"
+				? context.options[0]
+				: context.options[1]) || {};
+		const nameMatches =
+			typeof context.options[0] === "string"
+				? context.options[0]
+				: "always";
+		const considerPropertyDescriptor = options.considerPropertyDescriptor;
+		const includeModuleExports = options.includeCommonJSModuleExports;
+		const ecmaVersion = context.languageOptions.ecmaVersion;
+
+		/**
+		 * Check whether node is a certain CallExpression.
+		 * @param {string} objName object name
+		 * @param {string} funcName function name
+		 * @param {ASTNode} node The node to check
+		 * @returns {boolean} `true` if node matches CallExpression
+		 */
+		function isPropertyCall(objName, funcName, node) {
+			if (!node) {
+				return false;
+			}
+			return (
+				node.type === "CallExpression" &&
+				astUtils.isSpecificMemberAccess(node.callee, objName, funcName)
+			);
+		}
+
+		/**
+		 * Compares identifiers based on the nameMatches option
+		 * @param {string} x the first identifier
+		 * @param {string} y the second identifier
+		 * @returns {boolean} whether the two identifiers should warn.
+		 */
+		function shouldWarn(x, y) {
+			return (
+				(nameMatches === "always" && x !== y) ||
+				(nameMatches === "never" && x === y)
+			);
+		}
+
+		/**
+		 * Reports
+		 * @param {ASTNode} node The node to report
+		 * @param {string} name The variable or property name
+		 * @param {string} funcName The function name
+		 * @param {boolean} isProp True if the reported node is a property assignment
+		 * @returns {void}
+		 */
+		function report(node, name, funcName, isProp) {
+			let messageId;
+
+			if (nameMatches === "always" && isProp) {
+				messageId = "matchProperty";
+			} else if (nameMatches === "always") {
+				messageId = "matchVariable";
+			} else if (isProp) {
+				messageId = "notMatchProperty";
+			} else {
+				messageId = "notMatchVariable";
+			}
+			context.report({
+				node,
+				messageId,
+				data: {
+					name,
+					funcName,
+				},
+			});
+		}
+
+		/**
+		 * Determines whether a given node is a string literal
+		 * @param {ASTNode} node The node to check
+		 * @returns {boolean} `true` if the node is a string literal
+		 */
+		function isStringLiteral(node) {
+			return node.type === "Literal" && typeof node.value === "string";
+		}
+
+		//--------------------------------------------------------------------------
+		// Public
+		//--------------------------------------------------------------------------
+
+		return {
+			VariableDeclarator(node) {
+				if (
+					!node.init ||
+					node.init.type !== "FunctionExpression" ||
+					node.id.type !== "Identifier"
+				) {
+					return;
+				}
+				if (
+					node.init.id &&
+					shouldWarn(node.id.name, node.init.id.name)
+				) {
+					report(node, node.id.name, node.init.id.name, false);
+				}
+			},
+
+			AssignmentExpression(node) {
+				if (
+					node.right.type !== "FunctionExpression" ||
+					(node.left.computed &&
+						node.left.property.type !== "Literal") ||
+					(!includeModuleExports && isModuleExports(node.left)) ||
+					(node.left.type !== "Identifier" &&
+						node.left.type !== "MemberExpression")
+				) {
+					return;
+				}
+
+				const isProp = node.left.type === "MemberExpression";
+				const name = isProp
+					? astUtils.getStaticPropertyName(node.left)
+					: node.left.name;
+
+				if (
+					node.right.id &&
+					name &&
+					isIdentifier(name) &&
+					shouldWarn(name, node.right.id.name)
+				) {
+					report(node, name, node.right.id.name, isProp);
+				}
+			},
+
+			"Property, PropertyDefinition[value]"(node) {
+				if (
+					!(node.value.type === "FunctionExpression" && node.value.id)
+				) {
+					return;
+				}
+
+				if (node.key.type === "Identifier" && !node.computed) {
+					const functionName = node.value.id.name;
+					let propertyName = node.key.name;
+
+					if (
+						considerPropertyDescriptor &&
+						propertyName === "value" &&
+						node.parent.type === "ObjectExpression"
+					) {
+						if (
+							isPropertyCall(
+								"Object",
+								"defineProperty",
+								node.parent.parent,
+							) ||
+							isPropertyCall(
+								"Reflect",
+								"defineProperty",
+								node.parent.parent,
+							)
+						) {
+							const property = node.parent.parent.arguments[1];
+
+							if (
+								isStringLiteral(property) &&
+								shouldWarn(property.value, functionName)
+							) {
+								report(
+									node,
+									property.value,
+									functionName,
+									true,
+								);
+							}
+						} else if (
+							isPropertyCall(
+								"Object",
+								"defineProperties",
+								node.parent.parent.parent.parent,
+							)
+						) {
+							propertyName = node.parent.parent.key.name;
+							if (
+								!node.parent.parent.computed &&
+								shouldWarn(propertyName, functionName)
+							) {
+								report(node, propertyName, functionName, true);
+							}
+						} else if (
+							isPropertyCall(
+								"Object",
+								"create",
+								node.parent.parent.parent.parent,
+							)
+						) {
+							propertyName = node.parent.parent.key.name;
+							if (
+								!node.parent.parent.computed &&
+								shouldWarn(propertyName, functionName)
+							) {
+								report(node, propertyName, functionName, true);
+							}
+						} else if (shouldWarn(propertyName, functionName)) {
+							report(node, propertyName, functionName, true);
+						}
+					} else if (shouldWarn(propertyName, functionName)) {
+						report(node, propertyName, functionName, true);
+					}
+					return;
+				}
+
+				if (
+					isStringLiteral(node.key) &&
+					isIdentifier(node.key.value, ecmaVersion) &&
+					shouldWarn(node.key.value, node.value.id.name)
+				) {
+					report(node, node.key.value, node.value.id.name, true);
+				}
+			},
+		};
+	},
+};

package/packages/config-eslint/node_modules/eslint/lib/rules/func-names.js

@@ -0,0 +1,192 @@
+/**
+ * @fileoverview Rule to warn when a function expression does not have a name.
+ * @author Kyle T. Nunery
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+
+/**
+ * Checks whether or not a given variable is a function name.
+ * @param {eslint-scope.Variable} variable A variable to check.
+ * @returns {boolean} `true` if the variable is a function name.
+ */
+function isFunctionName(variable) {
+	return variable && variable.defs[0].type === "FunctionName";
+}
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "suggestion",
+
+		defaultOptions: ["always", {}],
+
+		docs: {
+			description: "Require or disallow named `function` expressions",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/func-names",
+		},
+
+		schema: {
+			definitions: {
+				value: {
+					enum: ["always", "as-needed", "never"],
+				},
+			},
+			items: [
+				{
+					$ref: "#/definitions/value",
+				},
+				{
+					type: "object",
+					properties: {
+						generators: {
+							$ref: "#/definitions/value",
+						},
+					},
+					additionalProperties: false,
+				},
+			],
+		},
+
+		messages: {
+			unnamed: "Unexpected unnamed {{name}}.",
+			named: "Unexpected named {{name}}.",
+		},
+	},
+
+	create(context) {
+		const sourceCode = context.sourceCode;
+
+		/**
+		 * Returns the config option for the given node.
+		 * @param {ASTNode} node A node to get the config for.
+		 * @returns {string} The config option.
+		 */
+		function getConfigForNode(node) {
+			if (node.generator && context.options[1].generators) {
+				return context.options[1].generators;
+			}
+
+			return context.options[0];
+		}
+
+		/**
+		 * Determines whether the current FunctionExpression node is a get, set, or
+		 * shorthand method in an object literal or a class.
+		 * @param {ASTNode} node A node to check.
+		 * @returns {boolean} True if the node is a get, set, or shorthand method.
+		 */
+		function isObjectOrClassMethod(node) {
+			const parent = node.parent;
+
+			return (
+				parent.type === "MethodDefinition" ||
+				(parent.type === "Property" &&
+					(parent.method ||
+						parent.kind === "get" ||
+						parent.kind === "set"))
+			);
+		}
+
+		/**
+		 * Determines whether the current FunctionExpression node has a name that would be
+		 * inferred from context in a conforming ES6 environment.
+		 * @param {ASTNode} node A node to check.
+		 * @returns {boolean} True if the node would have a name assigned automatically.
+		 */
+		function hasInferredName(node) {
+			const parent = node.parent;
+
+			return (
+				isObjectOrClassMethod(node) ||
+				(parent.type === "VariableDeclarator" &&
+					parent.id.type === "Identifier" &&
+					parent.init === node) ||
+				(parent.type === "Property" && parent.value === node) ||
+				(parent.type === "PropertyDefinition" &&
+					parent.value === node) ||
+				(parent.type === "AssignmentExpression" &&
+					parent.left.type === "Identifier" &&
+					parent.right === node) ||
+				(parent.type === "AssignmentPattern" &&
+					parent.left.type === "Identifier" &&
+					parent.right === node)
+			);
+		}
+
+		/**
+		 * Reports that an unnamed function should be named
+		 * @param {ASTNode} node The node to report in the event of an error.
+		 * @returns {void}
+		 */
+		function reportUnexpectedUnnamedFunction(node) {
+			context.report({
+				node,
+				messageId: "unnamed",
+				loc: astUtils.getFunctionHeadLoc(node, sourceCode),
+				data: { name: astUtils.getFunctionNameWithKind(node) },
+			});
+		}
+
+		/**
+		 * Reports that a named function should be unnamed
+		 * @param {ASTNode} node The node to report in the event of an error.
+		 * @returns {void}
+		 */
+		function reportUnexpectedNamedFunction(node) {
+			context.report({
+				node,
+				messageId: "named",
+				loc: astUtils.getFunctionHeadLoc(node, sourceCode),
+				data: { name: astUtils.getFunctionNameWithKind(node) },
+			});
+		}
+
+		/**
+		 * The listener for function nodes.
+		 * @param {ASTNode} node function node
+		 * @returns {void}
+		 */
+		function handleFunction(node) {
+			// Skip recursive functions.
+			const nameVar = sourceCode.getDeclaredVariables(node)[0];
+
+			if (isFunctionName(nameVar) && nameVar.references.length > 0) {
+				return;
+			}
+
+			const hasName = Boolean(node.id && node.id.name);
+			const config = getConfigForNode(node);
+
+			if (config === "never") {
+				if (hasName && node.type !== "FunctionDeclaration") {
+					reportUnexpectedNamedFunction(node);
+				}
+			} else if (config === "as-needed") {
+				if (!hasName && !hasInferredName(node)) {
+					reportUnexpectedUnnamedFunction(node);
+				}
+			} else {
+				if (!hasName && !isObjectOrClassMethod(node)) {
+					reportUnexpectedUnnamedFunction(node);
+				}
+			}
+		}
+
+		return {
+			"FunctionExpression:exit": handleFunction,
+			"ExportDefaultDeclaration > FunctionDeclaration": handleFunction,
+		};
+	},
+};