@conorroberts/utils 0.0.35 → 0.0.37

package/dist/oxlint/no-inline-components.mjs

@@ -0,0 +1,350 @@
+import { defineRule } from "oxlint";
+
+//#region src/oxlint-plugins/no-inline-components.js
+/**
+* @typedef {import("oxlint").Context} RuleContext
+* @typedef {import("oxlint").ESTree.Node} ESTNode
+* @typedef {import("oxlint").ESTree.Expression} ESTExpression
+* @typedef {import("oxlint").ESTree.Pattern} ESTPattern
+* @typedef {import("oxlint").ESTree.ReturnStatement} ReturnStatementNode
+* @typedef {import("oxlint").ESTree.VariableDeclarator} VariableDeclaratorNode
+* @typedef {import("oxlint").ESTree.AssignmentExpression} AssignmentExpressionNode
+* @typedef {import("oxlint").ESTree.Function | import("oxlint").ESTree.ArrowFunctionExpression} FunctionLikeNode
+*/
+/**
+* @typedef {object} RecordedAssignment
+* @property {ESTExpression} node
+* @property {string[]} names
+*/
+/**
+* @typedef {object} NestedFunctionRecord
+* @property {FunctionLikeNode} node
+* @property {string} name
+*/
+/**
+* @typedef {object} FunctionContext
+* @property {FunctionLikeNode} node
+* @property {FunctionContext | null} parent
+* @property {string} name
+* @property {boolean} returnsJsx
+* @property {Set<string>} jsxBindingNames
+* @property {RecordedAssignment[]} jsxAssignments
+* @property {NestedFunctionRecord[]} nestedJsxChildren
+*/
+const JSX_NODE_TYPES = new Set(["JSXElement", "JSXFragment"]);
+const FUNCTION_NODE_TYPES = new Set([
+	"FunctionDeclaration",
+	"FunctionExpression",
+	"ArrowFunctionExpression"
+]);
+/**
+* @param {unknown} name
+* @returns {name is string}
+*/
+const isComponentName = (name) => typeof name === "string" && /^[A-Z]/.test(name);
+/**
+* @param {unknown} name
+* @returns {name is string}
+*/
+const isHookName = (name) => typeof name === "string" && name.startsWith("use");
+/**
+* @param {unknown} node
+* @returns {node is ESTNode & { type: string }}
+*/
+const isNode = (node) => Boolean(node && typeof node === "object" && "type" in node);
+/**
+* @param {unknown} node
+* @returns {node is FunctionLikeNode}
+*/
+const isFunctionLike = (node) => isNode(node) && FUNCTION_NODE_TYPES.has(node.type);
+/**
+* @param {ESTNode | null | undefined} node
+* @returns {FunctionLikeNode | null}
+*/
+const getEnclosingFunction = (node) => {
+	const findFunction = (current) => {
+		if (!current) return null;
+		if (isFunctionLike(current)) return current;
+		return findFunction(isNode(current) ? current.parent ?? null : null);
+	};
+	return findFunction(isNode(node) ? node.parent ?? null : null);
+};
+/**
+* @param {FunctionLikeNode} node
+*/
+const isFunctionUsedAsJsxProp = (node) => {
+	const checkJsxProp = (current) => {
+		if (!current) return false;
+		if (current.type === "JSXAttribute") return true;
+		if (isFunctionLike(current)) return false;
+		return checkJsxProp(isNode(current) ? current.parent ?? null : null);
+	};
+	return checkJsxProp(isNode(node) ? node.parent ?? null : null);
+};
+/**
+* @param {FunctionLikeNode} node
+*/
+const isFunctionImmediatelyInvoked = (node) => {
+	const parent = isNode(node) ? node.parent ?? null : null;
+	if (!parent) return false;
+	if (parent.type === "CallExpression" && parent.callee === node) return true;
+	return false;
+};
+/**
+* @param {ESTExpression | null | undefined} root
+*/
+const expressionContainsJsx = (root) => {
+	if (!root || !isNode(root)) return false;
+	const stack = [root];
+	while (stack.length > 0) {
+		const current = stack.pop();
+		if (!current || !isNode(current)) continue;
+		if (JSX_NODE_TYPES.has(current.type)) return true;
+		if (FUNCTION_NODE_TYPES.has(current.type) && current !== root) continue;
+		for (const key of Object.keys(current)) {
+			if (key === "parent") continue;
+			const value = current[key];
+			if (!value) continue;
+			if (Array.isArray(value)) {
+				for (const element of value) if (isNode(element)) stack.push(element);
+			} else if (isNode(value)) stack.push(value);
+		}
+	}
+	return false;
+};
+/**
+* @param {ESTExpression | null | undefined} root
+* @param {Set<string>} bindingNames
+*/
+const expressionProducesJsx = (root, bindingNames) => {
+	if (!root) return false;
+	if (expressionContainsJsx(root)) return true;
+	if (!isNode(root)) return false;
+	const type = root.type;
+	if (type === "Identifier") return bindingNames.has(root.name);
+	if (type === "ConditionalExpression") return expressionProducesJsx(root.consequent, bindingNames) || expressionProducesJsx(root.alternate, bindingNames);
+	if (type === "LogicalExpression") return expressionProducesJsx(root.left, bindingNames) || expressionProducesJsx(root.right, bindingNames);
+	if (type === "SequenceExpression") {
+		const expressions = root.expressions ?? [];
+		return expressionProducesJsx(expressions[expressions.length - 1] ?? null, bindingNames);
+	}
+	if (type === "ArrayExpression") return root.elements.some((element) => {
+		if (!element) return false;
+		if (element.type === "SpreadElement") return expressionProducesJsx(element.argument, bindingNames);
+		return expressionProducesJsx(element, bindingNames);
+	});
+	if (type === "ParenthesizedExpression") return expressionProducesJsx(root.expression, bindingNames);
+	if (type === "AwaitExpression" || type === "UnaryExpression" || type === "UpdateExpression") return expressionProducesJsx(root.argument, bindingNames);
+	if (type === "TSAsExpression" || type === "TSTypeAssertion" || type === "TSNonNullExpression" || type === "ChainExpression") return expressionProducesJsx(root.expression, bindingNames);
+	return false;
+};
+/**
+* @param {ESTPattern | null | undefined} pattern
+* @param {string[]} names
+*/
+const collectBindingNames = (pattern, names) => {
+	if (!pattern || !isNode(pattern)) return;
+	const type = pattern.type;
+	if (type === "Identifier") {
+		names.push(pattern.name);
+		return;
+	}
+	if (type === "ArrayPattern") {
+		for (const element of pattern.elements) {
+			if (!element) continue;
+			if (element.type === "RestElement") collectBindingNames(element.argument, names);
+			else collectBindingNames(element, names);
+		}
+		return;
+	}
+	if (type === "ObjectPattern") {
+		for (const property of pattern.properties) {
+			if (!property) continue;
+			if (property.type === "Property") collectBindingNames(property.value, names);
+			else if (property.type === "RestElement") collectBindingNames(property.argument, names);
+		}
+		return;
+	}
+	if (type === "AssignmentPattern") {
+		collectBindingNames(pattern.left, names);
+		return;
+	}
+	if (type === "RestElement") collectBindingNames(pattern.argument, names);
+};
+/**
+* @param {FunctionLikeNode} node
+*/
+const getFunctionName = (node) => {
+	if (node.type === "FunctionDeclaration" && node.id && node.id.type === "Identifier") return node.id.name;
+	if ((node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") && node.id) {
+		if (node.id.type === "Identifier") return node.id.name;
+	}
+	const parent = node.parent;
+	if (!parent || !isNode(parent)) return "";
+	if (parent.type === "VariableDeclarator") return parent.id && parent.id.type === "Identifier" ? parent.id.name : "";
+	if (parent.type === "AssignmentExpression") return parent.left && parent.left.type === "Identifier" ? parent.left.name : "";
+	if (parent.type === "Property" || parent.type === "MethodDefinition") return parent.key && parent.key.type === "Identifier" ? parent.key.name : "";
+	if (parent.type === "CallExpression") {
+		const callParent = parent.parent;
+		if (callParent && isNode(callParent)) {
+			if (callParent.type === "VariableDeclarator") return callParent.id && callParent.id.type === "Identifier" ? callParent.id.name : "";
+			if (callParent.type === "AssignmentExpression") return callParent.left && callParent.left.type === "Identifier" ? callParent.left.name : "";
+		}
+	}
+	return "";
+};
+/**
+* @param {string} name
+*/
+const describeFunction = (name) => name ? `function '${name}'` : "this function";
+/**
+* @param {string} name
+*/
+const describeNested = (name) => name ? `function '${name}'` : "an anonymous function";
+/**
+* @param {string[]} names
+* @param {string} fnName
+*/
+const createAssignmentMessage = (names, fnName) => {
+	return `Avoid storing JSX in ${names.length === 0 ? "local variables" : names.length === 1 ? `local '${names[0]}'` : `locals ${names.map((name) => `'${name}'`).join(", ")}`} inside ${describeFunction(fnName)}; return the JSX directly instead.`;
+};
+/**
+* @param {string} childName
+* @param {string} parentName
+*/
+const createNestedFunctionMessage = (childName, parentName) => `JSX-returning ${describeNested(childName)} should not be declared inside ${describeFunction(parentName)}. Extract it to module scope.`;
+/**
+* @param {string} name
+*/
+const createIIFEMessage = (name) => `JSX-returning ${describeNested(name)} should not be declared as an immediately invoked function expression (IIFE). Extract it to a named function at module scope.`;
+const rule = defineRule({
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Disallow JSX-returning functions and JSX-valued assignments within other functions that also return JSX.",
+			recommended: false
+		},
+		schema: []
+	},
+	createOnce(context) {
+		/** @type {FunctionContext[]} */
+		const functionStack = [];
+		const currentFunction = () => functionStack[functionStack.length - 1] ?? null;
+		/**
+		* @param {FunctionLikeNode} node
+		*/
+		const enterFunction = (node) => {
+			/** @type {FunctionContext} */
+			const fnCtx = {
+				node,
+				parent: currentFunction(),
+				name: getFunctionName(node),
+				returnsJsx: false,
+				jsxBindingNames: /* @__PURE__ */ new Set(),
+				jsxAssignments: [],
+				nestedJsxChildren: []
+			};
+			functionStack.push(fnCtx);
+			if (node.type === "ArrowFunctionExpression" && node.body && node.body.type !== "BlockStatement") {
+				if (expressionProducesJsx(node.body, fnCtx.jsxBindingNames)) fnCtx.returnsJsx = true;
+			}
+		};
+		const exitFunction = () => {
+			const fnCtx = functionStack.pop();
+			if (!fnCtx) return;
+			if (fnCtx.returnsJsx && isFunctionImmediatelyInvoked(fnCtx.node)) {
+				context.report({
+					node: fnCtx.node,
+					message: createIIFEMessage(fnCtx.name)
+				});
+				return;
+			}
+			if (fnCtx.parent && fnCtx.returnsJsx && fnCtx.name && !isFunctionUsedAsJsxProp(fnCtx.node)) fnCtx.parent.nestedJsxChildren.push({
+				node: fnCtx.node,
+				name: fnCtx.name
+			});
+			if (!fnCtx.returnsJsx) return;
+			for (const assignment of fnCtx.jsxAssignments) context.report({
+				node: assignment.node,
+				message: createAssignmentMessage(assignment.names, fnCtx.name)
+			});
+			for (const nested of fnCtx.nestedJsxChildren) context.report({
+				node: nested.node,
+				message: createNestedFunctionMessage(nested.name, fnCtx.name)
+			});
+		};
+		/** @param {ReturnStatementNode} node */
+		const handleReturnStatement = (node) => {
+			const fnCtx = currentFunction();
+			if (!fnCtx) return;
+			const argument = node.argument;
+			if (!argument || isFunctionLike(argument)) return;
+			if (expressionProducesJsx(argument, fnCtx.jsxBindingNames)) fnCtx.returnsJsx = true;
+		};
+		/** @param {VariableDeclaratorNode} node */
+		const handleVariableDeclarator = (node) => {
+			const fnCtx = currentFunction();
+			if (!fnCtx) return;
+			const init = node.init;
+			if (!init || isFunctionLike(init)) return;
+			if (!expressionContainsJsx(init)) return;
+			const names = [];
+			collectBindingNames(node.id, names);
+			for (const name of names) fnCtx.jsxBindingNames.add(name);
+			fnCtx.jsxAssignments.push({
+				node: init,
+				names
+			});
+		};
+		/** @param {AssignmentExpressionNode} node */
+		const handleAssignmentExpression = (node) => {
+			if (node.operator !== "=") return;
+			const fnCtx = currentFunction();
+			if (!fnCtx) return;
+			const right = node.right;
+			if (!right || isFunctionLike(right)) return;
+			if (!expressionContainsJsx(right)) return;
+			const names = [];
+			if (node.left && node.left.type === "Identifier") {
+				names.push(node.left.name);
+				fnCtx.jsxBindingNames.add(node.left.name);
+			}
+			fnCtx.jsxAssignments.push({
+				node: right,
+				names
+			});
+		};
+		return {
+			FunctionDeclaration(node) {
+				if (isFunctionLike(node)) enterFunction(node);
+			},
+			"FunctionDeclaration:exit": exitFunction,
+			FunctionExpression(node) {
+				if (isFunctionLike(node)) enterFunction(node);
+			},
+			"FunctionExpression:exit": exitFunction,
+			ArrowFunctionExpression(node) {
+				if (isFunctionLike(node)) enterFunction(node);
+			},
+			"ArrowFunctionExpression:exit": exitFunction,
+			ReturnStatement(node) {
+				if (node.type === "ReturnStatement") handleReturnStatement(node);
+			},
+			VariableDeclarator(node) {
+				if (node.type === "VariableDeclarator") handleVariableDeclarator(node);
+			},
+			AssignmentExpression(node) {
+				if (node.type === "AssignmentExpression") handleAssignmentExpression(node);
+			}
+		};
+	}
+});
+const noInlineComponentsRule = rule;
+var no_inline_components_default = {
+	meta: { name: "no-inline-components" },
+	rules: { "no-inline-components": rule }
+};
+
+//#endregion
+export { no_inline_components_default as default, getEnclosingFunction, getFunctionName, isComponentName, isHookName, noInlineComponentsRule };
+//# sourceMappingURL=no-inline-components.mjs.map

package/dist/oxlint/no-inline-components.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-inline-components.mjs","names":[],"sources":["../../src/oxlint-plugins/no-inline-components.js"],"sourcesContent":["import { defineRule } from \"oxlint\";\r\n\r\n/**\r\n * @typedef {import(\"oxlint\").Context} RuleContext\r\n * @typedef {import(\"oxlint\").ESTree.Node} ESTNode\r\n * @typedef {import(\"oxlint\").ESTree.Expression} ESTExpression\r\n * @typedef {import(\"oxlint\").ESTree.Pattern} ESTPattern\r\n * @typedef {import(\"oxlint\").ESTree.ReturnStatement} ReturnStatementNode\r\n * @typedef {import(\"oxlint\").ESTree.VariableDeclarator} VariableDeclaratorNode\r\n * @typedef {import(\"oxlint\").ESTree.AssignmentExpression} AssignmentExpressionNode\r\n * @typedef {import(\"oxlint\").ESTree.Function | import(\"oxlint\").ESTree.ArrowFunctionExpression} FunctionLikeNode\r\n */\r\n\r\n/**\r\n * @typedef {object} RecordedAssignment\r\n * @property {ESTExpression} node\r\n * @property {string[]} names\r\n */\r\n\r\n/**\r\n * @typedef {object} NestedFunctionRecord\r\n * @property {FunctionLikeNode} node\r\n * @property {string} name\r\n */\r\n\r\n/**\r\n * @typedef {object} FunctionContext\r\n * @property {FunctionLikeNode} node\r\n * @property {FunctionContext | null} parent\r\n * @property {string} name\r\n * @property {boolean} returnsJsx\r\n * @property {Set<string>} jsxBindingNames\r\n * @property {RecordedAssignment[]} jsxAssignments\r\n * @property {NestedFunctionRecord[]} nestedJsxChildren\r\n */\r\n\r\nconst JSX_NODE_TYPES = new Set([\"JSXElement\", \"JSXFragment\"]);\r\nconst FUNCTION_NODE_TYPES = new Set([\"FunctionDeclaration\", \"FunctionExpression\", \"ArrowFunctionExpression\"]);\r\n\r\n/**\r\n * @param {unknown} name\r\n * @returns {name is string}\r\n */\r\nexport const isComponentName = (name) => typeof name === \"string\" && /^[A-Z]/.test(name);\r\n\r\n/**\r\n * @param {unknown} name\r\n * @returns {name is string}\r\n */\r\nexport const isHookName = (name) => typeof name === \"string\" && name.startsWith(\"use\");\r\n\r\n/**\r\n * @param {unknown} node\r\n * @returns {node is ESTNode & { type: string }}\r\n */\r\nconst isNode = (node) => Boolean(node && typeof node === \"object\" && \"type\" in node);\r\n\r\n/**\r\n * @param {unknown} node\r\n * @returns {node is FunctionLikeNode}\r\n */\r\nconst isFunctionLike = (node) => isNode(node) && FUNCTION_NODE_TYPES.has(node.type);\r\n\r\n/**\r\n * @param {ESTNode | null | undefined} node\r\n * @returns {FunctionLikeNode | null}\r\n */\r\nexport const getEnclosingFunction = (node) => {\r\n  const findFunction = (current) => {\r\n    if (!current) return null;\r\n    if (isFunctionLike(current)) {\r\n      return current;\r\n    }\r\n    return findFunction(isNode(current) ? (current.parent ?? null) : null);\r\n  };\r\n  return findFunction(isNode(node) ? (node.parent ?? null) : null);\r\n};\r\n\r\n/**\r\n * @param {FunctionLikeNode} node\r\n */\r\nconst isFunctionUsedAsJsxProp = (node) => {\r\n  const checkJsxProp = (current) => {\r\n    if (!current) return false;\r\n    if (current.type === \"JSXAttribute\") {\r\n      return true;\r\n    }\r\n    if (isFunctionLike(current)) {\r\n      return false;\r\n    }\r\n    return checkJsxProp(isNode(current) ? (current.parent ?? null) : null);\r\n  };\r\n  return checkJsxProp(isNode(node) ? (node.parent ?? null) : null);\r\n};\r\n\r\n/**\r\n * @param {FunctionLikeNode} node\r\n */\r\nconst isFunctionImmediatelyInvoked = (node) => {\r\n  const parent = isNode(node) ? (node.parent ?? null) : null;\r\n  if (!parent) return false;\r\n\r\n  // Check if the function is the callee of a CallExpression (i.e., it's immediately invoked)\r\n  if (parent.type === \"CallExpression\" && parent.callee === node) {\r\n    return true;\r\n  }\r\n\r\n  return false;\r\n};\r\n\r\n/**\r\n * @param {ESTExpression | null | undefined} root\r\n */\r\nconst expressionContainsJsx = (root) => {\r\n  if (!root || !isNode(root)) return false;\r\n\r\n  const stack = [root];\r\n\r\n  while (stack.length > 0) {\r\n    const current = stack.pop();\r\n    if (!current || !isNode(current)) continue;\r\n\r\n    if (JSX_NODE_TYPES.has(current.type)) {\r\n      return true;\r\n    }\r\n\r\n    if (FUNCTION_NODE_TYPES.has(current.type) && current !== root) {\r\n      continue;\r\n    }\r\n\r\n    for (const key of Object.keys(current)) {\r\n      if (key === \"parent\") continue;\r\n\r\n      const value = current[key];\r\n      if (!value) continue;\r\n\r\n      if (Array.isArray(value)) {\r\n        for (const element of value) {\r\n          if (isNode(element)) {\r\n            stack.push(element);\r\n          }\r\n        }\r\n      } else if (isNode(value)) {\r\n        stack.push(value);\r\n      }\r\n    }\r\n  }\r\n\r\n  return false;\r\n};\r\n\r\n/**\r\n * @param {ESTExpression | null | undefined} root\r\n * @param {Set<string>} bindingNames\r\n */\r\nconst expressionProducesJsx = (root, bindingNames) => {\r\n  if (!root) return false;\r\n  if (expressionContainsJsx(root)) return true;\r\n\r\n  if (!isNode(root)) return false;\r\n\r\n  const type = root.type;\r\n\r\n  if (type === \"Identifier\") {\r\n    return bindingNames.has(root.name);\r\n  }\r\n\r\n  if (type === \"ConditionalExpression\") {\r\n    return expressionProducesJsx(root.consequent, bindingNames) || expressionProducesJsx(root.alternate, bindingNames);\r\n  }\r\n\r\n  if (type === \"LogicalExpression\") {\r\n    return expressionProducesJsx(root.left, bindingNames) || expressionProducesJsx(root.right, bindingNames);\r\n  }\r\n\r\n  if (type === \"SequenceExpression\") {\r\n    const expressions = root.expressions ?? [];\r\n    const last = expressions[expressions.length - 1] ?? null;\r\n    return expressionProducesJsx(last, bindingNames);\r\n  }\r\n\r\n  if (type === \"ArrayExpression\") {\r\n    return root.elements.some((element) => {\r\n      if (!element) return false;\r\n      if (element.type === \"SpreadElement\") {\r\n        return expressionProducesJsx(element.argument, bindingNames);\r\n      }\r\n      return expressionProducesJsx(element, bindingNames);\r\n    });\r\n  }\r\n\r\n  if (type === \"ParenthesizedExpression\") {\r\n    return expressionProducesJsx(root.expression, bindingNames);\r\n  }\r\n\r\n  if (type === \"AwaitExpression\" || type === \"UnaryExpression\" || type === \"UpdateExpression\") {\r\n    return expressionProducesJsx(root.argument, bindingNames);\r\n  }\r\n\r\n  if (\r\n    type === \"TSAsExpression\" ||\r\n    type === \"TSTypeAssertion\" ||\r\n    type === \"TSNonNullExpression\" ||\r\n    type === \"ChainExpression\"\r\n  ) {\r\n    return expressionProducesJsx(root.expression, bindingNames);\r\n  }\r\n\r\n  return false;\r\n};\r\n\r\n/**\r\n * @param {ESTPattern | null | undefined} pattern\r\n * @param {string[]} names\r\n */\r\nconst collectBindingNames = (pattern, names) => {\r\n  if (!pattern || !isNode(pattern)) return;\r\n\r\n  const type = pattern.type;\r\n\r\n  if (type === \"Identifier\") {\r\n    names.push(pattern.name);\r\n    return;\r\n  }\r\n\r\n  if (type === \"ArrayPattern\") {\r\n    for (const element of pattern.elements) {\r\n      if (!element) continue;\r\n      if (element.type === \"RestElement\") {\r\n        collectBindingNames(element.argument, names);\r\n      } else {\r\n        collectBindingNames(element, names);\r\n      }\r\n    }\r\n    return;\r\n  }\r\n\r\n  if (type === \"ObjectPattern\") {\r\n    for (const property of pattern.properties) {\r\n      if (!property) continue;\r\n      if (property.type === \"Property\") {\r\n        collectBindingNames(property.value, names);\r\n      } else if (property.type === \"RestElement\") {\r\n        collectBindingNames(property.argument, names);\r\n      }\r\n    }\r\n    return;\r\n  }\r\n\r\n  if (type === \"AssignmentPattern\") {\r\n    collectBindingNames(pattern.left, names);\r\n    return;\r\n  }\r\n\r\n  if (type === \"RestElement\") {\r\n    collectBindingNames(pattern.argument, names);\r\n  }\r\n};\r\n\r\n/**\r\n * @param {FunctionLikeNode} node\r\n */\r\nexport const getFunctionName = (node) => {\r\n  if (node.type === \"FunctionDeclaration\" && node.id && node.id.type === \"Identifier\") {\r\n    return node.id.name;\r\n  }\r\n\r\n  if ((node.type === \"FunctionExpression\" || node.type === \"ArrowFunctionExpression\") && node.id) {\r\n    if (node.id.type === \"Identifier\") return node.id.name;\r\n  }\r\n\r\n  const parent = node.parent;\r\n  if (!parent || !isNode(parent)) return \"\";\r\n\r\n  if (parent.type === \"VariableDeclarator\") {\r\n    return parent.id && parent.id.type === \"Identifier\" ? parent.id.name : \"\";\r\n  }\r\n\r\n  if (parent.type === \"AssignmentExpression\") {\r\n    return parent.left && parent.left.type === \"Identifier\" ? parent.left.name : \"\";\r\n  }\r\n\r\n  if (parent.type === \"Property\" || parent.type === \"MethodDefinition\") {\r\n    return parent.key && parent.key.type === \"Identifier\" ? parent.key.name : \"\";\r\n  }\r\n\r\n  // Handle functions passed as arguments to calls (e.g., useCallback, useMemo)\r\n  if (parent.type === \"CallExpression\") {\r\n    const callParent = parent.parent;\r\n    if (callParent && isNode(callParent)) {\r\n      if (callParent.type === \"VariableDeclarator\") {\r\n        return callParent.id && callParent.id.type === \"Identifier\" ? callParent.id.name : \"\";\r\n      }\r\n      if (callParent.type === \"AssignmentExpression\") {\r\n        return callParent.left && callParent.left.type === \"Identifier\" ? callParent.left.name : \"\";\r\n      }\r\n    }\r\n  }\r\n\r\n  return \"\";\r\n};\r\n\r\n/**\r\n * @param {string} name\r\n */\r\nconst describeFunction = (name) => (name ? `function '${name}'` : \"this function\");\r\n\r\n/**\r\n * @param {string} name\r\n */\r\nconst describeNested = (name) => (name ? `function '${name}'` : \"an anonymous function\");\r\n\r\n/**\r\n * @param {string[]} names\r\n * @param {string} fnName\r\n */\r\nconst createAssignmentMessage = (names, fnName) => {\r\n  const target =\r\n    names.length === 0\r\n      ? \"local variables\"\r\n      : names.length === 1\r\n        ? `local '${names[0]}'`\r\n        : `locals ${names.map((name) => `'${name}'`).join(\", \")}`;\r\n\r\n  return `Avoid storing JSX in ${target} inside ${describeFunction(fnName)}; return the JSX directly instead.`;\r\n};\r\n\r\n/**\r\n * @param {string} childName\r\n * @param {string} parentName\r\n */\r\nconst createNestedFunctionMessage = (childName, parentName) =>\r\n  `JSX-returning ${describeNested(childName)} should not be declared inside ${describeFunction(parentName)}. Extract it to module scope.`;\r\n\r\n/**\r\n * @param {string} name\r\n */\r\nconst createIIFEMessage = (name) =>\r\n  `JSX-returning ${describeNested(name)} should not be declared as an immediately invoked function expression (IIFE). Extract it to a named function at module scope.`;\r\n\r\nconst rule = defineRule({\r\n  meta: {\r\n    type: \"problem\",\r\n    docs: {\r\n      description:\r\n        \"Disallow JSX-returning functions and JSX-valued assignments within other functions that also return JSX.\",\r\n      recommended: false,\r\n    },\r\n    schema: [],\r\n  },\r\n\r\n  createOnce(context) {\r\n    /** @type {FunctionContext[]} */\r\n    const functionStack = [];\r\n\r\n    const currentFunction = () => functionStack[functionStack.length - 1] ?? null;\r\n\r\n    /**\r\n     * @param {FunctionLikeNode} node\r\n     */\r\n    const enterFunction = (node) => {\r\n      const parent = currentFunction();\r\n      /** @type {FunctionContext} */\r\n      const fnCtx = {\r\n        node,\r\n        parent,\r\n        name: getFunctionName(node),\r\n        returnsJsx: false,\r\n        jsxBindingNames: new Set(),\r\n        jsxAssignments: [],\r\n        nestedJsxChildren: [],\r\n      };\r\n\r\n      functionStack.push(fnCtx);\r\n\r\n      if (node.type === \"ArrowFunctionExpression\" && node.body && node.body.type !== \"BlockStatement\") {\r\n        if (expressionProducesJsx(node.body, fnCtx.jsxBindingNames)) {\r\n          fnCtx.returnsJsx = true;\r\n        }\r\n      }\r\n    };\r\n\r\n    const exitFunction = () => {\r\n      const fnCtx = functionStack.pop();\r\n      if (!fnCtx) return;\r\n\r\n      if (fnCtx.returnsJsx && isFunctionImmediatelyInvoked(fnCtx.node)) {\r\n        context.report({\r\n          node: fnCtx.node,\r\n          message: createIIFEMessage(fnCtx.name),\r\n        });\r\n        return;\r\n      }\r\n\r\n      if (fnCtx.parent && fnCtx.returnsJsx && fnCtx.name && !isFunctionUsedAsJsxProp(fnCtx.node)) {\r\n        fnCtx.parent.nestedJsxChildren.push({ node: fnCtx.node, name: fnCtx.name });\r\n      }\r\n\r\n      if (!fnCtx.returnsJsx) return;\r\n\r\n      for (const assignment of fnCtx.jsxAssignments) {\r\n        context.report({\r\n          node: assignment.node,\r\n          message: createAssignmentMessage(assignment.names, fnCtx.name),\r\n        });\r\n      }\r\n\r\n      for (const nested of fnCtx.nestedJsxChildren) {\r\n        context.report({\r\n          node: nested.node,\r\n          message: createNestedFunctionMessage(nested.name, fnCtx.name),\r\n        });\r\n      }\r\n    };\r\n\r\n    /** @param {ReturnStatementNode} node */\r\n    const handleReturnStatement = (node) => {\r\n      const fnCtx = currentFunction();\r\n      if (!fnCtx) return;\r\n\r\n      const argument = node.argument;\r\n      if (!argument || isFunctionLike(argument)) return;\r\n\r\n      if (expressionProducesJsx(argument, fnCtx.jsxBindingNames)) {\r\n        fnCtx.returnsJsx = true;\r\n      }\r\n    };\r\n\r\n    /** @param {VariableDeclaratorNode} node */\r\n    const handleVariableDeclarator = (node) => {\r\n      const fnCtx = currentFunction();\r\n      if (!fnCtx) return;\r\n\r\n      const init = node.init;\r\n      if (!init || isFunctionLike(init)) return;\r\n      if (!expressionContainsJsx(init)) return;\r\n\r\n      const names = [];\r\n      collectBindingNames(node.id, names);\r\n      for (const name of names) {\r\n        fnCtx.jsxBindingNames.add(name);\r\n      }\r\n\r\n      fnCtx.jsxAssignments.push({ node: init, names });\r\n    };\r\n\r\n    /** @param {AssignmentExpressionNode} node */\r\n    const handleAssignmentExpression = (node) => {\r\n      if (node.operator !== \"=\") return;\r\n\r\n      const fnCtx = currentFunction();\r\n      if (!fnCtx) return;\r\n\r\n      const right = node.right;\r\n      if (!right || isFunctionLike(right)) return;\r\n      if (!expressionContainsJsx(right)) return;\r\n\r\n      const names = [];\r\n      if (node.left && node.left.type === \"Identifier\") {\r\n        names.push(node.left.name);\r\n        fnCtx.jsxBindingNames.add(node.left.name);\r\n      }\r\n\r\n      fnCtx.jsxAssignments.push({ node: right, names });\r\n    };\r\n\r\n    return /** @type {import(\"oxlint\").VisitorWithHooks} */ ({\r\n      FunctionDeclaration(node) {\r\n        if (isFunctionLike(node)) enterFunction(node);\r\n      },\r\n      \"FunctionDeclaration:exit\": exitFunction,\r\n      FunctionExpression(node) {\r\n        if (isFunctionLike(node)) enterFunction(node);\r\n      },\r\n      \"FunctionExpression:exit\": exitFunction,\r\n      ArrowFunctionExpression(node) {\r\n        if (isFunctionLike(node)) enterFunction(node);\r\n      },\r\n      \"ArrowFunctionExpression:exit\": exitFunction,\r\n      ReturnStatement(node) {\r\n        if (node.type === \"ReturnStatement\") handleReturnStatement(node);\r\n      },\r\n      VariableDeclarator(node) {\r\n        if (node.type === \"VariableDeclarator\") handleVariableDeclarator(node);\r\n      },\r\n      AssignmentExpression(node) {\r\n        if (node.type === \"AssignmentExpression\") handleAssignmentExpression(node);\r\n      },\r\n    });\r\n  },\r\n});\r\n\r\nexport const noInlineComponentsRule = rule;\r\n\r\nexport default {\r\n  meta: { name: \"no-inline-components\" },\r\n  rules: { \"no-inline-components\": rule },\r\n};\r\n"],"mappings":"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"}

package/dist/oxlint/no-react-namespace.d.mts

@@ -0,0 +1,16 @@
+import * as oxlint27 from "oxlint";
+
+//#region src/oxlint-plugins/no-react-namespace.d.ts
+declare const noReactNamespaceRule: oxlint27.Rule;
+declare namespace _default {
+  namespace meta {
+    let name: string;
+  }
+  let rules: {
+    "no-react-namespace": oxlint27.Rule;
+  };
+}
+type ESTNode = oxlint27.ESTree.Node;
+//#endregion
+export { ESTNode, _default as default, noReactNamespaceRule };
+//# sourceMappingURL=no-react-namespace.d.mts.map

package/dist/oxlint/no-react-namespace.mjs

@@ -0,0 +1,75 @@
+import { defineRule } from "oxlint";
+
+//#region src/oxlint-plugins/no-react-namespace.js
+/** @typedef {import("oxlint").ESTree.Node} ESTNode */
+/**
+* Check if a MemberExpression is accessing the React namespace
+* @param {ESTNode} node
+* @returns {boolean}
+*/
+const isReactNamespaceAccess = (node) => {
+	if (node.type !== "MemberExpression") return false;
+	const object = node.object;
+	if (!object || object.type !== "Identifier" || object.name !== "React") return false;
+	return true;
+};
+/**
+* Check if this is a type annotation context (TypeScript)
+* @param {ESTNode} node
+* @returns {boolean}
+*/
+const isTypeContext = (node) => {
+	const checkParent = (current) => {
+		if (!current) return false;
+		if (new Set([
+			"TSTypeReference",
+			"TSTypeAnnotation",
+			"TSTypeParameterInstantiation",
+			"TSInterfaceHeritage",
+			"TSTypeQuery",
+			"TSTypeAliasDeclaration",
+			"TSInterfaceDeclaration",
+			"TSTypeLiteral",
+			"TSPropertySignature",
+			"TSIndexSignature",
+			"TSMethodSignature",
+			"TSCallSignatureDeclaration",
+			"TSConstructSignatureDeclaration",
+			"TSExpressionWithTypeArguments"
+		]).has(current.type)) return true;
+		if (current.type === "ExpressionStatement" || current.type === "VariableDeclarator" || current.type === "CallExpression" || current.type === "ReturnStatement") return false;
+		return checkParent(current.parent);
+	};
+	return checkParent(node.parent);
+};
+const rule = defineRule({
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Disallow using the React namespace for accessing React APIs. Use destructured imports instead (e.g., import { useState } from 'react').",
+			recommended: true
+		},
+		schema: []
+	},
+	createOnce(context) {
+		return { MemberExpression(node) {
+			if (node.type !== "MemberExpression") return;
+			if (!isReactNamespaceAccess(node)) return;
+			if (isTypeContext(node)) return;
+			const propertyName = node.property && node.property.type === "Identifier" ? node.property.name : "property";
+			context.report({
+				node,
+				message: `Avoid using 'React.${propertyName}'. Import '${propertyName}' directly from 'react' instead (e.g., import { ${propertyName} } from 'react').`
+			});
+		} };
+	}
+});
+const noReactNamespaceRule = rule;
+var no_react_namespace_default = {
+	meta: { name: "no-react-namespace" },
+	rules: { "no-react-namespace": rule }
+};
+
+//#endregion
+export { no_react_namespace_default as default, noReactNamespaceRule };
+//# sourceMappingURL=no-react-namespace.mjs.map

package/dist/oxlint/no-react-namespace.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-react-namespace.mjs","names":[],"sources":["../../src/oxlint-plugins/no-react-namespace.js"],"sourcesContent":["import { defineRule } from \"oxlint\";\r\n\r\n/** @typedef {import(\"oxlint\").ESTree.Node} ESTNode */\r\n\r\n/**\r\n * Check if a MemberExpression is accessing the React namespace\r\n * @param {ESTNode} node\r\n * @returns {boolean}\r\n */\r\nconst isReactNamespaceAccess = (node) => {\r\n  if (node.type !== \"MemberExpression\") return false;\r\n\r\n  const object = node.object;\r\n  if (!object || object.type !== \"Identifier\" || object.name !== \"React\") {\r\n    return false;\r\n  }\r\n\r\n  return true;\r\n};\r\n\r\n/**\r\n * Check if this is a type annotation context (TypeScript)\r\n * @param {ESTNode} node\r\n * @returns {boolean}\r\n */\r\nconst isTypeContext = (node) => {\r\n  const checkParent = (current) => {\r\n    if (!current) return false;\r\n\r\n    // Type annotation contexts where React namespace is allowed\r\n    const typeContextTypes = new Set([\r\n      \"TSTypeReference\",\r\n      \"TSTypeAnnotation\",\r\n      \"TSTypeParameterInstantiation\",\r\n      \"TSInterfaceHeritage\",\r\n      \"TSTypeQuery\",\r\n      \"TSTypeAliasDeclaration\",\r\n      \"TSInterfaceDeclaration\",\r\n      \"TSTypeLiteral\",\r\n      \"TSPropertySignature\",\r\n      \"TSIndexSignature\",\r\n      \"TSMethodSignature\",\r\n      \"TSCallSignatureDeclaration\",\r\n      \"TSConstructSignatureDeclaration\",\r\n      \"TSExpressionWithTypeArguments\",\r\n    ]);\r\n\r\n    if (typeContextTypes.has(current.type)) {\r\n      return true;\r\n    }\r\n\r\n    // Stop at statement or expression boundaries\r\n    if (\r\n      current.type === \"ExpressionStatement\" ||\r\n      current.type === \"VariableDeclarator\" ||\r\n      current.type === \"CallExpression\" ||\r\n      current.type === \"ReturnStatement\"\r\n    ) {\r\n      return false;\r\n    }\r\n\r\n    return checkParent(current.parent);\r\n  };\r\n\r\n  return checkParent(node.parent);\r\n};\r\n\r\nconst rule = defineRule({\r\n  meta: {\r\n    type: \"problem\",\r\n    docs: {\r\n      description:\r\n        \"Disallow using the React namespace for accessing React APIs. Use destructured imports instead (e.g., import { useState } from 'react').\",\r\n      recommended: true,\r\n    },\r\n    schema: [],\r\n  },\r\n  createOnce(context) {\r\n    return /** @type {import(\"oxlint\").VisitorWithHooks} */ ({\r\n      /**\r\n       * @param {ESTNode} node\r\n       */\r\n      MemberExpression(node) {\r\n        if (node.type !== \"MemberExpression\") return;\r\n\r\n        if (!isReactNamespaceAccess(node)) return;\r\n\r\n        // Allow React namespace in type annotations\r\n        if (isTypeContext(node)) return;\r\n\r\n        const propertyName = node.property && node.property.type === \"Identifier\" ? node.property.name : \"property\";\r\n\r\n        context.report({\r\n          node,\r\n          message: `Avoid using 'React.${propertyName}'. Import '${propertyName}' directly from 'react' instead (e.g., import { ${propertyName} } from 'react').`,\r\n        });\r\n      },\r\n    });\r\n  },\r\n});\r\n\r\nexport const noReactNamespaceRule = rule;\r\n\r\nexport default {\r\n  meta: { name: \"no-react-namespace\" },\r\n  rules: { \"no-react-namespace\": rule },\r\n};\r\n"],"mappings":";;;;;;;;;AASA,MAAM,0BAA0B,SAAS;AACvC,KAAI,KAAK,SAAS,mBAAoB,QAAO;CAE7C,MAAM,SAAS,KAAK;AACpB,KAAI,CAAC,UAAU,OAAO,SAAS,gBAAgB,OAAO,SAAS,QAC7D,QAAO;AAGT,QAAO;;;;;;;AAQT,MAAM,iBAAiB,SAAS;CAC9B,MAAM,eAAe,YAAY;AAC/B,MAAI,CAAC,QAAS,QAAO;AAoBrB,MAjByB,IAAI,IAAI;GAC/B;GACA;GACA;GACA;GACA;GACA;GACA;GACA;GACA;GACA;GACA;GACA;GACA;GACA;GACD,CAAC,CAEmB,IAAI,QAAQ,KAAK,CACpC,QAAO;AAIT,MACE,QAAQ,SAAS,yBACjB,QAAQ,SAAS,wBACjB,QAAQ,SAAS,oBACjB,QAAQ,SAAS,kBAEjB,QAAO;AAGT,SAAO,YAAY,QAAQ,OAAO;;AAGpC,QAAO,YAAY,KAAK,OAAO;;AAGjC,MAAM,OAAO,WAAW;CACtB,MAAM;EACJ,MAAM;EACN,MAAM;GACJ,aACE;GACF,aAAa;GACd;EACD,QAAQ,EAAE;EACX;CACD,WAAW,SAAS;AAClB,SAAyD,EAIvD,iBAAiB,MAAM;AACrB,OAAI,KAAK,SAAS,mBAAoB;AAEtC,OAAI,CAAC,uBAAuB,KAAK,CAAE;AAGnC,OAAI,cAAc,KAAK,CAAE;GAEzB,MAAM,eAAe,KAAK,YAAY,KAAK,SAAS,SAAS,eAAe,KAAK,SAAS,OAAO;AAEjG,WAAQ,OAAO;IACb;IACA,SAAS,sBAAsB,aAAa,aAAa,aAAa,kDAAkD,aAAa;IACtI,CAAC;KAEL;;CAEJ,CAAC;AAEF,MAAa,uBAAuB;AAEpC,iCAAe;CACb,MAAM,EAAE,MAAM,sBAAsB;CACpC,OAAO,EAAE,sBAAsB,MAAM;CACtC"}

package/dist/oxlint/no-switch-plugin.d.mts

@@ -0,0 +1,15 @@
+import * as oxlint33 from "oxlint";
+
+//#region src/oxlint-plugins/no-switch-plugin.d.ts
+declare namespace _default {
+  namespace meta {
+    let name: string;
+  }
+  let rules: {
+    "no-switch": oxlint33.Rule;
+  };
+}
+type ESTNode = oxlint33.ESTree.Node;
+//#endregion
+export { ESTNode, _default as default };
+//# sourceMappingURL=no-switch-plugin.d.mts.map

package/dist/oxlint/no-switch-plugin.mjs

@@ -0,0 +1,31 @@
+import { defineRule } from "oxlint";
+
+//#region src/oxlint-plugins/no-switch-plugin.js
+/** @typedef {import("oxlint").ESTree.Node} ESTNode */
+const noSwitchRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Disallow switch/case statements",
+			recommended: true
+		},
+		schema: []
+	},
+	createOnce(context) {
+		return { SwitchStatement(node) {
+			if (node.type !== "SwitchStatement") return;
+			context.report({
+				node,
+				message: "Use of switch/case is disallowed. Use object map or if/else instead."
+			});
+		} };
+	}
+});
+var no_switch_plugin_default = {
+	meta: { name: "no-switch-plugin" },
+	rules: { "no-switch": noSwitchRule }
+};
+
+//#endregion
+export { no_switch_plugin_default as default };
+//# sourceMappingURL=no-switch-plugin.mjs.map

package/dist/oxlint/no-switch-plugin.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-switch-plugin.mjs","names":[],"sources":["../../src/oxlint-plugins/no-switch-plugin.js"],"sourcesContent":["import { defineRule } from \"oxlint\";\n\n/** @typedef {import(\"oxlint\").ESTree.Node} ESTNode */\n\nconst noSwitchRule = defineRule({\n  meta: {\n    type: \"problem\",\n    docs: {\n      description: \"Disallow switch/case statements\",\n      recommended: true,\n    },\n    schema: [],\n  },\n  createOnce(context) {\n    return /** @type {import(\"oxlint\").VisitorWithHooks} */ ({\n      /**\n       * @param {ESTNode} node\n       */\n      SwitchStatement(node) {\n        if (node.type !== \"SwitchStatement\") return;\n\n        context.report({\n          node,\n          message: \"Use of switch/case is disallowed. Use object map or if/else instead.\",\n        });\n      },\n    });\n  },\n});\n\nexport default {\n  meta: {\n    name: \"no-switch-plugin\",\n  },\n  rules: {\n    \"no-switch\": noSwitchRule,\n  },\n};\n"],"mappings":";;;;AAIA,MAAM,eAAe,WAAW;CAC9B,MAAM;EACJ,MAAM;EACN,MAAM;GACJ,aAAa;GACb,aAAa;GACd;EACD,QAAQ,EAAE;EACX;CACD,WAAW,SAAS;AAClB,SAAyD,EAIvD,gBAAgB,MAAM;AACpB,OAAI,KAAK,SAAS,kBAAmB;AAErC,WAAQ,OAAO;IACb;IACA,SAAS;IACV,CAAC;KAEL;;CAEJ,CAAC;AAEF,+BAAe;CACb,MAAM,EACJ,MAAM,oBACP;CACD,OAAO,EACL,aAAa,cACd;CACF"}

package/dist/oxlint/no-top-level-let.d.mts

@@ -0,0 +1,16 @@
+import * as oxlint10 from "oxlint";
+
+//#region src/oxlint-plugins/no-top-level-let.d.ts
+declare const noTopLevelLetRule: oxlint10.Rule;
+declare namespace _default {
+  namespace meta {
+    let name: string;
+  }
+  let rules: {
+    "no-top-level-let": oxlint10.Rule;
+  };
+}
+type ESTNode = oxlint10.ESTree.Node;
+//#endregion
+export { ESTNode, _default as default, noTopLevelLetRule };
+//# sourceMappingURL=no-top-level-let.d.mts.map

package/dist/oxlint/no-top-level-let.mjs

@@ -0,0 +1,66 @@
+import { defineRule } from "oxlint";
+
+//#region src/oxlint-plugins/no-top-level-let.js
+/** @typedef {import("oxlint").ESTree.Node} ESTNode */
+/**
+* Get the enclosing function node for a given node
+* @param {ESTNode} node
+* @returns {ESTNode | null}
+*/
+const getEnclosingFunction = (node) => {
+	const findFunction = (current) => {
+		if (!current) return null;
+		if (current.type === "FunctionDeclaration" || current.type === "FunctionExpression" || current.type === "ArrowFunctionExpression") return current;
+		return findFunction(current.parent);
+	};
+	return findFunction(node.parent);
+};
+/**
+* Check if a node is inside a loop
+* @param {ESTNode} node
+* @param {ESTNode} stopAt - Stop searching when we reach this node
+* @returns {boolean}
+*/
+const isInsideLoop = (node, stopAt) => {
+	const checkLoop = (current) => {
+		if (!current || current === stopAt) return false;
+		if (current.type === "ForStatement" || current.type === "ForInStatement" || current.type === "ForOfStatement" || current.type === "WhileStatement" || current.type === "DoWhileStatement") return true;
+		return checkLoop(current.parent);
+	};
+	return checkLoop(node.parent);
+};
+const rule = defineRule({
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Disallow top-level `let` declarations inside functions to prevent conditional reassignment.",
+			recommended: false
+		},
+		schema: []
+	},
+	createOnce(context) {
+		return { VariableDeclaration(rawNode) {
+			if (rawNode.type !== "VariableDeclaration") return;
+			const node = rawNode;
+			if (node.kind !== "let") return;
+			const fn = getEnclosingFunction(node);
+			if (!fn || fn.type !== "FunctionDeclaration" && fn.type !== "FunctionExpression" && fn.type !== "ArrowFunctionExpression") return;
+			const parent = node.parent;
+			if (!parent || parent.type !== "BlockStatement" || parent.parent !== fn) return;
+			if (isInsideLoop(node, fn)) return;
+			context.report({
+				node,
+				message: "Avoid using `let` at the top level of functions; prefer `const` with extracted functions to avoid conditional reassignment. Extract conditional logic into a separate function that returns the appropriate value."
+			});
+		} };
+	}
+});
+const noTopLevelLetRule = rule;
+var no_top_level_let_default = {
+	meta: { name: "no-top-level-let" },
+	rules: { "no-top-level-let": rule }
+};
+
+//#endregion
+export { no_top_level_let_default as default, noTopLevelLetRule };
+//# sourceMappingURL=no-top-level-let.mjs.map

package/dist/oxlint/no-top-level-let.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-top-level-let.mjs","names":[],"sources":["../../src/oxlint-plugins/no-top-level-let.js"],"sourcesContent":["import { defineRule } from \"oxlint\";\r\n\r\n/** @typedef {import(\"oxlint\").ESTree.Node} ESTNode */\r\n\r\n/**\r\n * Get the enclosing function node for a given node\r\n * @param {ESTNode} node\r\n * @returns {ESTNode | null}\r\n */\r\nconst getEnclosingFunction = (node) => {\r\n  const findFunction = (current) => {\r\n    if (!current) return null;\r\n    if (\r\n      current.type === \"FunctionDeclaration\" ||\r\n      current.type === \"FunctionExpression\" ||\r\n      current.type === \"ArrowFunctionExpression\"\r\n    ) {\r\n      return current;\r\n    }\r\n    return findFunction(current.parent);\r\n  };\r\n  return findFunction(node.parent);\r\n};\r\n\r\n/**\r\n * Check if a node is inside a loop\r\n * @param {ESTNode} node\r\n * @param {ESTNode} stopAt - Stop searching when we reach this node\r\n * @returns {boolean}\r\n */\r\nconst isInsideLoop = (node, stopAt) => {\r\n  const checkLoop = (current) => {\r\n    if (!current || current === stopAt) return false;\r\n    if (\r\n      current.type === \"ForStatement\" ||\r\n      current.type === \"ForInStatement\" ||\r\n      current.type === \"ForOfStatement\" ||\r\n      current.type === \"WhileStatement\" ||\r\n      current.type === \"DoWhileStatement\"\r\n    ) {\r\n      return true;\r\n    }\r\n    return checkLoop(current.parent);\r\n  };\r\n  return checkLoop(node.parent);\r\n};\r\n\r\nconst rule = defineRule({\r\n  meta: {\r\n    type: \"problem\",\r\n    docs: {\r\n      description: \"Disallow top-level `let` declarations inside functions to prevent conditional reassignment.\",\r\n      recommended: false,\r\n    },\r\n    schema: [],\r\n  },\r\n\r\n  createOnce(context) {\r\n    return /** @type {import(\"oxlint\").VisitorWithHooks} */ ({\r\n      /**\r\n       * @param {ESTNode} rawNode\r\n       */\r\n      VariableDeclaration(rawNode) {\r\n        if (rawNode.type !== \"VariableDeclaration\") return;\r\n        const node = rawNode;\r\n\r\n        if (node.kind !== \"let\") return;\r\n\r\n        const fn = getEnclosingFunction(node);\r\n        if (\r\n          !fn ||\r\n          (fn.type !== \"FunctionDeclaration\" &&\r\n            fn.type !== \"FunctionExpression\" &&\r\n            fn.type !== \"ArrowFunctionExpression\")\r\n        ) {\r\n          return;\r\n        }\r\n\r\n        const parent = node.parent;\r\n        if (!parent || parent.type !== \"BlockStatement\" || parent.parent !== fn) return;\r\n\r\n        // Allow let declarations inside loops\r\n        if (isInsideLoop(node, fn)) return;\r\n\r\n        context.report({\r\n          node,\r\n          message:\r\n            \"Avoid using `let` at the top level of functions; prefer `const` with extracted functions to avoid conditional reassignment. Extract conditional logic into a separate function that returns the appropriate value.\",\r\n        });\r\n      },\r\n    });\r\n  },\r\n});\r\n\r\nexport const noTopLevelLetRule = rule;\r\n\r\nexport default {\r\n  meta: { name: \"no-top-level-let\" },\r\n  rules: { \"no-top-level-let\": rule },\r\n};\r\n"],"mappings":";;;;;;;;;AASA,MAAM,wBAAwB,SAAS;CACrC,MAAM,gBAAgB,YAAY;AAChC,MAAI,CAAC,QAAS,QAAO;AACrB,MACE,QAAQ,SAAS,yBACjB,QAAQ,SAAS,wBACjB,QAAQ,SAAS,0BAEjB,QAAO;AAET,SAAO,aAAa,QAAQ,OAAO;;AAErC,QAAO,aAAa,KAAK,OAAO;;;;;;;;AASlC,MAAM,gBAAgB,MAAM,WAAW;CACrC,MAAM,aAAa,YAAY;AAC7B,MAAI,CAAC,WAAW,YAAY,OAAQ,QAAO;AAC3C,MACE,QAAQ,SAAS,kBACjB,QAAQ,SAAS,oBACjB,QAAQ,SAAS,oBACjB,QAAQ,SAAS,oBACjB,QAAQ,SAAS,mBAEjB,QAAO;AAET,SAAO,UAAU,QAAQ,OAAO;;AAElC,QAAO,UAAU,KAAK,OAAO;;AAG/B,MAAM,OAAO,WAAW;CACtB,MAAM;EACJ,MAAM;EACN,MAAM;GACJ,aAAa;GACb,aAAa;GACd;EACD,QAAQ,EAAE;EACX;CAED,WAAW,SAAS;AAClB,SAAyD,EAIvD,oBAAoB,SAAS;AAC3B,OAAI,QAAQ,SAAS,sBAAuB;GAC5C,MAAM,OAAO;AAEb,OAAI,KAAK,SAAS,MAAO;GAEzB,MAAM,KAAK,qBAAqB,KAAK;AACrC,OACE,CAAC,MACA,GAAG,SAAS,yBACX,GAAG,SAAS,wBACZ,GAAG,SAAS,0BAEd;GAGF,MAAM,SAAS,KAAK;AACpB,OAAI,CAAC,UAAU,OAAO,SAAS,oBAAoB,OAAO,WAAW,GAAI;AAGzE,OAAI,aAAa,MAAM,GAAG,CAAE;AAE5B,WAAQ,OAAO;IACb;IACA,SACE;IACH,CAAC;KAEL;;CAEJ,CAAC;AAEF,MAAa,oBAAoB;AAEjC,+BAAe;CACb,MAAM,EAAE,MAAM,oBAAoB;CAClC,OAAO,EAAE,oBAAoB,MAAM;CACpC"}