@alexlit/lint-kit 175.0.0 → 176.0.1

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

@@ -1,152 +0,0 @@
-/**
- * @fileoverview Rule to disallow negating the left operand of relational operators
- * @author Toru Nagashima
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-/**
- * Checks whether the given operator is `in` or `instanceof`
- * @param {string} op The operator type to check.
- * @returns {boolean} `true` if the operator is `in` or `instanceof`
- */
-function isInOrInstanceOfOperator(op) {
-	return op === "in" || op === "instanceof";
-}
-
-/**
- * Checks whether the given operator is an ordering relational operator or not.
- * @param {string} op The operator type to check.
- * @returns {boolean} `true` if the operator is an ordering relational operator.
- */
-function isOrderingRelationalOperator(op) {
-	return op === "<" || op === ">" || op === ">=" || op === "<=";
-}
-
-/**
- * Checks whether the given node is a logical negation expression or not.
- * @param {ASTNode} node The node to check.
- * @returns {boolean} `true` if the node is a logical negation expression.
- */
-function isNegation(node) {
-	return node.type === "UnaryExpression" && node.operator === "!";
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "problem",
-
-		defaultOptions: [
-			{
-				enforceForOrderingRelations: false,
-			},
-		],
-
-		docs: {
-			description:
-				"Disallow negating the left operand of relational operators",
-			recommended: true,
-			url: "https://eslint.org/docs/latest/rules/no-unsafe-negation",
-		},
-
-		hasSuggestions: true,
-
-		schema: [
-			{
-				type: "object",
-				properties: {
-					enforceForOrderingRelations: {
-						type: "boolean",
-					},
-				},
-				additionalProperties: false,
-			},
-		],
-
-		fixable: null,
-
-		messages: {
-			unexpected:
-				"Unexpected negating the left operand of '{{operator}}' operator.",
-			suggestNegatedExpression:
-				"Negate '{{operator}}' expression instead of its left operand. This changes the current behavior.",
-			suggestParenthesisedNegation:
-				"Wrap negation in '()' to make the intention explicit. This preserves the current behavior.",
-		},
-	},
-
-	create(context) {
-		const sourceCode = context.sourceCode;
-		const [{ enforceForOrderingRelations }] = context.options;
-
-		return {
-			BinaryExpression(node) {
-				const operator = node.operator;
-				const orderingRelationRuleApplies =
-					enforceForOrderingRelations &&
-					isOrderingRelationalOperator(operator);
-
-				if (
-					(isInOrInstanceOfOperator(operator) ||
-						orderingRelationRuleApplies) &&
-					isNegation(node.left) &&
-					!astUtils.isParenthesised(sourceCode, node.left)
-				) {
-					context.report({
-						node,
-						loc: node.left.loc,
-						messageId: "unexpected",
-						data: { operator },
-						suggest: [
-							{
-								messageId: "suggestNegatedExpression",
-								data: { operator },
-								fix(fixer) {
-									const negationToken =
-										sourceCode.getFirstToken(node.left);
-									const fixRange = [
-										negationToken.range[1],
-										node.range[1],
-									];
-									const text = sourceCode.text.slice(
-										fixRange[0],
-										fixRange[1],
-									);
-
-									return fixer.replaceTextRange(
-										fixRange,
-										`(${text})`,
-									);
-								},
-							},
-							{
-								messageId: "suggestParenthesisedNegation",
-								fix(fixer) {
-									return fixer.replaceText(
-										node.left,
-										`(${sourceCode.getText(node.left)})`,
-									);
-								},
-							},
-						],
-					});
-				}
-			},
-		};
-	},
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/no-unsafe-optional-chaining.js

@@ -1,221 +0,0 @@
-/**
- * @fileoverview Rule to disallow unsafe optional chaining
- * @author Yeon JuAn
- */
-
-"use strict";
-
-const UNSAFE_ARITHMETIC_OPERATORS = new Set(["+", "-", "/", "*", "%", "**"]);
-const UNSAFE_ASSIGNMENT_OPERATORS = new Set([
-	"+=",
-	"-=",
-	"/=",
-	"*=",
-	"%=",
-	"**=",
-]);
-const UNSAFE_RELATIONAL_OPERATORS = new Set(["in", "instanceof"]);
-
-/**
- * Checks whether a node is a destructuring pattern or not
- * @param {ASTNode} node node to check
- * @returns {boolean} `true` if a node is a destructuring pattern, otherwise `false`
- */
-function isDestructuringPattern(node) {
-	return node.type === "ObjectPattern" || node.type === "ArrayPattern";
-}
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "problem",
-
-		defaultOptions: [
-			{
-				disallowArithmeticOperators: false,
-			},
-		],
-
-		docs: {
-			description:
-				"Disallow use of optional chaining in contexts where the `undefined` value is not allowed",
-			recommended: true,
-			url: "https://eslint.org/docs/latest/rules/no-unsafe-optional-chaining",
-		},
-		schema: [
-			{
-				type: "object",
-				properties: {
-					disallowArithmeticOperators: {
-						type: "boolean",
-					},
-				},
-				additionalProperties: false,
-			},
-		],
-		fixable: null,
-		messages: {
-			unsafeOptionalChain:
-				"Unsafe usage of optional chaining. If it short-circuits with 'undefined' the evaluation will throw TypeError.",
-			unsafeArithmetic:
-				"Unsafe arithmetic operation on optional chaining. It can result in NaN.",
-		},
-	},
-
-	create(context) {
-		const [{ disallowArithmeticOperators }] = context.options;
-
-		/**
-		 * Reports unsafe usage of optional chaining
-		 * @param {ASTNode} node node to report
-		 * @returns {void}
-		 */
-		function reportUnsafeUsage(node) {
-			context.report({
-				messageId: "unsafeOptionalChain",
-				node,
-			});
-		}
-
-		/**
-		 * Reports unsafe arithmetic operation on optional chaining
-		 * @param {ASTNode} node node to report
-		 * @returns {void}
-		 */
-		function reportUnsafeArithmetic(node) {
-			context.report({
-				messageId: "unsafeArithmetic",
-				node,
-			});
-		}
-
-		/**
-		 * Checks and reports if a node can short-circuit with `undefined` by optional chaining.
-		 * @param {ASTNode} [node] node to check
-		 * @param {Function} reportFunc report function
-		 * @returns {void}
-		 */
-		function checkUndefinedShortCircuit(node, reportFunc) {
-			if (!node) {
-				return;
-			}
-			switch (node.type) {
-				case "LogicalExpression":
-					if (node.operator === "||" || node.operator === "??") {
-						checkUndefinedShortCircuit(node.right, reportFunc);
-					} else if (node.operator === "&&") {
-						checkUndefinedShortCircuit(node.left, reportFunc);
-						checkUndefinedShortCircuit(node.right, reportFunc);
-					}
-					break;
-				case "SequenceExpression":
-					checkUndefinedShortCircuit(
-						node.expressions.at(-1),
-						reportFunc,
-					);
-					break;
-				case "ConditionalExpression":
-					checkUndefinedShortCircuit(node.consequent, reportFunc);
-					checkUndefinedShortCircuit(node.alternate, reportFunc);
-					break;
-				case "AwaitExpression":
-					checkUndefinedShortCircuit(node.argument, reportFunc);
-					break;
-				case "ChainExpression":
-					reportFunc(node);
-					break;
-				default:
-					break;
-			}
-		}
-
-		/**
-		 * Checks unsafe usage of optional chaining
-		 * @param {ASTNode} node node to check
-		 * @returns {void}
-		 */
-		function checkUnsafeUsage(node) {
-			checkUndefinedShortCircuit(node, reportUnsafeUsage);
-		}
-
-		/**
-		 * Checks unsafe arithmetic operations on optional chaining
-		 * @param {ASTNode} node node to check
-		 * @returns {void}
-		 */
-		function checkUnsafeArithmetic(node) {
-			checkUndefinedShortCircuit(node, reportUnsafeArithmetic);
-		}
-
-		return {
-			"AssignmentExpression, AssignmentPattern"(node) {
-				if (isDestructuringPattern(node.left)) {
-					checkUnsafeUsage(node.right);
-				}
-			},
-			"ClassDeclaration, ClassExpression"(node) {
-				checkUnsafeUsage(node.superClass);
-			},
-			CallExpression(node) {
-				if (!node.optional) {
-					checkUnsafeUsage(node.callee);
-				}
-			},
-			NewExpression(node) {
-				checkUnsafeUsage(node.callee);
-			},
-			VariableDeclarator(node) {
-				if (isDestructuringPattern(node.id)) {
-					checkUnsafeUsage(node.init);
-				}
-			},
-			MemberExpression(node) {
-				if (!node.optional) {
-					checkUnsafeUsage(node.object);
-				}
-			},
-			TaggedTemplateExpression(node) {
-				checkUnsafeUsage(node.tag);
-			},
-			ForOfStatement(node) {
-				checkUnsafeUsage(node.right);
-			},
-			SpreadElement(node) {
-				if (node.parent && node.parent.type !== "ObjectExpression") {
-					checkUnsafeUsage(node.argument);
-				}
-			},
-			BinaryExpression(node) {
-				if (UNSAFE_RELATIONAL_OPERATORS.has(node.operator)) {
-					checkUnsafeUsage(node.right);
-				}
-				if (
-					disallowArithmeticOperators &&
-					UNSAFE_ARITHMETIC_OPERATORS.has(node.operator)
-				) {
-					checkUnsafeArithmetic(node.right);
-					checkUnsafeArithmetic(node.left);
-				}
-			},
-			WithStatement(node) {
-				checkUnsafeUsage(node.object);
-			},
-			UnaryExpression(node) {
-				if (
-					disallowArithmeticOperators &&
-					UNSAFE_ARITHMETIC_OPERATORS.has(node.operator)
-				) {
-					checkUnsafeArithmetic(node.argument);
-				}
-			},
-			AssignmentExpression(node) {
-				if (
-					disallowArithmeticOperators &&
-					UNSAFE_ASSIGNMENT_OPERATORS.has(node.operator)
-				) {
-					checkUnsafeArithmetic(node.right);
-				}
-			},
-		};
-	},
-};

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

@@ -1,227 +0,0 @@
-/**
- * @fileoverview Flag expressions in statement position that do not side effect
- * @author Michael Ficarra
- */
-"use strict";
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/**
- * Returns `true`.
- * @returns {boolean} `true`.
- */
-function alwaysTrue() {
-	return true;
-}
-
-/**
- * Returns `false`.
- * @returns {boolean} `false`.
- */
-function alwaysFalse() {
-	return false;
-}
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		dialects: ["javascript", "typescript"],
-		language: "javascript",
-		type: "suggestion",
-
-		docs: {
-			description: "Disallow unused expressions",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/no-unused-expressions",
-		},
-
-		schema: [
-			{
-				type: "object",
-				properties: {
-					allowShortCircuit: {
-						type: "boolean",
-					},
-					allowTernary: {
-						type: "boolean",
-					},
-					allowTaggedTemplates: {
-						type: "boolean",
-					},
-					enforceForJSX: {
-						type: "boolean",
-					},
-					ignoreDirectives: {
-						type: "boolean",
-					},
-				},
-				additionalProperties: false,
-			},
-		],
-
-		defaultOptions: [
-			{
-				allowShortCircuit: false,
-				allowTernary: false,
-				allowTaggedTemplates: false,
-				enforceForJSX: false,
-				ignoreDirectives: false,
-			},
-		],
-
-		messages: {
-			unusedExpression:
-				"Expected an assignment or function call and instead saw an expression.",
-		},
-	},
-
-	create(context) {
-		const [
-			{
-				allowShortCircuit,
-				allowTernary,
-				allowTaggedTemplates,
-				enforceForJSX,
-				ignoreDirectives,
-			},
-		] = context.options;
-
-		/**
-		 * Has AST suggesting a directive.
-		 * @param {ASTNode} node any node
-		 * @returns {boolean} whether the given node structurally represents a directive
-		 */
-		function looksLikeDirective(node) {
-			return (
-				node.type === "ExpressionStatement" &&
-				node.expression.type === "Literal" &&
-				typeof node.expression.value === "string"
-			);
-		}
-
-		/**
-		 * Gets the leading sequence of members in a list that pass the predicate.
-		 * @param {Function} predicate ([a] -> Boolean) the function used to make the determination
-		 * @param {a[]} list the input list
-		 * @returns {a[]} the leading sequence of members in the given list that pass the given predicate
-		 */
-		function takeWhile(predicate, list) {
-			for (let i = 0; i < list.length; ++i) {
-				if (!predicate(list[i])) {
-					return list.slice(0, i);
-				}
-			}
-			return list.slice();
-		}
-
-		/**
-		 * Gets leading directives nodes in a Node body.
-		 * @param {ASTNode} node a Program or BlockStatement node
-		 * @returns {ASTNode[]} the leading sequence of directive nodes in the given node's body
-		 */
-		function directives(node) {
-			return takeWhile(looksLikeDirective, node.body);
-		}
-
-		/**
-		 * Detect if a Node is a directive.
-		 * @param {ASTNode} node any node
-		 * @returns {boolean} whether the given node is considered a directive in its current position
-		 */
-		function isDirective(node) {
-			/**
-			 * https://tc39.es/ecma262/#directive-prologue
-			 *
-			 * Only `FunctionBody`, `ScriptBody` and `ModuleBody` can have directive prologue.
-			 * Class static blocks do not have directive prologue.
-			 */
-			return (
-				astUtils.isTopLevelExpressionStatement(node) &&
-				directives(node.parent).includes(node)
-			);
-		}
-
-		/**
-		 * The member functions return `true` if the type has no side-effects.
-		 * Unknown nodes are handled as `false`, then this rule ignores those.
-		 */
-		const Checker = Object.assign(Object.create(null), {
-			isDisallowed(node) {
-				return (Checker[node.type] || alwaysFalse)(node);
-			},
-
-			ArrayExpression: alwaysTrue,
-			ArrowFunctionExpression: alwaysTrue,
-			BinaryExpression: alwaysTrue,
-			ChainExpression(node) {
-				return Checker.isDisallowed(node.expression);
-			},
-			ClassExpression: alwaysTrue,
-			ConditionalExpression(node) {
-				if (allowTernary) {
-					return (
-						Checker.isDisallowed(node.consequent) ||
-						Checker.isDisallowed(node.alternate)
-					);
-				}
-				return true;
-			},
-			FunctionExpression: alwaysTrue,
-			Identifier: alwaysTrue,
-			JSXElement() {
-				return enforceForJSX;
-			},
-			JSXFragment() {
-				return enforceForJSX;
-			},
-			Literal: alwaysTrue,
-			LogicalExpression(node) {
-				if (allowShortCircuit) {
-					return Checker.isDisallowed(node.right);
-				}
-				return true;
-			},
-			MemberExpression: alwaysTrue,
-			MetaProperty: alwaysTrue,
-			ObjectExpression: alwaysTrue,
-			SequenceExpression: alwaysTrue,
-			TaggedTemplateExpression() {
-				return !allowTaggedTemplates;
-			},
-			TemplateLiteral: alwaysTrue,
-			ThisExpression: alwaysTrue,
-			UnaryExpression(node) {
-				return node.operator !== "void" && node.operator !== "delete";
-			},
-			// TypeScript-specific node types
-			TSAsExpression(node) {
-				return Checker.isDisallowed(node.expression);
-			},
-			TSTypeAssertion(node) {
-				return Checker.isDisallowed(node.expression);
-			},
-			TSNonNullExpression(node) {
-				return Checker.isDisallowed(node.expression);
-			},
-			TSInstantiationExpression(node) {
-				return Checker.isDisallowed(node.expression);
-			},
-		});
-
-		return {
-			ExpressionStatement(node) {
-				if (
-					Checker.isDisallowed(node.expression) &&
-					!astUtils.isDirective(node) &&
-					!(ignoreDirectives && isDirective(node))
-				) {
-					context.report({ node, messageId: "unusedExpression" });
-				}
-			},
-		};
-	},
-};