oxlint-plugin-eslint 1.52.0

package/rules/no-warning-comments.cjs

@@ -0,0 +1,112 @@
+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-warning-comments.js
+/**
+* @fileoverview Rule that warns about used warning comments
+* @author Alexander Schmidt <https://github.com/lxanders>
+*/
+var require_no_warning_comments = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let escapeRegExp = require_ast_utils$1.n(), astUtils = require_ast_utils$1.t();
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			defaultOptions: [{
+				location: "start",
+				terms: [
+					"todo",
+					"fixme",
+					"xxx"
+				]
+			}],
+			docs: {
+				description: "Disallow specified warning terms in comments",
+				recommended: !1,
+				frozen: !0,
+				url: "https://eslint.org/docs/latest/rules/no-warning-comments"
+			},
+			schema: [{
+				type: "object",
+				properties: {
+					terms: {
+						type: "array",
+						items: { type: "string" }
+					},
+					location: { enum: ["start", "anywhere"] },
+					decoration: {
+						type: "array",
+						items: {
+							type: "string",
+							pattern: "^\\S$"
+						},
+						minItems: 1,
+						uniqueItems: !0
+					}
+				},
+				additionalProperties: !1
+			}],
+			messages: { unexpectedComment: "Unexpected '{{matchedTerm}}' comment: '{{comment}}'." }
+		},
+		create(context) {
+			let sourceCode = context.sourceCode, [{ decoration, location, terms: warningTerms }] = context.options, escapedDecoration = escapeRegExp(decoration ? decoration.join("") : ""), selfConfigRegEx = /\bno-warning-comments\b/u;
+			/**
+			* Convert a warning term into a RegExp which will match a comment containing that whole word in the specified
+			* location ("start" or "anywhere"). If the term starts or ends with non word characters, then the match will not
+			* require word boundaries on that side.
+			* @param {string} term A term to convert to a RegExp
+			* @returns {RegExp} The term converted to a RegExp
+			*/
+			function convertToRegExp(term) {
+				let escaped = escapeRegExp(term), prefix = "";
+				location === "start" ? prefix = `^[\\s${escapedDecoration}]*` : /^\w/u.test(term) && (prefix = "\\b");
+				let suffix = /\w$/u.test(term) ? "\\b" : "";
+				return RegExp(`${prefix}${escaped}${suffix}`, "iu");
+			}
+			let warningRegExps = warningTerms.map(convertToRegExp);
+			/**
+			* Checks the specified comment for matches of the configured warning terms and returns the matches.
+			* @param {string} comment The comment which is checked.
+			* @returns {Array} All matched warning terms for this comment.
+			*/
+			function commentContainsWarningTerm(comment) {
+				let matches = [];
+				return warningRegExps.forEach((regex, index) => {
+					regex.test(comment) && matches.push(warningTerms[index]);
+				}), matches;
+			}
+			/**
+			* Checks the specified node for matching warning comments and reports them.
+			* @param {ASTNode} node The AST node being checked.
+			* @returns {void} undefined.
+			*/
+			function checkComment(node) {
+				let comment = node.value;
+				astUtils.isDirectiveComment(node) && selfConfigRegEx.test(comment) || commentContainsWarningTerm(comment).forEach((matchedTerm) => {
+					let commentToDisplay = "", truncated = !1;
+					for (let c of comment.trim().split(/\s+/u)) {
+						let tmp = commentToDisplay ? `${commentToDisplay} ${c}` : c;
+						if (tmp.length <= 40) commentToDisplay = tmp;
+						else {
+							truncated = !0;
+							break;
+						}
+					}
+					context.report({
+						node,
+						messageId: "unexpectedComment",
+						data: {
+							matchedTerm,
+							comment: `${commentToDisplay}${truncated ? "..." : ""}`
+						}
+					});
+				});
+			}
+			return { Program() {
+				sourceCode.getAllComments().filter((token) => token.type !== "Shebang").forEach(checkComment);
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-warning-comments.cjs
+module.exports = require_no_warning_comments().create;
+//#endregion

package/rules/no-whitespace-before-property.cjs

@@ -0,0 +1,72 @@
+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-whitespace-before-property.js
+/**
+* @fileoverview Rule to disallow whitespace before properties
+* @author Kai Cataldo
+* @deprecated in ESLint v8.53.0
+*/
+var require_no_whitespace_before_property = /* @__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: "no-whitespace-before-property",
+						url: "https://eslint.style/rules/no-whitespace-before-property"
+					}
+				}]
+			},
+			type: "layout",
+			docs: {
+				description: "Disallow whitespace before properties",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/no-whitespace-before-property"
+			},
+			fixable: "whitespace",
+			schema: [],
+			messages: { unexpectedWhitespace: "Unexpected whitespace before property {{propName}}." }
+		},
+		create(context) {
+			let sourceCode = context.sourceCode;
+			/**
+			* Reports whitespace before property token
+			* @param {ASTNode} node the node to report in the event of an error
+			* @param {Token} leftToken the left token
+			* @param {Token} rightToken the right token
+			* @returns {void}
+			* @private
+			*/
+			function reportError(node, leftToken, rightToken) {
+				context.report({
+					node,
+					messageId: "unexpectedWhitespace",
+					data: { propName: sourceCode.getText(node.property) },
+					fix(fixer) {
+						let replacementText = "";
+						return !node.computed && !node.optional && astUtils.isDecimalInteger(node.object) || sourceCode.commentsExistBetween(leftToken, rightToken) ? null : (node.optional ? replacementText = "?." : node.computed || (replacementText = "."), fixer.replaceTextRange([leftToken.range[1], rightToken.range[0]], replacementText));
+					}
+				});
+			}
+			return { MemberExpression(node) {
+				let rightToken, leftToken;
+				astUtils.isTokenOnSameLine(node.object, node.property) && (node.computed ? (rightToken = sourceCode.getTokenBefore(node.property, astUtils.isOpeningBracketToken), leftToken = sourceCode.getTokenBefore(rightToken, node.optional ? 1 : 0)) : (rightToken = sourceCode.getFirstToken(node.property), leftToken = sourceCode.getTokenBefore(rightToken, 1)), sourceCode.isSpaceBetweenTokens(leftToken, rightToken) && reportError(node, leftToken, rightToken));
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-whitespace-before-property.cjs
+module.exports = require_no_whitespace_before_property().create;
+//#endregion

package/rules/no-with.cjs

@@ -0,0 +1,32 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/no-with.js
+/**
+* @fileoverview Rule to flag use of with statement
+* @author Nicholas C. Zakas
+*/
+var require_no_with = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Disallow `with` statements",
+				recommended: !0,
+				url: "https://eslint.org/docs/latest/rules/no-with"
+			},
+			schema: [],
+			messages: { unexpectedWith: "Unexpected use of 'with' statement." }
+		},
+		create(context) {
+			return { WithStatement(node) {
+				context.report({
+					node,
+					messageId: "unexpectedWith"
+				});
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-with.cjs
+module.exports = require_no_with().create;
+//#endregion

package/rules/nonblock-statement-body-position.cjs

@@ -0,0 +1,107 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/nonblock-statement-body-position.js
+/**
+* @fileoverview enforce the location of single-line statements
+* @author Teddy Katz
+* @deprecated in ESLint v8.53.0
+*/
+var require_nonblock_statement_body_position = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	let POSITION_SCHEMA = { enum: [
+		"beside",
+		"below",
+		"any"
+	] };
+	/** @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: "nonblock-statement-body-position",
+						url: "https://eslint.style/rules/nonblock-statement-body-position"
+					}
+				}]
+			},
+			type: "layout",
+			docs: {
+				description: "Enforce the location of single-line statements",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/nonblock-statement-body-position"
+			},
+			fixable: "whitespace",
+			schema: [POSITION_SCHEMA, {
+				properties: { overrides: {
+					properties: {
+						if: POSITION_SCHEMA,
+						else: POSITION_SCHEMA,
+						while: POSITION_SCHEMA,
+						do: POSITION_SCHEMA,
+						for: POSITION_SCHEMA
+					},
+					additionalProperties: !1
+				} },
+				additionalProperties: !1
+			}],
+			messages: {
+				expectNoLinebreak: "Expected no linebreak before this statement.",
+				expectLinebreak: "Expected a linebreak before this statement."
+			}
+		},
+		create(context) {
+			let sourceCode = context.sourceCode;
+			/**
+			* Gets the applicable preference for a particular keyword
+			* @param {string} keywordName The name of a keyword, e.g. 'if'
+			* @returns {string} The applicable option for the keyword, e.g. 'beside'
+			*/
+			function getOption(keywordName) {
+				return context.options[1] && context.options[1].overrides && context.options[1].overrides[keywordName] || context.options[0] || "beside";
+			}
+			/**
+			* Validates the location of a single-line statement
+			* @param {ASTNode} node The single-line statement
+			* @param {string} keywordName The applicable keyword name for the single-line statement
+			* @returns {void}
+			*/
+			function validateStatement(node, keywordName) {
+				let option = getOption(keywordName);
+				if (node.type === "BlockStatement" || option === "any") return;
+				let tokenBefore = sourceCode.getTokenBefore(node);
+				tokenBefore.loc.end.line === node.loc.start.line && option === "below" ? context.report({
+					node,
+					messageId: "expectLinebreak",
+					fix: (fixer) => fixer.insertTextBefore(node, "\n")
+				}) : tokenBefore.loc.end.line !== node.loc.start.line && option === "beside" && context.report({
+					node,
+					messageId: "expectNoLinebreak",
+					fix(fixer) {
+						return sourceCode.getText().slice(tokenBefore.range[1], node.range[0]).trim() ? null : fixer.replaceTextRange([tokenBefore.range[1], node.range[0]], " ");
+					}
+				});
+			}
+			return {
+				IfStatement(node) {
+					validateStatement(node.consequent, "if"), node.alternate && node.alternate.type !== "IfStatement" && validateStatement(node.alternate, "else");
+				},
+				WhileStatement: (node) => validateStatement(node.body, "while"),
+				DoWhileStatement: (node) => validateStatement(node.body, "do"),
+				ForStatement: (node) => validateStatement(node.body, "for"),
+				ForInStatement: (node) => validateStatement(node.body, "for"),
+				ForOfStatement: (node) => validateStatement(node.body, "for")
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/nonblock-statement-body-position.cjs
+module.exports = require_nonblock_statement_body_position().create;
+//#endregion

package/rules/object-curly-newline.cjs

@@ -0,0 +1,194 @@
+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/object-curly-newline.js
+/**
+* @fileoverview Rule to require or disallow line breaks inside braces.
+* @author Toru Nagashima
+* @deprecated in ESLint v8.53.0
+*/
+var require_object_curly_newline = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t(), OPTION_VALUE = { oneOf: [{ enum: ["always", "never"] }, {
+		type: "object",
+		properties: {
+			multiline: { type: "boolean" },
+			minProperties: {
+				type: "integer",
+				minimum: 0
+			},
+			consistent: { type: "boolean" }
+		},
+		additionalProperties: !1,
+		minProperties: 1
+	}] };
+	/**
+	* Normalizes a given option value.
+	* @param {string|Object|undefined} value An option value to parse.
+	* @returns {{multiline: boolean, minProperties: number, consistent: boolean}} Normalized option object.
+	*/
+	function normalizeOptionValue(value) {
+		let multiline = !1, minProperties = Infinity, consistent = !1;
+		return value ? value === "always" ? minProperties = 0 : value === "never" ? minProperties = Infinity : (multiline = !!value.multiline, minProperties = value.minProperties || Infinity, consistent = !!value.consistent) : consistent = !0, {
+			multiline,
+			minProperties,
+			consistent
+		};
+	}
+	/**
+	* Checks if a value is an object.
+	* @param {any} value The value to check
+	* @returns {boolean} `true` if the value is an object, otherwise `false`
+	*/
+	function isObject(value) {
+		return typeof value == "object" && !!value;
+	}
+	/**
+	* Checks if an option is a node-specific option
+	* @param {any} option The option to check
+	* @returns {boolean} `true` if the option is node-specific, otherwise `false`
+	*/
+	function isNodeSpecificOption(option) {
+		return isObject(option) || typeof option == "string";
+	}
+	/**
+	* Normalizes a given option value.
+	* @param {string|Object|undefined} options An option value to parse.
+	* @returns {{
+	*   ObjectExpression: {multiline: boolean, minProperties: number, consistent: boolean},
+	*   ObjectPattern: {multiline: boolean, minProperties: number, consistent: boolean},
+	*   ImportDeclaration: {multiline: boolean, minProperties: number, consistent: boolean},
+	*   ExportNamedDeclaration : {multiline: boolean, minProperties: number, consistent: boolean}
+	* }} Normalized option object.
+	*/
+	function normalizeOptions(options) {
+		if (isObject(options) && Object.values(options).some(isNodeSpecificOption)) return {
+			ObjectExpression: normalizeOptionValue(options.ObjectExpression),
+			ObjectPattern: normalizeOptionValue(options.ObjectPattern),
+			ImportDeclaration: normalizeOptionValue(options.ImportDeclaration),
+			ExportNamedDeclaration: normalizeOptionValue(options.ExportDeclaration)
+		};
+		let value = normalizeOptionValue(options);
+		return {
+			ObjectExpression: value,
+			ObjectPattern: value,
+			ImportDeclaration: value,
+			ExportNamedDeclaration: value
+		};
+	}
+	/**
+	* Determines if ObjectExpression, ObjectPattern, ImportDeclaration or ExportNamedDeclaration
+	* node needs to be checked for missing line breaks
+	* @param {ASTNode} node Node under inspection
+	* @param {Object} options option specific to node type
+	* @param {Token} first First object property
+	* @param {Token} last Last object property
+	* @returns {boolean} `true` if node needs to be checked for missing line breaks
+	*/
+	function areLineBreaksRequired(node, options, first, last) {
+		let objectProperties;
+		return objectProperties = node.type === "ObjectExpression" || node.type === "ObjectPattern" ? node.properties : node.specifiers.filter((s) => s.type === "ImportSpecifier" || s.type === "ExportSpecifier"), objectProperties.length >= options.minProperties || options.multiline && objectProperties.length > 0 && first.loc.start.line !== last.loc.end.line;
+	}
+	/** @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: "object-curly-newline",
+						url: "https://eslint.style/rules/object-curly-newline"
+					}
+				}]
+			},
+			type: "layout",
+			docs: {
+				description: "Enforce consistent line breaks after opening and before closing braces",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/object-curly-newline"
+			},
+			fixable: "whitespace",
+			schema: [{ oneOf: [OPTION_VALUE, {
+				type: "object",
+				properties: {
+					ObjectExpression: OPTION_VALUE,
+					ObjectPattern: OPTION_VALUE,
+					ImportDeclaration: OPTION_VALUE,
+					ExportDeclaration: OPTION_VALUE
+				},
+				additionalProperties: !1,
+				minProperties: 1
+			}] }],
+			messages: {
+				unexpectedLinebreakBeforeClosingBrace: "Unexpected line break before this closing brace.",
+				unexpectedLinebreakAfterOpeningBrace: "Unexpected line break after this opening brace.",
+				expectedLinebreakBeforeClosingBrace: "Expected a line break before this closing brace.",
+				expectedLinebreakAfterOpeningBrace: "Expected a line break after this opening brace."
+			}
+		},
+		create(context) {
+			let sourceCode = context.sourceCode, normalizedOptions = normalizeOptions(context.options[0]);
+			/**
+			* Reports a given node if it violated this rule.
+			* @param {ASTNode} node A node to check. This is an ObjectExpression, ObjectPattern, ImportDeclaration or ExportNamedDeclaration node.
+			* @returns {void}
+			*/
+			function check(node) {
+				let options = normalizedOptions[node.type];
+				if (node.type === "ImportDeclaration" && !node.specifiers.some((specifier) => specifier.type === "ImportSpecifier") || node.type === "ExportNamedDeclaration" && !node.specifiers.some((specifier) => specifier.type === "ExportSpecifier")) return;
+				let openBrace = sourceCode.getFirstToken(node, (token) => token.value === "{"), closeBrace;
+				closeBrace = node.typeAnnotation ? sourceCode.getTokenBefore(node.typeAnnotation) : sourceCode.getLastToken(node, (token) => token.value === "}");
+				let first = sourceCode.getTokenAfter(openBrace, { includeComments: !0 }), last = sourceCode.getTokenBefore(closeBrace, { includeComments: !0 }), needsLineBreaks = areLineBreaksRequired(node, options, first, last), hasCommentsFirstToken = astUtils.isCommentToken(first), hasCommentsLastToken = astUtils.isCommentToken(last);
+				if (first = sourceCode.getTokenAfter(openBrace), last = sourceCode.getTokenBefore(closeBrace), needsLineBreaks) astUtils.isTokenOnSameLine(openBrace, first) && context.report({
+					messageId: "expectedLinebreakAfterOpeningBrace",
+					node,
+					loc: openBrace.loc,
+					fix(fixer) {
+						return hasCommentsFirstToken ? null : fixer.insertTextAfter(openBrace, "\n");
+					}
+				}), astUtils.isTokenOnSameLine(last, closeBrace) && context.report({
+					messageId: "expectedLinebreakBeforeClosingBrace",
+					node,
+					loc: closeBrace.loc,
+					fix(fixer) {
+						return hasCommentsLastToken ? null : fixer.insertTextBefore(closeBrace, "\n");
+					}
+				});
+				else {
+					let consistent = options.consistent, hasLineBreakBetweenOpenBraceAndFirst = !astUtils.isTokenOnSameLine(openBrace, first), hasLineBreakBetweenCloseBraceAndLast = !astUtils.isTokenOnSameLine(last, closeBrace);
+					(!consistent && hasLineBreakBetweenOpenBraceAndFirst || consistent && hasLineBreakBetweenOpenBraceAndFirst && !hasLineBreakBetweenCloseBraceAndLast) && context.report({
+						messageId: "unexpectedLinebreakAfterOpeningBrace",
+						node,
+						loc: openBrace.loc,
+						fix(fixer) {
+							return hasCommentsFirstToken ? null : fixer.removeRange([openBrace.range[1], first.range[0]]);
+						}
+					}), (!consistent && hasLineBreakBetweenCloseBraceAndLast || consistent && !hasLineBreakBetweenOpenBraceAndFirst && hasLineBreakBetweenCloseBraceAndLast) && context.report({
+						messageId: "unexpectedLinebreakBeforeClosingBrace",
+						node,
+						loc: closeBrace.loc,
+						fix(fixer) {
+							return hasCommentsLastToken ? null : fixer.removeRange([last.range[1], closeBrace.range[0]]);
+						}
+					});
+				}
+			}
+			return {
+				ObjectExpression: check,
+				ObjectPattern: check,
+				ImportDeclaration: check,
+				ExportNamedDeclaration: check
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/object-curly-newline.cjs
+module.exports = require_object_curly_newline().create;
+//#endregion