@conorroberts/utils 0.0.59 → 0.0.61

package/dist/oxlint/no-emoji.mjs

@@ -1,85 +0,0 @@
-import { defineRule } from "oxlint";
-
-//#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 = 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;
-
-//#endregion
-export { noEmojiRule };
-//# sourceMappingURL=no-emoji.mjs.map

package/dist/oxlint/no-emoji.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"no-emoji.mjs","names":[],"sources":["../../src/oxlint-plugins/no-emoji.js"],"sourcesContent":["import { defineRule } from \"oxlint\";\n\n/** @typedef {import(\"oxlint\").ESTree.Node} ESTNode */\n\n/**\n * Regex pattern to match emojis\n * Covers most common emoji ranges in Unicode\n */\nconst EMOJI_REGEX =\n  /[\\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;\n\n/**\n * Find emojis in a string\n * @param {string} text\n * @returns {RegExpMatchArray | null}\n */\nconst findEmojis = (text) => {\n  return text.match(EMOJI_REGEX);\n};\n\n/**\n * Get a preview of the emoji found\n * @param {string} text\n * @returns {string}\n */\nconst getEmojiPreview = (text) => {\n  const emojis = findEmojis(text);\n  if (!emojis || emojis.length === 0) return \"\";\n\n  const uniqueEmojis = [...new Set(emojis)];\n  const preview = uniqueEmojis.slice(0, 3).join(\" \");\n\n  return uniqueEmojis.length > 3 ? `${preview} ...` : preview;\n};\n\nconst rule = defineRule({\n  meta: {\n    type: \"problem\",\n    docs: {\n      description: \"Disallow the use of emojis in code. Use icons from a component library instead.\",\n      recommended: true,\n    },\n    schema: [],\n  },\n  createOnce(context) {\n    return /** @type {import(\"oxlint\").VisitorWithHooks} */ ({\n      /**\n       * Check string literals\n       * @param {ESTNode} node\n       */\n      StringLiteral(node) {\n        if (node.type !== \"StringLiteral\") return;\n\n        const emojis = findEmojis(node.value);\n        if (emojis && emojis.length > 0) {\n          const preview = getEmojiPreview(node.value);\n          context.report({\n            node,\n            message: `Emojis are not allowed in code. Found: ${preview}. Use icons from a component library instead.`,\n          });\n        }\n      },\n\n      /**\n       * Check template literals\n       * @param {ESTNode} node\n       */\n      TemplateLiteral(node) {\n        if (node.type !== \"TemplateLiteral\") return;\n\n        // Check each quasi (template string part)\n        for (const quasi of node.quasis) {\n          if (quasi.type !== \"TemplateElement\") continue;\n\n          const text = quasi.value.raw;\n          const emojis = findEmojis(text);\n\n          if (emojis && emojis.length > 0) {\n            const preview = getEmojiPreview(text);\n            context.report({\n              node: quasi,\n              message: `Emojis are not allowed in code. Found: ${preview}. Use icons from a component library instead.`,\n            });\n          }\n        }\n      },\n\n      /**\n       * Check JSX text\n       * @param {ESTNode} node\n       */\n      JSXText(node) {\n        if (node.type !== \"JSXText\") return;\n\n        const emojis = findEmojis(node.value);\n        if (emojis && emojis.length > 0) {\n          const preview = getEmojiPreview(node.value);\n          context.report({\n            node,\n            message: `Emojis are not allowed in code. Found: ${preview}. Use icons from a component library instead.`,\n          });\n        }\n      },\n    });\n  },\n});\n\nexport const noEmojiRule = rule;\n\n"],"mappings":";;;;;;;;AAQA,MAAM,cACJ;;;;;;AAOF,MAAM,cAAc,SAAS;AAC3B,QAAO,KAAK,MAAM,YAAY;;;;;;;AAQhC,MAAM,mBAAmB,SAAS;CAChC,MAAM,SAAS,WAAW,KAAK;AAC/B,KAAI,CAAC,UAAU,OAAO,WAAW,EAAG,QAAO;CAE3C,MAAM,eAAe,CAAC,GAAG,IAAI,IAAI,OAAO,CAAC;CACzC,MAAM,UAAU,aAAa,MAAM,GAAG,EAAE,CAAC,KAAK,IAAI;AAElD,QAAO,aAAa,SAAS,IAAI,GAAG,QAAQ,QAAQ;;AAGtD,MAAM,OAAO,WAAW;CACtB,MAAM;EACJ,MAAM;EACN,MAAM;GACJ,aAAa;GACb,aAAa;GACd;EACD,QAAQ,EAAE;EACX;CACD,WAAW,SAAS;AAClB,SAAyD;GAKvD,cAAc,MAAM;AAClB,QAAI,KAAK,SAAS,gBAAiB;IAEnC,MAAM,SAAS,WAAW,KAAK,MAAM;AACrC,QAAI,UAAU,OAAO,SAAS,GAAG;KAC/B,MAAM,UAAU,gBAAgB,KAAK,MAAM;AAC3C,aAAQ,OAAO;MACb;MACA,SAAS,0CAA0C,QAAQ;MAC5D,CAAC;;;GAQN,gBAAgB,MAAM;AACpB,QAAI,KAAK,SAAS,kBAAmB;AAGrC,SAAK,MAAM,SAAS,KAAK,QAAQ;AAC/B,SAAI,MAAM,SAAS,kBAAmB;KAEtC,MAAM,OAAO,MAAM,MAAM;KACzB,MAAM,SAAS,WAAW,KAAK;AAE/B,SAAI,UAAU,OAAO,SAAS,GAAG;MAC/B,MAAM,UAAU,gBAAgB,KAAK;AACrC,cAAQ,OAAO;OACb,MAAM;OACN,SAAS,0CAA0C,QAAQ;OAC5D,CAAC;;;;GASR,QAAQ,MAAM;AACZ,QAAI,KAAK,SAAS,UAAW;IAE7B,MAAM,SAAS,WAAW,KAAK,MAAM;AACrC,QAAI,UAAU,OAAO,SAAS,GAAG;KAC/B,MAAM,UAAU,gBAAgB,KAAK,MAAM;AAC3C,aAAQ,OAAO;MACb;MACA,SAAS,0CAA0C,QAAQ;MAC5D,CAAC;;;GAGP;;CAEJ,CAAC;AAEF,MAAa,cAAc"}

package/dist/oxlint/no-finally.d.mts

@@ -1,8 +0,0 @@
-import * as oxlint4 from "oxlint";
-
-//#region src/oxlint-plugins/no-finally.d.ts
-declare const noFinallyRule: oxlint4.Rule;
-type ESTNode = oxlint4.ESTree.Node;
-//#endregion
-export { ESTNode, noFinallyRule };
-//# sourceMappingURL=no-finally.d.mts.map

package/dist/oxlint/no-finally.mjs

@@ -1,28 +0,0 @@
-import { defineRule } from "oxlint";
-
-//#region src/oxlint-plugins/no-finally.js
-/** @typedef {import("oxlint").ESTree.Node} ESTNode */
-const rule = 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;
-
-//#endregion
-export { noFinallyRule };
-//# sourceMappingURL=no-finally.mjs.map

package/dist/oxlint/no-finally.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"no-finally.mjs","names":[],"sources":["../../src/oxlint-plugins/no-finally.js"],"sourcesContent":["import { defineRule } from \"oxlint\";\n\n/** @typedef {import(\"oxlint\").ESTree.Node} ESTNode */\n\nconst rule = defineRule({\n  meta: {\n    type: \"problem\",\n    docs: {\n      description: \"Disallow 'finally' blocks in try/catch/finally statements\",\n      recommended: true,\n    },\n    schema: [],\n  },\n  createOnce(context) {\n    return /** @type {import(\"oxlint\").VisitorWithHooks} */ ({\n      /**\n       * @param {ESTNode} node\n       */\n      TryStatement(node) {\n        if (node.type !== \"TryStatement\") return;\n\n        if (node.finalizer) {\n          context.report({\n            node: node.finalizer,\n            message: \"Use of 'finally' blocks is disallowed. Handle cleanup explicitly in try/catch blocks instead.\",\n          });\n        }\n      },\n    });\n  },\n});\n\nexport const noFinallyRule = rule;\n\n"],"mappings":";;;;AAIA,MAAM,OAAO,WAAW;CACtB,MAAM;EACJ,MAAM;EACN,MAAM;GACJ,aAAa;GACb,aAAa;GACd;EACD,QAAQ,EAAE;EACX;CACD,WAAW,SAAS;AAClB,SAAyD,EAIvD,aAAa,MAAM;AACjB,OAAI,KAAK,SAAS,eAAgB;AAElC,OAAI,KAAK,UACP,SAAQ,OAAO;IACb,MAAM,KAAK;IACX,SAAS;IACV,CAAC;KAGP;;CAEJ,CAAC;AAEF,MAAa,gBAAgB"}

package/dist/oxlint/no-function-call-in-jsx.d.mts

@@ -1,11 +0,0 @@
-import * as oxlint0 from "oxlint";
-
-//#region src/oxlint-plugins/no-function-call-in-jsx.d.ts
-declare const noFunctionCallInJsxRule: oxlint0.Rule;
-type RuleContext = oxlint0.Context;
-type ESTNode = oxlint0.ESTree.Node;
-type JSXExpressionContainer = oxlint0.ESTree.JSXExpressionContainer;
-type CallExpression = oxlint0.ESTree.CallExpression;
-//#endregion
-export { CallExpression, ESTNode, JSXExpressionContainer, RuleContext, noFunctionCallInJsxRule };
-//# sourceMappingURL=no-function-call-in-jsx.d.mts.map

package/dist/oxlint/no-function-call-in-jsx.mjs

@@ -1,70 +0,0 @@
-import { defineRule } from "oxlint";
-
-//#region src/oxlint-plugins/no-function-call-in-jsx.js
-/**
-* @typedef {import("oxlint").Context} RuleContext
-* @typedef {import("oxlint").ESTree.Node} ESTNode
-* @typedef {import("oxlint").ESTree.JSXExpressionContainer} JSXExpressionContainer
-* @typedef {import("oxlint").ESTree.CallExpression} CallExpression
-*/
-/**
-* @param {unknown} node
-* @returns {node is ESTNode & { type: string }}
-*/
-const isNode = (node) => Boolean(node && typeof node === "object" && "type" in node);
-/**
-* @param {ESTNode | null | undefined} node
-* @returns {boolean}
-*/
-const isInJSXExpressionContainer = (node) => {
-	const findJSXContainer = (current) => {
-		if (!current) return false;
-		if (current.type === "JSXExpressionContainer") return true;
-		return findJSXContainer(isNode(current) ? current.parent ?? null : null);
-	};
-	return findJSXContainer(isNode(node) ? node.parent ?? null : null);
-};
-/**
-* @param {CallExpression} node
-* @returns {string}
-*/
-const getCalleeName = (node) => {
-	const callee = node.callee;
-	if (!callee) return "function";
-	if (callee.type === "Identifier") return callee.name;
-	if (callee.type === "MemberExpression") {
-		const property = callee.property;
-		if (property && property.type === "Identifier") return property.name;
-	}
-	return "function";
-};
-const rule = defineRule({
-	meta: {
-		type: "problem",
-		docs: {
-			description: "Disallow function calls within JSX expression containers",
-			recommended: false
-		},
-		schema: []
-	},
-	create(context) {
-		/**
-		* @param {CallExpression} node
-		*/
-		const handleCallExpression = (node) => {
-			if (node.type !== "CallExpression") return;
-			if (!isInJSXExpressionContainer(node)) return;
-			const calleeName = getCalleeName(node);
-			context.report({
-				node,
-				message: `Avoid calling '${calleeName}()' directly in JSX. Store the result in a variable or use a component instead.`
-			});
-		};
-		return { CallExpression: handleCallExpression };
-	}
-});
-const noFunctionCallInJsxRule = rule;
-
-//#endregion
-export { noFunctionCallInJsxRule };
-//# sourceMappingURL=no-function-call-in-jsx.mjs.map

package/dist/oxlint/no-function-call-in-jsx.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"no-function-call-in-jsx.mjs","names":[],"sources":["../../src/oxlint-plugins/no-function-call-in-jsx.js"],"sourcesContent":["import { defineRule } from \"oxlint\";\n\n/**\n * @typedef {import(\"oxlint\").Context} RuleContext\n * @typedef {import(\"oxlint\").ESTree.Node} ESTNode\n * @typedef {import(\"oxlint\").ESTree.JSXExpressionContainer} JSXExpressionContainer\n * @typedef {import(\"oxlint\").ESTree.CallExpression} CallExpression\n */\n\n/**\n * @param {unknown} node\n * @returns {node is ESTNode & { type: string }}\n */\nconst isNode = (node) => Boolean(node && typeof node === \"object\" && \"type\" in node);\n\n/**\n * @param {ESTNode | null | undefined} node\n * @returns {boolean}\n */\nconst isInJSXExpressionContainer = (node) => {\n  const findJSXContainer = (current) => {\n    if (!current) return false;\n    if (current.type === \"JSXExpressionContainer\") {\n      return true;\n    }\n    return findJSXContainer(isNode(current) ? current.parent ?? null : null);\n  };\n  return findJSXContainer(isNode(node) ? node.parent ?? null : null);\n};\n\n/**\n * @param {CallExpression} node\n * @returns {string}\n */\nconst getCalleeName = (node) => {\n  const callee = node.callee;\n  if (!callee) return \"function\";\n\n  if (callee.type === \"Identifier\") {\n    return callee.name;\n  }\n\n  if (callee.type === \"MemberExpression\") {\n    const property = callee.property;\n    if (property && property.type === \"Identifier\") {\n      return property.name;\n    }\n  }\n\n  return \"function\";\n};\n\nconst rule = defineRule({\n  meta: {\n    type: \"problem\",\n    docs: {\n      description: \"Disallow function calls within JSX expression containers\",\n      recommended: false,\n    },\n    schema: [],\n  },\n\n  create(context) {\n    /**\n     * @param {CallExpression} node\n     */\n    const handleCallExpression = (node) => {\n      if (node.type !== \"CallExpression\") return;\n\n      if (!isInJSXExpressionContainer(node)) return;\n\n      const calleeName = getCalleeName(node);\n\n      context.report({\n        node: node,\n        message: `Avoid calling '${calleeName}()' directly in JSX. Store the result in a variable or use a component instead.`,\n      });\n    };\n\n    return {\n      CallExpression: handleCallExpression,\n    };\n  },\n});\n\nexport const noFunctionCallInJsxRule = rule;\n\n"],"mappings":";;;;;;;;;;;;;AAaA,MAAM,UAAU,SAAS,QAAQ,QAAQ,OAAO,SAAS,YAAY,UAAU,KAAK;;;;;AAMpF,MAAM,8BAA8B,SAAS;CAC3C,MAAM,oBAAoB,YAAY;AACpC,MAAI,CAAC,QAAS,QAAO;AACrB,MAAI,QAAQ,SAAS,yBACnB,QAAO;AAET,SAAO,iBAAiB,OAAO,QAAQ,GAAG,QAAQ,UAAU,OAAO,KAAK;;AAE1E,QAAO,iBAAiB,OAAO,KAAK,GAAG,KAAK,UAAU,OAAO,KAAK;;;;;;AAOpE,MAAM,iBAAiB,SAAS;CAC9B,MAAM,SAAS,KAAK;AACpB,KAAI,CAAC,OAAQ,QAAO;AAEpB,KAAI,OAAO,SAAS,aAClB,QAAO,OAAO;AAGhB,KAAI,OAAO,SAAS,oBAAoB;EACtC,MAAM,WAAW,OAAO;AACxB,MAAI,YAAY,SAAS,SAAS,aAChC,QAAO,SAAS;;AAIpB,QAAO;;AAGT,MAAM,OAAO,WAAW;CACtB,MAAM;EACJ,MAAM;EACN,MAAM;GACJ,aAAa;GACb,aAAa;GACd;EACD,QAAQ,EAAE;EACX;CAED,OAAO,SAAS;;;;EAId,MAAM,wBAAwB,SAAS;AACrC,OAAI,KAAK,SAAS,iBAAkB;AAEpC,OAAI,CAAC,2BAA2B,KAAK,CAAE;GAEvC,MAAM,aAAa,cAAc,KAAK;AAEtC,WAAQ,OAAO;IACP;IACN,SAAS,kBAAkB,WAAW;IACvC,CAAC;;AAGJ,SAAO,EACL,gBAAgB,sBACjB;;CAEJ,CAAC;AAEF,MAAa,0BAA0B"}

package/dist/oxlint/no-inline-components.d.mts

@@ -1,36 +0,0 @@
-import * as oxlint26 from "oxlint";
-
-//#region src/oxlint-plugins/no-inline-components.d.ts
-declare function isComponentName(name: unknown): name is string;
-declare function isHookName(name: unknown): name is string;
-declare function getEnclosingFunction(node: ESTNode | null | undefined): FunctionLikeNode | null;
-declare function getFunctionName(node: FunctionLikeNode): string;
-declare const noInlineComponentsRule: oxlint26.Rule;
-type RuleContext = oxlint26.Context;
-type ESTNode = oxlint26.ESTree.Node;
-type ESTExpression = oxlint26.ESTree.Expression;
-type ESTPattern = oxlint26.ESTree.Pattern;
-type ReturnStatementNode = oxlint26.ESTree.ReturnStatement;
-type VariableDeclaratorNode = oxlint26.ESTree.VariableDeclarator;
-type AssignmentExpressionNode = oxlint26.ESTree.AssignmentExpression;
-type FunctionLikeNode = oxlint26.ESTree.Function | oxlint26.ESTree.ArrowFunctionExpression;
-type RecordedAssignment = {
-  node: ESTExpression;
-  names: string[];
-};
-type NestedFunctionRecord = {
-  node: FunctionLikeNode;
-  name: string;
-};
-type FunctionContext = {
-  node: FunctionLikeNode;
-  parent: FunctionContext | null;
-  name: string;
-  returnsJsx: boolean;
-  jsxBindingNames: Set<string>;
-  jsxAssignments: RecordedAssignment[];
-  nestedJsxChildren: NestedFunctionRecord[];
-};
-//#endregion
-export { AssignmentExpressionNode, ESTExpression, ESTNode, ESTPattern, FunctionContext, FunctionLikeNode, NestedFunctionRecord, RecordedAssignment, ReturnStatementNode, RuleContext, VariableDeclaratorNode, getEnclosingFunction, getFunctionName, isComponentName, isHookName, noInlineComponentsRule };
-//# sourceMappingURL=no-inline-components.d.mts.map

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

@@ -1,374 +0,0 @@
-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);
-	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(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
-			});
-		};
-		/**
-		* @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(arg);
-					})) {
-						fnCtx.jsxBindingNames.add(arrayName);
-						fnCtx.jsxAssignments.push({
-							node,
-							names: [arrayName]
-						});
-					}
-				}
-			}
-		};
-		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);
-			},
-			CallExpression(node) {
-				if (node.type === "CallExpression") handleCallExpression(node);
-			}
-		};
-	}
-});
-const noInlineComponentsRule = rule;
-
-//#endregion
-export { getEnclosingFunction, getFunctionName, isComponentName, isHookName, noInlineComponentsRule };
-//# sourceMappingURL=no-inline-components.mjs.map