@alexlit/lint-kit 183.0.0 → 183.2.0

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

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

@@ -1,204 +0,0 @@
-/**
- * @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");
-
-//------------------------------------------------------------------------------
-// Types
-//------------------------------------------------------------------------------
-
-/** @typedef {import("eslint-scope").Variable} Variable */
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-/**
- * Checks whether or not a given variable is a function name.
- * @param {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"],
-				},
-			},
-			type: "array",
-			items: [
-				{
-					$ref: "#/definitions/value",
-				},
-				{
-					type: "object",
-					properties: {
-						generators: {
-							$ref: "#/definitions/value",
-						},
-					},
-					additionalProperties: false,
-				},
-			],
-			additionalItems: 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,
-		};
-	},
-};