@alexlit/lint-kit 183.1.0 → 183.3.0

package/packages/config-eslint/node_modules/eslint/lib/rules/prefer-destructuring.js

@@ -1,332 +0,0 @@
-/**
- * @fileoverview Prefer destructuring from arrays and objects
- * @author Alex LaFroscia
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-const PRECEDENCE_OF_ASSIGNMENT_EXPR = astUtils.getPrecedence({
-	type: "AssignmentExpression",
-});
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-
-		docs: {
-			description: "Require destructuring from arrays and/or objects",
-			recommended: false,
-			frozen: true,
-			url: "https://eslint.org/docs/latest/rules/prefer-destructuring",
-		},
-
-		fixable: "code",
-
-		schema: [
-			{
-				/*
-				 * old support {array: Boolean, object: Boolean}
-				 * new support {VariableDeclarator: {}, AssignmentExpression: {}}
-				 */
-				oneOf: [
-					{
-						type: "object",
-						properties: {
-							VariableDeclarator: {
-								type: "object",
-								properties: {
-									array: {
-										type: "boolean",
-									},
-									object: {
-										type: "boolean",
-									},
-								},
-								additionalProperties: false,
-							},
-							AssignmentExpression: {
-								type: "object",
-								properties: {
-									array: {
-										type: "boolean",
-									},
-									object: {
-										type: "boolean",
-									},
-								},
-								additionalProperties: false,
-							},
-						},
-						additionalProperties: false,
-					},
-					{
-						type: "object",
-						properties: {
-							array: {
-								type: "boolean",
-							},
-							object: {
-								type: "boolean",
-							},
-						},
-						additionalProperties: false,
-					},
-				],
-			},
-			{
-				type: "object",
-				properties: {
-					enforceForRenamedProperties: {
-						type: "boolean",
-					},
-				},
-				additionalProperties: false,
-			},
-		],
-
-		messages: {
-			preferDestructuring: "Use {{type}} destructuring.",
-		},
-	},
-	create(context) {
-		const enabledTypes = context.options[0];
-		const enforceForRenamedProperties =
-			context.options[1] &&
-			context.options[1].enforceForRenamedProperties;
-		let normalizedOptions = {
-			VariableDeclarator: { array: true, object: true },
-			AssignmentExpression: { array: true, object: true },
-		};
-
-		if (enabledTypes) {
-			normalizedOptions =
-				typeof enabledTypes.array !== "undefined" ||
-				typeof enabledTypes.object !== "undefined"
-					? {
-							VariableDeclarator: enabledTypes,
-							AssignmentExpression: enabledTypes,
-						}
-					: enabledTypes;
-		}
-
-		//--------------------------------------------------------------------------
-		// Helpers
-		//--------------------------------------------------------------------------
-
-		/**
-		 * Checks if destructuring type should be checked.
-		 * @param {string} nodeType "AssignmentExpression" or "VariableDeclarator"
-		 * @param {string} destructuringType "array" or "object"
-		 * @returns {boolean} `true` if the destructuring type should be checked for the given node
-		 */
-		function shouldCheck(nodeType, destructuringType) {
-			return (
-				normalizedOptions &&
-				normalizedOptions[nodeType] &&
-				normalizedOptions[nodeType][destructuringType]
-			);
-		}
-
-		/**
-		 * Determines if the given node is accessing an array index
-		 *
-		 * This is used to differentiate array index access from object property
-		 * access.
-		 * @param {ASTNode} node the node to evaluate
-		 * @returns {boolean} whether or not the node is an integer
-		 */
-		function isArrayIndexAccess(node) {
-			return Number.isInteger(node.property.value);
-		}
-
-		/**
-		 * Report that the given node should use destructuring
-		 * @param {ASTNode} reportNode the node to report
-		 * @param {string} type the type of destructuring that should have been done
-		 * @param {Function|null} fix the fix function or null to pass to context.report
-		 * @returns {void}
-		 */
-		function report(reportNode, type, fix) {
-			context.report({
-				node: reportNode,
-				messageId: "preferDestructuring",
-				data: { type },
-				fix,
-			});
-		}
-
-		/**
-		 * Determines if a node should be fixed into object destructuring
-		 *
-		 * The fixer only fixes the simplest case of object destructuring,
-		 * like: `let x = a.x`;
-		 *
-		 * Assignment expression is not fixed.
-		 * Array destructuring is not fixed.
-		 * Renamed property is not fixed.
-		 * @param {ASTNode} node the node to evaluate
-		 * @returns {boolean} whether or not the node should be fixed
-		 */
-		function shouldFix(node) {
-			return (
-				node.type === "VariableDeclarator" &&
-				node.id.type === "Identifier" &&
-				node.init.type === "MemberExpression" &&
-				!node.init.computed &&
-				node.init.property.type === "Identifier" &&
-				node.id.name === node.init.property.name
-			);
-		}
-
-		/**
-		 * Fix a node into object destructuring.
-		 * This function only handles the simplest case of object destructuring,
-		 * see {@link shouldFix}.
-		 * @param {SourceCodeFixer} fixer the fixer object
-		 * @param {ASTNode} node the node to be fixed.
-		 * @returns {Object} a fix for the node
-		 */
-		function fixIntoObjectDestructuring(fixer, node) {
-			const rightNode = node.init;
-			const sourceCode = context.sourceCode;
-
-			// Don't fix if that would remove any comments. Only comments inside `rightNode.object` can be preserved.
-			if (
-				sourceCode.getCommentsInside(node).length >
-				sourceCode.getCommentsInside(rightNode.object).length
-			) {
-				return null;
-			}
-
-			let objectText = sourceCode.getText(rightNode.object);
-
-			if (
-				astUtils.getPrecedence(rightNode.object) <
-				PRECEDENCE_OF_ASSIGNMENT_EXPR
-			) {
-				objectText = `(${objectText})`;
-			}
-
-			return fixer.replaceText(
-				node,
-				`{${rightNode.property.name}} = ${objectText}`,
-			);
-		}
-
-		/**
-		 * Check that the `prefer-destructuring` rules are followed based on the
-		 * given left- and right-hand side of the assignment.
-		 *
-		 * Pulled out into a separate method so that VariableDeclarators and
-		 * AssignmentExpressions can share the same verification logic.
-		 * @param {ASTNode} leftNode the left-hand side of the assignment
-		 * @param {ASTNode} rightNode the right-hand side of the assignment
-		 * @param {ASTNode} reportNode the node to report the error on
-		 * @returns {void}
-		 */
-		function performCheck(leftNode, rightNode, reportNode) {
-			if (
-				rightNode.type !== "MemberExpression" ||
-				rightNode.object.type === "Super" ||
-				rightNode.property.type === "PrivateIdentifier"
-			) {
-				return;
-			}
-
-			if (isArrayIndexAccess(rightNode)) {
-				if (shouldCheck(reportNode.type, "array")) {
-					report(reportNode, "array", null);
-				}
-				return;
-			}
-
-			const fix = shouldFix(reportNode)
-				? fixer => fixIntoObjectDestructuring(fixer, reportNode)
-				: null;
-
-			if (
-				shouldCheck(reportNode.type, "object") &&
-				enforceForRenamedProperties
-			) {
-				report(reportNode, "object", fix);
-				return;
-			}
-
-			if (shouldCheck(reportNode.type, "object")) {
-				const property = rightNode.property;
-
-				if (
-					(property.type === "Literal" &&
-						leftNode.name === property.value) ||
-					(property.type === "Identifier" &&
-						leftNode.name === property.name &&
-						!rightNode.computed)
-				) {
-					report(reportNode, "object", fix);
-				}
-			}
-		}
-
-		/**
-		 * Check if a given variable declarator is coming from an property access
-		 * that should be using destructuring instead
-		 * @param {ASTNode} node the variable declarator to check
-		 * @returns {void}
-		 */
-		function checkVariableDeclarator(node) {
-			// Skip if variable is declared without assignment
-			if (!node.init) {
-				return;
-			}
-
-			// Variable declarations using explicit resource management cannot use destructuring (parse error)
-			if (
-				node.parent.kind === "using" ||
-				node.parent.kind === "await using"
-			) {
-				return;
-			}
-
-			// We only care about member expressions past this point
-			if (node.init.type !== "MemberExpression") {
-				return;
-			}
-
-			performCheck(node.id, node.init, node);
-		}
-
-		/**
-		 * Run the `prefer-destructuring` check on an AssignmentExpression
-		 * @param {ASTNode} node the AssignmentExpression node
-		 * @returns {void}
-		 */
-		function checkAssignmentExpression(node) {
-			if (node.operator === "=") {
-				performCheck(node.left, node.right, node);
-			}
-		}
-
-		//--------------------------------------------------------------------------
-		// Public
-		//--------------------------------------------------------------------------
-
-		return {
-			VariableDeclarator: checkVariableDeclarator,
-			AssignmentExpression: checkAssignmentExpression,
-		};
-	},
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/prefer-exponentiation-operator.js

@@ -1,235 +0,0 @@
-/**
- * @fileoverview Rule to disallow Math.pow in favor of the ** operator
- * @author Milos Djermanovic
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-const { CALL, ReferenceTracker } = require("@eslint-community/eslint-utils");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-const PRECEDENCE_OF_EXPONENTIATION_EXPR = astUtils.getPrecedence({
-	type: "BinaryExpression",
-	operator: "**",
-});
-
-/**
- * Determines whether the given node needs parens if used as the base in an exponentiation binary expression.
- * @param {ASTNode} base The node to check.
- * @returns {boolean} `true` if the node needs to be parenthesised.
- */
-function doesBaseNeedParens(base) {
-	return (
-		// '**' is right-associative, parens are needed when Math.pow(a ** b, c) is converted to (a ** b) ** c
-		astUtils.getPrecedence(base) <= PRECEDENCE_OF_EXPONENTIATION_EXPR ||
-		// An unary operator cannot be used immediately before an exponentiation expression
-		base.type === "AwaitExpression" ||
-		base.type === "UnaryExpression"
-	);
-}
-
-/**
- * Determines whether the given node needs parens if used as the exponent in an exponentiation binary expression.
- * @param {ASTNode} exponent The node to check.
- * @returns {boolean} `true` if the node needs to be parenthesised.
- */
-function doesExponentNeedParens(exponent) {
-	// '**' is right-associative, there is no need for parens when Math.pow(a, b ** c) is converted to a ** b ** c
-	return astUtils.getPrecedence(exponent) < PRECEDENCE_OF_EXPONENTIATION_EXPR;
-}
-
-/**
- * Determines whether an exponentiation binary expression at the place of the given node would need parens.
- * @param {ASTNode} node A node that would be replaced by an exponentiation binary expression.
- * @param {SourceCode} sourceCode A SourceCode object.
- * @returns {boolean} `true` if the expression needs to be parenthesised.
- */
-function doesExponentiationExpressionNeedParens(node, sourceCode) {
-	const parent =
-		node.parent.type === "ChainExpression"
-			? node.parent.parent
-			: node.parent;
-
-	const parentPrecedence = astUtils.getPrecedence(parent);
-	const needsParens =
-		parent.type === "ClassDeclaration" ||
-		(parent.type.endsWith("Expression") &&
-			(parentPrecedence === -1 ||
-				parentPrecedence >= PRECEDENCE_OF_EXPONENTIATION_EXPR) &&
-			!(
-				parent.type === "BinaryExpression" &&
-				parent.operator === "**" &&
-				parent.right === node
-			) &&
-			!(
-				(parent.type === "CallExpression" ||
-					parent.type === "NewExpression") &&
-				parent.arguments.includes(node)
-			) &&
-			!(
-				parent.type === "MemberExpression" &&
-				parent.computed &&
-				parent.property === node
-			) &&
-			!(parent.type === "ArrayExpression"));
-
-	return needsParens && !astUtils.isParenthesised(sourceCode, node);
-}
-
-/**
- * Optionally parenthesizes given text.
- * @param {string} text The text to parenthesize.
- * @param {boolean} shouldParenthesize If `true`, the text will be parenthesised.
- * @returns {string} parenthesised or unchanged text.
- */
-function parenthesizeIfShould(text, shouldParenthesize) {
-	return shouldParenthesize ? `(${text})` : text;
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-
-		docs: {
-			description:
-				"Disallow the use of `Math.pow` in favor of the `**` operator",
-			recommended: false,
-			frozen: true,
-			url: "https://eslint.org/docs/latest/rules/prefer-exponentiation-operator",
-		},
-
-		schema: [],
-		fixable: "code",
-
-		messages: {
-			useExponentiation: "Use the '**' operator instead of 'Math.pow'.",
-		},
-	},
-
-	create(context) {
-		const sourceCode = context.sourceCode;
-
-		/**
-		 * Reports the given node.
-		 * @param {ASTNode} node 'Math.pow()' node to report.
-		 * @returns {void}
-		 */
-		function report(node) {
-			context.report({
-				node,
-				messageId: "useExponentiation",
-				fix(fixer) {
-					if (
-						node.arguments.length !== 2 ||
-						node.arguments.some(
-							arg => arg.type === "SpreadElement",
-						) ||
-						sourceCode.getCommentsInside(node).length > 0
-					) {
-						return null;
-					}
-
-					const base = node.arguments[0],
-						exponent = node.arguments[1],
-						baseText = sourceCode.getText(base),
-						exponentText = sourceCode.getText(exponent),
-						shouldParenthesizeBase = doesBaseNeedParens(base),
-						shouldParenthesizeExponent =
-							doesExponentNeedParens(exponent),
-						shouldParenthesizeAll =
-							doesExponentiationExpressionNeedParens(
-								node,
-								sourceCode,
-							);
-
-					let prefix = "",
-						suffix = "";
-
-					if (!shouldParenthesizeAll) {
-						if (!shouldParenthesizeBase) {
-							const firstReplacementToken =
-									sourceCode.getFirstToken(base),
-								tokenBefore = sourceCode.getTokenBefore(node);
-
-							if (
-								tokenBefore &&
-								tokenBefore.range[1] === node.range[0] &&
-								!astUtils.canTokensBeAdjacent(
-									tokenBefore,
-									firstReplacementToken,
-								)
-							) {
-								prefix = " "; // a+Math.pow(++b, c) -> a+ ++b**c
-							}
-						}
-						if (!shouldParenthesizeExponent) {
-							const lastReplacementToken =
-									sourceCode.getLastToken(exponent),
-								tokenAfter = sourceCode.getTokenAfter(node);
-
-							if (
-								tokenAfter &&
-								node.range[1] === tokenAfter.range[0] &&
-								!astUtils.canTokensBeAdjacent(
-									lastReplacementToken,
-									tokenAfter,
-								)
-							) {
-								suffix = " "; // Math.pow(a, b)in c -> a**b in c
-							}
-						}
-					}
-
-					const baseReplacement = parenthesizeIfShould(
-							baseText,
-							shouldParenthesizeBase,
-						),
-						exponentReplacement = parenthesizeIfShould(
-							exponentText,
-							shouldParenthesizeExponent,
-						),
-						replacement = parenthesizeIfShould(
-							`${baseReplacement}**${exponentReplacement}`,
-							shouldParenthesizeAll,
-						);
-
-					return fixer.replaceText(
-						node,
-						`${prefix}${replacement}${suffix}`,
-					);
-				},
-			});
-		}
-
-		return {
-			Program(node) {
-				const scope = sourceCode.getScope(node);
-				const tracker = new ReferenceTracker(scope);
-				const trackMap = {
-					Math: {
-						pow: { [CALL]: true },
-					},
-				};
-
-				for (const { node: refNode } of tracker.iterateGlobalReferences(
-					trackMap,
-				)) {
-					report(refNode);
-				}
-			},
-		};
-	},
-};