@alexlit/lint-kit 166.1.0 → 167.0.0

package/packages/config-eslint/node_modules/eslint/lib/rules/no-unexpected-multiline.js

@@ -1,130 +0,0 @@
-/**
- * @fileoverview Rule to spot scenarios where a newline looks like it is ending a statement, but is not.
- * @author Glen Mailer
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "problem",
-
-		docs: {
-			description: "Disallow confusing multiline expressions",
-			recommended: true,
-			url: "https://eslint.org/docs/latest/rules/no-unexpected-multiline",
-		},
-
-		schema: [],
-		messages: {
-			function:
-				"Unexpected newline between function and ( of function call.",
-			property:
-				"Unexpected newline between object and [ of property access.",
-			taggedTemplate:
-				"Unexpected newline between template tag and template literal.",
-			division:
-				"Unexpected newline between numerator and division operator.",
-		},
-	},
-
-	create(context) {
-		const REGEX_FLAG_MATCHER = /^[gimsuy]+$/u;
-
-		const sourceCode = context.sourceCode;
-
-		/**
-		 * Check to see if there is a newline between the node and the following open bracket
-		 * line's expression
-		 * @param {ASTNode} node The node to check.
-		 * @param {string} messageId The error messageId to use.
-		 * @returns {void}
-		 * @private
-		 */
-		function checkForBreakAfter(node, messageId) {
-			const openParen = sourceCode.getTokenAfter(
-				node,
-				astUtils.isNotClosingParenToken,
-			);
-			const nodeExpressionEnd = sourceCode.getTokenBefore(openParen);
-
-			if (openParen.loc.start.line !== nodeExpressionEnd.loc.end.line) {
-				context.report({
-					node,
-					loc: openParen.loc,
-					messageId,
-				});
-			}
-		}
-
-		//--------------------------------------------------------------------------
-		// Public API
-		//--------------------------------------------------------------------------
-
-		return {
-			MemberExpression(node) {
-				if (!node.computed || node.optional) {
-					return;
-				}
-				checkForBreakAfter(node.object, "property");
-			},
-
-			TaggedTemplateExpression(node) {
-				const { quasi } = node;
-
-				// handles common tags, parenthesized tags, and typescript's generic type arguments
-				const tokenBefore = sourceCode.getTokenBefore(quasi);
-
-				if (tokenBefore.loc.end.line !== quasi.loc.start.line) {
-					context.report({
-						node,
-						loc: {
-							start: quasi.loc.start,
-							end: {
-								line: quasi.loc.start.line,
-								column: quasi.loc.start.column + 1,
-							},
-						},
-						messageId: "taggedTemplate",
-					});
-				}
-			},
-
-			CallExpression(node) {
-				if (node.arguments.length === 0 || node.optional) {
-					return;
-				}
-				checkForBreakAfter(node.callee, "function");
-			},
-
-			"BinaryExpression[operator='/'] > BinaryExpression[operator='/'].left"(
-				node,
-			) {
-				const secondSlash = sourceCode.getTokenAfter(
-					node,
-					token => token.value === "/",
-				);
-				const tokenAfterOperator =
-					sourceCode.getTokenAfter(secondSlash);
-
-				if (
-					tokenAfterOperator.type === "Identifier" &&
-					REGEX_FLAG_MATCHER.test(tokenAfterOperator.value) &&
-					secondSlash.range[1] === tokenAfterOperator.range[0]
-				) {
-					checkForBreakAfter(node.left, "division");
-				}
-			},
-		};
-	},
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/no-unmodified-loop-condition.js

@@ -1,360 +0,0 @@
-/**
- * @fileoverview Rule to disallow use of unmodified expressions in loop conditions
- * @author Toru Nagashima
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const Traverser = require("../shared/traverser"),
-	astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-const SENTINEL_PATTERN =
-	/(?:(?:Call|Class|Function|Member|New|Yield)Expression|Statement|Declaration)$/u;
-const LOOP_PATTERN = /^(?:DoWhile|For|While)Statement$/u; // for-in/of statements don't have `test` property.
-const GROUP_PATTERN = /^(?:BinaryExpression|ConditionalExpression)$/u;
-const SKIP_PATTERN = /^(?:ArrowFunction|Class|Function)Expression$/u;
-const DYNAMIC_PATTERN = /^(?:Call|Member|New|TaggedTemplate|Yield)Expression$/u;
-
-/**
- * @typedef {Object} LoopConditionInfo
- * @property {eslint-scope.Reference} reference - The reference.
- * @property {ASTNode} group - BinaryExpression or ConditionalExpression nodes
- *      that the reference is belonging to.
- * @property {Function} isInLoop - The predicate which checks a given reference
- *      is in this loop.
- * @property {boolean} modified - The flag that the reference is modified in
- *      this loop.
- */
-
-/**
- * Checks whether or not a given reference is a write reference.
- * @param {eslint-scope.Reference} reference A reference to check.
- * @returns {boolean} `true` if the reference is a write reference.
- */
-function isWriteReference(reference) {
-	if (reference.init) {
-		const def = reference.resolved && reference.resolved.defs[0];
-
-		if (!def || def.type !== "Variable" || def.parent.kind !== "var") {
-			return false;
-		}
-	}
-	return reference.isWrite();
-}
-
-/**
- * Checks whether or not a given loop condition info does not have the modified
- * flag.
- * @param {LoopConditionInfo} condition A loop condition info to check.
- * @returns {boolean} `true` if the loop condition info is "unmodified".
- */
-function isUnmodified(condition) {
-	return !condition.modified;
-}
-
-/**
- * Checks whether or not a given loop condition info does not have the modified
- * flag and does not have the group this condition belongs to.
- * @param {LoopConditionInfo} condition A loop condition info to check.
- * @returns {boolean} `true` if the loop condition info is "unmodified".
- */
-function isUnmodifiedAndNotBelongToGroup(condition) {
-	return !(condition.modified || condition.group);
-}
-
-/**
- * Checks whether or not a given reference is inside of a given node.
- * @param {ASTNode} node A node to check.
- * @param {eslint-scope.Reference} reference A reference to check.
- * @returns {boolean} `true` if the reference is inside of the node.
- */
-function isInRange(node, reference) {
-	const or = node.range;
-	const ir = reference.identifier.range;
-
-	return or[0] <= ir[0] && ir[1] <= or[1];
-}
-
-/**
- * Checks whether or not a given reference is inside of a loop node's condition.
- * @param {ASTNode} node A node to check.
- * @param {eslint-scope.Reference} reference A reference to check.
- * @returns {boolean} `true` if the reference is inside of the loop node's
- *      condition.
- */
-const isInLoop = {
-	WhileStatement: isInRange,
-	DoWhileStatement: isInRange,
-	ForStatement(node, reference) {
-		return (
-			isInRange(node, reference) &&
-			!(node.init && isInRange(node.init, reference))
-		);
-	},
-};
-
-/**
- * Gets the function which encloses a given reference.
- * This supports only FunctionDeclaration.
- * @param {eslint-scope.Reference} reference A reference to get.
- * @returns {ASTNode|null} The function node or null.
- */
-function getEncloseFunctionDeclaration(reference) {
-	let node = reference.identifier;
-
-	while (node) {
-		if (node.type === "FunctionDeclaration") {
-			return node.id ? node : null;
-		}
-
-		node = node.parent;
-	}
-
-	return null;
-}
-
-/**
- * Updates the "modified" flags of given loop conditions with given modifiers.
- * @param {LoopConditionInfo[]} conditions The loop conditions to be updated.
- * @param {eslint-scope.Reference[]} modifiers The references to update.
- * @returns {void}
- */
-function updateModifiedFlag(conditions, modifiers) {
-	for (let i = 0; i < conditions.length; ++i) {
-		const condition = conditions[i];
-
-		for (let j = 0; !condition.modified && j < modifiers.length; ++j) {
-			const modifier = modifiers[j];
-			let funcNode, funcVar;
-
-			/*
-			 * Besides checking for the condition being in the loop, we want to
-			 * check the function that this modifier is belonging to is called
-			 * in the loop.
-			 * FIXME: This should probably be extracted to a function.
-			 */
-			const inLoop =
-				condition.isInLoop(modifier) ||
-				Boolean(
-					(funcNode = getEncloseFunctionDeclaration(modifier)) &&
-						(funcVar = astUtils.getVariableByName(
-							modifier.from.upper,
-							funcNode.id.name,
-						)) &&
-						funcVar.references.some(condition.isInLoop),
-				);
-
-			condition.modified = inLoop;
-		}
-	}
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "problem",
-
-		docs: {
-			description: "Disallow unmodified loop conditions",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/no-unmodified-loop-condition",
-		},
-
-		schema: [],
-
-		messages: {
-			loopConditionNotModified:
-				"'{{name}}' is not modified in this loop.",
-		},
-	},
-
-	create(context) {
-		const sourceCode = context.sourceCode;
-		let groupMap = null;
-
-		/**
-		 * Reports a given condition info.
-		 * @param {LoopConditionInfo} condition A loop condition info to report.
-		 * @returns {void}
-		 */
-		function report(condition) {
-			const node = condition.reference.identifier;
-
-			context.report({
-				node,
-				messageId: "loopConditionNotModified",
-				data: node,
-			});
-		}
-
-		/**
-		 * Registers given conditions to the group the condition belongs to.
-		 * @param {LoopConditionInfo[]} conditions A loop condition info to
-		 *      register.
-		 * @returns {void}
-		 */
-		function registerConditionsToGroup(conditions) {
-			for (let i = 0; i < conditions.length; ++i) {
-				const condition = conditions[i];
-
-				if (condition.group) {
-					let group = groupMap.get(condition.group);
-
-					if (!group) {
-						group = [];
-						groupMap.set(condition.group, group);
-					}
-					group.push(condition);
-				}
-			}
-		}
-
-		/**
-		 * Reports references which are inside of unmodified groups.
-		 * @param {LoopConditionInfo[]} conditions A loop condition info to report.
-		 * @returns {void}
-		 */
-		function checkConditionsInGroup(conditions) {
-			if (conditions.every(isUnmodified)) {
-				conditions.forEach(report);
-			}
-		}
-
-		/**
-		 * Checks whether or not a given group node has any dynamic elements.
-		 * @param {ASTNode} root A node to check.
-		 *      This node is one of BinaryExpression or ConditionalExpression.
-		 * @returns {boolean} `true` if the node is dynamic.
-		 */
-		function hasDynamicExpressions(root) {
-			let retv = false;
-
-			Traverser.traverse(root, {
-				visitorKeys: sourceCode.visitorKeys,
-				enter(node) {
-					if (DYNAMIC_PATTERN.test(node.type)) {
-						retv = true;
-						this.break();
-					} else if (SKIP_PATTERN.test(node.type)) {
-						this.skip();
-					}
-				},
-			});
-
-			return retv;
-		}
-
-		/**
-		 * Creates the loop condition information from a given reference.
-		 * @param {eslint-scope.Reference} reference A reference to create.
-		 * @returns {LoopConditionInfo|null} Created loop condition info, or null.
-		 */
-		function toLoopCondition(reference) {
-			if (reference.init) {
-				return null;
-			}
-
-			let group = null;
-			let child = reference.identifier;
-			let node = child.parent;
-
-			while (node) {
-				if (SENTINEL_PATTERN.test(node.type)) {
-					if (LOOP_PATTERN.test(node.type) && node.test === child) {
-						// This reference is inside of a loop condition.
-						return {
-							reference,
-							group,
-							isInLoop: isInLoop[node.type].bind(null, node),
-							modified: false,
-						};
-					}
-
-					// This reference is outside of a loop condition.
-					break;
-				}
-
-				/*
-				 * If it's inside of a group, OK if either operand is modified.
-				 * So stores the group this reference belongs to.
-				 */
-				if (GROUP_PATTERN.test(node.type)) {
-					// If this expression is dynamic, no need to check.
-					if (hasDynamicExpressions(node)) {
-						break;
-					} else {
-						group = node;
-					}
-				}
-
-				child = node;
-				node = node.parent;
-			}
-
-			return null;
-		}
-
-		/**
-		 * Finds unmodified references which are inside of a loop condition.
-		 * Then reports the references which are outside of groups.
-		 * @param {eslint-scope.Variable} variable A variable to report.
-		 * @returns {void}
-		 */
-		function checkReferences(variable) {
-			// Gets references that exist in loop conditions.
-			const conditions = variable.references
-				.map(toLoopCondition)
-				.filter(Boolean);
-
-			if (conditions.length === 0) {
-				return;
-			}
-
-			// Registers the conditions to belonging groups.
-			registerConditionsToGroup(conditions);
-
-			// Check the conditions are modified.
-			const modifiers = variable.references.filter(isWriteReference);
-
-			if (modifiers.length > 0) {
-				updateModifiedFlag(conditions, modifiers);
-			}
-
-			/*
-			 * Reports the conditions which are not belonging to groups.
-			 * Others will be reported after all variables are done.
-			 */
-			conditions.filter(isUnmodifiedAndNotBelongToGroup).forEach(report);
-		}
-
-		return {
-			"Program:exit"(node) {
-				const queue = [sourceCode.getScope(node)];
-
-				groupMap = new Map();
-
-				let scope;
-
-				while ((scope = queue.pop())) {
-					queue.push(...scope.childScopes);
-					scope.variables.forEach(checkReferences);
-				}
-
-				groupMap.forEach(checkConditionsInGroup);
-				groupMap = null;
-			},
-		};
-	},
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/no-unneeded-ternary.js

@@ -1,232 +0,0 @@
-/**
- * @fileoverview Rule to flag no-unneeded-ternary
- * @author Gyandeep Singh
- */
-
-"use strict";
-
-const astUtils = require("./utils/ast-utils");
-
-// Operators that always result in a boolean value
-const BOOLEAN_OPERATORS = new Set([
-	"==",
-	"===",
-	"!=",
-	"!==",
-	">",
-	">=",
-	"<",
-	"<=",
-	"in",
-	"instanceof",
-]);
-const OPERATOR_INVERSES = {
-	"==": "!=",
-	"!=": "==",
-	"===": "!==",
-	"!==": "===",
-
-	// Operators like < and >= are not true inverses, since both will return false with NaN.
-};
-const OR_PRECEDENCE = astUtils.getPrecedence({
-	type: "LogicalExpression",
-	operator: "||",
-});
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-
-		defaultOptions: [{ defaultAssignment: true }],
-
-		docs: {
-			description:
-				"Disallow ternary operators when simpler alternatives exist",
-			recommended: false,
-			frozen: true,
-			url: "https://eslint.org/docs/latest/rules/no-unneeded-ternary",
-		},
-
-		schema: [
-			{
-				type: "object",
-				properties: {
-					defaultAssignment: {
-						type: "boolean",
-					},
-				},
-				additionalProperties: false,
-			},
-		],
-
-		fixable: "code",
-
-		messages: {
-			unnecessaryConditionalExpression:
-				"Unnecessary use of boolean literals in conditional expression.",
-			unnecessaryConditionalAssignment:
-				"Unnecessary use of conditional expression for default assignment.",
-		},
-	},
-
-	create(context) {
-		const [{ defaultAssignment }] = context.options;
-		const sourceCode = context.sourceCode;
-
-		/**
-		 * Test if the node is a boolean literal
-		 * @param {ASTNode} node The node to report.
-		 * @returns {boolean} True if the its a boolean literal
-		 * @private
-		 */
-		function isBooleanLiteral(node) {
-			return node.type === "Literal" && typeof node.value === "boolean";
-		}
-
-		/**
-		 * Creates an expression that represents the boolean inverse of the expression represented by the original node
-		 * @param {ASTNode} node A node representing an expression
-		 * @returns {string} A string representing an inverted expression
-		 */
-		function invertExpression(node) {
-			if (
-				node.type === "BinaryExpression" &&
-				Object.hasOwn(OPERATOR_INVERSES, node.operator)
-			) {
-				const operatorToken = sourceCode.getFirstTokenBetween(
-					node.left,
-					node.right,
-					token => token.value === node.operator,
-				);
-				const text = sourceCode.getText();
-
-				return (
-					text.slice(node.range[0], operatorToken.range[0]) +
-					OPERATOR_INVERSES[node.operator] +
-					text.slice(operatorToken.range[1], node.range[1])
-				);
-			}
-
-			if (
-				astUtils.getPrecedence(node) <
-				astUtils.getPrecedence({ type: "UnaryExpression" })
-			) {
-				return `!(${astUtils.getParenthesisedText(sourceCode, node)})`;
-			}
-			return `!${astUtils.getParenthesisedText(sourceCode, node)}`;
-		}
-
-		/**
-		 * Tests if a given node always evaluates to a boolean value
-		 * @param {ASTNode} node An expression node
-		 * @returns {boolean} True if it is determined that the node will always evaluate to a boolean value
-		 */
-		function isBooleanExpression(node) {
-			return (
-				(node.type === "BinaryExpression" &&
-					BOOLEAN_OPERATORS.has(node.operator)) ||
-				(node.type === "UnaryExpression" && node.operator === "!")
-			);
-		}
-
-		/**
-		 * Test if the node matches the pattern id ? id : expression
-		 * @param {ASTNode} node The ConditionalExpression to check.
-		 * @returns {boolean} True if the pattern is matched, and false otherwise
-		 * @private
-		 */
-		function matchesDefaultAssignment(node) {
-			return (
-				node.test.type === "Identifier" &&
-				node.consequent.type === "Identifier" &&
-				node.test.name === node.consequent.name
-			);
-		}
-
-		return {
-			ConditionalExpression(node) {
-				if (
-					isBooleanLiteral(node.alternate) &&
-					isBooleanLiteral(node.consequent)
-				) {
-					context.report({
-						node,
-						messageId: "unnecessaryConditionalExpression",
-						fix(fixer) {
-							if (
-								node.consequent.value === node.alternate.value
-							) {
-								// Replace `foo ? true : true` with just `true`, but don't replace `foo() ? true : true`
-								return node.test.type === "Identifier"
-									? fixer.replaceText(
-											node,
-											node.consequent.value.toString(),
-										)
-									: null;
-							}
-							if (node.alternate.value) {
-								// Replace `foo() ? false : true` with `!(foo())`
-								return fixer.replaceText(
-									node,
-									invertExpression(node.test),
-								);
-							}
-
-							// Replace `foo ? true : false` with `foo` if `foo` is guaranteed to be a boolean, or `!!foo` otherwise.
-
-							return fixer.replaceText(
-								node,
-								isBooleanExpression(node.test)
-									? astUtils.getParenthesisedText(
-											sourceCode,
-											node.test,
-										)
-									: `!${invertExpression(node.test)}`,
-							);
-						},
-					});
-				} else if (
-					!defaultAssignment &&
-					matchesDefaultAssignment(node)
-				) {
-					context.report({
-						node,
-						messageId: "unnecessaryConditionalAssignment",
-						fix(fixer) {
-							const shouldParenthesizeAlternate =
-								(astUtils.getPrecedence(node.alternate) <
-									OR_PRECEDENCE ||
-									astUtils.isCoalesceExpression(
-										node.alternate,
-									)) &&
-								!astUtils.isParenthesised(
-									sourceCode,
-									node.alternate,
-								);
-							const alternateText = shouldParenthesizeAlternate
-								? `(${sourceCode.getText(node.alternate)})`
-								: astUtils.getParenthesisedText(
-										sourceCode,
-										node.alternate,
-									);
-							const testText = astUtils.getParenthesisedText(
-								sourceCode,
-								node.test,
-							);
-
-							return fixer.replaceText(
-								node,
-								`${testText} || ${alternateText}`,
-							);
-						},
-					});
-				}
-			},
-		};
-	},
-};