@pyreon/lint 0.11.9 → 0.12.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pyreon/lint",
-  "version": "0.11.9",
+  "version": "0.12.0",
   "description": "Pyreon-specific linter — 56 rules for signals, JSX, SSR, performance, router, and architecture",
   "homepage": "https://github.com/pyreon/pyreon/tree/main/packages/lint#readme",
   "bugs": {

package/src/rules/jsx/no-props-destructure.ts

@@ -3,11 +3,9 @@ import { getSpan, isDestructuring } from '../../utils/ast'
 
 function containsJSXReturn(node: any): boolean {
   if (!node) return false
-  // Arrow with expression body returning JSX
   if (node.type === 'JSXElement' || node.type === 'JSXFragment') return true
   if (node.type === 'ParenthesizedExpression') return containsJSXReturn(node.expression)
 
-  // Block body — look for return statements with JSX
   if (node.type === 'BlockStatement') {
     for (const stmt of node.body ?? []) {
       if (stmt.type === 'ReturnStatement' && containsJSXReturn(stmt.argument)) {
@@ -18,46 +16,89 @@ function containsJSXReturn(node: any): boolean {
   return false
 }
 
+/**
+ * Extract destructured property names from an ObjectPattern.
+ * Returns names for the fix suggestion.
+ */
+function getDestructuredNames(pattern: any): string[] {
+  if (pattern.type !== 'ObjectPattern') return []
+  const names: string[] = []
+  for (const prop of pattern.properties ?? []) {
+    if (prop.type === 'ObjectProperty' && prop.key?.type === 'Identifier') {
+      names.push(prop.key.name)
+    }
+  }
+  return names
+}
+
 export const noPropsDestructure: Rule = {
   meta: {
     id: 'pyreon/no-props-destructure',
     category: 'jsx',
     description:
-      'Disallow destructuring props in component functions — it breaks signal reactivity.',
+      'Disallow destructuring props in component functions — breaks reactive prop tracking. Use props.x or splitProps().',
     severity: 'error',
     fixable: false,
   },
   create(context) {
+    let functionDepth = 0
+
     const callbacks: VisitorCallbacks = {
       ArrowFunctionExpression(node: any) {
-        checkFunction(node, context)
+        functionDepth++
+        checkFunction(node, context, functionDepth)
+      },
+      'ArrowFunctionExpression:exit'() {
+        functionDepth--
       },
       FunctionDeclaration(node: any) {
-        checkFunction(node, context)
+        functionDepth++
+        checkFunction(node, context, functionDepth)
+      },
+      'FunctionDeclaration:exit'() {
+        functionDepth--
       },
       FunctionExpression(node: any) {
-        checkFunction(node, context)
+        functionDepth++
+        checkFunction(node, context, functionDepth)
+      },
+      'FunctionExpression:exit'() {
+        functionDepth--
       },
     }
     return callbacks
   },
 }
 
-function checkFunction(node: any, context: any) {
+function checkFunction(node: any, context: any, depth: number) {
   const params = node.params
   if (!params || params.length === 0) return
 
   const firstParam = params[0]
   if (!isDestructuring(firstParam)) return
 
-  // Check if this function returns JSX
+  // Skip HOC inner functions (depth > 1)
+  if (depth > 1) return
+
   const body = node.body
   if (!body) return
 
   if (containsJSXReturn(body)) {
+    const names = getDestructuredNames(firstParam)
+    const hasRest = (firstParam.properties ?? []).some((p: any) => p.type === 'RestElement')
+
+    let suggestion = 'Use `props.x` pattern for reactive prop access.'
+    if (names.length > 0) {
+      const propsAccess = names.map((n) => `props.${n}`).join(', ')
+      suggestion = `Use \`props\` parameter and access as ${propsAccess}.`
+      if (hasRest) {
+        suggestion += ` For rest props, use \`splitProps(props, [${names.map((n) => `'${n}'`).join(', ')}])\`.`
+      }
+    }
+
     context.report({
       message:
-        'Destructured props in a component function — this breaks signal reactivity. Use `props.x` or `splitProps()` instead.',
+        `Destructured props in component function — breaks reactive prop tracking. ${suggestion}`,
       span: getSpan(firstParam),
     })
   }

package/src/watcher.ts

@@ -41,7 +41,7 @@ export function watchAndLint(options: LintOptions & { format: string }): void {
   // Debounce map: filePath -> timeout
   const pending = new Map<string, ReturnType<typeof setTimeout>>()
 
-  // eslint-disable-next-line no-console
+  // oxlint-disable-next-line no-console
   console.log(`\x1b[2m[pyreon-lint] Watching for changes...\x1b[0m\n`)
 
   for (const p of options.paths) {