@alexlit/lint-kit 183.0.0 → 183.2.0

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

@@ -1,270 +0,0 @@
-/**
- * @fileoverview Rule to replace assignment expressions with operator assignment
- * @author Brandon Mills
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-/**
- * Checks whether an operator is commutative and has an operator assignment
- * shorthand form.
- * @param {string} operator Operator to check.
- * @returns {boolean} True if the operator is commutative and has a
- *     shorthand form.
- */
-function isCommutativeOperatorWithShorthand(operator) {
-	return ["*", "&", "^", "|"].includes(operator);
-}
-
-/**
- * Checks whether an operator is not commutative and has an operator assignment
- * shorthand form.
- * @param {string} operator Operator to check.
- * @returns {boolean} True if the operator is not commutative and has
- *     a shorthand form.
- */
-function isNonCommutativeOperatorWithShorthand(operator) {
-	return ["+", "-", "/", "%", "<<", ">>", ">>>", "**"].includes(operator);
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/**
- * Determines if the left side of a node can be safely fixed (i.e. if it activates the same getters/setters and)
- * toString calls regardless of whether assignment shorthand is used)
- * @param {ASTNode} node The node on the left side of the expression
- * @returns {boolean} `true` if the node can be fixed
- */
-function canBeFixed(node) {
-	return (
-		node.type === "Identifier" ||
-		(node.type === "MemberExpression" &&
-			(node.object.type === "Identifier" ||
-				node.object.type === "ThisExpression") &&
-			(!node.computed || node.property.type === "Literal"))
-	);
-}
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-
-		defaultOptions: ["always"],
-
-		docs: {
-			description:
-				"Require or disallow assignment operator shorthand where possible",
-			recommended: false,
-			frozen: true,
-			url: "https://eslint.org/docs/latest/rules/operator-assignment",
-		},
-
-		schema: [
-			{
-				enum: ["always", "never"],
-			},
-		],
-
-		fixable: "code",
-		messages: {
-			replaced:
-				"Assignment (=) can be replaced with operator assignment ({{operator}}).",
-			unexpected:
-				"Unexpected operator assignment ({{operator}}) shorthand.",
-		},
-	},
-
-	create(context) {
-		const never = context.options[0] === "never";
-		const sourceCode = context.sourceCode;
-
-		/**
-		 * Returns the operator token of an AssignmentExpression or BinaryExpression
-		 * @param {ASTNode} node An AssignmentExpression or BinaryExpression node
-		 * @returns {Token} The operator token in the node
-		 */
-		function getOperatorToken(node) {
-			return sourceCode.getFirstTokenBetween(
-				node.left,
-				node.right,
-				token => token.value === node.operator,
-			);
-		}
-
-		/**
-		 * Ensures that an assignment uses the shorthand form where possible.
-		 * @param {ASTNode} node An AssignmentExpression node.
-		 * @returns {void}
-		 */
-		function verify(node) {
-			if (
-				node.operator !== "=" ||
-				node.right.type !== "BinaryExpression"
-			) {
-				return;
-			}
-
-			const left = node.left;
-			const expr = node.right;
-			const operator = expr.operator;
-
-			if (
-				isCommutativeOperatorWithShorthand(operator) ||
-				isNonCommutativeOperatorWithShorthand(operator)
-			) {
-				const replacementOperator = `${operator}=`;
-
-				if (astUtils.isSameReference(left, expr.left, true)) {
-					context.report({
-						node,
-						messageId: "replaced",
-						data: { operator: replacementOperator },
-						fix(fixer) {
-							if (canBeFixed(left) && canBeFixed(expr.left)) {
-								const equalsToken = getOperatorToken(node);
-								const operatorToken = getOperatorToken(expr);
-								const leftText = sourceCode
-									.getText()
-									.slice(node.range[0], equalsToken.range[0]);
-								const rightText = sourceCode
-									.getText()
-									.slice(
-										operatorToken.range[1],
-										node.right.range[1],
-									);
-
-								// Check for comments that would be removed.
-								if (
-									sourceCode.commentsExistBetween(
-										equalsToken,
-										operatorToken,
-									)
-								) {
-									return null;
-								}
-
-								return fixer.replaceText(
-									node,
-									`${leftText}${replacementOperator}${rightText}`,
-								);
-							}
-							return null;
-						},
-					});
-				} else if (
-					astUtils.isSameReference(left, expr.right, true) &&
-					isCommutativeOperatorWithShorthand(operator)
-				) {
-					/*
-					 * This case can't be fixed safely.
-					 * If `a` and `b` both have custom valueOf() behavior, then fixing `a = b * a` to `a *= b` would
-					 * change the execution order of the valueOf() functions.
-					 */
-					context.report({
-						node,
-						messageId: "replaced",
-						data: { operator: replacementOperator },
-					});
-				}
-			}
-		}
-
-		/**
-		 * Warns if an assignment expression uses operator assignment shorthand.
-		 * @param {ASTNode} node An AssignmentExpression node.
-		 * @returns {void}
-		 */
-		function prohibit(node) {
-			if (
-				node.operator !== "=" &&
-				!astUtils.isLogicalAssignmentOperator(node.operator)
-			) {
-				context.report({
-					node,
-					messageId: "unexpected",
-					data: { operator: node.operator },
-					fix(fixer) {
-						if (canBeFixed(node.left)) {
-							const firstToken = sourceCode.getFirstToken(node);
-							const operatorToken = getOperatorToken(node);
-							const leftText = sourceCode
-								.getText()
-								.slice(node.range[0], operatorToken.range[0]);
-							const newOperator = node.operator.slice(0, -1);
-							let rightText;
-
-							// Check for comments that would be duplicated.
-							if (
-								sourceCode.commentsExistBetween(
-									firstToken,
-									operatorToken,
-								)
-							) {
-								return null;
-							}
-
-							// If this change would modify precedence (e.g. `foo *= bar + 1` => `foo = foo * (bar + 1)`), parenthesize the right side.
-							if (
-								astUtils.getPrecedence(node.right) <=
-									astUtils.getPrecedence({
-										type: "BinaryExpression",
-										operator: newOperator,
-									}) &&
-								!astUtils.isParenthesised(
-									sourceCode,
-									node.right,
-								)
-							) {
-								rightText = `${sourceCode.text.slice(operatorToken.range[1], node.right.range[0])}(${sourceCode.getText(node.right)})`;
-							} else {
-								const tokenAfterOperator =
-									sourceCode.getTokenAfter(operatorToken, {
-										includeComments: true,
-									});
-								let rightTextPrefix = "";
-
-								if (
-									operatorToken.range[1] ===
-										tokenAfterOperator.range[0] &&
-									!astUtils.canTokensBeAdjacent(
-										{
-											type: "Punctuator",
-											value: newOperator,
-										},
-										tokenAfterOperator,
-									)
-								) {
-									rightTextPrefix = " "; // foo+=+bar -> foo= foo+ +bar
-								}
-
-								rightText = `${rightTextPrefix}${sourceCode.text.slice(operatorToken.range[1], node.range[1])}`;
-							}
-
-							return fixer.replaceText(
-								node,
-								`${leftText}= ${leftText}${newOperator}${rightText}`,
-							);
-						}
-						return null;
-					},
-				});
-			}
-		}
-
-		return {
-			AssignmentExpression: !never ? verify : prohibit,
-		};
-	},
-};

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

@@ -1,315 +0,0 @@
-/**
- * @fileoverview Operator linebreak - enforces operator linebreak style of two types: after and before
- * @author Benoît Zugmeyer
- * @deprecated in ESLint v8.53.0
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		deprecated: {
-			message: "Formatting rules are being moved out of ESLint core.",
-			url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/",
-			deprecatedSince: "8.53.0",
-			availableUntil: "11.0.0",
-			replacedBy: [
-				{
-					message:
-						"ESLint Stylistic now maintains deprecated stylistic core rules.",
-					url: "https://eslint.style/guide/migration",
-					plugin: {
-						name: "@stylistic/eslint-plugin",
-						url: "https://eslint.style",
-					},
-					rule: {
-						name: "operator-linebreak",
-						url: "https://eslint.style/rules/operator-linebreak",
-					},
-				},
-			],
-		},
-		type: "layout",
-
-		docs: {
-			description: "Enforce consistent linebreak style for operators",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/operator-linebreak",
-		},
-
-		schema: [
-			{
-				enum: ["after", "before", "none", null],
-			},
-			{
-				type: "object",
-				properties: {
-					overrides: {
-						type: "object",
-						additionalProperties: {
-							enum: ["after", "before", "none", "ignore"],
-						},
-					},
-				},
-				additionalProperties: false,
-			},
-		],
-
-		fixable: "code",
-
-		messages: {
-			operatorAtBeginning:
-				"'{{operator}}' should be placed at the beginning of the line.",
-			operatorAtEnd:
-				"'{{operator}}' should be placed at the end of the line.",
-			badLinebreak: "Bad line breaking before and after '{{operator}}'.",
-			noLinebreak:
-				"There should be no line break before or after '{{operator}}'.",
-		},
-	},
-
-	create(context) {
-		const usedDefaultGlobal = !context.options[0];
-		const globalStyle = context.options[0] || "after";
-		const options = context.options[1] || {};
-		const styleOverrides = options.overrides
-			? Object.assign({}, options.overrides)
-			: {};
-
-		if (usedDefaultGlobal && !styleOverrides["?"]) {
-			styleOverrides["?"] = "before";
-		}
-
-		if (usedDefaultGlobal && !styleOverrides[":"]) {
-			styleOverrides[":"] = "before";
-		}
-
-		const sourceCode = context.sourceCode;
-
-		//--------------------------------------------------------------------------
-		// Helpers
-		//--------------------------------------------------------------------------
-
-		/**
-		 * Gets a fixer function to fix rule issues
-		 * @param {Token} operatorToken The operator token of an expression
-		 * @param {string} desiredStyle The style for the rule. One of 'before', 'after', 'none'
-		 * @returns {Function} A fixer function
-		 */
-		function getFixer(operatorToken, desiredStyle) {
-			return fixer => {
-				const tokenBefore = sourceCode.getTokenBefore(operatorToken);
-				const tokenAfter = sourceCode.getTokenAfter(operatorToken);
-				const textBefore = sourceCode.text.slice(
-					tokenBefore.range[1],
-					operatorToken.range[0],
-				);
-				const textAfter = sourceCode.text.slice(
-					operatorToken.range[1],
-					tokenAfter.range[0],
-				);
-				const hasLinebreakBefore = !astUtils.isTokenOnSameLine(
-					tokenBefore,
-					operatorToken,
-				);
-				const hasLinebreakAfter = !astUtils.isTokenOnSameLine(
-					operatorToken,
-					tokenAfter,
-				);
-				let newTextBefore, newTextAfter;
-
-				if (
-					hasLinebreakBefore !== hasLinebreakAfter &&
-					desiredStyle !== "none"
-				) {
-					// If there is a comment before and after the operator, don't do a fix.
-					if (
-						sourceCode.getTokenBefore(operatorToken, {
-							includeComments: true,
-						}) !== tokenBefore &&
-						sourceCode.getTokenAfter(operatorToken, {
-							includeComments: true,
-						}) !== tokenAfter
-					) {
-						return null;
-					}
-
-					/*
-					 * If there is only one linebreak and it's on the wrong side of the operator, swap the text before and after the operator.
-					 * foo &&
-					 *           bar
-					 * would get fixed to
-					 * foo
-					 *        && bar
-					 */
-					newTextBefore = textAfter;
-					newTextAfter = textBefore;
-				} else {
-					const LINEBREAK_REGEX =
-						astUtils.createGlobalLinebreakMatcher();
-
-					// Otherwise, if no linebreak is desired and no comments interfere, replace the linebreaks with empty strings.
-					newTextBefore =
-						desiredStyle === "before" || textBefore.trim()
-							? textBefore
-							: textBefore.replace(LINEBREAK_REGEX, "");
-					newTextAfter =
-						desiredStyle === "after" || textAfter.trim()
-							? textAfter
-							: textAfter.replace(LINEBREAK_REGEX, "");
-
-					// If there was no change (due to interfering comments), don't output a fix.
-					if (
-						newTextBefore === textBefore &&
-						newTextAfter === textAfter
-					) {
-						return null;
-					}
-				}
-
-				if (
-					newTextAfter === "" &&
-					tokenAfter.type === "Punctuator" &&
-					"+-".includes(operatorToken.value) &&
-					tokenAfter.value === operatorToken.value
-				) {
-					// To avoid accidentally creating a ++ or -- operator, insert a space if the operator is a +/- and the following token is a unary +/-.
-					newTextAfter += " ";
-				}
-
-				return fixer.replaceTextRange(
-					[tokenBefore.range[1], tokenAfter.range[0]],
-					newTextBefore + operatorToken.value + newTextAfter,
-				);
-			};
-		}
-
-		/**
-		 * Checks the operator placement
-		 * @param {ASTNode} node The node to check
-		 * @param {ASTNode} rightSide The node that comes after the operator in `node`
-		 * @param {string} operator The operator
-		 * @private
-		 * @returns {void}
-		 */
-		function validateNode(node, rightSide, operator) {
-			/*
-			 * Find the operator token by searching from the right side, because between the left side and the operator
-			 * there could be additional tokens from type annotations. Search specifically for the token which
-			 * value equals the operator, in order to skip possible opening parentheses before the right side node.
-			 */
-			const operatorToken = sourceCode.getTokenBefore(
-				rightSide,
-				token => token.value === operator,
-			);
-			const leftToken = sourceCode.getTokenBefore(operatorToken);
-			const rightToken = sourceCode.getTokenAfter(operatorToken);
-			const operatorStyleOverride = styleOverrides[operator];
-			const style = operatorStyleOverride || globalStyle;
-			const fix = getFixer(operatorToken, style);
-
-			// if single line
-			if (
-				astUtils.isTokenOnSameLine(leftToken, operatorToken) &&
-				astUtils.isTokenOnSameLine(operatorToken, rightToken)
-			) {
-				// do nothing.
-			} else if (
-				operatorStyleOverride !== "ignore" &&
-				!astUtils.isTokenOnSameLine(leftToken, operatorToken) &&
-				!astUtils.isTokenOnSameLine(operatorToken, rightToken)
-			) {
-				// lone operator
-				context.report({
-					node,
-					loc: operatorToken.loc,
-					messageId: "badLinebreak",
-					data: {
-						operator,
-					},
-					fix,
-				});
-			} else if (
-				style === "before" &&
-				astUtils.isTokenOnSameLine(leftToken, operatorToken)
-			) {
-				context.report({
-					node,
-					loc: operatorToken.loc,
-					messageId: "operatorAtBeginning",
-					data: {
-						operator,
-					},
-					fix,
-				});
-			} else if (
-				style === "after" &&
-				astUtils.isTokenOnSameLine(operatorToken, rightToken)
-			) {
-				context.report({
-					node,
-					loc: operatorToken.loc,
-					messageId: "operatorAtEnd",
-					data: {
-						operator,
-					},
-					fix,
-				});
-			} else if (style === "none") {
-				context.report({
-					node,
-					loc: operatorToken.loc,
-					messageId: "noLinebreak",
-					data: {
-						operator,
-					},
-					fix,
-				});
-			}
-		}
-
-		/**
-		 * Validates a binary expression using `validateNode`
-		 * @param {BinaryExpression|LogicalExpression|AssignmentExpression} node node to be validated
-		 * @returns {void}
-		 */
-		function validateBinaryExpression(node) {
-			validateNode(node, node.right, node.operator);
-		}
-
-		//--------------------------------------------------------------------------
-		// Public
-		//--------------------------------------------------------------------------
-
-		return {
-			BinaryExpression: validateBinaryExpression,
-			LogicalExpression: validateBinaryExpression,
-			AssignmentExpression: validateBinaryExpression,
-			VariableDeclarator(node) {
-				if (node.init) {
-					validateNode(node, node.init, "=");
-				}
-			},
-			PropertyDefinition(node) {
-				if (node.value) {
-					validateNode(node, node.value, "=");
-				}
-			},
-			ConditionalExpression(node) {
-				validateNode(node, node.consequent, "?");
-				validateNode(node, node.alternate, ":");
-			},
-		};
-	},
-};