@lichens-innovation/eslint-plugin-coding-guide 1.0.0

package/dist/index.js

@@ -0,0 +1,1294 @@
+import { ESLintUtils as e } from "@typescript-eslint/utils";
+//#region src/configs/recommended.ts
+var t = (e) => ({
+	name: "coding-guide/recommended",
+	files: ["**/*.{ts,tsx}"],
+	plugins: { "coding-guide": e },
+	rules: Object.fromEntries(Object.keys(e.rules).map((e) => [`coding-guide/${e}`, "error"]))
+}), n = e.RuleCreator((e) => `https://github.com/Lichens-Innovation/eslint-plugin-coding-guide/blob/main/docs/rules/${e}.md`), r = /* @__PURE__ */ new Set([
+	"utils",
+	"types",
+	"helpers",
+	"constants",
+	"config",
+	"client",
+	"index"
+]), i = [
+	{
+		nameSuffix: "Page",
+		kebabSuffix: "-page"
+	},
+	{
+		nameSuffix: "Dialog",
+		kebabSuffix: "-dialog"
+	},
+	{
+		nameSuffix: "Provider",
+		kebabSuffix: "-provider"
+	}
+], a = (e) => (e.replaceAll("\\", "/").split("/").pop() ?? e).replace(/\.(tsx|ts|jsx|js)$/, ""), o = (e) => {
+	let t = [];
+	for (let n of e.declarations) {
+		if (n.id.type !== "Identifier") continue;
+		let e = n.init?.type === "ArrowFunctionExpression" || n.init?.type === "FunctionExpression";
+		t.push({
+			name: n.id.name,
+			isFunctionLike: e
+		});
+	}
+	return t;
+}, s = (e) => {
+	let t = [];
+	for (let n of e) {
+		if (n.type !== "ExportNamedDeclaration" || !n.declaration) continue;
+		let e = n.declaration;
+		if (e.type === "FunctionDeclaration" && e.id) {
+			t.push({
+				name: e.id.name,
+				isFunctionLike: !0
+			});
+			continue;
+		}
+		if (e.type === "ClassDeclaration" && e.id) {
+			t.push({
+				name: e.id.name,
+				isFunctionLike: !1
+			});
+			continue;
+		}
+		e.type === "VariableDeclaration" && t.push(...o(e));
+	}
+	return t;
+}, c = n({
+	name: "filename-convention-by-export-shape",
+	meta: {
+		type: "suggestion",
+		docs: { description: "Enforce filename conventions against a file's exported shape" },
+		schema: [],
+		messages: {
+			genericBasename: "'{{basename}}' is a generic root-level filename — prefix it with its domain (e.g. '{{example}}').",
+			hookFilename: "This file's sole export '{{name}}' is a hook — rename the file to start with 'use-'.",
+			suffixFilename: "This file's sole export '{{name}}' ends in '{{nameSuffix}}' — rename the file to end with '{{kebabSuffix}}'."
+		}
+	},
+	defaultOptions: [],
+	create(e) {
+		return { "Program:exit"(t) {
+			let n = a(e.filename);
+			r.has(n.toLowerCase()) && e.report({
+				node: t,
+				messageId: "genericBasename",
+				data: {
+					basename: n,
+					example: `<domain>.${n}.ts`
+				}
+			});
+			let o = s(t.body);
+			if (o.length !== 1) return;
+			let [c] = o;
+			if (!c.isFunctionLike) return;
+			let { name: l } = c;
+			if (/^use[A-Z]/.test(l)) {
+				n.startsWith("use-") || e.report({
+					node: t,
+					messageId: "hookFilename",
+					data: { name: l }
+				});
+				return;
+			}
+			for (let { nameSuffix: r, kebabSuffix: a } of i) if (l.endsWith(r)) {
+				n.endsWith(a) || e.report({
+					node: t,
+					messageId: "suffixFilename",
+					data: {
+						name: l,
+						nameSuffix: r,
+						kebabSuffix: a
+					}
+				});
+				return;
+			}
+		} };
+	}
+}), l = (e) => typeof e == "object" && !!e && typeof e.type == "string", u = (e) => Object.entries(e).filter(([e]) => e !== "parent").flatMap(([, e]) => Array.isArray(e) ? e : [e]).filter(l), ee = (e) => e?.type === "ArrayExpression" || e?.type === "ObjectExpression", te = ({ scope: e, ancestorScope: t }) => {
+	let n = e;
+	for (; n;) {
+		if (n === t) return !0;
+		n = n.upper;
+	}
+	return !1;
+}, d = ({ node: e, functionScope: t, sourceCode: n }) => {
+	let r = !1, i = (e) => {
+		if (!r) {
+			if (e.type === "Identifier") {
+				let i = n.getScope(e).references.find((t) => t.identifier === e)?.resolved;
+				i && te({
+					scope: i.scope,
+					ancestorScope: t
+				}) && (r = !0);
+				return;
+			}
+			for (let t of u(e)) i(t);
+		}
+	};
+	return i(e), r;
+}, f = (e) => e.type === "ArrayExpression" && e.elements.length > 0 || e.type === "ObjectExpression" && e.properties.length > 0, p = (e) => {
+	let t = e.block;
+	if (t.type === "FunctionDeclaration" && t.id) return t.id.name;
+	if (t.parent?.type === "VariableDeclarator" && t.parent.id.type === "Identifier") return t.parent.id.name;
+}, ne = (e) => !!e && (/^[A-Z]/.test(e) || /^use[A-Z]/.test(e)), re = n({
+	name: "hoist-static-component-constants",
+	meta: {
+		type: "suggestion",
+		docs: { description: "Disallow a static array/object literal declared inside a component body" },
+		schema: [],
+		messages: { hoist: "'{{name}}' has no dependency on this component's scope — hoist it to module scope." }
+	},
+	defaultOptions: [],
+	create(e) {
+		let t = e.sourceCode;
+		return { VariableDeclarator(n) {
+			if (n.id.type !== "Identifier" || !ee(n.init) || !f(n.init)) return;
+			let r = t.getScope(n);
+			r.type === "function" && ne(p(r)) && (d({
+				node: n.init,
+				functionScope: r,
+				sourceCode: t
+			}) || e.report({
+				node: n,
+				messageId: "hoist",
+				data: { name: n.id.name }
+			}));
+		} };
+	}
+}), ie = /* @__PURE__ */ new Set([
+	"Property",
+	"ObjectExpression",
+	"ArrayExpression",
+	"SpreadElement",
+	"ChainExpression",
+	"ConditionalExpression",
+	"LogicalExpression",
+	"TSAsExpression",
+	"TSSatisfiesExpression",
+	"TSNonNullExpression",
+	"TSTypeAssertion"
+]), ae = "\n{{name}} has {{count}} parameters. Maximum allowed is {{max}}.\nThe idea is to group related parameters together into a single object making callsites more readable because the caller needs to explicitly name each parameter.\nThe house style is a named Args interface: capitalize the function name, add an Args suffix, and take a single destructured object of that type. Do not leave the shape inline and anonymous.\nExample:\n  interface BuildSiteEquipmentKeyArgs {\n    siteSlug?: string;\n    equipmentSlug?: string;\n  }\n\n  const buildSiteEquipmentSlugKey = ({ siteSlug, equipmentSlug }: BuildSiteEquipmentKeyArgs) => {\n    // ...\n  }\n", oe = (e) => {
+	let t = e.parent;
+	if (e.type === "ArrowFunctionExpression") return "Arrow function";
+	if (t?.type === "MethodDefinition" || t?.type === "Property" && t.method) {
+		let e = t.key;
+		return e.type === "Identifier" ? `Method '${e.name}'` : "Method";
+	}
+	return e.type === "FunctionDeclaration" && e.id?.name ? `Function '${e.id.name}'` : t?.type === "VariableDeclarator" && t.id.type === "Identifier" ? `Function '${t.id.name}'` : "Function";
+}, se = (e) => {
+	let t = e.parent;
+	return t?.type === "JSXExpressionContainer" && t.parent?.type === "JSXAttribute";
+}, m = (e) => {
+	let t = e, n = /* @__PURE__ */ new Set();
+	for (; t.parent && !n.has(t);) {
+		n.add(t);
+		let e = t.parent;
+		if (e.type === "CallExpression" || e.type === "NewExpression") return e.arguments.includes(t);
+		if (ie.has(e.type)) {
+			t = e;
+			continue;
+		}
+		break;
+	}
+	return !1;
+}, h = (e) => {
+	let t = e.replaceAll("\\", "/");
+	return t.includes("/node_modules/") || t.includes("/typescript/lib/");
+}, ce = (e) => {
+	let t = /* @__PURE__ */ new Set(), n = (e) => {
+		if (t.has(e)) return [];
+		if (t.add(e), e.isUnion() || e.isIntersection()) return e.types.flatMap(n);
+		let r = [];
+		for (let t of e.getCallSignatures()) {
+			let e = t.getDeclaration();
+			e && r.push(e.getSourceFile().fileName);
+		}
+		let i = e.aliasSymbol ?? e.getSymbol();
+		for (let e of i?.getDeclarations() ?? []) r.push(e.getSourceFile().fileName);
+		return r;
+	};
+	return n(e).some(h);
+}, le = ({ base: e, methodName: t, checker: n }) => (n.getPropertyOfType(e, t)?.getDeclarations() ?? []).some((e) => h(e.getSourceFile().fileName)), ue = ({ functionNode: e, services: t, checker: n }) => {
+	let r = e.parent;
+	if (r?.type !== "MethodDefinition") return !1;
+	let i = r.parent.parent;
+	if (i.type !== "ClassDeclaration" && i.type !== "ClassExpression") return !1;
+	let a = r.key.type === "Identifier" ? r.key.name : null;
+	if (!a) return !1;
+	let o = t.esTreeNodeToTSNodeMap.get(i);
+	return (n.getTypeAtLocation(o).getBaseTypes() ?? []).some((e) => le({
+		base: e,
+		methodName: a,
+		checker: n
+	}));
+}, de = ({ node: e, tsNode: t, checker: n }) => {
+	if (e.type === "FunctionDeclaration") return !1;
+	let r = n.getContextualType(t);
+	return !!r && ce(r);
+}, fe = n({
+	name: "max-params-project",
+	meta: {
+		type: "suggestion",
+		docs: { description: "Enforce a maximum number of parameters on project-owned functions" },
+		schema: [{ oneOf: [{
+			type: "integer",
+			minimum: 0
+		}, {
+			type: "object",
+			properties: { max: {
+				type: "integer",
+				minimum: 0
+			} },
+			additionalProperties: !1
+		}] }],
+		messages: { exceed: ae }
+	},
+	defaultOptions: [1],
+	create(t, [n]) {
+		let r = typeof n == "number" ? n : n.max ?? 1, i = (e) => {
+			let n = t.sourceCode.getScope(e);
+			for (; n;) {
+				let t = n.variables.find((t) => t.name === e.name);
+				if (t) return t;
+				n = n.upper;
+			}
+			return null;
+		}, a = (e) => {
+			let t = e.parent;
+			if (t?.type !== "VariableDeclarator" || t.init !== e || t.id.type !== "Identifier") return !1;
+			let n = i(t.id);
+			return n ? n.references.some((e) => e.identifier !== t.id && m(e.identifier)) : !1;
+		}, o = (e) => se(e) || m(e) ? !0 : a(e), s = (n) => {
+			try {
+				let r = e.getParserServices(t, !0);
+				if (!r.program) return !1;
+				let i = r.program.getTypeChecker(), a = r.esTreeNodeToTSNodeMap.get(n);
+				return a ? de({
+					node: n,
+					tsNode: a,
+					checker: i
+				}) ? !0 : ue({
+					functionNode: n,
+					services: r,
+					checker: i
+				}) : !1;
+			} catch {
+				return !1;
+			}
+		}, c = (e) => {
+			e.params.length <= r || o(e) || s(e) || t.report({
+				node: e,
+				messageId: "exceed",
+				data: {
+					name: oe(e),
+					count: e.params.length,
+					max: r
+				}
+			});
+		};
+		return {
+			FunctionDeclaration: c,
+			FunctionExpression: c,
+			ArrowFunctionExpression: c
+		};
+	}
+}), pe = (e) => e.type === "TSUndefinedKeyword", me = (e) => {
+	let t = e.parent;
+	if (!t || t.type === "AssignmentPattern") return null;
+	let n = t.type === "TSParameterProperty" ? t : e, r = n.parent;
+	return r && "params" in r && Array.isArray(r.params) && r.params.includes(n) && e.type === "Identifier" ? e : null;
+}, g = (e) => {
+	let t = e.parent;
+	if (!t || t.type !== "TSTypeAnnotation") return null;
+	let n = t.parent;
+	return n ? n.type === "TSPropertySignature" || n.type === "PropertyDefinition" ? n : n.type === "Identifier" || n.type === "ObjectPattern" || n.type === "ArrayPattern" ? me(n) : null : null;
+}, _ = n({
+	name: "no-explicit-undefined-optional",
+	meta: {
+		type: "suggestion",
+		docs: { description: "Use `?` instead of an explicit `| undefined` on params/properties that support it" },
+		fixable: "code",
+		schema: [],
+		messages: {
+			useOptionalModifier: "Do not use explicit `| undefined` to mark {{what}} optional — use `?` instead.",
+			redundantUndefined: "{{what}} is already optional (`?`) — remove the redundant explicit `undefined`."
+		}
+	},
+	defaultOptions: [],
+	create(e) {
+		let t = e.sourceCode;
+		return { TSUnionType(n) {
+			let r = n.types.filter((e) => !pe(e));
+			if (r.length === n.types.length || r.length === 0) return;
+			let i = g(n);
+			if (!i) return;
+			let a = i.optional === !0, o = ["TSPropertySignature", "PropertyDefinition"].includes(i.type) ? "this property" : "this parameter";
+			e.report({
+				node: n,
+				messageId: a ? "redundantUndefined" : "useOptionalModifier",
+				data: { what: o },
+				fix: r.length === 1 ? (e) => {
+					let i = [e.replaceText(n, t.getText(r[0]))];
+					return !a && n.parent && i.push(e.insertTextBefore(n.parent, "?")), i;
+				} : null
+			});
+		} };
+	}
+}), v = n({
+	name: "no-exported-mutable-state",
+	meta: {
+		type: "suggestion",
+		docs: { description: "Disallow exporting a mutable (let/var) module-scoped binding" },
+		schema: [],
+		messages: { noMutableExport: "Do not export a mutable ({{kind}}) binding — export a const, or a getter/setter pair." }
+	},
+	defaultOptions: [],
+	create(e) {
+		return { ExportNamedDeclaration(t) {
+			let n = t.declaration;
+			!n || n.type !== "VariableDeclaration" || n.kind !== "const" && e.report({
+				node: t,
+				messageId: "noMutableExport",
+				data: { kind: n.kind }
+			});
+		} };
+	}
+}), y = /^use[A-Z]/, b = (e) => e.argument?.type === "JSXElement" || e.argument?.type === "JSXFragment", x = (e) => {
+	let t = !1, n = (r) => {
+		if (!t && !(r !== e && [
+			"FunctionDeclaration",
+			"FunctionExpression",
+			"ArrowFunctionExpression"
+		].includes(r.type))) {
+			if (r.type === "ReturnStatement" && b(r)) {
+				t = !0;
+				return;
+			}
+			for (let e of u(r)) n(e);
+		}
+	};
+	return ["JSXElement", "JSXFragment"].includes(e.body.type) ? !0 : (n(e.body), t);
+}, S = n({
+	name: "no-hook-returning-jsx",
+	meta: {
+		type: "suggestion",
+		docs: { description: "Disallow a use* hook returning JSX" },
+		schema: [],
+		messages: { hookReturnsJsx: "'{{name}}' is named like a hook but returns JSX — hooks should return data, not markup." }
+	},
+	defaultOptions: [],
+	create(e) {
+		let t = ({ node: t, name: n }) => {
+			!n || !y.test(n) || x(t) && e.report({
+				node: t,
+				messageId: "hookReturnsJsx",
+				data: { name: n }
+			});
+		};
+		return {
+			FunctionDeclaration(e) {
+				t({
+					node: e,
+					name: e.id?.name
+				});
+			},
+			"VariableDeclarator > ArrowFunctionExpression"(e) {
+				let n = e.parent;
+				t({
+					node: e,
+					name: n.id.type === "Identifier" ? n.id.name : void 0
+				});
+			}
+		};
+	}
+}), C = /* @__PURE__ */ new Set([
+	"filter",
+	"sort",
+	"map",
+	"reduce"
+]), w = (e) => {
+	let t = 0, n = e;
+	for (; n.type === "CallExpression";) {
+		let e = n.callee;
+		if (e.type !== "MemberExpression" || e.computed || e.property.type !== "Identifier" || !C.has(e.property.name) || (t += 1, e.object.type === "Super")) break;
+		n = e.object;
+	}
+	return t;
+}, T = n({
+	name: "no-inline-array-chain-in-jsx",
+	meta: {
+		type: "suggestion",
+		docs: { description: "Disallow chained array methods directly inside a JSX expression" },
+		schema: [],
+		messages: { precompute: "Chained {{count}} array methods inline in JSX — precompute the list with an imported helper." }
+	},
+	defaultOptions: [],
+	create(e) {
+		return { JSXExpressionContainer(t) {
+			let n = t.expression;
+			if (n.type !== "CallExpression") return;
+			let r = w(n);
+			r < 2 || e.report({
+				node: n,
+				messageId: "precompute",
+				data: { count: r }
+			});
+		} };
+	}
+}), E = (e) => e.type === "ArrowFunctionExpression" ? e.body.type === "ArrowFunctionExpression" || e.body.type === "BlockStatement" && e.body.body.some((e) => e.type === "ReturnStatement" && e.argument?.type === "ArrowFunctionExpression") : !1, D = n({
+	name: "no-inline-curried-handler",
+	meta: {
+		type: "suggestion",
+		docs: { description: "Disallow a curried handler factory declared as a local component variable" },
+		schema: [],
+		messages: { extractToUtils: "'{{name}}' is a curried handler factory declared inside a component — move it to a *.utils.ts file." }
+	},
+	defaultOptions: [],
+	create(e) {
+		return { VariableDeclarator(t) {
+			!t.init || !E(t.init) || t.id.type === "Identifier" && e.sourceCode.getScope(t).type === "function" && e.report({
+				node: t,
+				messageId: "extractToUtils",
+				data: { name: t.id.name }
+			});
+		} };
+	}
+}), O = (e) => e.type === "LogicalExpression" && e.operator === "&&" ? O(e.left) + O(e.right) : 1, k = n({
+	name: "no-inline-guard-chain-handler",
+	meta: {
+		type: "suggestion",
+		docs: { description: "Disallow a JSX prop arrow whose body is a long && guard chain" },
+		schema: [],
+		messages: { extractHandler: "JSX prop arrow guards with a {{count}}-term `&&` chain — extract a named handler with early returns." }
+	},
+	defaultOptions: [],
+	create(e) {
+		return { JSXAttribute(t) {
+			let n = t.value;
+			if (n?.type !== "JSXExpressionContainer") return;
+			let r = n.expression;
+			if (r.type !== "ArrowFunctionExpression" || r.body.type !== "LogicalExpression" || r.body.operator !== "&&") return;
+			let i = O(r.body);
+			i < 3 || e.report({
+				node: r,
+				messageId: "extractHandler",
+				data: { count: i }
+			});
+		} };
+	}
+}), A = n({
+	name: "no-inline-object-param-type",
+	meta: {
+		type: "suggestion",
+		docs: { description: "Disallow inline object type literals on function parameters" },
+		schema: [],
+		messages: { extractInterface: "Inline object type on this parameter — extract a named `interface` above the function." }
+	},
+	defaultOptions: [],
+	create(e) {
+		let t = (t) => {
+			let n = "typeAnnotation" in t ? t.typeAnnotation?.typeAnnotation : void 0;
+			n?.type === "TSTypeLiteral" && e.report({
+				node: n,
+				messageId: "extractInterface"
+			});
+		}, n = (e) => {
+			e.params.forEach(t);
+		};
+		return {
+			FunctionDeclaration: n,
+			FunctionExpression: n,
+			ArrowFunctionExpression: n
+		};
+	}
+}), j = /^render[A-Z]/, M = (e) => {
+	if (e?.scope.type !== "function") return !1;
+	let t = e.defs[0];
+	return t?.type === "FunctionName" || t?.type === "Variable";
+}, N = (e) => {
+	let t = e.parent;
+	for (; t;) {
+		if (t.type === "JSXExpressionContainer") return !0;
+		t = t.parent;
+	}
+	return !1;
+}, P = n({
+	name: "no-inline-render-function",
+	meta: {
+		type: "suggestion",
+		docs: { description: "Disallow calling a locally-declared render* helper function from within JSX" },
+		schema: [],
+		messages: { extractSubcomponent: "'{{name}}' is a local render helper called from JSX — extract a `<{{suggested}} />` subcomponent instead." }
+	},
+	defaultOptions: [],
+	create(e) {
+		return { CallExpression(t) {
+			if (t.callee.type !== "Identifier" || !j.test(t.callee.name) || !N(t) || !M(e.sourceCode.getScope(t).references.find((e) => e.identifier === t.callee)?.resolved ?? void 0)) return;
+			let n = t.callee.name, r = n.slice(6) || "Section";
+			e.report({
+				node: t,
+				messageId: "extractSubcomponent",
+				data: {
+					name: n,
+					suggested: r
+				}
+			});
+		} };
+	}
+}), F = n({
+	name: "no-jsx-in-variable",
+	meta: {
+		type: "suggestion",
+		docs: { description: "Disallow storing a JSX element/fragment in a variable" },
+		schema: [],
+		messages: { declareComponent: "JSX stored in a variable — declare a small named component with explicit props instead." }
+	},
+	defaultOptions: [],
+	create(e) {
+		return { VariableDeclarator(t) {
+			t.init && (t.init.type === "JSXElement" || t.init.type === "JSXFragment") && e.report({
+				node: t,
+				messageId: "declareComponent"
+			});
+		} };
+	}
+}), I = n({
+	name: "no-nested-try",
+	meta: {
+		type: "suggestion",
+		docs: { description: "Disallow nesting a try statement inside another try block or catch handler" },
+		schema: [],
+		messages: { nestedTry: "Nested try/catch — flatten into a single try/catch that handles both error paths." }
+	},
+	defaultOptions: [],
+	create(e) {
+		return { TryStatement(t) {
+			let n = t, r = t.parent;
+			for (; r;) {
+				if ([
+					"FunctionDeclaration",
+					"FunctionExpression",
+					"ArrowFunctionExpression"
+				].includes(r.type)) return;
+				if (r.type === "TryStatement" && (n === r.block || n === r.handler)) {
+					e.report({
+						node: t,
+						messageId: "nestedTry"
+					});
+					return;
+				}
+				n = r, r = r.parent;
+			}
+		} };
+	}
+}), L = /^use[A-Z]/, R = (e) => e.type === "CallExpression" && e.callee.type === "Identifier" && L.test(e.callee.name) ? !0 : u(e).some((e) => R(e)), z = n({
+	name: "no-non-hook-use-prefix",
+	meta: {
+		type: "suggestion",
+		docs: { description: "Disallow a use* named function whose body calls no hook" },
+		schema: [],
+		messages: { misnamed: "'{{name}}' is named like a hook but calls no hook internally — rename it to a plain action verb." }
+	},
+	defaultOptions: [],
+	create(e) {
+		let t = ({ node: t, name: n }) => {
+			!n || !L.test(n) || R(t.body) || e.report({
+				node: t,
+				messageId: "misnamed",
+				data: { name: n }
+			});
+		};
+		return {
+			FunctionDeclaration(e) {
+				t({
+					node: e,
+					name: e.id?.name
+				});
+			},
+			"VariableDeclarator > ArrowFunctionExpression"(e) {
+				let n = e.parent;
+				t({
+					node: e,
+					name: n.id.type === "Identifier" ? n.id.name : void 0
+				});
+			}
+		};
+	}
+}), he = /^render/i, ge = (e) => e ? ["JSXElement", "JSXFragment"].includes(e.body.type) ? !0 : e.body.type === "BlockStatement" && e.body.body.some((e) => e.type === "ReturnStatement" && e.argument && ["JSXElement", "JSXFragment"].includes(e.argument.type)) : !1, _e = n({
+	name: "no-render-fn-in-usecallback",
+	meta: {
+		type: "suggestion",
+		docs: { description: "Disallow useCallback wrapping a JSX-returning or render*-named function" },
+		schema: [],
+		messages: { extractSubcomponent: "useCallback wraps a render function — extract a `<Component />` instead; reserve useCallback for event handlers." }
+	},
+	defaultOptions: [],
+	create(e) {
+		return { CallExpression(t) {
+			if (t.callee.type !== "Identifier" || t.callee.name !== "useCallback") return;
+			let [n] = t.arguments;
+			if (!n || n.type !== "ArrowFunctionExpression" && n.type !== "FunctionExpression") return;
+			let r = t.parent.type === "VariableDeclarator" ? t.parent : null, i = r?.id.type === "Identifier" ? r.id.name : "";
+			!ge(n) && !he.test(i) || e.report({
+				node: t,
+				messageId: "extractSubcomponent"
+			});
+		} };
+	}
+}), ve = n({
+	name: "no-tests-in-dunder-folder",
+	meta: {
+		type: "suggestion",
+		docs: { description: "Disallow test files inside a __tests__ folder" },
+		schema: [],
+		messages: { colocate: "This test lives in a `__tests__` folder — colocate it as `*.test.ts(x)` next to its source file." }
+	},
+	defaultOptions: [],
+	create(e) {
+		return { Program(t) {
+			e.filename.replaceAll("\\", "/").includes("/__tests__/") && e.report({
+				node: t,
+				messageId: "colocate"
+			});
+		} };
+	}
+}), B = (e) => ["CallExpression", "NewExpression"].includes(e.type) ? !0 : u(e).some((e) => B(e)), ye = n({
+	name: "no-trivial-usememo",
+	meta: {
+		type: "suggestion",
+		docs: { description: "Disallow useMemo whose body has no function call (likely unnecessary memoization)" },
+		schema: [],
+		messages: { unnecessaryMemo: "useMemo body has no function call inside — likely too trivial to be worth memoizing." }
+	},
+	defaultOptions: [],
+	create(e) {
+		return { CallExpression(t) {
+			if (t.callee.type !== "Identifier" || t.callee.name !== "useMemo") return;
+			let [n] = t.arguments;
+			if (!n || n.type !== "ArrowFunctionExpression") return;
+			let r = n.body.type === "BlockStatement" ? n.body.body.find((e) => e.type === "ReturnStatement")?.argument : n.body;
+			r && (B(r) || e.report({
+				node: t,
+				messageId: "unnecessaryMemo"
+			}));
+		} };
+	}
+}), be = (e) => e.callee.type === "MemberExpression" && e.callee.object.type === "Identifier" && e.callee.object.name === "JSON" && e.callee.property.type === "Identifier" && e.callee.property.name === "parse", xe = (e) => {
+	let t = e, n;
+	for (; t;) {
+		if (t.type === "TryStatement" && n === t.block) return !0;
+		if ([
+			"FunctionDeclaration",
+			"FunctionExpression",
+			"ArrowFunctionExpression"
+		].includes(t.type)) return !1;
+		n = t, t = t.parent;
+	}
+	return !1;
+}, Se = n({
+	name: "no-unguarded-json-parse",
+	meta: {
+		type: "suggestion",
+		docs: { description: "Require JSON.parse(...) to be wrapped in a try/catch" },
+		schema: [],
+		messages: { unguarded: "JSON.parse(...) can throw on malformed input — wrap it in a try/catch." }
+	},
+	defaultOptions: [],
+	create(e) {
+		return { CallExpression(t) {
+			be(t) && (xe(t) || e.report({
+				node: t,
+				messageId: "unguarded"
+			}));
+		} };
+	}
+}), Ce = {
+	HTMLDivElement: "div",
+	HTMLSpanElement: "span",
+	HTMLButtonElement: "button",
+	HTMLInputElement: "input",
+	HTMLTextAreaElement: "textarea",
+	HTMLSelectElement: "select",
+	HTMLFormElement: "form",
+	HTMLAnchorElement: "a",
+	HTMLUListElement: "ul",
+	HTMLLIElement: "li",
+	HTMLTableElement: "table",
+	HTMLCanvasElement: "canvas",
+	HTMLVideoElement: "video",
+	HTMLAudioElement: "audio",
+	HTMLImageElement: "img",
+	HTMLParagraphElement: "p",
+	HTMLHeadingElement: "h1",
+	HTMLLabelElement: "label"
+}, we = (e) => e.body.some((e) => e.type === "ImportDeclaration" && e.source.value === "react" && e.specifiers.some((e) => e.type === "ImportSpecifier" && e.imported.type === "Identifier" && e.imported.name === "ElementRef")), Te = n({
+	name: "prefer-element-ref-type",
+	meta: {
+		type: "suggestion",
+		docs: { description: "Prefer useRef<ElementRef<\"tag\">>(null) over a raw HTMLXxxElement type argument" },
+		fixable: "code",
+		schema: [],
+		messages: { preferElementRef: "Use `ElementRef<\"{{tag}}\">` instead of `{{typeName}}` for this ref." }
+	},
+	defaultOptions: [],
+	create(e) {
+		return { CallExpression(t) {
+			if (t.callee.type !== "Identifier" || t.callee.name !== "useRef") return;
+			let n = t.typeArguments?.params[0];
+			if (!n || n.type !== "TSTypeReference" || n.typeName.type !== "Identifier") return;
+			let r = n.typeName.name;
+			if (!/^HTML\w*Element$/.test(r)) return;
+			let i = Ce[r];
+			if (!i) {
+				e.report({
+					node: n,
+					messageId: "preferElementRef",
+					data: {
+						typeName: r,
+						tag: "?"
+					}
+				});
+				return;
+			}
+			let a = we(e.sourceCode.ast);
+			e.report({
+				node: n,
+				messageId: "preferElementRef",
+				data: {
+					typeName: r,
+					tag: i
+				},
+				fix: a ? (e) => e.replaceText(n, `ElementRef<"${i}">`) : void 0
+			});
+		} };
+	}
+}), V = (e) => e.type === "LogicalExpression" && e.operator === "||" ? [...V(e.left), ...V(e.right)] : [e], Ee = (e) => e.type === "BinaryExpression" && ["===", "=="].includes(e.operator) && e.right.type === "Literal", De = n({
+	name: "prefer-includes-over-or-chain",
+	meta: {
+		type: "suggestion",
+		docs: { description: "Prefer Array#includes over a chain of === comparisons against the same value" },
+		fixable: "code",
+		schema: [],
+		messages: { preferIncludes: "Repeated equality checks against the same value — use `[...].includes(...)` instead." }
+	},
+	defaultOptions: [],
+	create(e) {
+		let t = e.sourceCode;
+		return { LogicalExpression(n) {
+			if (n.operator !== "||" || n.parent.type === "LogicalExpression" && n.parent.operator === "||") return;
+			let r = V(n);
+			if (r.length < 2 || !r.every(Ee)) return;
+			let i = r, a = i.map((e) => t.getText(e.left)), [o] = a;
+			a.every((e) => e === o) && e.report({
+				node: n,
+				messageId: "preferIncludes",
+				fix: (e) => {
+					let r = i.map((e) => t.getText(e.right)).join(", ");
+					return e.replaceText(n, `[${r}].includes(${o})`);
+				}
+			});
+		} };
+	}
+}), Oe = 270620, H = (e) => {
+	let t = e;
+	for (; t.type === "TSAsExpression" || t.type === "TSSatisfiesExpression" || t.type === "TSTypeAssertion" || t.type === "TSNonNullExpression" || t.type === "ChainExpression";) t = t.expression;
+	return t;
+}, U = (e) => !!e && ["JSXElement", "JSXFragment"].includes(e.type), W = (e) => {
+	let t = e.parent;
+	if (!t || t.type !== "JSXExpressionContainer") return !1;
+	let n = t.parent;
+	return !!n && ["JSXElement", "JSXFragment"].includes(n.type);
+}, ke = (e) => {
+	let t = H(e);
+	return t.type === "Literal" && (t.value === null || t.value === !1) || t.type === "Identifier" && t.name === "undefined";
+}, G = (e) => {
+	let t = H(e);
+	return t.type === "MemberExpression" && !t.computed && t.property.type === "Identifier" && t.property.name === "length";
+}, K = (e) => {
+	let t = H(e);
+	return t.type === "UnaryExpression" && t.operator === "!" || t.type === "BinaryExpression" || t.type === "CallExpression" || t.type === "Literal" && typeof t.value == "boolean" || t.type === "LogicalExpression" && t.operator === "&&" && K(t.left) && K(t.right);
+}, q = (e) => e ? e.flags & Oe ? !0 : e.isUnion() ? e.types.every(q) : !1 : !1, J = (e) => U(e) ? [] : e.type === "LogicalExpression" && e.operator === "&&" ? [...J(e.left), ...J(e.right)] : [e], Ae = n({
+	name: "prefer-jsx-short-circuit",
+	meta: {
+		type: "suggestion",
+		docs: { description: "Prefer && short-circuit for optional JSX, with a boolean left side" },
+		fixable: "code",
+		schema: [],
+		messages: {
+			preferShortCircuit: "Use `&&` short-circuit instead of `cond ? jsx : null` for optional rendering.",
+			requireBooleanGuard: "Left side of `&&` in JSX may leak a non-boolean value — use `!!value` or a boolean comparison."
+		}
+	},
+	defaultOptions: [],
+	create(e) {
+		let t = e.sourceCode, n = (e) => {
+			let n = t.getTokenBefore(e), r = t.getTokenAfter(e);
+			return n?.value === "(" && r?.value === ")" ? t.text.slice(n.range[0], r.range[1]) : t.getText(e);
+		}, r = (e) => {
+			try {
+				let n = t.parserServices;
+				if (!n?.program || !n.esTreeNodeToTSNodeMap) return;
+				let r = n.esTreeNodeToTSNodeMap.get(e);
+				return r ? n.program.getTypeChecker().getTypeAtLocation(r) : void 0;
+			} catch {
+				return;
+			}
+		}, i = (e) => {
+			if (K(e)) return !1;
+			if (G(e)) return !0;
+			let t = r(e);
+			if (t) return !q(t);
+			let n = H(e);
+			return n.type === "Identifier" || n.type === "Literal" && typeof n.value == "boolean" ? !1 : n.type !== "JSXElement" && n.type !== "JSXFragment";
+		}, a = (e) => {
+			let n = t.getText(e);
+			if (G(e)) return `${n} > 0`;
+			let r = H(e);
+			return [
+				"Identifier",
+				"MemberExpression",
+				"ChainExpression"
+			].includes(r.type) ? `!!${n}` : `!!(${n})`;
+		}, o = (e) => e.type === "LogicalExpression" && e.operator === "&&" ? `${o(e.left)} && ${o(e.right)}` : i(e) ? a(e) : t.getText(e);
+		return {
+			"JSXExpressionContainer > ConditionalExpression"(t) {
+				t.type === "ConditionalExpression" && W(t) && (!U(t.consequent) || !ke(t.alternate) || e.report({
+					node: t,
+					messageId: "preferShortCircuit",
+					fix: (e) => {
+						let r = o(t.test), i = n(t.consequent);
+						return e.replaceText(t, `${r} && ${i}`);
+					}
+				}));
+			},
+			"JSXExpressionContainer > LogicalExpression[operator='&&']"(t) {
+				if (t.type === "LogicalExpression" && W(t)) for (let n of J(t)) i(n) && e.report({
+					node: n,
+					messageId: "requireBooleanGuard",
+					fix: (e) => e.replaceText(n, a(n))
+				});
+			}
+		};
+	}
+}), je = (e) => e.type === "Literal" && e.value === null || e.type === "Identifier" && e.name === "undefined", Me = n({
+	name: "prefer-nullish-helpers",
+	meta: {
+		type: "suggestion",
+		docs: { description: "Prefer isNullish/!isNullish over a manual null-and-undefined comparison pair" },
+		schema: [],
+		messages: {
+			preferNotNullish: "Manual `!== null && !== undefined` pair — use `!isNullish({{expr}})` instead.",
+			preferNullish: "Manual `=== null || === undefined` pair — use `isNullish({{expr}})` instead."
+		}
+	},
+	defaultOptions: [],
+	create(e) {
+		let t = e.sourceCode, n = ({ node: n, operator: r, logicalOperator: i, messageId: a }) => {
+			if (n.operator !== i) return;
+			let o = (e) => e.type === "BinaryExpression" && e.operator === r && je(e.right);
+			if (!o(n.left) || !o(n.right)) return;
+			let s = t.getText(n.left.left);
+			s === t.getText(n.right.left) && e.report({
+				node: n,
+				messageId: a,
+				data: { expr: s }
+			});
+		};
+		return { LogicalExpression(e) {
+			n({
+				node: e,
+				operator: "!==",
+				logicalOperator: "&&",
+				messageId: "preferNotNullish"
+			}), n({
+				node: e,
+				operator: "===",
+				logicalOperator: "||",
+				messageId: "preferNullish"
+			});
+		} };
+	}
+}), Ne = n({
+	name: "prefer-positive-condition",
+	meta: {
+		type: "suggestion",
+		docs: { description: "Prefer a positive condition in a ternary over a negated one with swapped branches" },
+		fixable: "code",
+		schema: [],
+		messages: { preferPositive: "Negated ternary condition — swap the branches and drop the `!` instead." }
+	},
+	defaultOptions: [],
+	create(e) {
+		let t = e.sourceCode;
+		return { ConditionalExpression(n) {
+			let r = n.test;
+			r.type !== "UnaryExpression" || r.operator !== "!" || !r.prefix || e.report({
+				node: n,
+				messageId: "preferPositive",
+				fix: (e) => {
+					let i = t.getText(r.argument), a = t.getText(n.consequent), o = t.getText(n.alternate);
+					return e.replaceText(n, `${i} ? ${o} : ${a}`);
+				}
+			});
+		} };
+	}
+}), Pe = n({
+	name: "prefer-props-with-children",
+	meta: {
+		type: "suggestion",
+		docs: { description: "Prefer PropsWithChildren<Props> over a hand-declared children property" },
+		schema: [],
+		messages: { preferPropsWithChildren: "'{{name}}' hand-declares a `children` property — wrap the props type in `PropsWithChildren<...>` instead." }
+	},
+	defaultOptions: [],
+	create(e) {
+		return { TSInterfaceDeclaration(t) {
+			let n = t.body.body.find((e) => e.type === "TSPropertySignature" && e.key.type === "Identifier" && e.key.name === "children");
+			n && e.report({
+				node: n,
+				messageId: "preferPropsWithChildren",
+				data: { name: t.id.name }
+			});
+		} };
+	}
+}), Fe = (e) => {
+	if (e.type !== "TSTypeReference") return !1;
+	let t = e.typeName;
+	return t.type === "TSQualifiedName" ? t.left.type === "Identifier" && t.left.name === "JSX" && t.right.name === "Element" : t.type === "Identifier" && ["ReactElement", "JSX.Element"].includes(t.name);
+}, Ie = (e) => ["TSNullKeyword", "TSUndefinedKeyword"].includes(e.type), Le = (e) => e.body.some((e) => e.type === "ImportDeclaration" && e.source.value === "react" && e.specifiers.some((e) => e.type === "ImportSpecifier" && e.imported.type === "Identifier" && e.imported.name === "ReactNode")), Re = n({
+	name: "prefer-reactnode-over-jsxelement-union",
+	meta: {
+		type: "suggestion",
+		docs: { description: "Prefer ReactNode over a JSX.Element | null | undefined union" },
+		fixable: "code",
+		schema: [],
+		messages: { preferReactNode: "Use `ReactNode` instead of a `JSX.Element`/`ReactElement` union with null/undefined." }
+	},
+	defaultOptions: [],
+	create(e) {
+		return { TSUnionType(t) {
+			let n = t.types.some(Fe), r = t.types.some(Ie);
+			if (!n || !r) return;
+			let i = Le(e.sourceCode.ast);
+			e.report({
+				node: t,
+				messageId: "preferReactNode",
+				fix: i ? (e) => e.replaceText(t, "ReactNode") : void 0
+			});
+		} };
+	}
+}), ze = /^(get|query|find)(All)?ByTestId$/, Be = n({
+	name: "prefer-role-query-over-testid",
+	meta: {
+		type: "suggestion",
+		docs: { description: "Prefer Testing Library's *ByRole queries over *ByTestId" },
+		schema: [],
+		messages: { preferRole: "'{{name}}' — prefer the equivalent `*ByRole` query for a semantic, accessible selector." }
+	},
+	defaultOptions: [],
+	create(e) {
+		let t = ({ node: t, name: n }) => {
+			ze.test(n) && e.report({
+				node: t,
+				messageId: "preferRole",
+				data: { name: n }
+			});
+		};
+		return { CallExpression(e) {
+			e.callee.type === "Identifier" ? t({
+				node: e,
+				name: e.callee.name
+			}) : e.callee.type === "MemberExpression" && e.callee.property.type === "Identifier" && t({
+				node: e.callee.property,
+				name: e.callee.property.name
+			});
+		} };
+	}
+}), Y = (e) => e.type === "CallExpression" && e.callee.type === "MemberExpression" && !e.callee.computed && e.callee.property.type === "Identifier" && e.callee.property.name === "find", Ve = n({
+	name: "prefer-some-over-find-check",
+	meta: {
+		type: "suggestion",
+		docs: { description: "Prefer Array#some over comparing Array#find's result to undefined" },
+		fixable: "code",
+		schema: [],
+		messages: { preferSome: "Use `.some(...)` instead of comparing `.find(...)` to undefined for an existence check." }
+	},
+	defaultOptions: [],
+	create(e) {
+		let t = e.sourceCode, n = (e) => {
+			let n = e.callee;
+			return `${t.getText(n.object)}.some(${e.arguments.map((e) => t.getText(e)).join(", ")})`;
+		};
+		return {
+			BinaryExpression(t) {
+				if (t.operator !== "!==" && t.operator !== "===") return;
+				let [r, i] = t.left.type === "CallExpression" ? [t.left, t.right] : [t.right, t.left];
+				if (!Y(r) || i.type !== "Identifier" || i.name !== "undefined") return;
+				let a = t.operator === "===";
+				e.report({
+					node: t,
+					messageId: "preferSome",
+					fix: (e) => {
+						let i = n(r);
+						return e.replaceText(t, a ? `!${i}` : i);
+					}
+				});
+			},
+			UnaryExpression(t) {
+				if (t.operator !== "!" || !t.prefix) return;
+				let r = t.argument;
+				Y(r) && e.report({
+					node: t,
+					messageId: "preferSome",
+					fix: (e) => e.replaceText(t, `!${n(r)}`)
+				});
+			}
+		};
+	}
+}), He = (e) => e.charAt(0).toLowerCase() + e.slice(1), Ue = ({ node: e, key: t }) => (e.type === "MemberExpression" || e.type === "MethodDefinition") && t === "property" && !e.computed || e.type === "Property" && t === "key" && !e.computed, We = (e) => !!e && typeof e == "object" && typeof e.type == "string", Ge = (e) => {
+	let t = (n) => {
+		if (!We(n)) return !1;
+		if (n.type === "Identifier" && n.name === e) return !0;
+		for (let e of Object.keys(n)) {
+			if (e === "parent" || Ue({
+				node: n,
+				key: e
+			})) continue;
+			let r = n[e];
+			if (Array.isArray(r) ? r.some(t) : t(r)) return !0;
+		}
+		return !1;
+	};
+	return t;
+}, Ke = n({
+	name: "prefer-state-updater-form",
+	meta: {
+		type: "suggestion",
+		docs: { description: "Prefer the updater-function form of a state setter when the new value depends on the current one" },
+		schema: [],
+		messages: { preferUpdaterForm: "'{{setter}}' argument references '{{state}}' directly — use the updater form `{{setter}}((current) => ...)` instead." }
+	},
+	defaultOptions: [],
+	create(e) {
+		return { CallExpression(t) {
+			if (t.callee.type !== "Identifier" || !/^set[A-Z]/.test(t.callee.name) || t.arguments.length !== 1) return;
+			let [n] = t.arguments;
+			if (["ArrowFunctionExpression", "FunctionExpression"].includes(n.type)) return;
+			let r = He(t.callee.name.slice(3));
+			Ge(r)(n) && e.report({
+				node: t,
+				messageId: "preferUpdaterForm",
+				data: {
+					setter: t.callee.name,
+					state: r
+				}
+			});
+		} };
+	}
+}), X = /* @__PURE__ */ new Set([
+	"setInterval",
+	"setTimeout",
+	"addEventListener",
+	"subscribe"
+]), qe = (e) => !!e && typeof e == "object" && typeof e.type == "string", Je = (e) => e.type === "CallExpression" ? e.callee.type === "Identifier" ? X.has(e.callee.name) : e.callee.type === "MemberExpression" && e.callee.property.type === "Identifier" && X.has(e.callee.property.name) : !1, Z = (e) => {
+	if (!qe(e)) return !1;
+	if (Je(e)) return !0;
+	if ([
+		"FunctionDeclaration",
+		"FunctionExpression",
+		"ArrowFunctionExpression"
+	].includes(e.type)) return !1;
+	for (let t of Object.keys(e)) {
+		if (t === "parent") continue;
+		let n = e[t];
+		if (Array.isArray(n) ? n.some((e) => Z(e)) : Z(n)) return !0;
+	}
+	return !1;
+}, Ye = (e) => e.body.some((e) => e.type === "ReturnStatement" && e.argument !== null && ["ArrowFunctionExpression", "FunctionExpression"].includes(e.argument.type)), Q = n({
+	name: "require-effect-cleanup",
+	meta: {
+		type: "suggestion",
+		docs: { description: "Require a cleanup return from a useEffect that registers a timer/listener/subscription" },
+		schema: [],
+		messages: { requireCleanup: "This effect registers a {{what}} but returns no cleanup function to tear it down." }
+	},
+	defaultOptions: [],
+	create(e) {
+		return { CallExpression(t) {
+			if (t.callee.type !== "Identifier" || t.callee.name !== "useEffect") return;
+			let [n] = t.arguments;
+			!n || n.type !== "ArrowFunctionExpression" && n.type !== "FunctionExpression" || n.body.type !== "BlockStatement" || Z(n.body) && (Ye(n.body) || e.report({
+				node: t,
+				messageId: "requireCleanup",
+				data: { what: "interval/listener/subscription" }
+			}));
+		} };
+	}
+}), Xe = (e) => {
+	let t = 0, n = e;
+	for (; n.type === "MemberExpression" || n.type === "CallExpression";) n.optional && (t += 1), n = n.type === "CallExpression" ? n.callee : n.object;
+	return t;
+}, Ze = (e) => e.parent.type === "LogicalExpression" && e.parent.operator === "??" && e.parent.left === e, Qe = n({
+	name: "require-fallback-on-deep-chain",
+	meta: {
+		type: "suggestion",
+		docs: { description: "Require a ?? fallback on a deep optional chain" },
+		schema: [{
+			type: "object",
+			properties: { minDepth: {
+				type: "integer",
+				minimum: 2
+			} },
+			additionalProperties: !1
+		}],
+		messages: { requireFallback: "Optional chain is {{depth}} levels deep with no `?? fallback` — add one." }
+	},
+	defaultOptions: [{}],
+	create(e, [t]) {
+		let n = t.minDepth ?? 3;
+		return { ChainExpression(t) {
+			let r = Xe(t.expression);
+			r < n || Ze(t) || e.report({
+				node: t,
+				messageId: "requireFallback",
+				data: { depth: r }
+			});
+		} };
+	}
+}), $e = n({
+	name: "require-numeric-enum-initializer",
+	meta: {
+		type: "suggestion",
+		docs: { description: "Require an explicit initializer on every enum member" },
+		schema: [],
+		messages: { missingInitializer: "Enum member '{{name}}' has no explicit initializer — assign an explicit value." }
+	},
+	defaultOptions: [],
+	create(e) {
+		return { TSEnumMember(t) {
+			if (t.initializer) return;
+			let n = t.id.type === "Identifier" ? t.id.name : e.sourceCode.getText(t.id);
+			e.report({
+				node: t,
+				messageId: "missingInitializer",
+				data: { name: n }
+			});
+		} };
+	}
+}), et = /* @__PURE__ */ new Set(["useState", "useRef"]), tt = (e) => {
+	let t = e.typeArguments;
+	return !!t && t.params.length > 0;
+}, nt = (e) => {
+	if (e.arguments.length === 0) return !0;
+	let [t] = e.arguments;
+	return t.type === "Literal" && t.value === null || t.type === "Identifier" && t.name === "undefined";
+}, $ = {
+	meta: { name: "@lichens-innovation/eslint-plugin-coding-guide" },
+	rules: {
+		"filename-convention-by-export-shape": c,
+		"hoist-static-component-constants": re,
+		"max-params-project": fe,
+		"no-explicit-undefined-optional": _,
+		"no-exported-mutable-state": v,
+		"no-hook-returning-jsx": S,
+		"no-inline-array-chain-in-jsx": T,
+		"no-inline-curried-handler": D,
+		"no-inline-guard-chain-handler": k,
+		"no-inline-object-param-type": A,
+		"no-inline-render-function": P,
+		"no-jsx-in-variable": F,
+		"no-nested-try": I,
+		"no-non-hook-use-prefix": z,
+		"no-render-fn-in-usecallback": _e,
+		"no-tests-in-dunder-folder": ve,
+		"no-trivial-usememo": ye,
+		"no-unguarded-json-parse": Se,
+		"prefer-element-ref-type": Te,
+		"prefer-includes-over-or-chain": De,
+		"prefer-jsx-short-circuit": Ae,
+		"prefer-nullish-helpers": Me,
+		"prefer-positive-condition": Ne,
+		"prefer-props-with-children": Pe,
+		"prefer-reactnode-over-jsxelement-union": Re,
+		"prefer-role-query-over-testid": Be,
+		"prefer-some-over-find-check": Ve,
+		"prefer-state-updater-form": Ke,
+		"require-effect-cleanup": Q,
+		"require-fallback-on-deep-chain": Qe,
+		"require-numeric-enum-initializer": $e,
+		"require-usestate-useref-generic": n({
+			name: "require-usestate-useref-generic",
+			meta: {
+				type: "suggestion",
+				docs: { description: "Require an explicit generic on useState()/useRef() when the initial value can't infer one" },
+				schema: [],
+				messages: { requireGeneric: "'{{name}}()' has no inferable type from its initial value — add an explicit `<Type>` generic." }
+			},
+			defaultOptions: [],
+			create(e) {
+				return { CallExpression(t) {
+					t.callee.type !== "Identifier" || !et.has(t.callee.name) || tt(t) || nt(t) && e.report({
+						node: t,
+						messageId: "requireGeneric",
+						data: { name: t.callee.name }
+					});
+				} };
+			}
+		}),
+		"todo-ticket-ref": n({
+			name: "todo-ticket-ref",
+			meta: {
+				type: "suggestion",
+				docs: { description: "Require a ticket reference in the TODO comment" },
+				schema: [{
+					type: "object",
+					properties: {
+						pattern: { type: "string" },
+						terms: {
+							type: "array",
+							items: { type: "string" }
+						},
+						commentPattern: { type: "string" },
+						description: { type: "string" },
+						comment: { type: "string" }
+					},
+					additionalProperties: !1
+				}],
+				messages: {
+					missingTicket: "{{ term }} comment doesn't reference a ticket number. Ticket pattern: {{ pattern }}",
+					missingTicketWithCommentPattern: "{{ term }} comment doesn't reference a ticket number. Comment pattern: {{ commentPattern }}",
+					missingTicketWithDescription: "{{ term }} comment doesn't reference a ticket number. {{ description }}"
+				}
+			},
+			defaultOptions: [{}],
+			create(e, [t]) {
+				let n = t.pattern ?? "([A-Z]+-\\d+)", r = t.terms ?? ["TODO"], i = t.commentPattern, a = t.description, o = e.sourceCode.getAllComments(), s = new RegExp(n, "i"), c = {};
+				for (let e of r) c[e] = i ? new RegExp(i, "i") : s;
+				let l = () => a ? "missingTicketWithDescription" : i ? "missingTicketWithCommentPattern" : "missingTicket";
+				return o.forEach((t) => {
+					let o = t.value;
+					for (let s of r) o.includes(s) && (c[s].test(o) || e.report({
+						loc: t.loc,
+						messageId: l(),
+						data: {
+							term: s,
+							pattern: n,
+							commentPattern: i ?? "",
+							description: a ?? ""
+						}
+					}));
+				}), {};
+			}
+		})
+	}
+}, rt = { recommended: t($) };
+//#endregion
+export { rt as configs, $ as default };
+
+//# sourceMappingURL=index.js.map