@alexlit/lint-kit 183.1.0 → 183.2.0

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}`,
-							);
-						},
-					});
-				}
-			},
-		};
-	},
-};

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

@@ -1,190 +0,0 @@
-/**
- * @fileoverview Rule to disallow loops with a body that allows only one iteration
- * @author Milos Djermanovic
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-const allLoopTypes = [
-	"WhileStatement",
-	"DoWhileStatement",
-	"ForStatement",
-	"ForInStatement",
-	"ForOfStatement",
-];
-
-/**
- * Checks all segments in a set and returns true if any are reachable.
- * @param {Set<CodePathSegment>} segments The segments to check.
- * @returns {boolean} True if any segment is reachable; false otherwise.
- */
-function isAnySegmentReachable(segments) {
-	for (const segment of segments) {
-		if (segment.reachable) {
-			return true;
-		}
-	}
-
-	return false;
-}
-
-/**
- * Determines whether the given node is the first node in the code path to which a loop statement
- * 'loops' for the next iteration.
- * @param {ASTNode} node The node to check.
- * @returns {boolean} `true` if the node is a looping target.
- */
-function isLoopingTarget(node) {
-	const parent = node.parent;
-
-	if (parent) {
-		switch (parent.type) {
-			case "WhileStatement":
-				return node === parent.test;
-			case "DoWhileStatement":
-				return node === parent.body;
-			case "ForStatement":
-				return node === (parent.update || parent.test || parent.body);
-			case "ForInStatement":
-			case "ForOfStatement":
-				return node === parent.left;
-
-			// no default
-		}
-	}
-
-	return false;
-}
-
-/**
- * Creates an array with elements from the first given array that are not included in the second given array.
- * @param {Array} arrA The array to compare from.
- * @param {Array} arrB The array to compare against.
- * @returns {Array} a new array that represents `arrA \ arrB`.
- */
-function getDifference(arrA, arrB) {
-	return arrA.filter(a => !arrB.includes(a));
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "problem",
-
-		defaultOptions: [{ ignore: [] }],
-
-		docs: {
-			description:
-				"Disallow loops with a body that allows only one iteration",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/no-unreachable-loop",
-		},
-
-		schema: [
-			{
-				type: "object",
-				properties: {
-					ignore: {
-						type: "array",
-						items: {
-							enum: allLoopTypes,
-						},
-						uniqueItems: true,
-					},
-				},
-				additionalProperties: false,
-			},
-		],
-
-		messages: {
-			invalid: "Invalid loop. Its body allows only one iteration.",
-		},
-	},
-
-	create(context) {
-		const [{ ignore: ignoredLoopTypes }] = context.options;
-		const loopTypesToCheck = getDifference(allLoopTypes, ignoredLoopTypes),
-			loopSelector = loopTypesToCheck.join(","),
-			loopsByTargetSegments = new Map(),
-			loopsToReport = new Set();
-
-		const codePathSegments = [];
-		let currentCodePathSegments = new Set();
-
-		return {
-			onCodePathStart() {
-				codePathSegments.push(currentCodePathSegments);
-				currentCodePathSegments = new Set();
-			},
-
-			onCodePathEnd() {
-				currentCodePathSegments = codePathSegments.pop();
-			},
-
-			onUnreachableCodePathSegmentStart(segment) {
-				currentCodePathSegments.add(segment);
-			},
-
-			onUnreachableCodePathSegmentEnd(segment) {
-				currentCodePathSegments.delete(segment);
-			},
-
-			onCodePathSegmentEnd(segment) {
-				currentCodePathSegments.delete(segment);
-			},
-
-			onCodePathSegmentStart(segment, node) {
-				currentCodePathSegments.add(segment);
-
-				if (isLoopingTarget(node)) {
-					const loop = node.parent;
-
-					loopsByTargetSegments.set(segment, loop);
-				}
-			},
-
-			onCodePathSegmentLoop(_, toSegment, node) {
-				const loop = loopsByTargetSegments.get(toSegment);
-
-				/**
-				 * The second iteration is reachable, meaning that the loop is valid by the logic of this rule,
-				 * only if there is at least one loop event with the appropriate target (which has been already
-				 * determined in the `loopsByTargetSegments` map), raised from either:
-				 *
-				 * - the end of the loop's body (in which case `node === loop`)
-				 * - a `continue` statement
-				 *
-				 * This condition skips loop events raised from `ForInStatement > .right` and `ForOfStatement > .right` nodes.
-				 */
-				if (node === loop || node.type === "ContinueStatement") {
-					// Removes loop if it exists in the set. Otherwise, `Set#delete` has no effect and doesn't throw.
-					loopsToReport.delete(loop);
-				}
-			},
-
-			[loopSelector](node) {
-				/**
-				 * Ignore unreachable loop statements to avoid unnecessary complexity in the implementation, or false positives otherwise.
-				 * For unreachable segments, the code path analysis does not raise events required for this implementation.
-				 */
-				if (isAnySegmentReachable(currentCodePathSegments)) {
-					loopsToReport.add(node);
-				}
-			},
-
-			"Program:exit"() {
-				loopsToReport.forEach(node =>
-					context.report({ node, messageId: "invalid" }),
-				);
-			},
-		};
-	},
-};

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

@@ -1,300 +0,0 @@
-/**
- * @fileoverview Checks for unreachable code due to return, throws, break, and continue.
- * @author Joel Feenstra
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-/**
- * @typedef {Object} ConstructorInfo
- * @property {ConstructorInfo | null} upper Info about the constructor that encloses this constructor.
- * @property {boolean} hasSuperCall The flag about having `super()` expressions.
- */
-
-/**
- * Checks whether or not a given variable declarator has the initializer.
- * @param {ASTNode} node A VariableDeclarator node to check.
- * @returns {boolean} `true` if the node has the initializer.
- */
-function isInitialized(node) {
-	return Boolean(node.init);
-}
-
-/**
- * Checks all segments in a set and returns true if all are unreachable.
- * @param {Set<CodePathSegment>} segments The segments to check.
- * @returns {boolean} True if all segments are unreachable; false otherwise.
- */
-function areAllSegmentsUnreachable(segments) {
-	for (const segment of segments) {
-		if (segment.reachable) {
-			return false;
-		}
-	}
-
-	return true;
-}
-
-/**
- * The class to distinguish consecutive unreachable statements.
- */
-class ConsecutiveRange {
-	constructor(sourceCode) {
-		this.sourceCode = sourceCode;
-		this.startNode = null;
-		this.endNode = null;
-	}
-
-	/**
-	 * The location object of this range.
-	 * @type {Object}
-	 */
-	get location() {
-		return {
-			start: this.startNode.loc.start,
-			end: this.endNode.loc.end,
-		};
-	}
-
-	/**
-	 * `true` if this range is empty.
-	 * @type {boolean}
-	 */
-	get isEmpty() {
-		return !(this.startNode && this.endNode);
-	}
-
-	/**
-	 * Checks whether the given node is inside of this range.
-	 * @param {ASTNode|Token} node The node to check.
-	 * @returns {boolean} `true` if the node is inside of this range.
-	 */
-	contains(node) {
-		return (
-			node.range[0] >= this.startNode.range[0] &&
-			node.range[1] <= this.endNode.range[1]
-		);
-	}
-
-	/**
-	 * Checks whether the given node is consecutive to this range.
-	 * @param {ASTNode} node The node to check.
-	 * @returns {boolean} `true` if the node is consecutive to this range.
-	 */
-	isConsecutive(node) {
-		return this.contains(this.sourceCode.getTokenBefore(node));
-	}
-
-	/**
-	 * Merges the given node to this range.
-	 * @param {ASTNode} node The node to merge.
-	 * @returns {void}
-	 */
-	merge(node) {
-		this.endNode = node;
-	}
-
-	/**
-	 * Resets this range by the given node or null.
-	 * @param {ASTNode|null} node The node to reset, or null.
-	 * @returns {void}
-	 */
-	reset(node) {
-		this.startNode = this.endNode = node;
-	}
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "problem",
-
-		docs: {
-			description:
-				"Disallow unreachable code after `return`, `throw`, `continue`, and `break` statements",
-			recommended: true,
-			url: "https://eslint.org/docs/latest/rules/no-unreachable",
-		},
-
-		schema: [],
-
-		messages: {
-			unreachableCode: "Unreachable code.",
-		},
-	},
-
-	create(context) {
-		/** @type {ConstructorInfo | null} */
-		let constructorInfo = null;
-
-		/** @type {ConsecutiveRange} */
-		const range = new ConsecutiveRange(context.sourceCode);
-
-		/** @type {Array<Set<CodePathSegment>>} */
-		const codePathSegments = [];
-
-		/** @type {Set<CodePathSegment>} */
-		let currentCodePathSegments = new Set();
-
-		/**
-		 * Reports a given node if it's unreachable.
-		 * @param {ASTNode} node A statement node to report.
-		 * @returns {void}
-		 */
-		function reportIfUnreachable(node) {
-			let nextNode = null;
-
-			if (
-				node &&
-				(node.type === "PropertyDefinition" ||
-					areAllSegmentsUnreachable(currentCodePathSegments))
-			) {
-				// Store this statement to distinguish consecutive statements.
-				if (range.isEmpty) {
-					range.reset(node);
-					return;
-				}
-
-				// Skip if this statement is inside of the current range.
-				if (range.contains(node)) {
-					return;
-				}
-
-				// Merge if this statement is consecutive to the current range.
-				if (range.isConsecutive(node)) {
-					range.merge(node);
-					return;
-				}
-
-				nextNode = node;
-			}
-
-			/*
-			 * Report the current range since this statement is reachable or is
-			 * not consecutive to the current range.
-			 */
-			if (!range.isEmpty) {
-				context.report({
-					messageId: "unreachableCode",
-					loc: range.location,
-					node: range.startNode,
-				});
-			}
-
-			// Update the current range.
-			range.reset(nextNode);
-		}
-
-		return {
-			// Manages the current code path.
-			onCodePathStart() {
-				codePathSegments.push(currentCodePathSegments);
-				currentCodePathSegments = new Set();
-			},
-
-			onCodePathEnd() {
-				currentCodePathSegments = codePathSegments.pop();
-			},
-
-			onUnreachableCodePathSegmentStart(segment) {
-				currentCodePathSegments.add(segment);
-			},
-
-			onUnreachableCodePathSegmentEnd(segment) {
-				currentCodePathSegments.delete(segment);
-			},
-
-			onCodePathSegmentEnd(segment) {
-				currentCodePathSegments.delete(segment);
-			},
-
-			onCodePathSegmentStart(segment) {
-				currentCodePathSegments.add(segment);
-			},
-
-			// Registers for all statement nodes (excludes FunctionDeclaration).
-			BlockStatement: reportIfUnreachable,
-			BreakStatement: reportIfUnreachable,
-			ClassDeclaration: reportIfUnreachable,
-			ContinueStatement: reportIfUnreachable,
-			DebuggerStatement: reportIfUnreachable,
-			DoWhileStatement: reportIfUnreachable,
-			ExpressionStatement: reportIfUnreachable,
-			ForInStatement: reportIfUnreachable,
-			ForOfStatement: reportIfUnreachable,
-			ForStatement: reportIfUnreachable,
-			IfStatement: reportIfUnreachable,
-			ImportDeclaration: reportIfUnreachable,
-			LabeledStatement: reportIfUnreachable,
-			ReturnStatement: reportIfUnreachable,
-			SwitchStatement: reportIfUnreachable,
-			ThrowStatement: reportIfUnreachable,
-			TryStatement: reportIfUnreachable,
-
-			VariableDeclaration(node) {
-				if (
-					node.kind !== "var" ||
-					node.declarations.some(isInitialized)
-				) {
-					reportIfUnreachable(node);
-				}
-			},
-
-			WhileStatement: reportIfUnreachable,
-			WithStatement: reportIfUnreachable,
-			ExportNamedDeclaration: reportIfUnreachable,
-			ExportDefaultDeclaration: reportIfUnreachable,
-			ExportAllDeclaration: reportIfUnreachable,
-
-			"Program:exit"() {
-				reportIfUnreachable();
-			},
-
-			/*
-			 * Instance fields defined in a subclass are never created if the constructor of the subclass
-			 * doesn't call `super()`, so their definitions are unreachable code.
-			 */
-			"MethodDefinition[kind='constructor']"() {
-				constructorInfo = {
-					upper: constructorInfo,
-					hasSuperCall: false,
-				};
-			},
-			"MethodDefinition[kind='constructor']:exit"(node) {
-				const { hasSuperCall } = constructorInfo;
-
-				constructorInfo = constructorInfo.upper;
-
-				// skip typescript constructors without the body
-				if (!node.value.body) {
-					return;
-				}
-
-				const classDefinition = node.parent.parent;
-
-				if (classDefinition.superClass && !hasSuperCall) {
-					for (const element of classDefinition.body.body) {
-						if (
-							element.type === "PropertyDefinition" &&
-							!element.static
-						) {
-							reportIfUnreachable(element);
-						}
-					}
-				}
-			},
-			"CallExpression > Super.callee"() {
-				if (constructorInfo) {
-					constructorInfo.hasSuperCall = true;
-				}
-			},
-		};
-	},
-};