oxlint-plugin-eslint 1.52.0

package/rules/id-denylist.cjs

@@ -0,0 +1,126 @@
+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/id-denylist.js
+/**
+* @fileoverview Rule that warns when identifier names that are
+* specified in the configuration are used.
+* @author Keith Cirkel (http://keithcirkel.co.uk)
+*/
+var require_id_denylist = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t();
+	/**
+	* Checks whether the given node represents assignment target in a normal assignment or destructuring.
+	* @param {ASTNode} node The node to check.
+	* @returns {boolean} `true` if the node is assignment target.
+	*/
+	function isAssignmentTarget(node) {
+		let parent = node.parent;
+		return parent.type === "AssignmentExpression" && parent.left === node || parent.type === "ArrayPattern" || parent.type === "RestElement" || parent.type === "Property" && parent.value === node && parent.parent.type === "ObjectPattern" || parent.type === "AssignmentPattern" && parent.left === node;
+	}
+	/**
+	* Checks whether the given node represents an imported name that is renamed in the same import/export specifier.
+	*
+	* Examples:
+	* import { a as b } from 'mod'; // node `a` is renamed import
+	* export { a as b } from 'mod'; // node `a` is renamed import
+	* @param {ASTNode} node `Identifier` node to check.
+	* @returns {boolean} `true` if the node is a renamed import.
+	*/
+	function isRenamedImport(node) {
+		let parent = node.parent;
+		return parent.type === "ImportSpecifier" && parent.imported !== parent.local && parent.imported === node || parent.type === "ExportSpecifier" && parent.parent.source && parent.local !== parent.exported && parent.local === node;
+	}
+	/**
+	* Checks whether the given node is an ObjectPattern destructuring.
+	*
+	* Examples:
+	* const { a : b } = foo;
+	* @param {ASTNode} node `Identifier` node to check.
+	* @returns {boolean} `true` if the node is in an ObjectPattern destructuring.
+	*/
+	function isPropertyNameInDestructuring(node) {
+		let parent = node.parent;
+		return !parent.computed && parent.type === "Property" && parent.parent.type === "ObjectPattern" && parent.key === node;
+	}
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			defaultOptions: [],
+			docs: {
+				description: "Disallow specified identifiers",
+				recommended: !1,
+				frozen: !0,
+				url: "https://eslint.org/docs/latest/rules/id-denylist"
+			},
+			schema: {
+				type: "array",
+				items: { type: "string" },
+				uniqueItems: !0
+			},
+			messages: {
+				restricted: "Identifier '{{name}}' is restricted.",
+				restrictedPrivate: "Identifier '#{{name}}' is restricted."
+			}
+		},
+		create(context) {
+			let denyList = new Set(context.options), reportedNodes = /* @__PURE__ */ new Set(), sourceCode = context.sourceCode, globalScope;
+			/**
+			* Checks whether the given name is restricted.
+			* @param {string} name The name to check.
+			* @returns {boolean} `true` if the name is restricted.
+			* @private
+			*/
+			function isRestricted(name) {
+				return denyList.has(name);
+			}
+			/**
+			* Checks whether the given node represents a reference to a global variable that is not declared in the source code.
+			* These identifiers will be allowed, as it is assumed that user has no control over the names of external global variables.
+			* @param {ASTNode} node `Identifier` node to check.
+			* @returns {boolean} `true` if the node is a reference to a global variable.
+			*/
+			function isReferenceToGlobalVariable(node) {
+				let variable = globalScope.set.get(node.name);
+				return variable && variable.defs.length === 0 && variable.references.some((ref) => ref.identifier === node);
+			}
+			/**
+			* Determines whether the given node should be checked.
+			* @param {ASTNode} node `Identifier` node.
+			* @returns {boolean} `true` if the node should be checked.
+			*/
+			function shouldCheck(node) {
+				if (astUtils.isImportAttributeKey(node)) return !1;
+				let parent = node.parent;
+				return parent.type === "MemberExpression" && parent.property === node && !parent.computed ? isAssignmentTarget(parent) : parent.type !== "CallExpression" && parent.type !== "NewExpression" && !isRenamedImport(node) && !isPropertyNameInDestructuring(node) && !isReferenceToGlobalVariable(node);
+			}
+			/**
+			* Reports an AST node as a rule violation.
+			* @param {ASTNode} node The node to report.
+			* @returns {void}
+			* @private
+			*/
+			function report(node) {
+				if (!reportedNodes.has(node.range.toString())) {
+					let isPrivate = node.type === "PrivateIdentifier";
+					context.report({
+						node,
+						messageId: isPrivate ? "restrictedPrivate" : "restricted",
+						data: { name: node.name }
+					}), reportedNodes.add(node.range.toString());
+				}
+			}
+			return {
+				Program(node) {
+					globalScope = sourceCode.getScope(node);
+				},
+				[["Identifier", "PrivateIdentifier"]](node) {
+					isRestricted(node.name) && shouldCheck(node) && report(node);
+				}
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/id-denylist.cjs
+module.exports = require_id_denylist().create;
+//#endregion

package/rules/id-length.cjs

@@ -0,0 +1,119 @@
+const require_chunk = require("../common/chunk.cjs"), require_ast_utils$1 = require("../common/ast-utils.cjs"), require_string_utils$1 = require("../common/string-utils.cjs");
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/id-length.js
+/**
+* @fileoverview Rule that warns when identifier names are shorter or longer
+* than the values provided in configuration.
+* @author Burak Yigit Kaya aka BYK
+*/
+var require_id_length = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let { getGraphemeCount } = require_string_utils$1.t(), { getModuleExportName, isImportAttributeKey } = require_ast_utils$1.t();
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			defaultOptions: [{
+				exceptionPatterns: [],
+				exceptions: [],
+				min: 2,
+				properties: "always"
+			}],
+			docs: {
+				description: "Enforce minimum and maximum identifier lengths",
+				recommended: !1,
+				frozen: !0,
+				url: "https://eslint.org/docs/latest/rules/id-length"
+			},
+			schema: [{
+				type: "object",
+				properties: {
+					min: { type: "integer" },
+					max: { type: "integer" },
+					exceptions: {
+						type: "array",
+						uniqueItems: !0,
+						items: { type: "string" }
+					},
+					exceptionPatterns: {
+						type: "array",
+						uniqueItems: !0,
+						items: { type: "string" }
+					},
+					properties: { enum: ["always", "never"] }
+				},
+				additionalProperties: !1
+			}],
+			messages: {
+				tooShort: "Identifier name '{{name}}' is too short (< {{min}}).",
+				tooShortPrivate: "Identifier name '#{{name}}' is too short (< {{min}}).",
+				tooLong: "Identifier name '{{name}}' is too long (> {{max}}).",
+				tooLongPrivate: "Identifier name #'{{name}}' is too long (> {{max}})."
+			}
+		},
+		create(context) {
+			let [options] = context.options, { max: maxLength = Infinity, min: minLength } = options, properties = options.properties !== "never", exceptions = new Set(options.exceptions), exceptionPatterns = options.exceptionPatterns.map((pattern) => new RegExp(pattern, "u")), reportedNodes = /* @__PURE__ */ new Set();
+			/**
+			* Checks if a string matches the provided exception patterns
+			* @param {string} name The string to check.
+			* @returns {boolean} if the string is a match
+			* @private
+			*/
+			function matchesExceptionPattern(name) {
+				return exceptionPatterns.some((pattern) => pattern.test(name));
+			}
+			let SUPPORTED_EXPRESSIONS = {
+				MemberExpression: properties && function(parent) {
+					return !parent.computed && (parent.parent.left === parent && parent.parent.type === "AssignmentExpression" || parent.parent.type === "Property" && parent.parent.value === parent && parent.parent.parent.type === "ObjectPattern" && parent.parent.parent.parent.left === parent.parent.parent);
+				},
+				AssignmentPattern(parent, node) {
+					return parent.left === node;
+				},
+				VariableDeclarator(parent, node) {
+					return parent.id === node;
+				},
+				Property(parent, node) {
+					if (parent.parent.type === "ObjectPattern") {
+						let isKeyAndValueSame = parent.value.name === parent.key.name;
+						return !isKeyAndValueSame && parent.value === node || isKeyAndValueSame && parent.key === node && properties;
+					}
+					return properties && !isImportAttributeKey(node) && !parent.computed && parent.key.name === node.name;
+				},
+				ImportSpecifier(parent, node) {
+					return parent.local === node && getModuleExportName(parent.imported) !== getModuleExportName(parent.local);
+				},
+				ImportDefaultSpecifier: !0,
+				ImportNamespaceSpecifier: !0,
+				RestElement: !0,
+				FunctionExpression: !0,
+				ArrowFunctionExpression: !0,
+				ClassDeclaration: !0,
+				FunctionDeclaration: !0,
+				MethodDefinition: !0,
+				PropertyDefinition: !0,
+				CatchClause: !0,
+				ArrayPattern: !0
+			};
+			return { [["Identifier", "PrivateIdentifier"]](node) {
+				let name = node.name, parent = node.parent, nameLength = getGraphemeCount(name), isShort = nameLength < minLength;
+				if (!(isShort || nameLength > maxLength) || exceptions.has(name) || matchesExceptionPattern(name)) return;
+				let isValidExpression = SUPPORTED_EXPRESSIONS[parent.type];
+				if (isValidExpression && !reportedNodes.has(node.range.toString()) && (isValidExpression === !0 || isValidExpression(parent, node))) {
+					reportedNodes.add(node.range.toString());
+					let messageId = isShort ? "tooShort" : "tooLong";
+					node.type === "PrivateIdentifier" && (messageId += "Private"), context.report({
+						node,
+						messageId,
+						data: {
+							name,
+							min: minLength,
+							max: maxLength
+						}
+					});
+				}
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/id-length.cjs
+module.exports = require_id_length().create;
+//#endregion

package/rules/id-match.cjs

@@ -0,0 +1,139 @@
+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/id-match.js
+/**
+* @fileoverview Rule to flag non-matching identifiers
+* @author Matthieu Larcher
+*/
+var require_id_match = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t();
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			defaultOptions: ["^.+$", {
+				classFields: !1,
+				ignoreDestructuring: !1,
+				onlyDeclarations: !1,
+				properties: !1
+			}],
+			docs: {
+				description: "Require identifiers to match a specified regular expression",
+				recommended: !1,
+				frozen: !0,
+				url: "https://eslint.org/docs/latest/rules/id-match"
+			},
+			schema: [{ type: "string" }, {
+				type: "object",
+				properties: {
+					properties: { type: "boolean" },
+					classFields: { type: "boolean" },
+					onlyDeclarations: { type: "boolean" },
+					ignoreDestructuring: { type: "boolean" }
+				},
+				additionalProperties: !1
+			}],
+			messages: {
+				notMatch: "Identifier '{{name}}' does not match the pattern '{{pattern}}'.",
+				notMatchPrivate: "Identifier '#{{name}}' does not match the pattern '{{pattern}}'."
+			}
+		},
+		create(context) {
+			let [pattern, { classFields: checkClassFields, ignoreDestructuring, onlyDeclarations, properties: checkProperties }] = context.options, regexp = new RegExp(pattern, "u"), sourceCode = context.sourceCode, globalScope, reportedNodes = /* @__PURE__ */ new Set(), ALLOWED_PARENT_TYPES = new Set(["CallExpression", "NewExpression"]), DECLARATION_TYPES = new Set(["FunctionDeclaration", "VariableDeclarator"]), IMPORT_TYPES = new Set([
+				"ImportSpecifier",
+				"ImportNamespaceSpecifier",
+				"ImportDefaultSpecifier"
+			]);
+			/**
+			* Checks whether the given node represents a reference to a global variable that is not declared in the source code.
+			* These identifiers will be allowed, as it is assumed that user has no control over the names of external global variables.
+			* @param {ASTNode} node `Identifier` node to check.
+			* @returns {boolean} `true` if the node is a reference to a global variable.
+			*/
+			function isReferenceToGlobalVariable(node) {
+				let variable = globalScope.set.get(node.name);
+				return variable && variable.defs.length === 0 && variable.references.some((ref) => ref.identifier === node);
+			}
+			/**
+			* Checks if a string matches the provided pattern
+			* @param {string} name The string to check.
+			* @returns {boolean} if the string is a match
+			* @private
+			*/
+			function isInvalid(name) {
+				return !regexp.test(name);
+			}
+			/**
+			* Checks if a parent of a node is an ObjectPattern.
+			* @param {ASTNode} node The node to check.
+			* @returns {boolean} if the node is inside an ObjectPattern
+			* @private
+			*/
+			function isInsideObjectPattern(node) {
+				let { parent } = node;
+				for (; parent;) {
+					if (parent.type === "ObjectPattern") return !0;
+					parent = parent.parent;
+				}
+				return !1;
+			}
+			/**
+			* Verifies if we should report an error or not based on the effective
+			* parent node and the identifier name.
+			* @param {ASTNode} effectiveParent The effective parent node of the node to be reported
+			* @param {string} name The identifier name of the identifier node
+			* @returns {boolean} whether an error should be reported or not
+			*/
+			function shouldReport(effectiveParent, name) {
+				return (!onlyDeclarations || DECLARATION_TYPES.has(effectiveParent.type)) && !ALLOWED_PARENT_TYPES.has(effectiveParent.type) && isInvalid(name);
+			}
+			/**
+			* Reports an AST node as a rule violation.
+			* @param {ASTNode} node The node to report.
+			* @returns {void}
+			* @private
+			*/
+			function report(node) {
+				if (!reportedNodes.has(node.range.toString())) {
+					let messageId = node.type === "PrivateIdentifier" ? "notMatchPrivate" : "notMatch";
+					context.report({
+						node,
+						messageId,
+						data: {
+							name: node.name,
+							pattern
+						}
+					}), reportedNodes.add(node.range.toString());
+				}
+			}
+			return {
+				Program(node) {
+					globalScope = sourceCode.getScope(node);
+				},
+				Identifier(node) {
+					let name = node.name, parent = node.parent, effectiveParent = parent.type === "MemberExpression" ? parent.parent : parent;
+					if (!(isReferenceToGlobalVariable(node) || astUtils.isImportAttributeKey(node))) if (parent.type === "MemberExpression") {
+						if (!checkProperties) return;
+						parent.object.type === "Identifier" && parent.object.name === name || effectiveParent.type === "AssignmentExpression" && effectiveParent.left.type === "MemberExpression" && effectiveParent.left.property.name === node.name ? isInvalid(name) && report(node) : effectiveParent.type === "AssignmentExpression" && effectiveParent.right.type !== "MemberExpression" && isInvalid(name) && report(node);
+					} else if (parent.type === "Property" && parent.parent.type === "ObjectExpression" && parent.key === node && !parent.computed) checkProperties && isInvalid(name) && report(node);
+					else if (parent.type === "Property" || parent.type === "AssignmentPattern") {
+						if (parent.parent && parent.parent.type === "ObjectPattern") {
+							!ignoreDestructuring && parent.shorthand && parent.value.left && isInvalid(name) && report(node);
+							let assignmentKeyEqualsValue = parent.key.name === parent.value.name;
+							if (!assignmentKeyEqualsValue && parent.key === node) return;
+							parent.value.name && isInvalid(name) && !(assignmentKeyEqualsValue && ignoreDestructuring) && report(node);
+						}
+						if (!checkProperties && !parent.computed || ignoreDestructuring && isInsideObjectPattern(node)) return;
+						parent.right !== node && shouldReport(effectiveParent, name) && report(node);
+					} else IMPORT_TYPES.has(parent.type) ? parent.local && parent.local.name === node.name && isInvalid(name) && report(node) : parent.type === "PropertyDefinition" ? checkClassFields && isInvalid(name) && report(node) : shouldReport(effectiveParent, name) && report(node);
+				},
+				PrivateIdentifier(node) {
+					node.parent.type === "PropertyDefinition" && !checkClassFields || isInvalid(node.name) && report(node);
+				}
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/id-match.cjs
+module.exports = require_id_match().create;
+//#endregion

package/rules/implicit-arrow-linebreak.cjs

@@ -0,0 +1,76 @@
+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/implicit-arrow-linebreak.js
+/**
+* @fileoverview enforce the location of arrow function bodies
+* @author Sharmila Jesupaul
+* @deprecated in ESLint v8.53.0
+*/
+var require_implicit_arrow_linebreak = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let { isCommentToken, isNotOpeningParenToken } = 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: "implicit-arrow-linebreak",
+						url: "https://eslint.style/rules/implicit-arrow-linebreak"
+					}
+				}]
+			},
+			type: "layout",
+			docs: {
+				description: "Enforce the location of arrow function bodies",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/implicit-arrow-linebreak"
+			},
+			fixable: "whitespace",
+			schema: [{ enum: ["beside", "below"] }],
+			messages: {
+				expected: "Expected a linebreak before this expression.",
+				unexpected: "Expected no linebreak before this expression."
+			}
+		},
+		create(context) {
+			let sourceCode = context.sourceCode, option = context.options[0] || "beside";
+			/**
+			* Validates the location of an arrow function body
+			* @param {ASTNode} node The arrow function body
+			* @returns {void}
+			*/
+			function validateExpression(node) {
+				if (node.body.type === "BlockStatement") return;
+				let arrowToken = sourceCode.getTokenBefore(node.body, isNotOpeningParenToken), firstTokenOfBody = sourceCode.getTokenAfter(arrowToken);
+				arrowToken.loc.end.line === firstTokenOfBody.loc.start.line && option === "below" ? context.report({
+					node: firstTokenOfBody,
+					messageId: "expected",
+					fix: (fixer) => fixer.insertTextBefore(firstTokenOfBody, "\n")
+				}) : arrowToken.loc.end.line !== firstTokenOfBody.loc.start.line && option === "beside" && context.report({
+					node: firstTokenOfBody,
+					messageId: "unexpected",
+					fix(fixer) {
+						return sourceCode.getFirstTokenBetween(arrowToken, firstTokenOfBody, {
+							includeComments: !0,
+							filter: isCommentToken
+						}) ? null : fixer.replaceTextRange([arrowToken.range[1], firstTokenOfBody.range[0]], " ");
+					}
+				});
+			}
+			return { ArrowFunctionExpression: (node) => validateExpression(node) };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/implicit-arrow-linebreak.cjs
+module.exports = require_implicit_arrow_linebreak().create;
+//#endregion