oxlint-plugin-eslint 1.52.0

package/rules/no-catch-shadow.cjs

@@ -0,0 +1,57 @@
+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-catch-shadow.js
+/**
+* @fileoverview Rule to flag variable leak in CatchClauses in IE 8 and earlier
+* @author Ian Christian Myers
+* @deprecated in ESLint v5.1.0
+*/
+var require_no_catch_shadow = /* @__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 `catch` clause parameters from shadowing variables in the outer scope",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/no-catch-shadow"
+			},
+			deprecated: {
+				message: "This rule was renamed.",
+				url: "https://eslint.org/blog/2018/07/eslint-v5.1.0-released/",
+				deprecatedSince: "5.1.0",
+				availableUntil: "11.0.0",
+				replacedBy: [{ rule: {
+					name: "no-shadow",
+					url: "https://eslint.org/docs/rules/no-shadow"
+				} }]
+			},
+			schema: [],
+			messages: { mutable: "Value of '{{name}}' may be overwritten in IE 8 and earlier." }
+		},
+		create(context) {
+			let sourceCode = context.sourceCode;
+			/**
+			* Check if the parameters are been shadowed
+			* @param {Object} scope current scope
+			* @param {string} name parameter name
+			* @returns {boolean} True is its been shadowed
+			*/
+			function paramIsShadowing(scope, name) {
+				return astUtils.getVariableByName(scope, name) !== null;
+			}
+			return { "CatchClause[param!=null]"(node) {
+				let scope = sourceCode.getScope(node);
+				scope.block === node && (scope = scope.upper), paramIsShadowing(scope, node.param.name) && context.report({
+					node,
+					messageId: "mutable",
+					data: { name: node.param.name }
+				});
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-catch-shadow.cjs
+module.exports = require_no_catch_shadow().create;
+//#endregion

package/rules/no-class-assign.cjs

@@ -0,0 +1,55 @@
+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-class-assign.js
+/**
+* @fileoverview A rule to disallow modifying variables of class declarations
+* @author Toru Nagashima
+*/
+var require_no_class_assign = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t();
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "problem",
+			docs: {
+				description: "Disallow reassigning class members",
+				recommended: !0,
+				url: "https://eslint.org/docs/latest/rules/no-class-assign"
+			},
+			schema: [],
+			messages: { class: "'{{name}}' is a class." }
+		},
+		create(context) {
+			let sourceCode = context.sourceCode;
+			/**
+			* Finds and reports references that are non initializer and writable.
+			* @param {Variable} variable A variable to check.
+			* @returns {void}
+			*/
+			function checkVariable(variable) {
+				astUtils.getModifyingReferences(variable.references).forEach((reference) => {
+					context.report({
+						node: reference.identifier,
+						messageId: "class",
+						data: { name: reference.identifier.name }
+					});
+				});
+			}
+			/**
+			* Finds and reports references that are non initializer and writable.
+			* @param {ASTNode} node A ClassDeclaration/ClassExpression node to check.
+			* @returns {void}
+			*/
+			function checkForClass(node) {
+				sourceCode.getDeclaredVariables(node).forEach(checkVariable);
+			}
+			return {
+				ClassDeclaration: checkForClass,
+				ClassExpression: checkForClass
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-class-assign.cjs
+module.exports = require_no_class_assign().create;
+//#endregion

package/rules/no-compare-neg-zero.cjs

@@ -0,0 +1,52 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/no-compare-neg-zero.js
+/**
+* @fileoverview The rule should warn against code that tries to compare against -0.
+* @author Aladdin-ADD <hh_2013@foxmail.com>
+*/
+var require_no_compare_neg_zero = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "problem",
+			docs: {
+				description: "Disallow comparing against `-0`",
+				recommended: !0,
+				url: "https://eslint.org/docs/latest/rules/no-compare-neg-zero"
+			},
+			fixable: null,
+			schema: [],
+			messages: { unexpected: "Do not use the '{{operator}}' operator to compare against -0." }
+		},
+		create(context) {
+			/**
+			* Checks a given node is -0
+			* @param {ASTNode} node A node to check.
+			* @returns {boolean} `true` if the node is -0.
+			*/
+			function isNegZero(node) {
+				return node.type === "UnaryExpression" && node.operator === "-" && node.argument.type === "Literal" && node.argument.value === 0;
+			}
+			let OPERATORS_TO_CHECK = new Set([
+				">",
+				">=",
+				"<",
+				"<=",
+				"==",
+				"===",
+				"!=",
+				"!=="
+			]);
+			return { BinaryExpression(node) {
+				OPERATORS_TO_CHECK.has(node.operator) && (isNegZero(node.left) || isNegZero(node.right)) && context.report({
+					node,
+					messageId: "unexpected",
+					data: { operator: node.operator }
+				});
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-compare-neg-zero.cjs
+module.exports = require_no_compare_neg_zero().create;
+//#endregion

package/rules/no-cond-assign.cjs

@@ -0,0 +1,104 @@
+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-cond-assign.js
+/**
+* @fileoverview Rule to flag assignment in a conditional statement's test expression
+* @author Stephen Murray <spmurrayzzz>
+*/
+var require_no_cond_assign = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t(), TEST_CONDITION_PARENT_TYPES = new Set([
+		"IfStatement",
+		"WhileStatement",
+		"DoWhileStatement",
+		"ForStatement",
+		"ConditionalExpression"
+	]), NODE_DESCRIPTIONS = {
+		DoWhileStatement: "a 'do...while' statement",
+		ForStatement: "a 'for' statement",
+		IfStatement: "an 'if' statement",
+		WhileStatement: "a 'while' statement"
+	};
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "problem",
+			defaultOptions: ["except-parens"],
+			docs: {
+				description: "Disallow assignment operators in conditional expressions",
+				recommended: !0,
+				url: "https://eslint.org/docs/latest/rules/no-cond-assign"
+			},
+			schema: [{ enum: ["except-parens", "always"] }],
+			messages: {
+				unexpected: "Unexpected assignment within {{type}}.",
+				missing: "Expected a conditional expression and instead saw an assignment."
+			}
+		},
+		create(context) {
+			let [prohibitAssign] = context.options, sourceCode = context.sourceCode;
+			/**
+			* Check whether an AST node is the test expression for a conditional statement.
+			* @param {!Object} node The node to test.
+			* @returns {boolean} `true` if the node is the text expression for a conditional statement; otherwise, `false`.
+			*/
+			function isConditionalTestExpression(node) {
+				return node.parent && TEST_CONDITION_PARENT_TYPES.has(node.parent.type) && node === node.parent.test;
+			}
+			/**
+			* Given an AST node, perform a bottom-up search for the first ancestor that represents a conditional statement.
+			* @param {!Object} node The node to use at the start of the search.
+			* @returns {?Object} The closest ancestor node that represents a conditional statement.
+			*/
+			function findConditionalAncestor(node) {
+				let currentAncestor = node;
+				do
+					if (isConditionalTestExpression(currentAncestor)) return currentAncestor.parent;
+				while ((currentAncestor = currentAncestor.parent) && !astUtils.isFunction(currentAncestor));
+				return null;
+			}
+			/**
+			* Check whether the code represented by an AST node is enclosed in two sets of parentheses.
+			* @param {!Object} node The node to test.
+			* @returns {boolean} `true` if the code is enclosed in two sets of parentheses; otherwise, `false`.
+			*/
+			function isParenthesisedTwice(node) {
+				let previousToken = sourceCode.getTokenBefore(node, 1), nextToken = sourceCode.getTokenAfter(node, 1);
+				return astUtils.isParenthesised(sourceCode, node) && previousToken && astUtils.isOpeningParenToken(previousToken) && previousToken.range[1] <= node.range[0] && astUtils.isClosingParenToken(nextToken) && nextToken.range[0] >= node.range[1];
+			}
+			/**
+			* Check a conditional statement's test expression for top-level assignments that are not enclosed in parentheses.
+			* @param {!Object} node The node for the conditional statement.
+			* @returns {void}
+			*/
+			function testForAssign(node) {
+				node.test && node.test.type === "AssignmentExpression" && (node.type === "ForStatement" ? !astUtils.isParenthesised(sourceCode, node.test) : !isParenthesisedTwice(node.test)) && context.report({
+					node: node.test,
+					messageId: "missing"
+				});
+			}
+			/**
+			* Check whether an assignment expression is descended from a conditional statement's test expression.
+			* @param {!Object} node The node for the assignment expression.
+			* @returns {void}
+			*/
+			function testForConditionalAncestor(node) {
+				let ancestor = findConditionalAncestor(node);
+				ancestor && context.report({
+					node,
+					messageId: "unexpected",
+					data: { type: NODE_DESCRIPTIONS[ancestor.type] || ancestor.type }
+				});
+			}
+			return prohibitAssign === "always" ? { AssignmentExpression: testForConditionalAncestor } : {
+				DoWhileStatement: testForAssign,
+				ForStatement: testForAssign,
+				IfStatement: testForAssign,
+				WhileStatement: testForAssign,
+				ConditionalExpression: testForAssign
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-cond-assign.cjs
+module.exports = require_no_cond_assign().create;
+//#endregion

package/rules/no-confusing-arrow.cjs

@@ -0,0 +1,87 @@
+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-confusing-arrow.js
+/**
+* @fileoverview A rule to warn against using arrow functions when they could be
+* confused with comparisons
+* @author Jxck <https://github.com/Jxck>
+* @deprecated in ESLint v8.53.0
+*/
+var require_no_confusing_arrow = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t();
+	/**
+	* Checks whether or not a node is a conditional expression.
+	* @param {ASTNode} node node to test
+	* @returns {boolean} `true` if the node is a conditional expression.
+	*/
+	function isConditional(node) {
+		return node && node.type === "ConditionalExpression";
+	}
+	/** @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: "no-confusing-arrow",
+						url: "https://eslint.style/rules/no-confusing-arrow"
+					}
+				}]
+			},
+			type: "suggestion",
+			docs: {
+				description: "Disallow arrow functions where they could be confused with comparisons",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/no-confusing-arrow"
+			},
+			fixable: "code",
+			schema: [{
+				type: "object",
+				properties: {
+					allowParens: {
+						type: "boolean",
+						default: !0
+					},
+					onlyOneSimpleParam: {
+						type: "boolean",
+						default: !1
+					}
+				},
+				additionalProperties: !1
+			}],
+			messages: { confusing: "Arrow function used ambiguously with a conditional expression." }
+		},
+		create(context) {
+			let config = context.options[0] || {}, allowParens = config.allowParens || config.allowParens === void 0, onlyOneSimpleParam = config.onlyOneSimpleParam, sourceCode = context.sourceCode;
+			/**
+			* Reports if an arrow function contains an ambiguous conditional.
+			* @param {ASTNode} node A node to check and report.
+			* @returns {void}
+			*/
+			function checkArrowFunc(node) {
+				let body = node.body;
+				isConditional(body) && !(allowParens && astUtils.isParenthesised(sourceCode, body)) && !(onlyOneSimpleParam && !(node.params.length === 1 && node.params[0].type === "Identifier")) && context.report({
+					node,
+					messageId: "confusing",
+					fix(fixer) {
+						return allowParens && fixer.replaceText(node.body, `(${sourceCode.getText(node.body)})`);
+					}
+				});
+			}
+			return { ArrowFunctionExpression: checkArrowFunc };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-confusing-arrow.cjs
+module.exports = require_no_confusing_arrow().create;
+//#endregion

package/rules/no-console.cjs

@@ -0,0 +1,138 @@
+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-console.js
+/**
+* @fileoverview Rule to flag use of console object
+* @author Nicholas C. Zakas
+*/
+var require_no_console = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t();
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			defaultOptions: [{}],
+			docs: {
+				description: "Disallow the use of `console`",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/no-console"
+			},
+			schema: [{
+				type: "object",
+				properties: { allow: {
+					type: "array",
+					items: { type: "string" },
+					minItems: 1,
+					uniqueItems: !0
+				} },
+				additionalProperties: !1
+			}],
+			hasSuggestions: !0,
+			messages: {
+				unexpected: "Unexpected console statement.",
+				limited: "Unexpected console statement. Only these console methods are allowed: {{ allowed }}.",
+				removeConsole: "Remove the console.{{ propertyName }}().",
+				removeMethodCall: "Remove the console method call."
+			}
+		},
+		create(context) {
+			let [{ allow: allowed = [] }] = context.options, sourceCode = context.sourceCode;
+			/**
+			* Checks whether the given reference is 'console' or not.
+			* @param {eslint-scope.Reference} reference The reference to check.
+			* @returns {boolean} `true` if the reference is 'console'.
+			*/
+			function isConsole(reference) {
+				let id = reference.identifier;
+				return id && id.name === "console";
+			}
+			/**
+			* Checks whether the property name of the given MemberExpression node
+			* is allowed by options or not.
+			* @param {ASTNode} node The MemberExpression node to check.
+			* @returns {boolean} `true` if the property name of the node is allowed.
+			*/
+			function isAllowed(node) {
+				let propertyName = astUtils.getStaticPropertyName(node);
+				return propertyName && allowed.includes(propertyName);
+			}
+			/**
+			* Checks whether the given reference is a member access which is not
+			* allowed by options or not.
+			* @param {eslint-scope.Reference} reference The reference to check.
+			* @returns {boolean} `true` if the reference is a member access which
+			*      is not allowed by options.
+			*/
+			function isMemberAccessExceptAllowed(reference) {
+				let node = reference.identifier, parent = node.parent;
+				return parent.type === "MemberExpression" && parent.object === node && !isAllowed(parent);
+			}
+			/**
+			* Checks if removing the ExpressionStatement node will cause ASI to
+			* break.
+			* eg.
+			* foo()
+			* console.log();
+			* [1, 2, 3].forEach(a => doSomething(a))
+			*
+			* Removing the console.log(); statement should leave two statements, but
+			* here the two statements will become one because [ causes continuation after
+			* foo().
+			* @param {ASTNode} node The ExpressionStatement node to check.
+			* @returns {boolean} `true` if ASI will break after removing the ExpressionStatement
+			*      node.
+			*/
+			function maybeAsiHazard(node) {
+				let SAFE_TOKENS_BEFORE = /^[:;{]$/u, UNSAFE_CHARS_AFTER = /^[-[(/+`]/u, tokenBefore = sourceCode.getTokenBefore(node), tokenAfter = sourceCode.getTokenAfter(node);
+				return !!tokenAfter && UNSAFE_CHARS_AFTER.test(tokenAfter.value) && tokenAfter.value !== "++" && tokenAfter.value !== "--" && !!tokenBefore && !SAFE_TOKENS_BEFORE.test(tokenBefore.value);
+			}
+			/**
+			* Checks if the MemberExpression node's parent.parent.parent is a
+			* Program, BlockStatement, StaticBlock, or SwitchCase node. This check
+			* is necessary to avoid providing a suggestion that might cause a syntax error.
+			*
+			* eg. if (a) console.log(b), removing console.log() here will lead to a
+			*     syntax error.
+			*     if (a) { console.log(b) }, removing console.log() here is acceptable.
+			*
+			* Additionally, it checks if the callee of the CallExpression node is
+			* the node itself.
+			*
+			* eg. foo(console.log), cannot provide a suggestion here.
+			* @param {ASTNode} node The MemberExpression node to check.
+			* @returns {boolean} `true` if a suggestion can be provided for a node.
+			*/
+			function canProvideSuggestions(node) {
+				return node.parent.type === "CallExpression" && node.parent.callee === node && node.parent.parent.type === "ExpressionStatement" && astUtils.STATEMENT_LIST_PARENTS.has(node.parent.parent.parent.type) && !maybeAsiHazard(node.parent.parent);
+			}
+			/**
+			* Reports the given reference as a violation.
+			* @param {eslint-scope.Reference} reference The reference to report.
+			* @returns {void}
+			*/
+			function report(reference) {
+				let node = reference.identifier.parent, suggest = [];
+				if (canProvideSuggestions(node)) {
+					let suggestion = { fix(fixer) {
+						return fixer.remove(node.parent.parent);
+					} };
+					node.computed ? suggestion.messageId = "removeMethodCall" : (suggestion.messageId = "removeConsole", suggestion.data = { propertyName: node.property.name }), suggest.push(suggestion);
+				}
+				context.report({
+					node,
+					loc: node.loc,
+					messageId: allowed.length ? "limited" : "unexpected",
+					data: { allowed: allowed.join(", ") },
+					suggest
+				});
+			}
+			return { "Program:exit"(node) {
+				let scope = sourceCode.getScope(node), consoleVar = astUtils.getVariableByName(scope, "console"), shadowed = consoleVar && consoleVar.defs.length > 0, references = consoleVar ? consoleVar.references : scope.through.filter(isConsole);
+				shadowed || references.filter(isMemberAccessExceptAllowed).forEach(report);
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-console.cjs
+module.exports = require_no_console().create;
+//#endregion

package/rules/no-const-assign.cjs

@@ -0,0 +1,50 @@
+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-const-assign.js
+/**
+* @fileoverview A rule to disallow modifying variables that are declared using `const`
+* @author Toru Nagashima
+*/
+var require_no_const_assign = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t(), CONSTANT_BINDINGS = new Set([
+		"const",
+		"using",
+		"await using"
+	]);
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "problem",
+			docs: {
+				description: "Disallow reassigning `const`, `using`, and `await using` variables",
+				recommended: !0,
+				url: "https://eslint.org/docs/latest/rules/no-const-assign"
+			},
+			schema: [],
+			messages: { const: "'{{name}}' is constant." }
+		},
+		create(context) {
+			let sourceCode = context.sourceCode;
+			/**
+			* Finds and reports references that are non initializer and writable.
+			* @param {Variable} variable A variable to check.
+			* @returns {void}
+			*/
+			function checkVariable(variable) {
+				astUtils.getModifyingReferences(variable.references).forEach((reference) => {
+					context.report({
+						node: reference.identifier,
+						messageId: "const",
+						data: { name: reference.identifier.name }
+					});
+				});
+			}
+			return { VariableDeclaration(node) {
+				CONSTANT_BINDINGS.has(node.kind) && sourceCode.getDeclaredVariables(node).forEach(checkVariable);
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-const-assign.cjs
+module.exports = require_no_const_assign().create;
+//#endregion