@pyreon/lint 0.11.5 → 0.11.6

package/src/rules/lifecycle/no-mount-in-effect.ts

@@ -1,31 +1,31 @@
-import type { Rule, VisitorCallbacks } from "../../types"
-import { getSpan, isCallTo } from "../../utils/ast"
+import type { Rule, VisitorCallbacks } from '../../types'
+import { getSpan, isCallTo } from '../../utils/ast'
 
 export const noMountInEffect: Rule = {
   meta: {
-    id: "pyreon/no-mount-in-effect",
-    category: "lifecycle",
-    description: "Warn when onMount is called inside effect().",
-    severity: "warn",
+    id: 'pyreon/no-mount-in-effect',
+    category: 'lifecycle',
+    description: 'Warn when onMount is called inside effect().',
+    severity: 'warn',
     fixable: false,
   },
   create(context) {
     let effectDepth = 0
     const callbacks: VisitorCallbacks = {
       CallExpression(node: any) {
-        if (isCallTo(node, "effect")) {
+        if (isCallTo(node, 'effect')) {
           effectDepth++
         }
-        if (effectDepth > 0 && isCallTo(node, "onMount")) {
+        if (effectDepth > 0 && isCallTo(node, 'onMount')) {
           context.report({
             message:
-              "`onMount` inside `effect()` — `onMount` runs once on mount, not on every effect re-run.",
+              '`onMount` inside `effect()` — `onMount` runs once on mount, not on every effect re-run.',
             span: getSpan(node),
           })
         }
       },
-      "CallExpression:exit"(node: any) {
-        if (isCallTo(node, "effect")) {
+      'CallExpression:exit'(node: any) {
+        if (isCallTo(node, 'effect')) {
           effectDepth--
         }
       },

package/src/rules/performance/no-eager-import.ts

@@ -1,13 +1,13 @@
-import type { Rule, VisitorCallbacks } from "../../types"
-import { getSpan } from "../../utils/ast"
-import { HEAVY_PACKAGES } from "../../utils/imports"
+import type { Rule, VisitorCallbacks } from '../../types'
+import { getSpan } from '../../utils/ast'
+import { HEAVY_PACKAGES } from '../../utils/imports'
 
 export const noEagerImport: Rule = {
   meta: {
-    id: "pyreon/no-eager-import",
-    category: "performance",
-    description: "Suggest lazy-loading heavy Pyreon packages (charts, code, document, flow).",
-    severity: "info",
+    id: 'pyreon/no-eager-import',
+    category: 'performance',
+    description: 'Suggest lazy-loading heavy Pyreon packages (charts, code, document, flow).',
+    severity: 'info',
     fixable: false,
   },
   create(context) {

package/src/rules/performance/no-effect-in-for.ts

@@ -1,13 +1,13 @@
-import type { Rule, VisitorCallbacks } from "../../types"
-import { getSpan, isCallTo } from "../../utils/ast"
+import type { Rule, VisitorCallbacks } from '../../types'
+import { getSpan, isCallTo } from '../../utils/ast'
 
 export const noEffectInFor: Rule = {
   meta: {
-    id: "pyreon/no-effect-in-for",
-    category: "performance",
+    id: 'pyreon/no-effect-in-for',
+    category: 'performance',
     description:
-      "Warn when effect() is created inside <For> — creates effects per item on every reconciliation.",
-    severity: "warn",
+      'Warn when effect() is created inside <For> — creates effects per item on every reconciliation.',
+    severity: 'warn',
     fixable: false,
   },
   create(context) {
@@ -15,22 +15,22 @@ export const noEffectInFor: Rule = {
     const callbacks: VisitorCallbacks = {
       JSXOpeningElement(node: any) {
         const name = node.name
-        if (name?.type === "JSXIdentifier" && name.name === "For") {
+        if (name?.type === 'JSXIdentifier' && name.name === 'For') {
           forJsxDepth++
         }
       },
       JSXClosingElement(node: any) {
         const name = node.name
-        if (name?.type === "JSXIdentifier" && name.name === "For") {
+        if (name?.type === 'JSXIdentifier' && name.name === 'For') {
           forJsxDepth--
         }
       },
       CallExpression(node: any) {
         if (forJsxDepth === 0) return
-        if (isCallTo(node, "effect")) {
+        if (isCallTo(node, 'effect')) {
           context.report({
             message:
-              "`effect()` inside `<For>` — this creates a new effect for every item on each reconciliation. Lift the effect outside.",
+              '`effect()` inside `<For>` — this creates a new effect for every item on each reconciliation. Lift the effect outside.',
             span: getSpan(node),
           })
         }

package/src/rules/performance/no-large-for-without-by.ts

@@ -1,24 +1,24 @@
-import type { Rule, VisitorCallbacks } from "../../types"
-import { getSpan, hasJSXAttribute } from "../../utils/ast"
+import type { Rule, VisitorCallbacks } from '../../types'
+import { getSpan, hasJSXAttribute } from '../../utils/ast'
 
 export const noLargeForWithoutBy: Rule = {
   meta: {
-    id: "pyreon/no-large-for-without-by",
-    category: "performance",
+    id: 'pyreon/no-large-for-without-by',
+    category: 'performance',
     description:
-      "Error when <For> is used without a `by` prop — critical for reconciliation performance.",
-    severity: "error",
+      'Error when <For> is used without a `by` prop — critical for reconciliation performance.',
+    severity: 'error',
     fixable: false,
   },
   create(context) {
     const callbacks: VisitorCallbacks = {
       JSXOpeningElement(node: any) {
         const name = node.name
-        if (!name || name.type !== "JSXIdentifier" || name.name !== "For") return
-        if (hasJSXAttribute(node, "by")) return
+        if (!name || name.type !== 'JSXIdentifier' || name.name !== 'For') return
+        if (hasJSXAttribute(node, 'by')) return
         context.report({
           message:
-            "`<For>` without `by` prop — provide a key function for efficient reconciliation.",
+            '`<For>` without `by` prop — provide a key function for efficient reconciliation.',
           span: getSpan(node),
         })
       },

package/src/rules/performance/prefer-show-over-display.ts

@@ -1,40 +1,40 @@
-import type { Rule, VisitorCallbacks } from "../../types"
-import { getSpan } from "../../utils/ast"
+import type { Rule, VisitorCallbacks } from '../../types'
+import { getSpan } from '../../utils/ast'
 
 export const preferShowOverDisplay: Rule = {
   meta: {
-    id: "pyreon/prefer-show-over-display",
-    category: "performance",
-    description: "Suggest <Show> over conditional `display` style property in JSX.",
-    severity: "info",
+    id: 'pyreon/prefer-show-over-display',
+    category: 'performance',
+    description: 'Suggest <Show> over conditional `display` style property in JSX.',
+    severity: 'info',
     fixable: false,
   },
   create(context) {
     const callbacks: VisitorCallbacks = {
       JSXAttribute(node: any) {
-        if (node.name?.type !== "JSXIdentifier" || node.name.name !== "style") return
+        if (node.name?.type !== 'JSXIdentifier' || node.name.name !== 'style') return
         const value = node.value
-        if (!value || value.type !== "JSXExpressionContainer") return
+        if (!value || value.type !== 'JSXExpressionContainer') return
         const expr = value.expression
-        if (!expr || expr.type !== "ObjectExpression") return
+        if (!expr || expr.type !== 'ObjectExpression') return
 
         for (const prop of expr.properties ?? []) {
-          if (prop.type !== "Property") continue
+          if (prop.type !== 'Property') continue
           const key = prop.key
           if (!key) continue
           const propName =
-            key.type === "Identifier" ? key.name : key.type === "Literal" ? key.value : null
-          if (propName === "display") {
+            key.type === 'Identifier' ? key.name : key.type === 'Literal' ? key.value : null
+          if (propName === 'display') {
             // Check if the value is conditional
             const val = prop.value
             if (
-              val?.type === "ConditionalExpression" ||
-              val?.type === "LogicalExpression" ||
-              val?.type === "CallExpression"
+              val?.type === 'ConditionalExpression' ||
+              val?.type === 'LogicalExpression' ||
+              val?.type === 'CallExpression'
             ) {
               context.report({
                 message:
-                  "Conditional `display` style — consider using `<Show>` for conditional rendering instead of toggling CSS display.",
+                  'Conditional `display` style — consider using `<Show>` for conditional rendering instead of toggling CSS display.',
                 span: getSpan(prop),
               })
             }

package/src/rules/reactivity/no-bare-signal-in-jsx.ts

@@ -1,15 +1,15 @@
-import type { Rule, VisitorCallbacks } from "../../types"
-import { getSpan } from "../../utils/ast"
+import type { Rule, VisitorCallbacks } from '../../types'
+import { getSpan } from '../../utils/ast'
 
 const SKIP_PREFIXES = /^(use|get|is|has|[A-Z])/
 
 export const noBareSignalInJsx: Rule = {
   meta: {
-    id: "pyreon/no-bare-signal-in-jsx",
-    category: "reactivity",
+    id: 'pyreon/no-bare-signal-in-jsx',
+    category: 'reactivity',
     description:
-      "Disallow bare signal calls in JSX text positions. Wrap in `() =>` for reactivity.",
-    severity: "error",
+      'Disallow bare signal calls in JSX text positions. Wrap in `() =>` for reactivity.',
+    severity: 'error',
     fixable: true,
   },
   create(context) {
@@ -18,21 +18,21 @@ export const noBareSignalInJsx: Rule = {
       JSXElement() {
         jsxDepth++
       },
-      "JSXElement:exit"() {
+      'JSXElement:exit'() {
         jsxDepth--
       },
       JSXFragment() {
         jsxDepth++
       },
-      "JSXFragment:exit"() {
+      'JSXFragment:exit'() {
         jsxDepth--
       },
       JSXExpressionContainer(node: any) {
         if (jsxDepth === 0) return
         const expr = node.expression
-        if (!expr || expr.type !== "CallExpression") return
+        if (!expr || expr.type !== 'CallExpression') return
         const callee = expr.callee
-        if (!callee || callee.type !== "Identifier") return
+        if (!callee || callee.type !== 'Identifier') return
 
         const name: string = callee.name
         if (SKIP_PREFIXES.test(name)) return

package/src/rules/reactivity/no-context-destructure.ts

@@ -0,0 +1,45 @@
+import type { Rule, VisitorCallbacks } from '../../types'
+import { getSpan } from '../../utils/ast'
+
+/**
+ * Detects destructuring the return value of useContext().
+ *
+ * `const { mode } = useContext(ctx)` loses reactivity when the context
+ * provides getter properties. The value is captured once at setup time.
+ *
+ * Correct: `const ctx = useContext(Ctx)` then read `ctx.mode` lazily.
+ */
+export const noContextDestructure: Rule = {
+  meta: {
+    id: 'pyreon/no-context-destructure',
+    category: 'reactivity',
+    description:
+      'Disallow destructuring useContext() — it breaks reactivity when context provides getters.',
+    severity: 'warn',
+    fixable: false,
+  },
+  create(context) {
+    const callbacks: VisitorCallbacks = {
+      VariableDeclarator(node: any) {
+        // Match: const { x } = useContext(...)
+        const id = node.id
+        const init = node.init
+        if (!id || !init) return
+        if (id.type !== 'ObjectPattern') return
+        if (
+          init.type !== 'CallExpression' ||
+          init.callee?.type !== 'Identifier' ||
+          init.callee.name !== 'useContext'
+        )
+          return
+
+        context.report({
+          message:
+            'Destructuring useContext() captures values once — reactive getters lose reactivity. Keep the object reference: `const ctx = useContext(Ctx)` and access `ctx.mode` lazily.',
+          span: getSpan(id),
+        })
+      },
+    }
+    return callbacks
+  },
+}

package/src/rules/reactivity/no-effect-assignment.ts

@@ -1,27 +1,27 @@
-import type { Rule, VisitorCallbacks } from "../../types"
-import { getSpan, isCallTo } from "../../utils/ast"
+import type { Rule, VisitorCallbacks } from '../../types'
+import { getSpan, isCallTo } from '../../utils/ast'
 
 function isUpdateCall(node: any): boolean {
   return (
-    node.type === "CallExpression" &&
-    node.callee?.type === "MemberExpression" &&
-    node.callee.property?.type === "Identifier" &&
-    node.callee.property.name === "update"
+    node.type === 'CallExpression' &&
+    node.callee?.type === 'MemberExpression' &&
+    node.callee.property?.type === 'Identifier' &&
+    node.callee.property.name === 'update'
   )
 }
 
 export const noEffectAssignment: Rule = {
   meta: {
-    id: "pyreon/no-effect-assignment",
-    category: "reactivity",
-    description: "Warn when an effect only contains a single .update() call.",
-    severity: "warn",
+    id: 'pyreon/no-effect-assignment',
+    category: 'reactivity',
+    description: 'Warn when an effect only contains a single .update() call.',
+    severity: 'warn',
     fixable: false,
   },
   create(context) {
     const callbacks: VisitorCallbacks = {
       CallExpression(node: any) {
-        if (!isCallTo(node, "effect")) return
+        if (!isCallTo(node, 'effect')) return
         const args = node.arguments
         if (!args || args.length === 0) return
 
@@ -29,7 +29,7 @@ export const noEffectAssignment: Rule = {
         if (!fn) return
 
         let body: any = null
-        if (fn.type === "ArrowFunctionExpression" || fn.type === "FunctionExpression") {
+        if (fn.type === 'ArrowFunctionExpression' || fn.type === 'FunctionExpression') {
           body = fn.body
         }
         if (!body) return
@@ -38,21 +38,21 @@ export const noEffectAssignment: Rule = {
         if (isUpdateCall(body)) {
           context.report({
             message:
-              "Effect contains a single `.update()` — consider using `computed()` for derived values.",
+              'Effect contains a single `.update()` — consider using `computed()` for derived values.',
             span: getSpan(node),
           })
           return
         }
 
         // Block body with single statement
-        if (body.type === "BlockStatement") {
+        if (body.type === 'BlockStatement') {
           const stmts = body.body
           if (stmts && stmts.length === 1) {
             const stmt = stmts[0]
-            if (stmt.type === "ExpressionStatement" && isUpdateCall(stmt.expression)) {
+            if (stmt.type === 'ExpressionStatement' && isUpdateCall(stmt.expression)) {
               context.report({
                 message:
-                  "Effect contains a single `.update()` — consider using `computed()` for derived values.",
+                  'Effect contains a single `.update()` — consider using `computed()` for derived values.',
                 span: getSpan(node),
               })
             }

package/src/rules/reactivity/no-nested-effect.ts

@@ -1,29 +1,29 @@
-import type { Rule, VisitorCallbacks } from "../../types"
-import { getSpan, isCallTo } from "../../utils/ast"
+import type { Rule, VisitorCallbacks } from '../../types'
+import { getSpan, isCallTo } from '../../utils/ast'
 
 export const noNestedEffect: Rule = {
   meta: {
-    id: "pyreon/no-nested-effect",
-    category: "reactivity",
-    description: "Warn against nesting effect() inside another effect().",
-    severity: "warn",
+    id: 'pyreon/no-nested-effect',
+    category: 'reactivity',
+    description: 'Warn against nesting effect() inside another effect().',
+    severity: 'warn',
     fixable: false,
   },
   create(context) {
     let effectDepth = 0
     const callbacks: VisitorCallbacks = {
       CallExpression(node: any) {
-        if (!isCallTo(node, "effect")) return
+        if (!isCallTo(node, 'effect')) return
         if (effectDepth > 0) {
           context.report({
-            message: "Nested `effect()` — consider using `computed()` for derived values instead.",
+            message: 'Nested `effect()` — consider using `computed()` for derived values instead.',
             span: getSpan(node),
           })
         }
         effectDepth++
       },
-      "CallExpression:exit"(node: any) {
-        if (isCallTo(node, "effect")) {
+      'CallExpression:exit'(node: any) {
+        if (isCallTo(node, 'effect')) {
           effectDepth--
         }
       },

package/src/rules/reactivity/no-peek-in-tracked.ts

@@ -1,31 +1,31 @@
-import type { Rule, VisitorCallbacks } from "../../types"
-import { getSpan, isCallTo, isPeekCall } from "../../utils/ast"
+import type { Rule, VisitorCallbacks } from '../../types'
+import { getSpan, isCallTo, isPeekCall } from '../../utils/ast'
 
 export const noPeekInTracked: Rule = {
   meta: {
-    id: "pyreon/no-peek-in-tracked",
-    category: "reactivity",
-    description: "Disallow .peek() inside effect() or computed() — it bypasses tracking.",
-    severity: "error",
+    id: 'pyreon/no-peek-in-tracked',
+    category: 'reactivity',
+    description: 'Disallow .peek() inside effect() or computed() — it bypasses tracking.',
+    severity: 'error',
     fixable: false,
   },
   create(context) {
     let trackedDepth = 0
     const callbacks: VisitorCallbacks = {
       CallExpression(node: any) {
-        if (isCallTo(node, "effect") || isCallTo(node, "computed")) {
+        if (isCallTo(node, 'effect') || isCallTo(node, 'computed')) {
           trackedDepth++
         }
         if (trackedDepth > 0 && isPeekCall(node)) {
           context.report({
             message:
-              "`.peek()` inside a tracked scope (effect/computed) bypasses dependency tracking — use a normal signal read instead.",
+              '`.peek()` inside a tracked scope (effect/computed) bypasses dependency tracking — use a normal signal read instead.',
             span: getSpan(node),
           })
         }
       },
-      "CallExpression:exit"(node: any) {
-        if (isCallTo(node, "effect") || isCallTo(node, "computed")) {
+      'CallExpression:exit'(node: any) {
+        if (isCallTo(node, 'effect') || isCallTo(node, 'computed')) {
           trackedDepth--
         }
       },

package/src/rules/reactivity/no-signal-in-loop.ts

@@ -1,12 +1,12 @@
-import type { Rule, VisitorCallbacks } from "../../types"
-import { getSpan } from "../../utils/ast"
+import type { Rule, VisitorCallbacks } from '../../types'
+import { getSpan } from '../../utils/ast'
 
 export const noSignalInLoop: Rule = {
   meta: {
-    id: "pyreon/no-signal-in-loop",
-    category: "reactivity",
-    description: "Disallow creating signals or computeds inside loops.",
-    severity: "error",
+    id: 'pyreon/no-signal-in-loop',
+    category: 'reactivity',
+    description: 'Disallow creating signals or computeds inside loops.',
+    severity: 'error',
     fixable: false,
   },
   create(context) {
@@ -15,38 +15,38 @@ export const noSignalInLoop: Rule = {
       ForStatement() {
         loopDepth++
       },
-      "ForStatement:exit"() {
+      'ForStatement:exit'() {
         loopDepth--
       },
       ForInStatement() {
         loopDepth++
       },
-      "ForInStatement:exit"() {
+      'ForInStatement:exit'() {
         loopDepth--
       },
       ForOfStatement() {
         loopDepth++
       },
-      "ForOfStatement:exit"() {
+      'ForOfStatement:exit'() {
         loopDepth--
       },
       WhileStatement() {
         loopDepth++
       },
-      "WhileStatement:exit"() {
+      'WhileStatement:exit'() {
         loopDepth--
       },
       DoWhileStatement() {
         loopDepth++
       },
-      "DoWhileStatement:exit"() {
+      'DoWhileStatement:exit'() {
         loopDepth--
       },
       CallExpression(node: any) {
         if (loopDepth === 0) return
         const callee = node.callee
-        if (!callee || callee.type !== "Identifier") return
-        if (callee.name === "signal" || callee.name === "computed") {
+        if (!callee || callee.type !== 'Identifier') return
+        if (callee.name === 'signal' || callee.name === 'computed') {
           context.report({
             message: `\`${callee.name}()\` inside a loop — signals should be created once at component setup, not on every iteration.`,
             span: getSpan(node),

package/src/rules/reactivity/no-signal-leak.ts

@@ -1,12 +1,12 @@
-import type { Rule, VisitorCallbacks } from "../../types"
-import { getSpan, isCallTo } from "../../utils/ast"
+import type { Rule, VisitorCallbacks } from '../../types'
+import { getSpan, isCallTo } from '../../utils/ast'
 
 export const noSignalLeak: Rule = {
   meta: {
-    id: "pyreon/no-signal-leak",
-    category: "reactivity",
-    description: "Warn about unused signal declarations (potential leaks).",
-    severity: "warn",
+    id: 'pyreon/no-signal-leak',
+    category: 'reactivity',
+    description: 'Warn about unused signal declarations (potential leaks).',
+    severity: 'warn',
     fixable: false,
   },
   create(context) {
@@ -19,9 +19,9 @@ export const noSignalLeak: Rule = {
     const callbacks: VisitorCallbacks = {
       VariableDeclarator(node: any) {
         const init = node.init
-        if (!init || !isCallTo(init, "signal")) return
+        if (!init || !isCallTo(init, 'signal')) return
         const id = node.id
-        if (!id || id.type !== "Identifier") return
+        if (!id || id.type !== 'Identifier') return
         signalDecls.set(id.name, {
           span: getSpan(node),
           declStart: id.start as number,
@@ -39,7 +39,7 @@ export const noSignalLeak: Rule = {
           ])
         }
       },
-      "Program:exit"() {
+      'Program:exit'() {
         for (const [name, { span, declStart, declEnd }] of signalDecls) {
           const occurrences = identifierOccurrences.get(name) ?? []
           // Filter out the declaration identifier itself

package/src/rules/reactivity/no-unbatched-updates.ts

@@ -1,5 +1,5 @@
-import type { Rule, VisitorCallbacks } from "../../types"
-import { getSpan, isCallTo, isSetCall } from "../../utils/ast"
+import type { Rule, VisitorCallbacks } from '../../types'
+import { getSpan, isCallTo, isSetCall } from '../../utils/ast'
 
 interface ScopeInfo {
   setCalls: Array<{ span: { start: number; end: number } }>
@@ -10,10 +10,10 @@ interface ScopeInfo {
 
 export const noUnbatchedUpdates: Rule = {
   meta: {
-    id: "pyreon/no-unbatched-updates",
-    category: "reactivity",
-    description: "Warn when 3+ .set() calls occur in the same function without batch().",
-    severity: "warn",
+    id: 'pyreon/no-unbatched-updates',
+    category: 'reactivity',
+    description: 'Warn when 3+ .set() calls occur in the same function without batch().',
+    severity: 'warn',
     fixable: false,
   },
   create(context) {
@@ -39,24 +39,24 @@ export const noUnbatchedUpdates: Rule = {
       FunctionDeclaration(node: any) {
         enterScope(node)
       },
-      "FunctionDeclaration:exit"() {
+      'FunctionDeclaration:exit'() {
         exitScope()
       },
       FunctionExpression(node: any) {
         enterScope(node)
       },
-      "FunctionExpression:exit"() {
+      'FunctionExpression:exit'() {
         exitScope()
       },
       ArrowFunctionExpression(node: any) {
         enterScope(node)
       },
-      "ArrowFunctionExpression:exit"() {
+      'ArrowFunctionExpression:exit'() {
         exitScope()
       },
       CallExpression(node: any) {
         const currentScope = scopeStack.length > 0 ? scopeStack[scopeStack.length - 1] : undefined
-        if (isCallTo(node, "batch")) {
+        if (isCallTo(node, 'batch')) {
           batchDepth++
           if (currentScope) {
             currentScope.hasBatch = true
@@ -66,8 +66,8 @@ export const noUnbatchedUpdates: Rule = {
           currentScope.setCalls.push({ span: getSpan(node) })
         }
       },
-      "CallExpression:exit"(node: any) {
-        if (isCallTo(node, "batch")) {
+      'CallExpression:exit'(node: any) {
+        if (isCallTo(node, 'batch')) {
           batchDepth--
         }
       },