@pyreon/lint 0.11.4 → 0.11.6

package/src/rules/jsx/use-by-not-key.ts

@@ -1,30 +1,30 @@
-import type { Rule, VisitorCallbacks } from "../../types"
-import { getJSXAttribute, getSpan, hasJSXAttribute } from "../../utils/ast"
+import type { Rule, VisitorCallbacks } from '../../types'
+import { getJSXAttribute, getSpan, hasJSXAttribute } from '../../utils/ast'
 
 export const useByNotKey: Rule = {
   meta: {
-    id: "pyreon/use-by-not-key",
-    category: "jsx",
+    id: 'pyreon/use-by-not-key',
+    category: 'jsx',
     description:
-      "Use `by` prop on <For> instead of `key` — JSX reserves `key` for VNode reconciliation.",
-    severity: "error",
+      'Use `by` prop on <For> instead of `key` — JSX reserves `key` for VNode reconciliation.',
+    severity: 'error',
     fixable: true,
   },
   create(context) {
     const callbacks: VisitorCallbacks = {
       JSXOpeningElement(node: any) {
-        const tagName = node.name?.type === "JSXIdentifier" ? node.name.name : null
-        if (tagName !== "For") return
-        const keyAttr = getJSXAttribute(node, "key")
+        const tagName = node.name?.type === 'JSXIdentifier' ? node.name.name : null
+        if (tagName !== 'For') return
+        const keyAttr = getJSXAttribute(node, 'key')
         if (!keyAttr) return
-        if (hasJSXAttribute(node, "by")) return // already has by
+        if (hasJSXAttribute(node, 'by')) return // already has by
 
         const attrSpan = getSpan(keyAttr.name)
         context.report({
           message:
-            "Use `by` prop on `<For>` instead of `key` — JSX reserves `key` for VNode reconciliation.",
+            'Use `by` prop on `<For>` instead of `key` — JSX reserves `key` for VNode reconciliation.',
           span: getSpan(keyAttr),
-          fix: { span: attrSpan, replacement: "by" },
+          fix: { span: attrSpan, replacement: 'by' },
         })
       },
     }

package/src/rules/lifecycle/no-dom-in-setup.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'
 
 const DOM_METHODS = new Set([
-  "querySelector",
-  "querySelectorAll",
-  "getElementById",
-  "getElementsByClassName",
-  "getElementsByTagName",
+  'querySelector',
+  'querySelectorAll',
+  'getElementById',
+  'getElementsByClassName',
+  'getElementsByTagName',
 ])
 
 export const noDomInSetup: Rule = {
   meta: {
-    id: "pyreon/no-dom-in-setup",
-    category: "lifecycle",
-    description: "Warn when DOM query methods are used outside onMount or effect.",
-    severity: "warn",
+    id: 'pyreon/no-dom-in-setup',
+    category: 'lifecycle',
+    description: 'Warn when DOM query methods are used outside onMount or effect.',
+    severity: 'warn',
     fixable: false,
   },
   create(context) {
     let safeDepth = 0 // inside onMount or effect
     const callbacks: VisitorCallbacks = {
       CallExpression(node: any) {
-        if (isCallTo(node, "onMount") || isCallTo(node, "effect")) {
+        if (isCallTo(node, 'onMount') || isCallTo(node, 'effect')) {
           safeDepth++
         }
 
@@ -30,10 +30,10 @@ export const noDomInSetup: Rule = {
         // Check for document.querySelector() etc.
         const callee = node.callee
         if (
-          callee?.type === "MemberExpression" &&
-          callee.object?.type === "Identifier" &&
-          callee.object.name === "document" &&
-          callee.property?.type === "Identifier" &&
+          callee?.type === 'MemberExpression' &&
+          callee.object?.type === 'Identifier' &&
+          callee.object.name === 'document' &&
+          callee.property?.type === 'Identifier' &&
           DOM_METHODS.has(callee.property.name)
         ) {
           context.report({
@@ -42,8 +42,8 @@ export const noDomInSetup: Rule = {
           })
         }
       },
-      "CallExpression:exit"(node: any) {
-        if (isCallTo(node, "onMount") || isCallTo(node, "effect")) {
+      'CallExpression:exit'(node: any) {
+        if (isCallTo(node, 'onMount') || isCallTo(node, 'effect')) {
           safeDepth--
         }
       },

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

@@ -1,32 +1,32 @@
-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 noEffectInMount: Rule = {
   meta: {
-    id: "pyreon/no-effect-in-mount",
-    category: "lifecycle",
+    id: 'pyreon/no-effect-in-mount',
+    category: 'lifecycle',
     description:
-      "Inform when effect() is created inside onMount — effects are typically created at setup time.",
-    severity: "info",
+      'Inform when effect() is created inside onMount — effects are typically created at setup time.',
+    severity: 'info',
     fixable: false,
   },
   create(context) {
     let mountDepth = 0
     const callbacks: VisitorCallbacks = {
       CallExpression(node: any) {
-        if (isCallTo(node, "onMount")) {
+        if (isCallTo(node, 'onMount')) {
           mountDepth++
         }
-        if (mountDepth > 0 && isCallTo(node, "effect")) {
+        if (mountDepth > 0 && isCallTo(node, 'effect')) {
           context.report({
             message:
-              "`effect()` inside `onMount` — effects are typically created at component setup time, not inside lifecycle hooks.",
+              '`effect()` inside `onMount` — effects are typically created at component setup time, not inside lifecycle hooks.',
             span: getSpan(node),
           })
         }
       },
-      "CallExpression:exit"(node: any) {
-        if (isCallTo(node, "onMount")) {
+      'CallExpression:exit'(node: any) {
+        if (isCallTo(node, 'onMount')) {
           mountDepth--
         }
       },

package/src/rules/lifecycle/no-missing-cleanup.ts

@@ -1,63 +1,63 @@
-import type { Rule, VisitorCallbacks } from "../../types"
-import { getSpan, isCallTo } from "../../utils/ast"
+import type { Rule, VisitorCallbacks } from '../../types'
+import { getSpan, isCallTo } from '../../utils/ast'
 
-const NEEDS_CLEANUP = new Set(["setInterval", "addEventListener"])
+const NEEDS_CLEANUP = new Set(['setInterval', 'addEventListener'])
 
 export const noMissingCleanup: Rule = {
   meta: {
-    id: "pyreon/no-missing-cleanup",
-    category: "lifecycle",
+    id: 'pyreon/no-missing-cleanup',
+    category: 'lifecycle',
     description:
-      "Warn when onMount uses setInterval/addEventListener without returning a cleanup function.",
-    severity: "warn",
+      'Warn when onMount uses setInterval/addEventListener without returning a cleanup function.',
+    severity: 'warn',
     fixable: false,
   },
   create(context) {
     const callbacks: VisitorCallbacks = {
       CallExpression(node: any) {
-        if (!isCallTo(node, "onMount")) return
+        if (!isCallTo(node, 'onMount')) return
         const args = node.arguments
         if (!args || args.length === 0) return
 
         const fn = args[0]
         if (!fn) return
-        if (fn.type !== "ArrowFunctionExpression" && fn.type !== "FunctionExpression") return
+        if (fn.type !== 'ArrowFunctionExpression' && fn.type !== 'FunctionExpression') return
 
         const body = fn.body
         if (!body) return
 
         // Only check block bodies
-        if (body.type !== "BlockStatement") return
+        if (body.type !== 'BlockStatement') return
 
         let hasCleanupTarget = false
         let hasReturn = false
 
         function walk(n: any) {
           if (!n) return
-          if (n.type === "CallExpression") {
+          if (n.type === 'CallExpression') {
             const callee = n.callee
-            if (callee?.type === "Identifier" && NEEDS_CLEANUP.has(callee.name)) {
+            if (callee?.type === 'Identifier' && NEEDS_CLEANUP.has(callee.name)) {
               hasCleanupTarget = true
             }
             if (
-              callee?.type === "MemberExpression" &&
-              callee.property?.type === "Identifier" &&
+              callee?.type === 'MemberExpression' &&
+              callee.property?.type === 'Identifier' &&
               NEEDS_CLEANUP.has(callee.property.name)
             ) {
               hasCleanupTarget = true
             }
           }
-          if (n.type === "ReturnStatement" && n.argument) {
+          if (n.type === 'ReturnStatement' && n.argument) {
             hasReturn = true
           }
           for (const key of Object.keys(n)) {
             const child = n[key]
-            if (child && typeof child === "object") {
+            if (child && typeof child === 'object') {
               if (Array.isArray(child)) {
                 for (const item of child) {
-                  if (item && typeof item.type === "string") walk(item)
+                  if (item && typeof item.type === 'string') walk(item)
                 }
-              } else if (typeof child.type === "string") {
+              } else if (typeof child.type === 'string') {
                 walk(child)
               }
             }
@@ -69,7 +69,7 @@ export const noMissingCleanup: Rule = {
         if (hasCleanupTarget && !hasReturn) {
           context.report({
             message:
-              "`onMount` uses `setInterval`/`addEventListener` without returning a cleanup function — this will cause a memory leak.",
+              '`onMount` uses `setInterval`/`addEventListener` without returning a cleanup function — this will cause a memory leak.',
             span: getSpan(node),
           })
         }

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),
               })
             }