oxlint-plugin-eslint 1.52.0

package/rules/space-in-parens.cjs

@@ -0,0 +1,175 @@
+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/space-in-parens.js
+/**
+* @fileoverview Disallows or enforces spaces inside of parentheses.
+* @author Jonathan Rajavuori
+* @deprecated in ESLint v8.53.0
+*/
+var require_space_in_parens = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t();
+	/** @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: "space-in-parens",
+						url: "https://eslint.style/rules/space-in-parens"
+					}
+				}]
+			},
+			type: "layout",
+			docs: {
+				description: "Enforce consistent spacing inside parentheses",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/space-in-parens"
+			},
+			fixable: "whitespace",
+			schema: [{ enum: ["always", "never"] }, {
+				type: "object",
+				properties: { exceptions: {
+					type: "array",
+					items: { enum: [
+						"{}",
+						"[]",
+						"()",
+						"empty"
+					] },
+					uniqueItems: !0
+				} },
+				additionalProperties: !1
+			}],
+			messages: {
+				missingOpeningSpace: "There must be a space after this paren.",
+				missingClosingSpace: "There must be a space before this paren.",
+				rejectedOpeningSpace: "There should be no space after this paren.",
+				rejectedClosingSpace: "There should be no space before this paren."
+			}
+		},
+		create(context) {
+			let ALWAYS = context.options[0] === "always", exceptionsArrayOptions = context.options[1] && context.options[1].exceptions || [], options = {}, exceptions;
+			exceptionsArrayOptions.length && (options.braceException = exceptionsArrayOptions.includes("{}"), options.bracketException = exceptionsArrayOptions.includes("[]"), options.parenException = exceptionsArrayOptions.includes("()"), options.empty = exceptionsArrayOptions.includes("empty"));
+			/**
+			* Produces an object with the opener and closer exception values
+			* @returns {Object} `openers` and `closers` exception values
+			* @private
+			*/
+			function getExceptions() {
+				let openers = [], closers = [];
+				return options.braceException && (openers.push("{"), closers.push("}")), options.bracketException && (openers.push("["), closers.push("]")), options.parenException && (openers.push("("), closers.push(")")), options.empty && (openers.push(")"), closers.push("(")), {
+					openers,
+					closers
+				};
+			}
+			let sourceCode = context.sourceCode;
+			/**
+			* Determines if a token is one of the exceptions for the opener paren
+			* @param {Object} token The token to check
+			* @returns {boolean} True if the token is one of the exceptions for the opener paren
+			*/
+			function isOpenerException(token) {
+				return exceptions.openers.includes(token.value);
+			}
+			/**
+			* Determines if a token is one of the exceptions for the closer paren
+			* @param {Object} token The token to check
+			* @returns {boolean} True if the token is one of the exceptions for the closer paren
+			*/
+			function isCloserException(token) {
+				return exceptions.closers.includes(token.value);
+			}
+			/**
+			* Determines if an opening paren is immediately followed by a required space
+			* @param {Object} openingParenToken The paren token
+			* @param {Object} tokenAfterOpeningParen The token after it
+			* @returns {boolean} True if the opening paren is missing a required space
+			*/
+			function openerMissingSpace(openingParenToken, tokenAfterOpeningParen) {
+				return sourceCode.isSpaceBetweenTokens(openingParenToken, tokenAfterOpeningParen) || !options.empty && astUtils.isClosingParenToken(tokenAfterOpeningParen) ? !1 : ALWAYS ? !isOpenerException(tokenAfterOpeningParen) : isOpenerException(tokenAfterOpeningParen);
+			}
+			/**
+			* Determines if an opening paren is immediately followed by a disallowed space
+			* @param {Object} openingParenToken The paren token
+			* @param {Object} tokenAfterOpeningParen The token after it
+			* @returns {boolean} True if the opening paren has a disallowed space
+			*/
+			function openerRejectsSpace(openingParenToken, tokenAfterOpeningParen) {
+				return !astUtils.isTokenOnSameLine(openingParenToken, tokenAfterOpeningParen) || tokenAfterOpeningParen.type === "Line" || !sourceCode.isSpaceBetweenTokens(openingParenToken, tokenAfterOpeningParen) ? !1 : ALWAYS ? isOpenerException(tokenAfterOpeningParen) : !isOpenerException(tokenAfterOpeningParen);
+			}
+			/**
+			* Determines if a closing paren is immediately preceded by a required space
+			* @param {Object} tokenBeforeClosingParen The token before the paren
+			* @param {Object} closingParenToken The paren token
+			* @returns {boolean} True if the closing paren is missing a required space
+			*/
+			function closerMissingSpace(tokenBeforeClosingParen, closingParenToken) {
+				return sourceCode.isSpaceBetweenTokens(tokenBeforeClosingParen, closingParenToken) || !options.empty && astUtils.isOpeningParenToken(tokenBeforeClosingParen) ? !1 : ALWAYS ? !isCloserException(tokenBeforeClosingParen) : isCloserException(tokenBeforeClosingParen);
+			}
+			/**
+			* Determines if a closer paren is immediately preceded by a disallowed space
+			* @param {Object} tokenBeforeClosingParen The token before the paren
+			* @param {Object} closingParenToken The paren token
+			* @returns {boolean} True if the closing paren has a disallowed space
+			*/
+			function closerRejectsSpace(tokenBeforeClosingParen, closingParenToken) {
+				return !astUtils.isTokenOnSameLine(tokenBeforeClosingParen, closingParenToken) || !sourceCode.isSpaceBetweenTokens(tokenBeforeClosingParen, closingParenToken) ? !1 : ALWAYS ? isCloserException(tokenBeforeClosingParen) : !isCloserException(tokenBeforeClosingParen);
+			}
+			return { Program: function checkParenSpaces(node) {
+				exceptions = getExceptions();
+				let tokens = sourceCode.tokensAndComments;
+				tokens.forEach((token, i) => {
+					let prevToken = tokens[i - 1], nextToken = tokens[i + 1];
+					!astUtils.isOpeningParenToken(token) && !astUtils.isClosingParenToken(token) || (token.value === "(" && openerMissingSpace(token, nextToken) && context.report({
+						node,
+						loc: token.loc,
+						messageId: "missingOpeningSpace",
+						fix(fixer) {
+							return fixer.insertTextAfter(token, " ");
+						}
+					}), token.value === "(" && openerRejectsSpace(token, nextToken) && context.report({
+						node,
+						loc: {
+							start: token.loc.end,
+							end: nextToken.loc.start
+						},
+						messageId: "rejectedOpeningSpace",
+						fix(fixer) {
+							return fixer.removeRange([token.range[1], nextToken.range[0]]);
+						}
+					}), token.value === ")" && closerMissingSpace(prevToken, token) && context.report({
+						node,
+						loc: token.loc,
+						messageId: "missingClosingSpace",
+						fix(fixer) {
+							return fixer.insertTextBefore(token, " ");
+						}
+					}), token.value === ")" && closerRejectsSpace(prevToken, token) && context.report({
+						node,
+						loc: {
+							start: prevToken.loc.end,
+							end: token.loc.start
+						},
+						messageId: "rejectedClosingSpace",
+						fix(fixer) {
+							return fixer.removeRange([prevToken.range[1], token.range[0]]);
+						}
+					}));
+				});
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/space-in-parens.cjs
+module.exports = require_space_in_parens().create;
+//#endregion

package/rules/space-infix-ops.cjs

@@ -0,0 +1,133 @@
+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/space-infix-ops.js
+/**
+* @fileoverview Require spaces around infix operators
+* @author Michael Ficarra
+* @deprecated in ESLint v8.53.0
+*/
+var require_space_infix_ops = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let { isEqToken } = require_ast_utils$1.t();
+	/** @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: "space-infix-ops",
+						url: "https://eslint.style/rules/space-infix-ops"
+					}
+				}]
+			},
+			type: "layout",
+			docs: {
+				description: "Require spacing around infix operators",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/space-infix-ops"
+			},
+			fixable: "whitespace",
+			schema: [{
+				type: "object",
+				properties: { int32Hint: {
+					type: "boolean",
+					default: !1
+				} },
+				additionalProperties: !1
+			}],
+			messages: { missingSpace: "Operator '{{operator}}' must be spaced." }
+		},
+		create(context) {
+			let int32Hint = context.options[0] ? context.options[0].int32Hint === !0 : !1, sourceCode = context.sourceCode;
+			/**
+			* Returns the first token which violates the rule
+			* @param {ASTNode} left The left node of the main node
+			* @param {ASTNode} right The right node of the main node
+			* @param {string} op The operator of the main node
+			* @returns {Object} The violator token or null
+			* @private
+			*/
+			function getFirstNonSpacedToken(left, right, op) {
+				let operator = sourceCode.getFirstTokenBetween(left, right, (token) => token.value === op), prev = sourceCode.getTokenBefore(operator), next = sourceCode.getTokenAfter(operator);
+				return !sourceCode.isSpaceBetweenTokens(prev, operator) || !sourceCode.isSpaceBetweenTokens(operator, next) ? operator : null;
+			}
+			/**
+			* Reports an AST node as a rule violation
+			* @param {ASTNode} mainNode The node to report
+			* @param {Object} culpritToken The token which has a problem
+			* @returns {void}
+			* @private
+			*/
+			function report(mainNode, culpritToken) {
+				context.report({
+					node: mainNode,
+					loc: culpritToken.loc,
+					messageId: "missingSpace",
+					data: { operator: culpritToken.value },
+					fix(fixer) {
+						let previousToken = sourceCode.getTokenBefore(culpritToken), afterToken = sourceCode.getTokenAfter(culpritToken), fixString = "";
+						return culpritToken.range[0] - previousToken.range[1] === 0 && (fixString = " "), fixString += culpritToken.value, afterToken.range[0] - culpritToken.range[1] === 0 && (fixString += " "), fixer.replaceText(culpritToken, fixString);
+					}
+				});
+			}
+			/**
+			* Check if the node is binary then report
+			* @param {ASTNode} node node to evaluate
+			* @returns {void}
+			* @private
+			*/
+			function checkBinary(node) {
+				let leftNode = node.left.typeAnnotation ? node.left.typeAnnotation : node.left, rightNode = node.right, nonSpacedNode = getFirstNonSpacedToken(leftNode, rightNode, node.operator || "=");
+				nonSpacedNode && (int32Hint && sourceCode.getText(node).endsWith("|0") || report(node, nonSpacedNode));
+			}
+			/**
+			* Check if the node is conditional
+			* @param {ASTNode} node node to evaluate
+			* @returns {void}
+			* @private
+			*/
+			function checkConditional(node) {
+				let nonSpacedConsequentNode = getFirstNonSpacedToken(node.test, node.consequent, "?"), nonSpacedAlternateNode = getFirstNonSpacedToken(node.consequent, node.alternate, ":");
+				nonSpacedConsequentNode && report(node, nonSpacedConsequentNode), nonSpacedAlternateNode && report(node, nonSpacedAlternateNode);
+			}
+			/**
+			* Check if the node is a variable
+			* @param {ASTNode} node node to evaluate
+			* @returns {void}
+			* @private
+			*/
+			function checkVar(node) {
+				let leftNode = node.id.typeAnnotation ? node.id.typeAnnotation : node.id, rightNode = node.init;
+				if (rightNode) {
+					let nonSpacedNode = getFirstNonSpacedToken(leftNode, rightNode, "=");
+					nonSpacedNode && report(node, nonSpacedNode);
+				}
+			}
+			return {
+				AssignmentExpression: checkBinary,
+				AssignmentPattern: checkBinary,
+				BinaryExpression: checkBinary,
+				LogicalExpression: checkBinary,
+				ConditionalExpression: checkConditional,
+				VariableDeclarator: checkVar,
+				PropertyDefinition(node) {
+					if (!node.value) return;
+					let operatorToken = sourceCode.getTokenBefore(node.value, isEqToken), leftToken = sourceCode.getTokenBefore(operatorToken), rightToken = sourceCode.getTokenAfter(operatorToken);
+					(!sourceCode.isSpaceBetweenTokens(leftToken, operatorToken) || !sourceCode.isSpaceBetweenTokens(operatorToken, rightToken)) && report(node, operatorToken);
+				}
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/space-infix-ops.cjs
+module.exports = require_space_infix_ops().create;
+//#endregion

package/rules/space-unary-ops.cjs

@@ -0,0 +1,237 @@
+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/space-unary-ops.js
+/**
+* @fileoverview This rule should require or disallow spaces before or after unary operations.
+* @author Marcin Kumorek
+* @deprecated in ESLint v8.53.0
+*/
+var require_space_unary_ops = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t();
+	/** @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: "space-unary-ops",
+						url: "https://eslint.style/rules/space-unary-ops"
+					}
+				}]
+			},
+			type: "layout",
+			docs: {
+				description: "Enforce consistent spacing before or after unary operators",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/space-unary-ops"
+			},
+			fixable: "whitespace",
+			schema: [{
+				type: "object",
+				properties: {
+					words: {
+						type: "boolean",
+						default: !0
+					},
+					nonwords: {
+						type: "boolean",
+						default: !1
+					},
+					overrides: {
+						type: "object",
+						additionalProperties: { type: "boolean" }
+					}
+				},
+				additionalProperties: !1
+			}],
+			messages: {
+				unexpectedBefore: "Unexpected space before unary operator '{{operator}}'.",
+				unexpectedAfter: "Unexpected space after unary operator '{{operator}}'.",
+				unexpectedAfterWord: "Unexpected space after unary word operator '{{word}}'.",
+				wordOperator: "Unary word operator '{{word}}' must be followed by whitespace.",
+				operator: "Unary operator '{{operator}}' must be followed by whitespace.",
+				beforeUnaryExpressions: "Space is required before unary expressions '{{token}}'."
+			}
+		},
+		create(context) {
+			let options = context.options[0] || {
+				words: !0,
+				nonwords: !1
+			}, sourceCode = context.sourceCode;
+			/**
+			* Check if the node is the first "!" in a "!!" convert to Boolean expression
+			* @param {ASTnode} node AST node
+			* @returns {boolean} Whether or not the node is first "!" in "!!"
+			*/
+			function isFirstBangInBangBangExpression(node) {
+				return node && node.type === "UnaryExpression" && node.argument.operator === "!" && node.argument && node.argument.type === "UnaryExpression" && node.argument.operator === "!";
+			}
+			/**
+			* Checks if an override exists for a given operator.
+			* @param {string} operator Operator
+			* @returns {boolean} Whether or not an override has been provided for the operator
+			*/
+			function overrideExistsForOperator(operator) {
+				return options.overrides && Object.hasOwn(options.overrides, operator);
+			}
+			/**
+			* Gets the value that the override was set to for this operator
+			* @param {string} operator Operator
+			* @returns {boolean} Whether or not an override enforces a space with this operator
+			*/
+			function overrideEnforcesSpaces(operator) {
+				return options.overrides[operator];
+			}
+			/**
+			* Verify Unary Word Operator has spaces after the word operator
+			* @param {ASTnode} node AST node
+			* @param {Object} firstToken first token from the AST node
+			* @param {Object} secondToken second token from the AST node
+			* @param {string} word The word to be used for reporting
+			* @returns {void}
+			*/
+			function verifyWordHasSpaces(node, firstToken, secondToken, word) {
+				secondToken.range[0] === firstToken.range[1] && context.report({
+					node,
+					messageId: "wordOperator",
+					data: { word },
+					fix(fixer) {
+						return fixer.insertTextAfter(firstToken, " ");
+					}
+				});
+			}
+			/**
+			* Verify Unary Word Operator doesn't have spaces after the word operator
+			* @param {ASTnode} node AST node
+			* @param {Object} firstToken first token from the AST node
+			* @param {Object} secondToken second token from the AST node
+			* @param {string} word The word to be used for reporting
+			* @returns {void}
+			*/
+			function verifyWordDoesntHaveSpaces(node, firstToken, secondToken, word) {
+				astUtils.canTokensBeAdjacent(firstToken, secondToken) && secondToken.range[0] > firstToken.range[1] && context.report({
+					node,
+					messageId: "unexpectedAfterWord",
+					data: { word },
+					fix(fixer) {
+						return fixer.removeRange([firstToken.range[1], secondToken.range[0]]);
+					}
+				});
+			}
+			/**
+			* Check Unary Word Operators for spaces after the word operator
+			* @param {ASTnode} node AST node
+			* @param {Object} firstToken first token from the AST node
+			* @param {Object} secondToken second token from the AST node
+			* @param {string} word The word to be used for reporting
+			* @returns {void}
+			*/
+			function checkUnaryWordOperatorForSpaces(node, firstToken, secondToken, word) {
+				overrideExistsForOperator(word) ? overrideEnforcesSpaces(word) ? verifyWordHasSpaces(node, firstToken, secondToken, word) : verifyWordDoesntHaveSpaces(node, firstToken, secondToken, word) : options.words ? verifyWordHasSpaces(node, firstToken, secondToken, word) : verifyWordDoesntHaveSpaces(node, firstToken, secondToken, word);
+			}
+			/**
+			* Verifies YieldExpressions satisfy spacing requirements
+			* @param {ASTnode} node AST node
+			* @returns {void}
+			*/
+			function checkForSpacesAfterYield(node) {
+				let tokens = sourceCode.getFirstTokens(node, 3);
+				!node.argument || node.delegate || checkUnaryWordOperatorForSpaces(node, tokens[0], tokens[1], "yield");
+			}
+			/**
+			* Verifies AwaitExpressions satisfy spacing requirements
+			* @param {ASTNode} node AwaitExpression AST node
+			* @returns {void}
+			*/
+			function checkForSpacesAfterAwait(node) {
+				let tokens = sourceCode.getFirstTokens(node, 3);
+				checkUnaryWordOperatorForSpaces(node, tokens[0], tokens[1], "await");
+			}
+			/**
+			* Verifies UnaryExpression, UpdateExpression and NewExpression have spaces before or after the operator
+			* @param {ASTnode} node AST node
+			* @param {Object} firstToken First token in the expression
+			* @param {Object} secondToken Second token in the expression
+			* @returns {void}
+			*/
+			function verifyNonWordsHaveSpaces(node, firstToken, secondToken) {
+				if (node.prefix) {
+					if (isFirstBangInBangBangExpression(node)) return;
+					firstToken.range[1] === secondToken.range[0] && context.report({
+						node,
+						messageId: "operator",
+						data: { operator: firstToken.value },
+						fix(fixer) {
+							return fixer.insertTextAfter(firstToken, " ");
+						}
+					});
+				} else firstToken.range[1] === secondToken.range[0] && context.report({
+					node,
+					messageId: "beforeUnaryExpressions",
+					data: { token: secondToken.value },
+					fix(fixer) {
+						return fixer.insertTextBefore(secondToken, " ");
+					}
+				});
+			}
+			/**
+			* Verifies UnaryExpression, UpdateExpression and NewExpression don't have spaces before or after the operator
+			* @param {ASTnode} node AST node
+			* @param {Object} firstToken First token in the expression
+			* @param {Object} secondToken Second token in the expression
+			* @returns {void}
+			*/
+			function verifyNonWordsDontHaveSpaces(node, firstToken, secondToken) {
+				node.prefix ? secondToken.range[0] > firstToken.range[1] && context.report({
+					node,
+					messageId: "unexpectedAfter",
+					data: { operator: firstToken.value },
+					fix(fixer) {
+						return astUtils.canTokensBeAdjacent(firstToken, secondToken) ? fixer.removeRange([firstToken.range[1], secondToken.range[0]]) : null;
+					}
+				}) : secondToken.range[0] > firstToken.range[1] && context.report({
+					node,
+					messageId: "unexpectedBefore",
+					data: { operator: secondToken.value },
+					fix(fixer) {
+						return fixer.removeRange([firstToken.range[1], secondToken.range[0]]);
+					}
+				});
+			}
+			/**
+			* Verifies UnaryExpression, UpdateExpression and NewExpression satisfy spacing requirements
+			* @param {ASTnode} node AST node
+			* @returns {void}
+			*/
+			function checkForSpaces(node) {
+				let tokens = node.type === "UpdateExpression" && !node.prefix ? sourceCode.getLastTokens(node, 2) : sourceCode.getFirstTokens(node, 2), firstToken = tokens[0], secondToken = tokens[1];
+				if ((node.type === "NewExpression" || node.prefix) && firstToken.type === "Keyword") {
+					checkUnaryWordOperatorForSpaces(node, firstToken, secondToken, firstToken.value);
+					return;
+				}
+				let operator = node.prefix ? tokens[0].value : tokens[1].value;
+				overrideExistsForOperator(operator) ? overrideEnforcesSpaces(operator) ? verifyNonWordsHaveSpaces(node, firstToken, secondToken) : verifyNonWordsDontHaveSpaces(node, firstToken, secondToken) : options.nonwords ? verifyNonWordsHaveSpaces(node, firstToken, secondToken) : verifyNonWordsDontHaveSpaces(node, firstToken, secondToken);
+			}
+			return {
+				UnaryExpression: checkForSpaces,
+				UpdateExpression: checkForSpaces,
+				NewExpression: checkForSpaces,
+				YieldExpression: checkForSpacesAfterYield,
+				AwaitExpression: checkForSpacesAfterAwait
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/space-unary-ops.cjs
+module.exports = require_space_unary_ops().create;
+//#endregion