oxlint-plugin-eslint 1.52.0

package/rules/no-unsafe-optional-chaining.cjs

@@ -0,0 +1,164 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/no-unsafe-optional-chaining.js
+/**
+* @fileoverview Rule to disallow unsafe optional chaining
+* @author Yeon JuAn
+*/
+var require_no_unsafe_optional_chaining = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	let UNSAFE_ARITHMETIC_OPERATORS = new Set([
+		"+",
+		"-",
+		"/",
+		"*",
+		"%",
+		"**"
+	]), UNSAFE_ASSIGNMENT_OPERATORS = new Set([
+		"+=",
+		"-=",
+		"/=",
+		"*=",
+		"%=",
+		"**="
+	]), 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: !1 }],
+			docs: {
+				description: "Disallow use of optional chaining in contexts where the `undefined` value is not allowed",
+				recommended: !0,
+				url: "https://eslint.org/docs/latest/rules/no-unsafe-optional-chaining"
+			},
+			schema: [{
+				type: "object",
+				properties: { disallowArithmeticOperators: { type: "boolean" } },
+				additionalProperties: !1
+			}],
+			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) {
+			let [{ 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) switch (node.type) {
+					case "LogicalExpression":
+						node.operator === "||" || node.operator === "??" ? checkUndefinedShortCircuit(node.right, reportFunc) : 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) {
+					isDestructuringPattern(node.left) && checkUnsafeUsage(node.right);
+				},
+				"ClassDeclaration, ClassExpression"(node) {
+					checkUnsafeUsage(node.superClass);
+				},
+				CallExpression(node) {
+					node.optional || checkUnsafeUsage(node.callee);
+				},
+				NewExpression(node) {
+					checkUnsafeUsage(node.callee);
+				},
+				VariableDeclarator(node) {
+					isDestructuringPattern(node.id) && checkUnsafeUsage(node.init);
+				},
+				MemberExpression(node) {
+					node.optional || checkUnsafeUsage(node.object);
+				},
+				TaggedTemplateExpression(node) {
+					checkUnsafeUsage(node.tag);
+				},
+				ForOfStatement(node) {
+					checkUnsafeUsage(node.right);
+				},
+				SpreadElement(node) {
+					node.parent && node.parent.type !== "ObjectExpression" && checkUnsafeUsage(node.argument);
+				},
+				BinaryExpression(node) {
+					UNSAFE_RELATIONAL_OPERATORS.has(node.operator) && checkUnsafeUsage(node.right), disallowArithmeticOperators && UNSAFE_ARITHMETIC_OPERATORS.has(node.operator) && (checkUnsafeArithmetic(node.right), checkUnsafeArithmetic(node.left));
+				},
+				WithStatement(node) {
+					checkUnsafeUsage(node.object);
+				},
+				UnaryExpression(node) {
+					disallowArithmeticOperators && UNSAFE_ARITHMETIC_OPERATORS.has(node.operator) && checkUnsafeArithmetic(node.argument);
+				},
+				AssignmentExpression(node) {
+					disallowArithmeticOperators && UNSAFE_ASSIGNMENT_OPERATORS.has(node.operator) && checkUnsafeArithmetic(node.right);
+				}
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-unsafe-optional-chaining.cjs
+module.exports = require_no_unsafe_optional_chaining().create;
+//#endregion

package/rules/no-unused-expressions.cjs

@@ -0,0 +1,163 @@
+const require_chunk = require("../common/chunk.cjs"), require_ast_utils$1 = require("../common/ast-utils.cjs");
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/no-unused-expressions.js
+/**
+* @fileoverview Flag expressions in statement position that do not side effect
+* @author Michael Ficarra
+*/
+var require_no_unused_expressions = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t();
+	/**
+	* Returns `true`.
+	* @returns {boolean} `true`.
+	*/
+	function alwaysTrue() {
+		return !0;
+	}
+	/**
+	* Returns `false`.
+	* @returns {boolean} `false`.
+	*/
+	function alwaysFalse() {
+		return !1;
+	}
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			dialects: ["javascript", "typescript"],
+			language: "javascript",
+			type: "suggestion",
+			docs: {
+				description: "Disallow unused expressions",
+				recommended: !1,
+				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: !1
+			}],
+			defaultOptions: [{
+				allowShortCircuit: !1,
+				allowTernary: !1,
+				allowTaggedTemplates: !1,
+				enforceForJSX: !1,
+				ignoreDirectives: !1
+			}],
+			messages: { unusedExpression: "Expected an assignment or function call and instead saw an expression." }
+		},
+		create(context) {
+			let [{ 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.
+			*/
+			let 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) {
+					return allowTernary ? Checker.isDisallowed(node.consequent) || Checker.isDisallowed(node.alternate) : !0;
+				},
+				FunctionExpression: alwaysTrue,
+				Identifier: alwaysTrue,
+				JSXElement() {
+					return enforceForJSX;
+				},
+				JSXFragment() {
+					return enforceForJSX;
+				},
+				Literal: alwaysTrue,
+				LogicalExpression(node) {
+					return allowShortCircuit ? Checker.isDisallowed(node.right) : !0;
+				},
+				MemberExpression: alwaysTrue,
+				MetaProperty: alwaysTrue,
+				ObjectExpression: alwaysTrue,
+				SequenceExpression: alwaysTrue,
+				TaggedTemplateExpression() {
+					return !allowTaggedTemplates;
+				},
+				TemplateLiteral: alwaysTrue,
+				ThisExpression: alwaysTrue,
+				UnaryExpression(node) {
+					return node.operator !== "void" && node.operator !== "delete";
+				},
+				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) {
+				Checker.isDisallowed(node.expression) && !astUtils.isDirective(node) && !(ignoreDirectives && isDirective(node)) && context.report({
+					node,
+					messageId: "unusedExpression"
+				});
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-unused-expressions.cjs
+module.exports = require_no_unused_expressions().create;
+//#endregion

package/rules/no-unused-labels.cjs

@@ -0,0 +1,97 @@
+const require_chunk = require("../common/chunk.cjs"), require_ast_utils$1 = require("../common/ast-utils.cjs");
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/no-unused-labels.js
+/**
+* @fileoverview Rule to disallow unused labels.
+* @author Toru Nagashima
+*/
+var require_no_unused_labels = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t();
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Disallow unused labels",
+				recommended: !0,
+				url: "https://eslint.org/docs/latest/rules/no-unused-labels"
+			},
+			schema: [],
+			fixable: "code",
+			messages: { unused: "'{{name}}:' is defined but never used." }
+		},
+		create(context) {
+			let sourceCode = context.sourceCode, scopeInfo = null;
+			/**
+			* Adds a scope info to the stack.
+			* @param {ASTNode} node A node to add. This is a LabeledStatement.
+			* @returns {void}
+			*/
+			function enterLabeledScope(node) {
+				scopeInfo = {
+					label: node.label.name,
+					used: !1,
+					upper: scopeInfo
+				};
+			}
+			/**
+			* Checks if a `LabeledStatement` node is fixable.
+			* For a node to be fixable, there must be no comments between the label and the body.
+			* Furthermore, is must be possible to remove the label without turning the body statement into a
+			* directive after other fixes are applied.
+			* @param {ASTNode} node The node to evaluate.
+			* @returns {boolean} Whether or not the node is fixable.
+			*/
+			function isFixable(node) {
+				if (sourceCode.getTokenAfter(node.label, { includeComments: !0 }) !== sourceCode.getTokenBefore(node.body, { includeComments: !0 })) return !1;
+				let ancestor = node.parent;
+				for (; ancestor.type === "LabeledStatement";) ancestor = ancestor.parent;
+				if (ancestor.type === "Program" || ancestor.type === "BlockStatement" && astUtils.isFunction(ancestor.parent)) {
+					let { body } = node;
+					if (body.type === "ExpressionStatement" && (body.expression.type === "Literal" && typeof body.expression.value == "string" || astUtils.isStaticTemplateLiteral(body.expression))) return !1;
+				}
+				return !0;
+			}
+			/**
+			* Removes the top of the stack.
+			* At the same time, this reports the label if it's never used.
+			* @param {ASTNode} node A node to report. This is a LabeledStatement.
+			* @returns {void}
+			*/
+			function exitLabeledScope(node) {
+				scopeInfo.used || context.report({
+					node: node.label,
+					messageId: "unused",
+					data: node.label,
+					fix: isFixable(node) ? (fixer) => fixer.removeRange([node.range[0], node.body.range[0]]) : null
+				}), scopeInfo = scopeInfo.upper;
+			}
+			/**
+			* Marks the label of a given node as used.
+			* @param {ASTNode} node A node to mark. This is a BreakStatement or
+			*      ContinueStatement.
+			* @returns {void}
+			*/
+			function markAsUsed(node) {
+				if (!node.label) return;
+				let label = node.label.name, info = scopeInfo;
+				for (; info;) {
+					if (info.label === label) {
+						info.used = !0;
+						break;
+					}
+					info = info.upper;
+				}
+			}
+			return {
+				LabeledStatement: enterLabeledScope,
+				"LabeledStatement:exit": exitLabeledScope,
+				BreakStatement: markAsUsed,
+				ContinueStatement: markAsUsed
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-unused-labels.cjs
+module.exports = require_no_unused_labels().create;
+//#endregion

package/rules/no-unused-private-class-members.cjs

@@ -0,0 +1,69 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/no-unused-private-class-members.js
+/**
+* @fileoverview Rule to flag declared but unused private class members
+* @author Tim van der Lippe
+*/
+var require_no_unused_private_class_members = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "problem",
+			docs: {
+				description: "Disallow unused private class members",
+				recommended: !0,
+				url: "https://eslint.org/docs/latest/rules/no-unused-private-class-members"
+			},
+			schema: [],
+			messages: { unusedPrivateClassMember: "'{{classMemberName}}' is defined but never used." }
+		},
+		create(context) {
+			let trackedClasses = [];
+			/**
+			* Check whether the current node is in a write only assignment.
+			* @param {ASTNode} privateIdentifierNode Node referring to a private identifier
+			* @returns {boolean} Whether the node is in a write only assignment
+			* @private
+			*/
+			function isWriteOnlyAssignment(privateIdentifierNode) {
+				let parentStatement = privateIdentifierNode.parent.parent, isAssignmentExpression = parentStatement.type === "AssignmentExpression";
+				return !isAssignmentExpression && parentStatement.type !== "ForInStatement" && parentStatement.type !== "ForOfStatement" && parentStatement.type !== "AssignmentPattern" || parentStatement.left !== privateIdentifierNode.parent ? !1 : isAssignmentExpression && parentStatement.operator !== "=" ? parentStatement.parent.type === "ExpressionStatement" : !0;
+			}
+			return {
+				ClassBody(classBodyNode) {
+					let privateMembers = /* @__PURE__ */ new Map();
+					trackedClasses.unshift(privateMembers);
+					for (let bodyMember of classBodyNode.body) (bodyMember.type === "PropertyDefinition" || bodyMember.type === "MethodDefinition") && bodyMember.key.type === "PrivateIdentifier" && privateMembers.set(bodyMember.key.name, {
+						declaredNode: bodyMember,
+						isAccessor: bodyMember.type === "MethodDefinition" && (bodyMember.kind === "set" || bodyMember.kind === "get")
+					});
+				},
+				PrivateIdentifier(privateIdentifierNode) {
+					let classBody = trackedClasses.find((classProperties) => classProperties.has(privateIdentifierNode.name));
+					if (!classBody) return;
+					let memberDefinition = classBody.get(privateIdentifierNode.name);
+					if (memberDefinition.isUsed || privateIdentifierNode.parent.type === "PropertyDefinition" || privateIdentifierNode.parent.type === "MethodDefinition") return;
+					if (memberDefinition.isAccessor) {
+						memberDefinition.isUsed = !0;
+						return;
+					}
+					if (isWriteOnlyAssignment(privateIdentifierNode)) return;
+					let wrappingExpressionType = privateIdentifierNode.parent.parent.type, parentOfWrappingExpressionType = privateIdentifierNode.parent.parent.parent.type;
+					wrappingExpressionType === "UpdateExpression" && parentOfWrappingExpressionType === "ExpressionStatement" || wrappingExpressionType === "Property" && parentOfWrappingExpressionType === "ObjectPattern" && privateIdentifierNode.parent.parent.value === privateIdentifierNode.parent || wrappingExpressionType !== "RestElement" && wrappingExpressionType !== "ArrayPattern" && (memberDefinition.isUsed = !0);
+				},
+				"ClassBody:exit"() {
+					let unusedPrivateMembers = trackedClasses.shift();
+					for (let [classMemberName, { declaredNode, isUsed }] of unusedPrivateMembers.entries()) isUsed || context.report({
+						node: declaredNode,
+						loc: declaredNode.key.loc,
+						messageId: "unusedPrivateClassMember",
+						data: { classMemberName: `#${classMemberName}` }
+					});
+				}
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-unused-private-class-members.cjs
+module.exports = require_no_unused_private_class_members().create;
+//#endregion