oxlint-plugin-eslint 1.52.0

package/rules/no-dupe-args.cjs

@@ -0,0 +1,61 @@
+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-dupe-args.js
+/**
+* @fileoverview Rule to flag duplicate arguments
+* @author Jamund Ferguson
+*/
+var require_no_dupe_args = /* @__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 duplicate arguments in `function` definitions",
+				recommended: !0,
+				url: "https://eslint.org/docs/latest/rules/no-dupe-args"
+			},
+			schema: [],
+			messages: { unexpected: "Duplicate param '{{name}}'." }
+		},
+		create(context) {
+			let sourceCode = context.sourceCode;
+			/**
+			* Checks whether or not a given definition is a parameter's.
+			* @param {eslint-scope.DefEntry} def A definition to check.
+			* @returns {boolean} `true` if the definition is a parameter's.
+			*/
+			function isParameter(def) {
+				return def.type === "Parameter";
+			}
+			/**
+			* Determines if a given node has duplicate parameters.
+			* @param {ASTNode} node The node to check.
+			* @returns {void}
+			* @private
+			*/
+			function checkParams(node) {
+				let variables = sourceCode.getDeclaredVariables(node);
+				for (let i = 0; i < variables.length; ++i) {
+					let variable = variables[i], defs = variable.defs.filter(isParameter), loc = {
+						start: astUtils.getOpeningParenOfParams(node, sourceCode).loc.start,
+						end: sourceCode.getTokenBefore(node.body).loc.end
+					};
+					defs.length >= 2 && context.report({
+						loc,
+						messageId: "unexpected",
+						data: { name: variable.name }
+					});
+				}
+			}
+			return {
+				FunctionDeclaration: checkParams,
+				FunctionExpression: checkParams
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-dupe-args.cjs
+module.exports = require_no_dupe_args().create;
+//#endregion

package/rules/no-dupe-class-members.cjs

@@ -0,0 +1,77 @@
+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-dupe-class-members.js
+/**
+* @fileoverview A rule to disallow duplicate name in class members.
+* @author Toru Nagashima
+*/
+var require_no_dupe_class_members = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t();
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "problem",
+			dialects: ["javascript", "typescript"],
+			language: "javascript",
+			docs: {
+				description: "Disallow duplicate class members",
+				recommended: !0,
+				url: "https://eslint.org/docs/latest/rules/no-dupe-class-members"
+			},
+			schema: [],
+			messages: { unexpected: "Duplicate name '{{name}}'." }
+		},
+		create(context) {
+			let stack = [];
+			/**
+			* Gets state of a given member name.
+			* @param {string} name A name of a member.
+			* @param {boolean} isStatic A flag which specifies that is a static member.
+			* @returns {Object} A state of a given member name.
+			*   - retv.init {boolean} A flag which shows the name is declared as normal member.
+			*   - retv.get {boolean} A flag which shows the name is declared as getter.
+			*   - retv.set {boolean} A flag which shows the name is declared as setter.
+			*/
+			function getState(name, isStatic) {
+				let stateMap = stack.at(-1), key = `$${name}`;
+				return stateMap[key] || (stateMap[key] = {
+					nonStatic: {
+						init: !1,
+						get: !1,
+						set: !1
+					},
+					static: {
+						init: !1,
+						get: !1,
+						set: !1
+					}
+				}), stateMap[key][isStatic ? "static" : "nonStatic"];
+			}
+			return {
+				Program() {
+					stack = [];
+				},
+				ClassBody() {
+					stack.push(Object.create(null));
+				},
+				"ClassBody:exit"() {
+					stack.pop();
+				},
+				"MethodDefinition, PropertyDefinition"(node) {
+					if (node.value && node.value.type === "TSEmptyBodyFunctionExpression") return;
+					let name = astUtils.getStaticPropertyName(node), kind = node.type === "MethodDefinition" ? node.kind : "field";
+					if (name === null || kind === "constructor") return;
+					let state = getState(name, node.static), isDuplicate;
+					kind === "get" ? (isDuplicate = state.init || state.get, state.get = !0) : kind === "set" ? (isDuplicate = state.init || state.set, state.set = !0) : (isDuplicate = state.init || state.get || state.set, state.init = !0), isDuplicate && context.report({
+						loc: node.key.loc,
+						messageId: "unexpected",
+						data: { name }
+					});
+				}
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-dupe-class-members.cjs
+module.exports = require_no_dupe_class_members().create;
+//#endregion

package/rules/no-dupe-else-if.cjs

@@ -0,0 +1,74 @@
+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-dupe-else-if.js
+/**
+* @fileoverview Rule to disallow duplicate conditions in if-else-if chains
+* @author Milos Djermanovic
+*/
+var require_no_dupe_else_if = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t();
+	/**
+	* Determines whether the first given array is a subset of the second given array.
+	* @param {Function} comparator A function to compare two elements, should return `true` if they are equal.
+	* @param {Array} arrA The array to compare from.
+	* @param {Array} arrB The array to compare against.
+	* @returns {boolean} `true` if the array `arrA` is a subset of the array `arrB`.
+	*/
+	function isSubsetByComparator(comparator, arrA, arrB) {
+		return arrA.every((a) => arrB.some((b) => comparator(a, b)));
+	}
+	/**
+	* Splits the given node by the given logical operator.
+	* @param {string} operator Logical operator `||` or `&&`.
+	* @param {ASTNode} node The node to split.
+	* @returns {ASTNode[]} Array of conditions that makes the node when joined by the operator.
+	*/
+	function splitByLogicalOperator(operator, node) {
+		return node.type === "LogicalExpression" && node.operator === operator ? [...splitByLogicalOperator(operator, node.left), ...splitByLogicalOperator(operator, node.right)] : [node];
+	}
+	let splitByOr = splitByLogicalOperator.bind(null, "||"), splitByAnd = splitByLogicalOperator.bind(null, "&&");
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "problem",
+			docs: {
+				description: "Disallow duplicate conditions in if-else-if chains",
+				recommended: !0,
+				url: "https://eslint.org/docs/latest/rules/no-dupe-else-if"
+			},
+			schema: [],
+			messages: { unexpected: "This branch can never execute. Its condition is a duplicate or covered by previous conditions in the if-else-if chain." }
+		},
+		create(context) {
+			let sourceCode = context.sourceCode;
+			/**
+			* Determines whether the two given nodes are considered to be equal. In particular, given that the nodes
+			* represent expressions in a boolean context, `||` and `&&` can be considered as commutative operators.
+			* @param {ASTNode} a First node.
+			* @param {ASTNode} b Second node.
+			* @returns {boolean} `true` if the nodes are considered to be equal.
+			*/
+			function equal(a, b) {
+				return a.type === b.type ? a.type === "LogicalExpression" && (a.operator === "||" || a.operator === "&&") && a.operator === b.operator ? equal(a.left, b.left) && equal(a.right, b.right) || equal(a.left, b.right) && equal(a.right, b.left) : astUtils.equalTokens(a, b, sourceCode) : !1;
+			}
+			let isSubset = isSubsetByComparator.bind(null, equal);
+			return { IfStatement(node) {
+				let test = node.test, conditionsToCheck = test.type === "LogicalExpression" && test.operator === "&&" ? [test, ...splitByAnd(test)] : [test], current = node, listToCheck = conditionsToCheck.map((c) => splitByOr(c).map(splitByAnd));
+				for (; current.parent && current.parent.type === "IfStatement" && current.parent.alternate === current;) {
+					current = current.parent;
+					let currentOrOperands = splitByOr(current.test).map(splitByAnd);
+					if (listToCheck = listToCheck.map((orOperands) => orOperands.filter((orOperand) => !currentOrOperands.some((currentOrOperand) => isSubset(currentOrOperand, orOperand)))), listToCheck.some((orOperands) => orOperands.length === 0)) {
+						context.report({
+							node: test,
+							messageId: "unexpected"
+						});
+						break;
+					}
+				}
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-dupe-else-if.cjs
+module.exports = require_no_dupe_else_if().create;
+//#endregion

package/rules/no-dupe-keys.cjs

@@ -0,0 +1,88 @@
+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-dupe-keys.js
+/**
+* @fileoverview Rule to flag use of duplicate keys in an object.
+* @author Ian Christian Myers
+*/
+var require_no_dupe_keys = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t(), GET_KIND = /^(?:init|get)$/u, SET_KIND = /^(?:init|set)$/u;
+	/**
+	* The class which stores properties' information of an object.
+	*/
+	var ObjectInfo = class {
+		/**
+		* @param {ObjectInfo|null} upper The information of the outer object.
+		* @param {ASTNode} node The ObjectExpression node of this information.
+		*/
+		constructor(upper, node) {
+			this.upper = upper, this.node = node, this.properties = /* @__PURE__ */ new Map();
+		}
+		/**
+		* Gets the information of the given Property node.
+		* @param {ASTNode} node The Property node to get.
+		* @returns {{get: boolean, set: boolean}} The information of the property.
+		*/
+		getPropertyInfo(node) {
+			let name = astUtils.getStaticPropertyName(node);
+			return this.properties.has(name) || this.properties.set(name, {
+				get: !1,
+				set: !1
+			}), this.properties.get(name);
+		}
+		/**
+		* Checks whether the given property has been defined already or not.
+		* @param {ASTNode} node The Property node to check.
+		* @returns {boolean} `true` if the property has been defined.
+		*/
+		isPropertyDefined(node) {
+			let entry = this.getPropertyInfo(node);
+			return GET_KIND.test(node.kind) && entry.get || SET_KIND.test(node.kind) && entry.set;
+		}
+		/**
+		* Defines the given property.
+		* @param {ASTNode} node The Property node to define.
+		* @returns {void}
+		*/
+		defineProperty(node) {
+			let entry = this.getPropertyInfo(node);
+			GET_KIND.test(node.kind) && (entry.get = !0), SET_KIND.test(node.kind) && (entry.set = !0);
+		}
+	};
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "problem",
+			docs: {
+				description: "Disallow duplicate keys in object literals",
+				recommended: !0,
+				url: "https://eslint.org/docs/latest/rules/no-dupe-keys"
+			},
+			schema: [],
+			messages: { unexpected: "Duplicate key '{{name}}'." }
+		},
+		create(context) {
+			let info = null;
+			return {
+				ObjectExpression(node) {
+					info = new ObjectInfo(info, node);
+				},
+				"ObjectExpression:exit"() {
+					info = info.upper;
+				},
+				Property(node) {
+					let name = astUtils.getStaticPropertyName(node);
+					node.parent.type === "ObjectExpression" && name !== null && (name === "__proto__" && node.kind === "init" && !node.computed && !node.shorthand && !node.method || (info.isPropertyDefined(node) && context.report({
+						node: info.node,
+						loc: node.key.loc,
+						messageId: "unexpected",
+						data: { name }
+					}), info.defineProperty(node)));
+				}
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-dupe-keys.cjs
+module.exports = require_no_dupe_keys().create;
+//#endregion

package/rules/no-duplicate-case.cjs

@@ -0,0 +1,49 @@
+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-duplicate-case.js
+/**
+* @fileoverview Rule to disallow a duplicate case label.
+* @author Dieter Oberkofler
+* @author Burak Yigit Kaya
+*/
+var require_no_duplicate_case = /* @__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 duplicate case labels",
+				recommended: !0,
+				url: "https://eslint.org/docs/latest/rules/no-duplicate-case"
+			},
+			schema: [],
+			messages: { unexpected: "Duplicate case label." }
+		},
+		create(context) {
+			let sourceCode = context.sourceCode;
+			/**
+			* Determines whether the two given nodes are considered to be equal.
+			* @param {ASTNode} a First node.
+			* @param {ASTNode} b Second node.
+			* @returns {boolean} `true` if the nodes are considered to be equal.
+			*/
+			function equal(a, b) {
+				return a.type === b.type ? astUtils.equalTokens(a, b, sourceCode) : !1;
+			}
+			return { SwitchStatement(node) {
+				let previousTests = [];
+				for (let switchCase of node.cases) if (switchCase.test) {
+					let test = switchCase.test;
+					previousTests.some((previousTest) => equal(previousTest, test)) ? context.report({
+						node: switchCase,
+						messageId: "unexpected"
+					}) : previousTests.push(test);
+				}
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-duplicate-case.cjs
+module.exports = require_no_duplicate_case().create;
+//#endregion

package/rules/no-duplicate-imports.cjs

@@ -0,0 +1,166 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/no-duplicate-imports.js
+/**
+* @fileoverview Restrict usage of duplicate imports.
+* @author Simen Bekkhus
+*/
+var require_no_duplicate_imports = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	let NAMED_TYPES = ["ImportSpecifier", "ExportSpecifier"], NAMESPACE_TYPES = ["ImportNamespaceSpecifier", "ExportNamespaceSpecifier"];
+	/**
+	* Check if an import/export type belongs to (ImportSpecifier|ExportSpecifier) or (ImportNamespaceSpecifier|ExportNamespaceSpecifier).
+	* @param {string} importExportType An import/export type to check.
+	* @param {string} type Can be "named" or "namespace"
+	* @returns {boolean} True if import/export type belongs to (ImportSpecifier|ExportSpecifier) or (ImportNamespaceSpecifier|ExportNamespaceSpecifier) and false if it doesn't.
+	*/
+	function isImportExportSpecifier(importExportType, type) {
+		return (type === "named" ? NAMED_TYPES : NAMESPACE_TYPES).includes(importExportType);
+	}
+	/**
+	* Return the type of (import|export).
+	* @param {ASTNode} node A node to get.
+	* @returns {string} The type of the (import|export).
+	*/
+	function getImportExportType(node) {
+		if (node.specifiers && node.specifiers.length > 0) {
+			let nodeSpecifiers = node.specifiers, index = nodeSpecifiers.findIndex(({ type }) => isImportExportSpecifier(type, "named") || isImportExportSpecifier(type, "namespace"));
+			return nodeSpecifiers[index > -1 ? index : 0].type;
+		}
+		return node.type === "ExportAllDeclaration" ? node.exported ? "ExportNamespaceSpecifier" : "ExportAll" : "SideEffectImport";
+	}
+	/**
+	* Returns a boolean indicates if two (import|export) can be merged
+	* @param {ASTNode} node1 A node to check.
+	* @param {ASTNode} node2 A node to check.
+	* @returns {boolean} True if two (import|export) can be merged, false if they can't.
+	*/
+	function isImportExportCanBeMerged(node1, node2) {
+		let importExportType1 = getImportExportType(node1), importExportType2 = getImportExportType(node2);
+		if ((node1.importKind === "type" || node1.exportKind === "type") && (node2.importKind === "type" || node2.exportKind === "type")) {
+			let isDefault1 = importExportType1 === "ImportDefaultSpecifier", isDefault2 = importExportType2 === "ImportDefaultSpecifier", isNamed1 = isImportExportSpecifier(importExportType1, "named"), isNamed2 = isImportExportSpecifier(importExportType2, "named");
+			if (isDefault1 && isNamed2 || isDefault2 && isNamed1) return !1;
+		}
+		return !(importExportType1 === "ExportAll" && importExportType2 !== "ExportAll" && importExportType2 !== "SideEffectImport" || importExportType1 !== "ExportAll" && importExportType1 !== "SideEffectImport" && importExportType2 === "ExportAll" || isImportExportSpecifier(importExportType1, "namespace") && isImportExportSpecifier(importExportType2, "named") || isImportExportSpecifier(importExportType2, "namespace") && isImportExportSpecifier(importExportType1, "named"));
+	}
+	/**
+	* Returns a boolean if we should report (import|export).
+	* @param {ASTNode} node A node to be reported or not.
+	* @param {[ASTNode]} previousNodes An array contains previous nodes of the module imported or exported.
+	* @param {boolean} allowSeparateTypeImports Whether to allow separate type and value imports.
+	* @returns {boolean} True if the (import|export) should be reported.
+	*/
+	function shouldReportImportExport(node, previousNodes, allowSeparateTypeImports) {
+		let i = 0;
+		for (; i < previousNodes.length;) {
+			let previousNode = previousNodes[i];
+			if (allowSeparateTypeImports && (node.importKind === "type" || node.exportKind === "type") != (previousNode.importKind === "type" || previousNode.exportKind === "type")) {
+				i++;
+				continue;
+			}
+			if (isImportExportCanBeMerged(node, previousNode)) return !0;
+			i++;
+		}
+		return !1;
+	}
+	/**
+	* Returns array contains only nodes with declarations types equal to type.
+	* @param {[{node: ASTNode, declarationType: string}]} nodes An array contains objects, each object contains a node and a declaration type.
+	* @param {string} type Declaration type.
+	* @returns {[ASTNode]} An array contains only nodes with declarations types equal to type.
+	*/
+	function getNodesByDeclarationType(nodes, type) {
+		return nodes.filter(({ declarationType }) => declarationType === type).map(({ node }) => node);
+	}
+	/**
+	* Returns the name of the module imported or re-exported.
+	* @param {ASTNode} node A node to get.
+	* @returns {string} The name of the module, or empty string if no name.
+	*/
+	function getModule(node) {
+		return node && node.source && node.source.value ? node.source.value.trim() : "";
+	}
+	/**
+	* Checks if the (import|export) can be merged with at least one import or one export, and reports if so.
+	* @param {RuleContext} context The ESLint rule context object.
+	* @param {ASTNode} node A node to get.
+	* @param {Map} modules A Map object contains as a key a module name and as value an array contains objects, each object contains a node and a declaration type.
+	* @param {string} declarationType A declaration type can be an import or export.
+	* @param {boolean} includeExports Whether or not to check for exports in addition to imports.
+	* @param {boolean} allowSeparateTypeImports Whether to allow separate type and value imports.
+	* @returns {void} No return value.
+	*/
+	function checkAndReport(context, node, modules, declarationType, includeExports, allowSeparateTypeImports) {
+		let module$1 = getModule(node);
+		if (modules.has(module$1)) {
+			let previousNodes = modules.get(module$1), messagesIds = [], importNodes = getNodesByDeclarationType(previousNodes, "import"), exportNodes;
+			includeExports && (exportNodes = getNodesByDeclarationType(previousNodes, "export")), declarationType === "import" ? (shouldReportImportExport(node, importNodes, allowSeparateTypeImports) && messagesIds.push("import"), includeExports && shouldReportImportExport(node, exportNodes, allowSeparateTypeImports) && messagesIds.push("importAs")) : declarationType === "export" && (shouldReportImportExport(node, exportNodes, allowSeparateTypeImports) && messagesIds.push("export"), shouldReportImportExport(node, importNodes, allowSeparateTypeImports) && messagesIds.push("exportAs")), messagesIds.forEach((messageId) => context.report({
+				node,
+				messageId,
+				data: { module: module$1 }
+			}));
+		}
+	}
+	/**
+	* @callback nodeCallback
+	* @param {ASTNode} node A node to handle.
+	*/
+	/**
+	* Returns a function handling the (imports|exports) of a given file
+	* @param {RuleContext} context The ESLint rule context object.
+	* @param {Map} modules A Map object contains as a key a module name and as value an array contains objects, each object contains a node and a declaration type.
+	* @param {string} declarationType A declaration type can be an import or export.
+	* @param {boolean} includeExports Whether or not to check for exports in addition to imports.
+	* @param {boolean} allowSeparateTypeImports Whether to allow separate type and value imports.
+	* @returns {nodeCallback} A function passed to ESLint to handle the statement.
+	*/
+	function handleImportsExports(context, modules, declarationType, includeExports, allowSeparateTypeImports) {
+		return function(node) {
+			let module$2 = getModule(node);
+			if (module$2) {
+				checkAndReport(context, node, modules, declarationType, includeExports, allowSeparateTypeImports);
+				let currentNode = {
+					node,
+					declarationType
+				}, nodes = [currentNode];
+				modules.has(module$2) && (nodes = [...modules.get(module$2), currentNode]), modules.set(module$2, nodes);
+			}
+		};
+	}
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			dialects: ["javascript", "typescript"],
+			language: "javascript",
+			type: "problem",
+			defaultOptions: [{
+				includeExports: !1,
+				allowSeparateTypeImports: !1
+			}],
+			docs: {
+				description: "Disallow duplicate module imports",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/no-duplicate-imports"
+			},
+			schema: [{
+				type: "object",
+				properties: {
+					includeExports: { type: "boolean" },
+					allowSeparateTypeImports: { type: "boolean" }
+				},
+				additionalProperties: !1
+			}],
+			messages: {
+				import: "'{{module}}' import is duplicated.",
+				importAs: "'{{module}}' import is duplicated as export.",
+				export: "'{{module}}' export is duplicated.",
+				exportAs: "'{{module}}' export is duplicated as import."
+			}
+		},
+		create(context) {
+			let [{ includeExports, allowSeparateTypeImports }] = context.options, modules = /* @__PURE__ */ new Map(), handlers = { ImportDeclaration: handleImportsExports(context, modules, "import", includeExports, allowSeparateTypeImports) };
+			return includeExports && (handlers.ExportNamedDeclaration = handleImportsExports(context, modules, "export", includeExports, allowSeparateTypeImports), handlers.ExportAllDeclaration = handleImportsExports(context, modules, "export", includeExports, allowSeparateTypeImports)), handlers;
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-duplicate-imports.cjs
+module.exports = require_no_duplicate_imports().create;
+//#endregion