@pyreon/lint 0.11.10 → 0.12.1

package/lib/cli.js

@@ -1118,39 +1118,72 @@ function containsJSXReturn(node) {
 	}
 	return false;
 }
+/**
+* Extract destructured property names from an ObjectPattern.
+* Returns names for the fix suggestion.
+*/
+function getDestructuredNames(pattern) {
+	if (pattern.type !== "ObjectPattern") return [];
+	const names = [];
+	for (const prop of pattern.properties ?? []) if (prop.type === "ObjectProperty" && prop.key?.type === "Identifier") names.push(prop.key.name);
+	return names;
+}
 const noPropsDestructure = {
 	meta: {
 		id: "pyreon/no-props-destructure",
 		category: "jsx",
-		description: "Disallow destructuring props in component functions — it breaks signal reactivity.",
+		description: "Disallow destructuring props in component functions — breaks reactive prop tracking. Use props.x or splitProps().",
 		severity: "error",
 		fixable: false
 	},
 	create(context) {
+		let functionDepth = 0;
 		return {
 			ArrowFunctionExpression(node) {
-				checkFunction(node, context);
+				functionDepth++;
+				checkFunction(node, context, functionDepth);
+			},
+			"ArrowFunctionExpression:exit"() {
+				functionDepth--;
 			},
 			FunctionDeclaration(node) {
-				checkFunction(node, context);
+				functionDepth++;
+				checkFunction(node, context, functionDepth);
+			},
+			"FunctionDeclaration:exit"() {
+				functionDepth--;
 			},
 			FunctionExpression(node) {
-				checkFunction(node, context);
+				functionDepth++;
+				checkFunction(node, context, functionDepth);
+			},
+			"FunctionExpression:exit"() {
+				functionDepth--;
 			}
 		};
 	}
 };
-function checkFunction(node, context) {
+function checkFunction(node, context, depth) {
 	const params = node.params;
 	if (!params || params.length === 0) return;
 	const firstParam = params[0];
 	if (!isDestructuring(firstParam)) return;
+	if (depth > 1) return;
 	const body = node.body;
 	if (!body) return;
-	if (containsJSXReturn(body)) context.report({
-		message: "Destructured props in a component function — this breaks signal reactivity. Use `props.x` or `splitProps()` instead.",
-		span: getSpan(firstParam)
-	});
+	if (containsJSXReturn(body)) {
+		const names = getDestructuredNames(firstParam);
+		const hasRest = (firstParam.properties ?? []).some((p) => p.type === "RestElement");
+		let suggestion = "Use `props.x` pattern for reactive prop access.";
+		if (names.length > 0) {
+			suggestion = `Use \`props\` parameter and access as ${names.map((n) => `props.${n}`).join(", ")}.`;
+			if (hasRest) suggestion += ` For rest props, use \`splitProps(props, [${names.map((n) => `'${n}'`).join(", ")}])\`.`;
+		}
+		context.report({
+			message: `Destructured props in component function — breaks reactive prop tracking. ${suggestion}`,
+			span: getSpan(firstParam)
+		});
+	}
 }
 
 //#endregion
@@ -1700,6 +1733,48 @@ const noSignalInLoop = {
 	}
 };
 
+//#endregion
+//#region src/rules/reactivity/no-signal-in-props.ts
+function isComponentTag(name) {
+	return name.length > 0 && name[0] === name[0]?.toUpperCase() && name[0] !== name[0]?.toLowerCase();
+}
+/**
+* Warn when a known signal/computed is called in a component prop position.
+* Component props are evaluated once at mount — signal reads are NOT reactive
+* unless the compiler wraps them with _rp(). The compiler handles this
+* automatically, but this rule catches manual h() calls and educates developers.
+*/
+const noSignalInProps = {
+	meta: {
+		id: "pyreon/no-signal-in-props",
+		category: "reactivity",
+		description: "Signal call in component prop — value captured once unless compiler wraps it. Use props.x pattern for reactivity.",
+		severity: "warn",
+		fixable: false
+	},
+	create(context) {
+		return { JSXExpressionContainer(node) {
+			const expr = node.expression;
+			if (!expr || expr.type !== "CallExpression") return;
+			const callee = expr.callee;
+			if (!callee || callee.type !== "Identifier") return;
+			const source = context.getSourceText();
+			let i = node.start - 1;
+			while (i >= 0 && source[i] !== "<" && source[i] !== ">") i--;
+			if (i < 0 || source[i] !== "<") return;
+			const tagStart = i + 1;
+			let tagEnd = tagStart;
+			while (tagEnd < source.length && /[\w.]/.test(source[tagEnd] ?? "")) tagEnd++;
+			const tagName = source.slice(tagStart, tagEnd);
+			if (!tagName || !isComponentTag(tagName)) return;
+			context.report({
+				message: `Signal call in <${tagName}> prop — use props.x pattern inside the component for reactive access.`,
+				span: getSpan(expr)
+			});
+		} };
+	}
+};
+
 //#endregion
 //#region src/rules/reactivity/no-signal-leak.ts
 const noSignalLeak = {
@@ -2418,6 +2493,7 @@ const allRules = [
 	noBareSignalInJsx,
 	noContextDestructure,
 	noSignalInLoop,
+	noSignalInProps,
 	noNestedEffect,
 	noPeekInTracked,
 	noUnbatchedUpdates,
@@ -2659,10 +2735,19 @@ function lintFile(filePath, sourceText, rules, config, cache) {
 		allCallbacks.push(rule.create(ctx));
 	}
 	new Visitor(mergeCallbacks(allCallbacks)).visit(program);
-	diagnostics.sort((a, b) => a.span.start - b.span.start);
+	const lines = sourceText.split("\n");
+	const filtered = diagnostics.filter((d) => {
+		const prevLineIdx = d.loc.line - 2;
+		if (prevLineIdx < 0) return true;
+		const prevLine = lines[prevLineIdx]?.trim();
+		if (!prevLine?.startsWith("// pyreon-lint-ignore")) return true;
+		const rest = prevLine.slice(21).trim();
+		return rest.length > 0 && rest !== d.ruleId;
+	});
+	filtered.sort((a, b) => a.span.start - b.span.start);
 	return {
 		filePath,
-		diagnostics
+		diagnostics: filtered
 	};
 }
 /**