oxlint-plugin-eslint 1.52.0

package/rules/no-redeclare.cjs

@@ -0,0 +1,103 @@
+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-redeclare.js
+/**
+* @fileoverview Rule to flag when the same variable is declared more then once.
+* @author Ilya Volodin
+*/
+var require_no_redeclare = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t();
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			defaultOptions: [{ builtinGlobals: !0 }],
+			docs: {
+				description: "Disallow variable redeclaration",
+				recommended: !0,
+				url: "https://eslint.org/docs/latest/rules/no-redeclare"
+			},
+			messages: {
+				redeclared: "'{{id}}' is already defined.",
+				redeclaredAsBuiltin: "'{{id}}' is already defined as a built-in global variable.",
+				redeclaredBySyntax: "'{{id}}' is already defined by a variable declaration."
+			},
+			schema: [{
+				type: "object",
+				properties: { builtinGlobals: { type: "boolean" } },
+				additionalProperties: !1
+			}]
+		},
+		create(context) {
+			let [{ builtinGlobals }] = context.options, sourceCode = context.sourceCode;
+			/**
+			* Iterate declarations of a given variable.
+			* @param {escope.variable} variable The variable object to iterate declarations.
+			* @returns {IterableIterator<{type:string,node:ASTNode,loc:SourceLocation}>} The declarations.
+			*/
+			function* iterateDeclarations(variable) {
+				builtinGlobals && (variable.eslintImplicitGlobalSetting === "readonly" || variable.eslintImplicitGlobalSetting === "writable") && (yield { type: "builtin" });
+				for (let id of variable.identifiers) yield {
+					type: "syntax",
+					node: id,
+					loc: id.loc
+				};
+				if (variable.eslintExplicitGlobalComments) for (let comment of variable.eslintExplicitGlobalComments) yield {
+					type: "comment",
+					node: comment,
+					loc: astUtils.getNameLocationInGlobalDirectiveComment(sourceCode, comment, variable.name)
+				};
+			}
+			/**
+			* Find variables in a given scope and flag redeclared ones.
+			* @param {Scope} scope An eslint-scope scope object.
+			* @returns {void}
+			* @private
+			*/
+			function findVariablesInScope(scope) {
+				for (let variable of scope.variables) {
+					let [declaration, ...extraDeclarations] = iterateDeclarations(variable);
+					if (extraDeclarations.length === 0) continue;
+					let detailMessageId = declaration.type === "builtin" ? "redeclaredAsBuiltin" : "redeclaredBySyntax", data = { id: variable.name };
+					for (let { type, node, loc } of extraDeclarations) {
+						let messageId = type === declaration.type ? "redeclared" : detailMessageId;
+						context.report({
+							node,
+							loc,
+							messageId,
+							data
+						});
+					}
+				}
+			}
+			/**
+			* Find variables in the current scope.
+			* @param {ASTNode} node The node of the current scope.
+			* @returns {void}
+			* @private
+			*/
+			function checkForBlock(node) {
+				let scope = sourceCode.getScope(node);
+				scope.block === node && findVariablesInScope(scope);
+			}
+			return {
+				Program(node) {
+					let scope = sourceCode.getScope(node);
+					findVariablesInScope(scope), scope.type === "global" && scope.childScopes[0] && scope.block === scope.childScopes[0].block && findVariablesInScope(scope.childScopes[0]);
+				},
+				FunctionDeclaration: checkForBlock,
+				FunctionExpression: checkForBlock,
+				ArrowFunctionExpression: checkForBlock,
+				StaticBlock: checkForBlock,
+				BlockStatement: checkForBlock,
+				ForStatement: checkForBlock,
+				ForInStatement: checkForBlock,
+				ForOfStatement: checkForBlock,
+				SwitchStatement: checkForBlock
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-redeclare.cjs
+module.exports = require_no_redeclare().create;
+//#endregion

package/rules/no-regex-spaces.cjs

@@ -0,0 +1,115 @@
+const require_chunk = require("../common/chunk.cjs"), require_ast_utils$1 = require("../common/ast-utils.cjs"), require_regexpp$1 = require("../common/regexpp.cjs");
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/no-regex-spaces.js
+/**
+* @fileoverview Rule to count multiple spaces in regular expressions
+* @author Matt DuVall <http://www.mattduvall.com/>
+*/
+var require_no_regex_spaces = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t(), regexpp = require_regexpp$1.t(), regExpParser = new regexpp.RegExpParser(), DOUBLE_SPACE = / {2}/u;
+	/**
+	* Check if node is a string
+	* @param {ASTNode} node node to evaluate
+	* @returns {boolean} True if its a string
+	* @private
+	*/
+	function isString(node) {
+		return node && node.type === "Literal" && typeof node.value == "string";
+	}
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Disallow multiple spaces in regular expressions",
+				recommended: !0,
+				url: "https://eslint.org/docs/latest/rules/no-regex-spaces"
+			},
+			schema: [],
+			fixable: "code",
+			messages: { multipleSpaces: "Spaces are hard to count. Use {{{length}}}." }
+		},
+		create(context) {
+			let sourceCode = context.sourceCode;
+			/**
+			* Validate regular expression
+			* @param {ASTNode} nodeToReport Node to report.
+			* @param {string} pattern Regular expression pattern to validate.
+			* @param {string} rawPattern Raw representation of the pattern in the source code.
+			* @param {number} rawPatternStartRange Start range of the pattern in the source code.
+			* @param {string} flags Regular expression flags.
+			* @returns {void}
+			* @private
+			*/
+			function checkRegex(nodeToReport, pattern, rawPattern, rawPatternStartRange, flags) {
+				if (!DOUBLE_SPACE.test(rawPattern)) return;
+				let characterClassNodes = [], regExpAST;
+				try {
+					regExpAST = regExpParser.parsePattern(pattern, 0, pattern.length, {
+						unicode: flags.includes("u"),
+						unicodeSets: flags.includes("v")
+					});
+				} catch {
+					return;
+				}
+				regexpp.visitRegExpAST(regExpAST, { onCharacterClassEnter(ccNode) {
+					characterClassNodes.push(ccNode);
+				} });
+				let spacesPattern = /( {2,})(?: [+*{?]|[^+*{?]|$)/gu, match;
+				for (; match = spacesPattern.exec(pattern);) {
+					let { 1: { length }, index } = match;
+					if (characterClassNodes.every(({ start, end }) => index < start || end <= index)) {
+						context.report({
+							node: nodeToReport,
+							messageId: "multipleSpaces",
+							data: { length },
+							fix(fixer) {
+								return pattern === rawPattern ? fixer.replaceTextRange([rawPatternStartRange + index, rawPatternStartRange + index + length], ` {${length}}`) : null;
+							}
+						});
+						return;
+					}
+				}
+			}
+			/**
+			* Validate regular expression literals
+			* @param {ASTNode} node node to validate
+			* @returns {void}
+			* @private
+			*/
+			function checkLiteral(node) {
+				if (node.regex) {
+					let pattern = node.regex.pattern, rawPattern = node.raw.slice(1, node.raw.lastIndexOf("/")), rawPatternStartRange = node.range[0] + 1, flags = node.regex.flags;
+					checkRegex(node, pattern, rawPattern, rawPatternStartRange, flags);
+				}
+			}
+			/**
+			* Validate strings passed to the RegExp constructor
+			* @param {ASTNode} node node to validate
+			* @returns {void}
+			* @private
+			*/
+			function checkFunction(node) {
+				let scope = sourceCode.getScope(node), regExpVar = astUtils.getVariableByName(scope, "RegExp"), shadowed = regExpVar && regExpVar.defs.length > 0, patternNode = node.arguments[0];
+				if (node.callee.type === "Identifier" && node.callee.name === "RegExp" && isString(patternNode) && !shadowed) {
+					let pattern = patternNode.value, rawPattern = patternNode.raw.slice(1, -1), rawPatternStartRange = patternNode.range[0] + 1, flags;
+					if (node.arguments.length < 2) flags = "";
+					else {
+						let flagsNode = node.arguments[1];
+						if (isString(flagsNode)) flags = flagsNode.value;
+						else return;
+					}
+					checkRegex(node, pattern, rawPattern, rawPatternStartRange, flags);
+				}
+			}
+			return {
+				Literal: checkLiteral,
+				CallExpression: checkFunction,
+				NewExpression: checkFunction
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-regex-spaces.cjs
+module.exports = require_no_regex_spaces().create;
+//#endregion

package/rules/no-restricted-exports.cjs

@@ -0,0 +1,117 @@
+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-restricted-exports.js
+/**
+* @fileoverview Rule to disallow specified names in exports
+* @author Milos Djermanovic
+*/
+var require_no_restricted_exports = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t();
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Disallow specified names in exports",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/no-restricted-exports"
+			},
+			schema: [{ anyOf: [{
+				type: "object",
+				properties: {
+					restrictedNamedExports: {
+						type: "array",
+						items: { type: "string" },
+						uniqueItems: !0
+					},
+					restrictedNamedExportsPattern: { type: "string" }
+				},
+				additionalProperties: !1
+			}, {
+				type: "object",
+				properties: {
+					restrictedNamedExports: {
+						type: "array",
+						items: {
+							type: "string",
+							pattern: "^(?!default$)"
+						},
+						uniqueItems: !0
+					},
+					restrictedNamedExportsPattern: { type: "string" },
+					restrictDefaultExports: {
+						type: "object",
+						properties: {
+							direct: { type: "boolean" },
+							named: { type: "boolean" },
+							defaultFrom: { type: "boolean" },
+							namedFrom: { type: "boolean" },
+							namespaceFrom: { type: "boolean" }
+						},
+						additionalProperties: !1
+					}
+				},
+				additionalProperties: !1
+			}] }],
+			messages: {
+				restrictedNamed: "'{{name}}' is restricted from being used as an exported name.",
+				restrictedDefault: "Exporting 'default' is restricted."
+			}
+		},
+		create(context) {
+			let restrictedNames = new Set(context.options[0] && context.options[0].restrictedNamedExports), restrictedNamePattern = context.options[0] && context.options[0].restrictedNamedExportsPattern, restrictDefaultExports = context.options[0] && context.options[0].restrictDefaultExports, sourceCode = context.sourceCode;
+			/**
+			* Checks and reports given exported name.
+			* @param {ASTNode} node exported `Identifier` or string `Literal` node to check.
+			* @returns {void}
+			*/
+			function checkExportedName(node) {
+				let name = astUtils.getModuleExportName(node), matchesRestrictedNamePattern = !1;
+				if (restrictedNamePattern && name !== "default" && (matchesRestrictedNamePattern = new RegExp(restrictedNamePattern, "u").test(name)), matchesRestrictedNamePattern || restrictedNames.has(name)) {
+					context.report({
+						node,
+						messageId: "restrictedNamed",
+						data: { name }
+					});
+					return;
+				}
+				if (name === "default") if (node.parent.type === "ExportAllDeclaration") restrictDefaultExports && restrictDefaultExports.namespaceFrom && context.report({
+					node,
+					messageId: "restrictedDefault"
+				});
+				else {
+					let isSourceSpecified = !!node.parent.parent.source, specifierLocalName = astUtils.getModuleExportName(node.parent.local);
+					if (!isSourceSpecified && restrictDefaultExports && restrictDefaultExports.named) {
+						context.report({
+							node,
+							messageId: "restrictedDefault"
+						});
+						return;
+					}
+					isSourceSpecified && restrictDefaultExports && (specifierLocalName === "default" && restrictDefaultExports.defaultFrom || specifierLocalName !== "default" && restrictDefaultExports.namedFrom) && context.report({
+						node,
+						messageId: "restrictedDefault"
+					});
+				}
+			}
+			return {
+				ExportAllDeclaration(node) {
+					node.exported && checkExportedName(node.exported);
+				},
+				ExportDefaultDeclaration(node) {
+					restrictDefaultExports && restrictDefaultExports.direct && context.report({
+						node,
+						messageId: "restrictedDefault"
+					});
+				},
+				ExportNamedDeclaration(node) {
+					let declaration = node.declaration;
+					declaration ? declaration.type === "FunctionDeclaration" || declaration.type === "ClassDeclaration" ? checkExportedName(declaration.id) : declaration.type === "VariableDeclaration" && sourceCode.getDeclaredVariables(declaration).map((v) => v.defs.find((d) => d.parent === declaration)).map((d) => d.name).forEach(checkExportedName) : node.specifiers.map((s) => s.exported).forEach(checkExportedName);
+				}
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-restricted-exports.cjs
+module.exports = require_no_restricted_exports().create;
+//#endregion

package/rules/no-restricted-globals.cjs

@@ -0,0 +1,147 @@
+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-restricted-globals.js
+/**
+* @fileoverview Restrict usage of specified globals.
+* @author Benoît Zugmeyer
+*/
+var require_no_restricted_globals = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t(), TYPE_NODES = new Set([
+		"TSTypeReference",
+		"TSInterfaceHeritage",
+		"TSClassImplements",
+		"TSTypeQuery",
+		"TSQualifiedName"
+	]), GLOBAL_OBJECTS = new Set([
+		"globalThis",
+		"self",
+		"window"
+	]), arrayOfGlobals = {
+		type: "array",
+		items: { oneOf: [{ type: "string" }, {
+			type: "object",
+			properties: {
+				name: { type: "string" },
+				message: { type: "string" }
+			},
+			required: ["name"],
+			additionalProperties: !1
+		}] },
+		uniqueItems: !0,
+		minItems: 0
+	};
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			dialects: ["javascript", "typescript"],
+			language: "javascript",
+			type: "suggestion",
+			docs: {
+				description: "Disallow specified global variables",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/no-restricted-globals"
+			},
+			schema: { anyOf: [arrayOfGlobals, {
+				type: "array",
+				items: [{
+					type: "object",
+					properties: {
+						globals: arrayOfGlobals,
+						checkGlobalObject: { type: "boolean" },
+						globalObjects: {
+							type: "array",
+							items: { type: "string" },
+							uniqueItems: !0
+						}
+					},
+					required: ["globals"],
+					additionalProperties: !1
+				}],
+				additionalItems: !1
+			}] },
+			messages: {
+				defaultMessage: "Unexpected use of '{{name}}'.",
+				customMessage: "Unexpected use of '{{name}}'. {{customMessage}}"
+			}
+		},
+		create(context) {
+			let { sourceCode, options } = context, isGlobalsObject = typeof options[0] == "object" && Object.hasOwn(options[0], "globals"), restrictedGlobals = isGlobalsObject ? options[0].globals : options, checkGlobalObject = isGlobalsObject ? options[0].checkGlobalObject : !1, userGlobalObjects = isGlobalsObject && options[0].globalObjects || [], globalObjects = new Set([...GLOBAL_OBJECTS, ...userGlobalObjects]);
+			if (restrictedGlobals.length === 0) return {};
+			let restrictedGlobalMessages = restrictedGlobals.reduce((memo, option) => (typeof option == "string" ? memo[option] = null : memo[option.name] = option.message, memo), {});
+			/**
+			* Report a variable to be used as a restricted global.
+			* @param {Reference} reference the variable reference
+			* @returns {void}
+			* @private
+			*/
+			function reportReference(reference) {
+				let name = reference.identifier.name, customMessage = restrictedGlobalMessages[name], messageId = customMessage ? "customMessage" : "defaultMessage";
+				context.report({
+					node: reference.identifier,
+					messageId,
+					data: {
+						name,
+						customMessage
+					}
+				});
+			}
+			/**
+			* Check if the given name is a restricted global name.
+			* @param {string} name name of a variable
+			* @returns {boolean} whether the variable is a restricted global or not
+			* @private
+			*/
+			function isRestricted(name) {
+				return Object.hasOwn(restrictedGlobalMessages, name);
+			}
+			/**
+			* Check if the given reference occurs within a TypeScript type context.
+			* @param {Reference} reference The variable reference to check.
+			* @returns {boolean} Whether the reference is in a type context.
+			* @private
+			*/
+			function isInTypeContext(reference) {
+				let parent = reference.identifier.parent;
+				return TYPE_NODES.has(parent.type);
+			}
+			return {
+				Program(node) {
+					let scope = sourceCode.getScope(node);
+					scope.variables.forEach((variable) => {
+						!variable.defs.length && isRestricted(variable.name) && variable.references.forEach((reference) => {
+							isInTypeContext(reference) || reportReference(reference);
+						});
+					}), scope.through.forEach((reference) => {
+						isRestricted(reference.identifier.name) && !isInTypeContext(reference) && reportReference(reference);
+					});
+				},
+				"Program:exit"(node) {
+					if (!checkGlobalObject) return;
+					let globalScope = sourceCode.getScope(node);
+					globalObjects.forEach((globalObjectName) => {
+						let variable = astUtils.getVariableByName(globalScope, globalObjectName);
+						variable && variable.references.forEach((reference) => {
+							let parent = reference.identifier.parent;
+							for (; astUtils.isSpecificMemberAccess(parent, null, globalObjectName);) parent = parent.parent;
+							let propertyName = astUtils.getStaticPropertyName(parent);
+							if (propertyName && isRestricted(propertyName)) {
+								let customMessage = restrictedGlobalMessages[propertyName], messageId = customMessage ? "customMessage" : "defaultMessage";
+								context.report({
+									node: parent.property,
+									messageId,
+									data: {
+										name: propertyName,
+										customMessage
+									}
+								});
+							}
+						});
+					});
+				}
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-restricted-globals.cjs
+module.exports = require_no_restricted_globals().create;
+//#endregion