@conorroberts/utils 0.0.60 → 0.0.61

package/dist/oxlint/index.mjs

@@ -0,0 +1,1091 @@
+import { definePlugin, defineRule } from "oxlint";
+
+//#region src/oxlint-plugins/jsx-component-pascal-case.js
+/**
+* @typedef {import("oxlint").Context} RuleContext
+* @typedef {import("oxlint").ESTree.Node} ESTNode
+* @typedef {import("oxlint").ESTree.Expression} ESTExpression
+* @typedef {import("oxlint").ESTree.ReturnStatement} ReturnStatementNode
+* @typedef {import("oxlint").ESTree.Function | import("oxlint").ESTree.ArrowFunctionExpression} FunctionLikeNode
+*/
+/**
+* @typedef {object} FunctionContext
+* @property {FunctionLikeNode} node
+* @property {string} name
+* @property {boolean} returnsJsx
+*/
+const JSX_NODE_TYPES$2 = new Set(["JSXElement", "JSXFragment"]);
+const FUNCTION_NODE_TYPES$3 = new Set([
+	"FunctionDeclaration",
+	"FunctionExpression",
+	"ArrowFunctionExpression"
+]);
+/**
+* @param {unknown} node
+* @returns {node is ESTNode & { type: string }}
+*/
+const isNode$3 = (node) => Boolean(node && typeof node === "object" && "type" in node);
+/**
+* @param {unknown} node
+* @returns {node is FunctionLikeNode}
+*/
+const isFunctionLike$3 = (node) => isNode$3(node) && FUNCTION_NODE_TYPES$3.has(node.type);
+/**
+* @param {unknown} name
+* @returns {name is string}
+*/
+const isPascalCase = (name) => typeof name === "string" && /^[A-Z]/.test(name);
+/**
+* Check if a name is a valid higher-order component name (starts with "with")
+* @param {unknown} name
+* @returns {name is string}
+*/
+const isHOCName = (name) => typeof name === "string" && /^with[A-Z]/.test(name);
+/**
+* @param {FunctionLikeNode} node
+*/
+const getFunctionName$2 = (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$3(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 "";
+	if (parent.type === "CallExpression") {
+		const callParent = parent.parent;
+		if (callParent && isNode$3(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 {ESTExpression | null | undefined} root
+*/
+const expressionContainsJsx$2 = (root) => {
+	if (!root || !isNode$3(root)) return false;
+	const stack = [root];
+	while (stack.length > 0) {
+		const current = stack.pop();
+		if (!current || !isNode$3(current)) continue;
+		if (JSX_NODE_TYPES$2.has(current.type)) return true;
+		if (FUNCTION_NODE_TYPES$3.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$3(element)) stack.push(element);
+			} else if (isNode$3(value)) stack.push(value);
+		}
+	}
+	return false;
+};
+const rule$8 = defineRule({
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Enforce PascalCase naming for functions that return JSX elements (components).",
+			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,
+				name: getFunctionName$2(node),
+				returnsJsx: false
+			};
+			functionStack.push(fnCtx);
+			if (node.type === "ArrowFunctionExpression" && node.body && node.body.type !== "BlockStatement") {
+				if (expressionContainsJsx$2(node.body)) fnCtx.returnsJsx = true;
+			}
+		};
+		const exitFunction = () => {
+			const fnCtx = functionStack.pop();
+			if (!fnCtx) return;
+			if (fnCtx.returnsJsx && fnCtx.name && !isPascalCase(fnCtx.name) && !isHOCName(fnCtx.name)) context.report({
+				node: fnCtx.node,
+				message: `Function '${fnCtx.name}' returns JSX and should use PascalCase naming (e.g., '${fnCtx.name.charAt(0).toUpperCase()}${fnCtx.name.slice(1)}').`
+			});
+		};
+		/** @param {ReturnStatementNode} node */
+		const handleReturnStatement = (node) => {
+			const fnCtx = currentFunction();
+			if (!fnCtx) return;
+			const argument = node.argument;
+			if (!argument || isFunctionLike$3(argument)) return;
+			if (expressionContainsJsx$2(argument)) fnCtx.returnsJsx = true;
+		};
+		return {
+			FunctionDeclaration(node) {
+				if (isFunctionLike$3(node)) enterFunction(node);
+			},
+			"FunctionDeclaration:exit": exitFunction,
+			FunctionExpression(node) {
+				if (isFunctionLike$3(node)) enterFunction(node);
+			},
+			"FunctionExpression:exit": exitFunction,
+			ArrowFunctionExpression(node) {
+				if (isFunctionLike$3(node)) enterFunction(node);
+			},
+			"ArrowFunctionExpression:exit": exitFunction,
+			ReturnStatement(node) {
+				if (node.type === "ReturnStatement") handleReturnStatement(node);
+			}
+		};
+	}
+});
+const jsxComponentPascalCaseRule = rule$8;
+
+//#endregion
+//#region src/oxlint-plugins/no-component-date-instantiation.js
+/**
+* @typedef {import("oxlint").Context} RuleContext
+* @typedef {import("oxlint").ESTree.Node} ESTNode
+* @typedef {import("oxlint").ESTree.NewExpression} NewExpressionNode
+* @typedef {import("oxlint").ESTree.ReturnStatement} ReturnStatementNode
+* @typedef {import("oxlint").ESTree.Function | import("oxlint").ESTree.ArrowFunctionExpression} FunctionLikeNode
+*/
+/**
+* @typedef {object} FunctionContext
+* @property {FunctionLikeNode} node
+* @property {FunctionContext | null} parent
+* @property {string} name
+* @property {boolean} returnsJsx
+* @property {NewExpressionNode[]} dateInstantiations
+*/
+const FUNCTION_NODE_TYPES$2 = new Set([
+	"FunctionDeclaration",
+	"FunctionExpression",
+	"ArrowFunctionExpression"
+]);
+/**
+* @param {unknown} node
+* @returns {node is ESTNode & { type: string }}
+*/
+const isNode$2 = (node) => Boolean(node && typeof node === "object" && "type" in node);
+/**
+* @param {unknown} node
+* @returns {node is FunctionLikeNode}
+*/
+const isFunctionLike$2 = (node) => isNode$2(node) && FUNCTION_NODE_TYPES$2.has(node.type);
+/**
+* Check if a function name follows React component naming convention (PascalCase)
+* @param {unknown} name
+* @returns {name is string}
+*/
+const isComponentName = (name) => typeof name === "string" && /^[A-Z]/.test(name);
+/**
+* Get the name of a function node
+* @param {FunctionLikeNode} node
+* @returns {string}
+*/
+const getFunctionName$1 = (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$2(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 : "";
+	return "";
+};
+/**
+* Check if a node is a JSX element or fragment
+* @param {ESTNode | null | undefined} node
+* @returns {boolean}
+*/
+const isJSXNode = (node) => {
+	if (!node || !isNode$2(node)) return false;
+	return node.type === "JSXElement" || node.type === "JSXFragment";
+};
+/**
+* Check if a NewExpression is creating a Date instance
+* @param {NewExpressionNode} node
+* @returns {boolean}
+*/
+const isDateInstantiation = (node) => {
+	if (node.callee.type === "Identifier" && node.callee.name === "Date") return true;
+	return false;
+};
+const rule$7 = defineRule({
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Disallow Date instantiation in the top scope of React components. Date instances declared on every render are bad because they change every render.",
+			recommended: true
+		},
+		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$1(node),
+				returnsJsx: false,
+				dateInstantiations: []
+			};
+			functionStack.push(fnCtx);
+			if (node.type === "ArrowFunctionExpression" && node.body && node.body.type !== "BlockStatement") {
+				if (isJSXNode(node.body)) fnCtx.returnsJsx = true;
+			}
+		};
+		const exitFunction = () => {
+			const fnCtx = functionStack.pop();
+			if (!fnCtx) return;
+			if (!fnCtx.returnsJsx) return;
+			if (!isComponentName(fnCtx.name)) return;
+			for (const dateNode of fnCtx.dateInstantiations) context.report({
+				node: dateNode,
+				message: `Avoid instantiating Date in the top scope of component '${fnCtx.name}'. Date instances change on every render. Move it inside an effect, event handler, or use useMemo/useCallback.`
+			});
+		};
+		/** @param {ReturnStatementNode} node */
+		const handleReturnStatement = (node) => {
+			const fnCtx = currentFunction();
+			if (!fnCtx) return;
+			const argument = node.argument;
+			if (!argument) return;
+			if (isJSXNode(argument)) fnCtx.returnsJsx = true;
+		};
+		/** @param {NewExpressionNode} node */
+		const handleNewExpression = (node) => {
+			if (!isDateInstantiation(node)) return;
+			const fnCtx = currentFunction();
+			if (!fnCtx) return;
+			fnCtx.dateInstantiations.push(node);
+		};
+		return {
+			FunctionDeclaration(node) {
+				if (isFunctionLike$2(node)) enterFunction(node);
+			},
+			"FunctionDeclaration:exit": exitFunction,
+			FunctionExpression(node) {
+				if (isFunctionLike$2(node)) enterFunction(node);
+			},
+			"FunctionExpression:exit": exitFunction,
+			ArrowFunctionExpression(node) {
+				if (isFunctionLike$2(node)) enterFunction(node);
+			},
+			"ArrowFunctionExpression:exit": exitFunction,
+			ReturnStatement(node) {
+				if (node.type === "ReturnStatement") handleReturnStatement(node);
+			},
+			NewExpression(node) {
+				if (node.type === "NewExpression") handleNewExpression(node);
+			}
+		};
+	}
+});
+const noComponentDateInstantiationRule = rule$7;
+
+//#endregion
+//#region src/oxlint-plugins/no-emoji.js
+/** @typedef {import("oxlint").ESTree.Node} ESTNode */
+/**
+* Regex pattern to match emojis
+* Covers most common emoji ranges in Unicode
+*/
+const EMOJI_REGEX = /[\u{1F300}-\u{1F9FF}\u{2600}-\u{26FF}\u{2700}-\u{27BF}\u{1F000}-\u{1F02F}\u{1F0A0}-\u{1F0FF}\u{1F100}-\u{1F64F}\u{1F680}-\u{1F6FF}\u{1F900}-\u{1F9FF}\u{1FA00}-\u{1FA6F}\u{1FA70}-\u{1FAFF}\u{FE00}-\u{FE0F}\u{203C}\u{2049}\u{20E3}\u{2139}\u{2194}-\u{2199}\u{21A9}-\u{21AA}\u{231A}-\u{231B}\u{2328}\u{23CF}\u{23E9}-\u{23F3}\u{23F8}-\u{23FA}\u{24C2}\u{25AA}-\u{25AB}\u{25B6}\u{25C0}\u{25FB}-\u{25FE}\u{2600}-\u{2604}\u{260E}\u{2611}\u{2614}-\u{2615}\u{2618}\u{261D}\u{2620}\u{2622}-\u{2623}\u{2626}\u{262A}\u{262E}-\u{262F}\u{2638}-\u{263A}\u{2640}\u{2642}\u{2648}-\u{2653}\u{265F}-\u{2660}\u{2663}\u{2665}-\u{2666}\u{2668}\u{267B}\u{267E}-\u{267F}\u{2692}-\u{2697}\u{2699}\u{269B}-\u{269C}\u{26A0}-\u{26A1}\u{26A7}\u{26AA}-\u{26AB}\u{26B0}-\u{26B1}\u{26BD}-\u{26BE}\u{26C4}-\u{26C5}\u{26C8}\u{26CE}\u{26CF}\u{26D1}\u{26D3}-\u{26D4}\u{26E9}-\u{26EA}\u{26F0}-\u{26F5}\u{26F7}-\u{26FA}\u{26FD}\u{2702}\u{2705}\u{2708}-\u{270D}\u{270F}\u{2712}\u{2714}\u{2716}\u{271D}\u{2721}\u{2728}\u{2733}-\u{2734}\u{2744}\u{2747}\u{274C}\u{274E}\u{2753}-\u{2755}\u{2757}\u{2763}-\u{2764}\u{2795}-\u{2797}\u{27A1}\u{27B0}\u{27BF}\u{2934}-\u{2935}\u{2B05}-\u{2B07}\u{2B1B}-\u{2B1C}\u{2B50}\u{2B55}\u{3030}\u{303D}\u{3297}\u{3299}]/gu;
+/**
+* Find emojis in a string
+* @param {string} text
+* @returns {RegExpMatchArray | null}
+*/
+const findEmojis = (text) => {
+	return text.match(EMOJI_REGEX);
+};
+/**
+* Get a preview of the emoji found
+* @param {string} text
+* @returns {string}
+*/
+const getEmojiPreview = (text) => {
+	const emojis = findEmojis(text);
+	if (!emojis || emojis.length === 0) return "";
+	const uniqueEmojis = [...new Set(emojis)];
+	const preview = uniqueEmojis.slice(0, 3).join(" ");
+	return uniqueEmojis.length > 3 ? `${preview} ...` : preview;
+};
+const rule$6 = defineRule({
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Disallow the use of emojis in code. Use icons from a component library instead.",
+			recommended: true
+		},
+		schema: []
+	},
+	createOnce(context) {
+		return {
+			StringLiteral(node) {
+				if (node.type !== "StringLiteral") return;
+				const emojis = findEmojis(node.value);
+				if (emojis && emojis.length > 0) {
+					const preview = getEmojiPreview(node.value);
+					context.report({
+						node,
+						message: `Emojis are not allowed in code. Found: ${preview}. Use icons from a component library instead.`
+					});
+				}
+			},
+			TemplateLiteral(node) {
+				if (node.type !== "TemplateLiteral") return;
+				for (const quasi of node.quasis) {
+					if (quasi.type !== "TemplateElement") continue;
+					const text = quasi.value.raw;
+					const emojis = findEmojis(text);
+					if (emojis && emojis.length > 0) {
+						const preview = getEmojiPreview(text);
+						context.report({
+							node: quasi,
+							message: `Emojis are not allowed in code. Found: ${preview}. Use icons from a component library instead.`
+						});
+					}
+				}
+			},
+			JSXText(node) {
+				if (node.type !== "JSXText") return;
+				const emojis = findEmojis(node.value);
+				if (emojis && emojis.length > 0) {
+					const preview = getEmojiPreview(node.value);
+					context.report({
+						node,
+						message: `Emojis are not allowed in code. Found: ${preview}. Use icons from a component library instead.`
+					});
+				}
+			}
+		};
+	}
+});
+const noEmojiRule = rule$6;
+
+//#endregion
+//#region src/oxlint-plugins/no-finally.js
+/** @typedef {import("oxlint").ESTree.Node} ESTNode */
+const rule$5 = defineRule({
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Disallow 'finally' blocks in try/catch/finally statements",
+			recommended: true
+		},
+		schema: []
+	},
+	createOnce(context) {
+		return { TryStatement(node) {
+			if (node.type !== "TryStatement") return;
+			if (node.finalizer) context.report({
+				node: node.finalizer,
+				message: "Use of 'finally' blocks is disallowed. Handle cleanup explicitly in try/catch blocks instead."
+			});
+		} };
+	}
+});
+const noFinallyRule = rule$5;
+
+//#endregion
+//#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$1 = new Set(["JSXElement", "JSXFragment"]);
+const FUNCTION_NODE_TYPES$1 = new Set([
+	"FunctionDeclaration",
+	"FunctionExpression",
+	"ArrowFunctionExpression"
+]);
+/**
+* @param {unknown} node
+* @returns {node is ESTNode & { type: string }}
+*/
+const isNode$1 = (node) => Boolean(node && typeof node === "object" && "type" in node);
+/**
+* @param {unknown} node
+* @returns {node is FunctionLikeNode}
+*/
+const isFunctionLike$1 = (node) => isNode$1(node) && FUNCTION_NODE_TYPES$1.has(node.type);
+/**
+* @param {FunctionLikeNode} node
+*/
+const isFunctionUsedAsJsxProp = (node) => {
+	const checkJsxProp = (current) => {
+		if (!current) return false;
+		if (current.type === "JSXAttribute") return true;
+		if (isFunctionLike$1(current)) return false;
+		return checkJsxProp(isNode$1(current) ? current.parent ?? null : null);
+	};
+	return checkJsxProp(isNode$1(node) ? node.parent ?? null : null);
+};
+/**
+* @param {FunctionLikeNode} node
+*/
+const isFunctionImmediatelyInvoked = (node) => {
+	const parent = isNode$1(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$1 = (root) => {
+	if (!root || !isNode$1(root)) return false;
+	const stack = [root];
+	while (stack.length > 0) {
+		const current = stack.pop();
+		if (!current || !isNode$1(current)) continue;
+		if (JSX_NODE_TYPES$1.has(current.type)) return true;
+		if (FUNCTION_NODE_TYPES$1.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$1(element)) stack.push(element);
+			} else if (isNode$1(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$1(root)) return true;
+	if (!isNode$1(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);
+	if (type === "CallExpression") return expressionProducesJsx(root.callee, bindingNames);
+	if (type === "MemberExpression") return expressionProducesJsx(root.object, bindingNames);
+	return false;
+};
+/**
+* @param {ESTPattern | null | undefined} pattern
+* @param {string[]} names
+*/
+const collectBindingNames = (pattern, names) => {
+	if (!pattern || !isNode$1(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$1(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$1(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$4 = 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$1(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$1(init)) return;
+			if (!expressionContainsJsx$1(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$1(right)) return;
+			if (!expressionContainsJsx$1(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
+			});
+		};
+		/**
+		* @param {import("oxlint").ESTree.CallExpression} node
+		*/
+		const handleCallExpression = (node) => {
+			const fnCtx = currentFunction();
+			if (!fnCtx) return;
+			if (node.callee && node.callee.type === "MemberExpression" && node.callee.property && node.callee.property.type === "Identifier" && node.callee.property.name === "push") {
+				const arrayObject = node.callee.object;
+				if (arrayObject && arrayObject.type === "Identifier") {
+					const arrayName = arrayObject.name;
+					if (node.arguments.some((arg) => {
+						if (!arg || arg.type === "SpreadElement") return false;
+						return expressionContainsJsx$1(arg);
+					})) {
+						fnCtx.jsxBindingNames.add(arrayName);
+						fnCtx.jsxAssignments.push({
+							node,
+							names: [arrayName]
+						});
+					}
+				}
+			}
+		};
+		return {
+			FunctionDeclaration(node) {
+				if (isFunctionLike$1(node)) enterFunction(node);
+			},
+			"FunctionDeclaration:exit": exitFunction,
+			FunctionExpression(node) {
+				if (isFunctionLike$1(node)) enterFunction(node);
+			},
+			"FunctionExpression:exit": exitFunction,
+			ArrowFunctionExpression(node) {
+				if (isFunctionLike$1(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);
+			},
+			CallExpression(node) {
+				if (node.type === "CallExpression") handleCallExpression(node);
+			}
+		};
+	}
+});
+const noInlineComponentsRule = rule$4;
+
+//#endregion
+//#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$3 = 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$3;
+
+//#endregion
+//#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."
+			});
+		} };
+	}
+});
+
+//#endregion
+//#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$2 = 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$2;
+
+//#endregion
+//#region src/oxlint-plugins/no-type-cast.js
+/** @typedef {import("oxlint").ESTree.Node} ESTNode */
+const rule$1 = defineRule({
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Disallow TypeScript type assertions (`as` and angle-bracket syntax) to prevent unsafe type casting.",
+			recommended: false
+		},
+		schema: []
+	},
+	createOnce(context) {
+		return {
+			TSAsExpression(rawNode) {
+				if (rawNode.type !== "TSAsExpression") return;
+				if (rawNode.typeAnnotation.type === "TSTypeReference" && rawNode.typeAnnotation.typeName.type === "Identifier" && rawNode.typeAnnotation.typeName.name === "const") return;
+				context.report({
+					node: rawNode,
+					message: "Type casting with `as` is not permitted. Use runtime validation with valibot or refactor to avoid type casting."
+				});
+			},
+			TSTypeAssertion(rawNode) {
+				if (rawNode.type !== "TSTypeAssertion") return;
+				context.report({
+					node: rawNode,
+					message: "Type casting with angle brackets `<Type>` is not permitted. Use runtime validation with valibot or refactor to avoid type casting."
+				});
+			},
+			TSNonNullExpression(rawNode) {
+				if (rawNode.type !== "TSNonNullExpression") return;
+				context.report({
+					node: rawNode,
+					message: "Non-null assertion operator `!` is not permitted. Handle null/undefined cases explicitly or use optional chaining."
+				});
+			}
+		};
+	}
+});
+const noTypeCastRule = rule$1;
+
+//#endregion
+//#region src/oxlint-plugins/pretty-props.js
+/**
+* @typedef {import("oxlint").Context} RuleContext
+* @typedef {import("oxlint").ESTree.Node} ESTNode
+* @typedef {import("oxlint").ESTree.Expression} ESTExpression
+* @typedef {import("oxlint").ESTree.Function | import("oxlint").ESTree.ArrowFunctionExpression} FunctionLikeNode
+*/
+const JSX_NODE_TYPES = new Set(["JSXElement", "JSXFragment"]);
+const FUNCTION_NODE_TYPES = new Set([
+	"FunctionDeclaration",
+	"FunctionExpression",
+	"ArrowFunctionExpression"
+]);
+/**
+* @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);
+/**
+* Check if an expression contains JSX
+* @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;
+};
+/**
+* Check if a function returns JSX
+* @param {FunctionLikeNode} node
+*/
+const functionReturnsJsx = (node) => {
+	if (node.type === "ArrowFunctionExpression" && node.body && node.body.type !== "BlockStatement") return expressionContainsJsx(node.body);
+	const body = node.body;
+	if (!body || body.type !== "BlockStatement") return false;
+	const stack = [body];
+	while (stack.length > 0) {
+		const current = stack.pop();
+		if (!current || !isNode(current)) continue;
+		if (current.type === "ReturnStatement") {
+			const argument = current.argument;
+			if (argument && expressionContainsJsx(argument)) return true;
+		}
+		if (FUNCTION_NODE_TYPES.has(current.type) && current !== body) 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;
+};
+const rule = defineRule({
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Enforce consistent props parameter naming and disallow destructuring in component parameters.",
+			recommended: false
+		},
+		schema: []
+	},
+	createOnce(context) {
+		/**
+		* @param {FunctionLikeNode} node
+		*/
+		const checkFunction = (node) => {
+			if (!functionReturnsJsx(node)) return;
+			const params = node.params;
+			if (!params || params.length === 0) return;
+			const firstParam = params[0];
+			if (!firstParam || !isNode(firstParam)) return;
+			if (firstParam.type === "ObjectPattern" || firstParam.type === "ArrayPattern") {
+				context.report({
+					node: firstParam,
+					message: "Props should not be destructured in the component parameter. Use 'props' instead and destructure inside the component body."
+				});
+				return;
+			}
+			if (firstParam.type === "Identifier") {
+				if (firstParam.name !== "props") context.report({
+					node: firstParam,
+					message: `Props parameter should be named 'props', not '${firstParam.name}'.`
+				});
+			}
+		};
+		return {
+			FunctionDeclaration(node) {
+				if (isFunctionLike(node)) checkFunction(node);
+			},
+			FunctionExpression(node) {
+				if (isFunctionLike(node)) checkFunction(node);
+			},
+			ArrowFunctionExpression(node) {
+				if (isFunctionLike(node)) checkFunction(node);
+			}
+		};
+	}
+});
+const prettyPropsRule = rule;
+
+//#endregion
+//#region src/oxlint-plugins/index.js
+const plugin = definePlugin({
+	meta: { name: "conorroberts" },
+	rules: {
+		"jsx-component-pascal-case": jsxComponentPascalCaseRule,
+		"no-component-date-instantiation": noComponentDateInstantiationRule,
+		"no-emoji": noEmojiRule,
+		"no-finally": noFinallyRule,
+		"no-inline-components": noInlineComponentsRule,
+		"no-react-namespace": noReactNamespaceRule,
+		"no-switch": noSwitchRule,
+		"no-top-level-let": noTopLevelLetRule,
+		"no-type-cast": noTypeCastRule,
+		"pretty-props": prettyPropsRule
+	}
+});
+var oxlint_plugins_default = plugin;
+
+//#endregion
+export { oxlint_plugins_default as default };
+//# sourceMappingURL=index.mjs.map