oxlint-plugin-eslint 1.52.0

package/rules/wrap-iife.cjs

@@ -0,0 +1,131 @@
+const require_chunk = require("../common/chunk.cjs"), require_ast_utils$1 = require("../common/ast-utils.cjs"), require_eslint_utils$1 = require("../common/eslint-utils.cjs");
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/wrap-iife.js
+/**
+* @fileoverview Rule to flag when IIFE is not wrapped in parens
+* @author Ilya Volodin
+* @deprecated in ESLint v8.53.0
+*/
+var require_wrap_iife = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t(), eslintUtils = require_eslint_utils$1.t();
+	/**
+	* Check if the given node is callee of a `NewExpression` node
+	* @param {ASTNode} node node to check
+	* @returns {boolean} True if the node is callee of a `NewExpression` node
+	* @private
+	*/
+	function isCalleeOfNewExpression(node) {
+		let maybeCallee = node.parent.type === "ChainExpression" ? node.parent : node;
+		return maybeCallee.parent.type === "NewExpression" && maybeCallee.parent.callee === maybeCallee;
+	}
+	/** @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: "wrap-iife",
+						url: "https://eslint.style/rules/wrap-iife"
+					}
+				}]
+			},
+			type: "layout",
+			docs: {
+				description: "Require parentheses around immediate `function` invocations",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/wrap-iife"
+			},
+			schema: [{ enum: [
+				"outside",
+				"inside",
+				"any"
+			] }, {
+				type: "object",
+				properties: { functionPrototypeMethods: {
+					type: "boolean",
+					default: !1
+				} },
+				additionalProperties: !1
+			}],
+			fixable: "code",
+			messages: {
+				wrapInvocation: "Wrap an immediate function invocation in parentheses.",
+				wrapExpression: "Wrap only the function expression in parens.",
+				moveInvocation: "Move the invocation into the parens that contain the function."
+			}
+		},
+		create(context) {
+			let style = context.options[0] || "outside", includeFunctionPrototypeMethods = context.options[1] && context.options[1].functionPrototypeMethods, sourceCode = context.sourceCode;
+			/**
+			* Check if the node is wrapped in any (). All parens count: grouping parens and parens for constructs such as if()
+			* @param {ASTNode} node node to evaluate
+			* @returns {boolean} True if it is wrapped in any parens
+			* @private
+			*/
+			function isWrappedInAnyParens(node) {
+				return astUtils.isParenthesised(sourceCode, node);
+			}
+			/**
+			* Check if the node is wrapped in grouping (). Parens for constructs such as if() don't count
+			* @param {ASTNode} node node to evaluate
+			* @returns {boolean} True if it is wrapped in grouping parens
+			* @private
+			*/
+			function isWrappedInGroupingParens(node) {
+				return eslintUtils.isParenthesized(1, node, sourceCode);
+			}
+			/**
+			* Get the function node from an IIFE
+			* @param {ASTNode} node node to evaluate
+			* @returns {ASTNode} node that is the function expression of the given IIFE, or null if none exist
+			*/
+			function getFunctionNodeFromIIFE(node) {
+				let callee = astUtils.skipChainExpression(node.callee);
+				return callee.type === "FunctionExpression" ? callee : includeFunctionPrototypeMethods && callee.type === "MemberExpression" && callee.object.type === "FunctionExpression" && (astUtils.getStaticPropertyName(callee) === "call" || astUtils.getStaticPropertyName(callee) === "apply") ? callee.object : null;
+			}
+			return { CallExpression(node) {
+				let innerNode = getFunctionNodeFromIIFE(node);
+				if (!innerNode) return;
+				let isCallExpressionWrapped = isWrappedInAnyParens(node), isFunctionExpressionWrapped = isWrappedInAnyParens(innerNode);
+				!isCallExpressionWrapped && !isFunctionExpressionWrapped ? context.report({
+					node,
+					messageId: "wrapInvocation",
+					fix(fixer) {
+						let nodeToSurround = style === "inside" ? innerNode : node;
+						return fixer.replaceText(nodeToSurround, `(${sourceCode.getText(nodeToSurround)})`);
+					}
+				}) : style === "inside" && !isFunctionExpressionWrapped ? context.report({
+					node,
+					messageId: "wrapExpression",
+					fix(fixer) {
+						if (isWrappedInGroupingParens(node) && !isCalleeOfNewExpression(node)) {
+							let parenAfter = sourceCode.getTokenAfter(node);
+							return fixer.replaceTextRange([innerNode.range[1], parenAfter.range[1]], `)${sourceCode.getText().slice(innerNode.range[1], parenAfter.range[0])}`);
+						}
+						return fixer.replaceText(innerNode, `(${sourceCode.getText(innerNode)})`);
+					}
+				}) : style === "outside" && !isCallExpressionWrapped && context.report({
+					node,
+					messageId: "moveInvocation",
+					fix(fixer) {
+						let parenAfter = sourceCode.getTokenAfter(innerNode);
+						return fixer.replaceTextRange([parenAfter.range[0], node.range[1]], `${sourceCode.getText().slice(parenAfter.range[1], node.range[1])})`);
+					}
+				});
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/wrap-iife.cjs
+module.exports = require_wrap_iife().create;
+//#endregion

package/rules/wrap-regex.cjs

@@ -0,0 +1,57 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/wrap-regex.js
+/**
+* @fileoverview Rule to flag when regex literals are not wrapped in parens
+* @author Matt DuVall <http://www.mattduvall.com>
+* @deprecated in ESLint v8.53.0
+*/
+var require_wrap_regex = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	/** @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: "wrap-regex",
+						url: "https://eslint.style/rules/wrap-regex"
+					}
+				}]
+			},
+			type: "layout",
+			docs: {
+				description: "Require parenthesis around regex literals",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/wrap-regex"
+			},
+			schema: [],
+			fixable: "code",
+			messages: { requireParens: "Wrap the regexp literal in parens to disambiguate the slash." }
+		},
+		create(context) {
+			let sourceCode = context.sourceCode;
+			return { Literal(node) {
+				if (sourceCode.getFirstToken(node).type === "RegularExpression") {
+					let beforeToken = sourceCode.getTokenBefore(node), afterToken = sourceCode.getTokenAfter(node), { parent } = node;
+					parent.type === "MemberExpression" && parent.object === node && !(beforeToken && beforeToken.value === "(" && afterToken && afterToken.value === ")") && context.report({
+						node,
+						messageId: "requireParens",
+						fix: (fixer) => fixer.replaceText(node, `(${sourceCode.getText(node)})`)
+					});
+				}
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/wrap-regex.cjs
+module.exports = require_wrap_regex().create;
+//#endregion

package/rules/yield-star-spacing.cjs

@@ -0,0 +1,115 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/yield-star-spacing.js
+/**
+* @fileoverview Rule to check the spacing around the * in yield* expressions.
+* @author Bryan Smith
+* @deprecated in ESLint v8.53.0
+*/
+var require_yield_star_spacing = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	/** @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: "yield-star-spacing",
+						url: "https://eslint.style/rules/yield-star-spacing"
+					}
+				}]
+			},
+			type: "layout",
+			docs: {
+				description: "Require or disallow spacing around the `*` in `yield*` expressions",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/yield-star-spacing"
+			},
+			fixable: "whitespace",
+			schema: [{ oneOf: [{ enum: [
+				"before",
+				"after",
+				"both",
+				"neither"
+			] }, {
+				type: "object",
+				properties: {
+					before: { type: "boolean" },
+					after: { type: "boolean" }
+				},
+				additionalProperties: !1
+			}] }],
+			messages: {
+				missingBefore: "Missing space before *.",
+				missingAfter: "Missing space after *.",
+				unexpectedBefore: "Unexpected space before *.",
+				unexpectedAfter: "Unexpected space after *."
+			}
+		},
+		create(context) {
+			let sourceCode = context.sourceCode, mode = (function(option) {
+				return !option || typeof option == "string" ? {
+					before: {
+						before: !0,
+						after: !1
+					},
+					after: {
+						before: !1,
+						after: !0
+					},
+					both: {
+						before: !0,
+						after: !0
+					},
+					neither: {
+						before: !1,
+						after: !1
+					}
+				}[option || "after"] : option;
+			})(context.options[0]);
+			/**
+			* Checks the spacing between two tokens before or after the star token.
+			* @param {string} side Either "before" or "after".
+			* @param {Token} leftToken `function` keyword token if side is "before", or
+			*     star token if side is "after".
+			* @param {Token} rightToken Star token if side is "before", or identifier
+			*     token if side is "after".
+			* @returns {void}
+			*/
+			function checkSpacing(side, leftToken, rightToken) {
+				if (sourceCode.isSpaceBetweenTokens(leftToken, rightToken) !== mode[side]) {
+					let after = leftToken.value === "*", spaceRequired = mode[side], node = after ? leftToken : rightToken, messageId;
+					messageId = spaceRequired ? side === "before" ? "missingBefore" : "missingAfter" : side === "before" ? "unexpectedBefore" : "unexpectedAfter", context.report({
+						node,
+						messageId,
+						fix(fixer) {
+							return spaceRequired ? after ? fixer.insertTextAfter(node, " ") : fixer.insertTextBefore(node, " ") : fixer.removeRange([leftToken.range[1], rightToken.range[0]]);
+						}
+					});
+				}
+			}
+			/**
+			* Enforces the spacing around the star if node is a yield* expression.
+			* @param {ASTNode} node A yield expression node.
+			* @returns {void}
+			*/
+			function checkExpression(node) {
+				if (!node.delegate) return;
+				let tokens = sourceCode.getFirstTokens(node, 3), yieldToken = tokens[0], starToken = tokens[1], nextToken = tokens[2];
+				checkSpacing("before", yieldToken, starToken), checkSpacing("after", starToken, nextToken);
+			}
+			return { YieldExpression: checkExpression };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/yield-star-spacing.cjs
+module.exports = require_yield_star_spacing().create;
+//#endregion

package/rules/yoda.cjs

@@ -0,0 +1,185 @@
+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/yoda.js
+/**
+* @fileoverview Rule to require or disallow yoda comparisons
+* @author Nicholas C. Zakas
+*/
+var require_yoda = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t();
+	/**
+	* Determines whether an operator is a comparison operator.
+	* @param {string} operator The operator to check.
+	* @returns {boolean} Whether or not it is a comparison operator.
+	*/
+	function isComparisonOperator(operator) {
+		return /^(?:==|===|!=|!==|<|>|<=|>=)$/u.test(operator);
+	}
+	/**
+	* Determines whether an operator is an equality operator.
+	* @param {string} operator The operator to check.
+	* @returns {boolean} Whether or not it is an equality operator.
+	*/
+	function isEqualityOperator(operator) {
+		return /^(?:==|===)$/u.test(operator);
+	}
+	/**
+	* Determines whether an operator is one used in a range test.
+	* Allowed operators are `<` and `<=`.
+	* @param {string} operator The operator to check.
+	* @returns {boolean} Whether the operator is used in range tests.
+	*/
+	function isRangeTestOperator(operator) {
+		return ["<", "<="].includes(operator);
+	}
+	/**
+	* Determines whether a non-Literal node is a negative number that should be
+	* treated as if it were a single Literal node.
+	* @param {ASTNode} node Node to test.
+	* @returns {boolean} True if the node is a negative number that looks like a
+	*                    real literal and should be treated as such.
+	*/
+	function isNegativeNumericLiteral(node) {
+		return node.type === "UnaryExpression" && node.operator === "-" && node.prefix && astUtils.isNumericLiteral(node.argument);
+	}
+	/**
+	* Determines whether a non-Literal node should be treated as a single Literal node.
+	* @param {ASTNode} node Node to test
+	* @returns {boolean} True if the node should be treated as a single Literal node.
+	*/
+	function looksLikeLiteral(node) {
+		return isNegativeNumericLiteral(node) || astUtils.isStaticTemplateLiteral(node);
+	}
+	/**
+	* Attempts to derive a Literal node from nodes that are treated like literals.
+	* @param {ASTNode} node Node to normalize.
+	* @returns {ASTNode} One of the following options.
+	*  1. The original node if the node is already a Literal
+	*  2. A normalized Literal node with the negative number as the value if the
+	*     node represents a negative number literal.
+	*  3. A normalized Literal node with the string as the value if the node is
+	*     a Template Literal without expression.
+	*  4. Otherwise `null`.
+	*/
+	function getNormalizedLiteral(node) {
+		return node.type === "Literal" ? node : isNegativeNumericLiteral(node) ? {
+			type: "Literal",
+			value: -node.argument.value,
+			raw: `-${node.argument.value}`
+		} : astUtils.isStaticTemplateLiteral(node) ? {
+			type: "Literal",
+			value: node.quasis[0].value.cooked,
+			raw: node.quasis[0].value.raw
+		} : null;
+	}
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			defaultOptions: ["never", {
+				exceptRange: !1,
+				onlyEquality: !1
+			}],
+			docs: {
+				description: "Require or disallow \"Yoda\" conditions",
+				recommended: !1,
+				frozen: !0,
+				url: "https://eslint.org/docs/latest/rules/yoda"
+			},
+			schema: [{ enum: ["always", "never"] }, {
+				type: "object",
+				properties: {
+					exceptRange: { type: "boolean" },
+					onlyEquality: { type: "boolean" }
+				},
+				additionalProperties: !1
+			}],
+			fixable: "code",
+			messages: { expected: "Expected literal to be on the {{expectedSide}} side of {{operator}}." }
+		},
+		create(context) {
+			let [when, { exceptRange, onlyEquality }] = context.options, always = when === "always", sourceCode = context.sourceCode;
+			/**
+			* Determines whether node represents a range test.
+			* A range test is a "between" test like `(0 <= x && x < 1)` or an "outside"
+			* test like `(x < 0 || 1 <= x)`. It must be wrapped in parentheses, and
+			* both operators must be `<` or `<=`. Finally, the literal on the left side
+			* must be less than or equal to the literal on the right side so that the
+			* test makes any sense.
+			* @param {ASTNode} node LogicalExpression node to test.
+			* @returns {boolean} Whether node is a range test.
+			*/
+			function isRangeTest(node) {
+				let left = node.left, right = node.right;
+				/**
+				* Determines whether node is of the form `0 <= x && x < 1`.
+				* @returns {boolean} Whether node is a "between" range test.
+				*/
+				function isBetweenTest() {
+					if (node.operator === "&&" && astUtils.isSameReference(left.right, right.left)) {
+						let leftLiteral = getNormalizedLiteral(left.left), rightLiteral = getNormalizedLiteral(right.right);
+						if (leftLiteral === null && rightLiteral === null) return !1;
+						if (rightLiteral === null || leftLiteral === null || leftLiteral.value <= rightLiteral.value) return !0;
+					}
+					return !1;
+				}
+				/**
+				* Determines whether node is of the form `x < 0 || 1 <= x`.
+				* @returns {boolean} Whether node is an "outside" range test.
+				*/
+				function isOutsideTest() {
+					if (node.operator === "||" && astUtils.isSameReference(left.left, right.right)) {
+						let leftLiteral = getNormalizedLiteral(left.right), rightLiteral = getNormalizedLiteral(right.left);
+						if (leftLiteral === null && rightLiteral === null) return !1;
+						if (rightLiteral === null || leftLiteral === null || leftLiteral.value <= rightLiteral.value) return !0;
+					}
+					return !1;
+				}
+				/**
+				* Determines whether node is wrapped in parentheses.
+				* @returns {boolean} Whether node is preceded immediately by an open
+				*                    paren token and followed immediately by a close
+				*                    paren token.
+				*/
+				function isParenWrapped() {
+					return astUtils.isParenthesised(sourceCode, node);
+				}
+				return node.type === "LogicalExpression" && left.type === "BinaryExpression" && right.type === "BinaryExpression" && isRangeTestOperator(left.operator) && isRangeTestOperator(right.operator) && (isBetweenTest() || isOutsideTest()) && isParenWrapped();
+			}
+			let OPERATOR_FLIP_MAP = {
+				"===": "===",
+				"!==": "!==",
+				"==": "==",
+				"!=": "!=",
+				"<": ">",
+				">": "<",
+				"<=": ">=",
+				">=": "<="
+			};
+			/**
+			* Returns a string representation of a BinaryExpression node with its sides/operator flipped around.
+			* @param {ASTNode} node The BinaryExpression node
+			* @returns {string} A string representation of the node with the sides and operator flipped
+			*/
+			function getFlippedString(node) {
+				let operatorToken = sourceCode.getFirstTokenBetween(node.left, node.right, (token) => token.value === node.operator), lastLeftToken = sourceCode.getTokenBefore(operatorToken), firstRightToken = sourceCode.getTokenAfter(operatorToken), source = sourceCode.getText(), leftText = source.slice(node.range[0], lastLeftToken.range[1]), textBeforeOperator = source.slice(lastLeftToken.range[1], operatorToken.range[0]), textAfterOperator = source.slice(operatorToken.range[1], firstRightToken.range[0]), rightText = source.slice(firstRightToken.range[0], node.range[1]), tokenBefore = sourceCode.getTokenBefore(node), tokenAfter = sourceCode.getTokenAfter(node), prefix = "", suffix = "";
+				return tokenBefore && tokenBefore.range[1] === node.range[0] && !astUtils.canTokensBeAdjacent(tokenBefore, firstRightToken) && (prefix = " "), tokenAfter && node.range[1] === tokenAfter.range[0] && !astUtils.canTokensBeAdjacent(lastLeftToken, tokenAfter) && (suffix = " "), prefix + rightText + textBeforeOperator + OPERATOR_FLIP_MAP[operatorToken.value] + textAfterOperator + leftText + suffix;
+			}
+			return { BinaryExpression(node) {
+				let expectedLiteral = always ? node.left : node.right, expectedNonLiteral = always ? node.right : node.left;
+				(expectedNonLiteral.type === "Literal" || looksLikeLiteral(expectedNonLiteral)) && !(expectedLiteral.type === "Literal" || looksLikeLiteral(expectedLiteral)) && !(!isEqualityOperator(node.operator) && onlyEquality) && isComparisonOperator(node.operator) && !(exceptRange && isRangeTest(node.parent)) && context.report({
+					node,
+					messageId: "expected",
+					data: {
+						operator: node.operator,
+						expectedSide: always ? "left" : "right"
+					},
+					fix: (fixer) => fixer.replaceText(node, getFlippedString(node))
+				});
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/yoda.cjs
+module.exports = require_yoda().create;
+//#endregion