@pyreon/lint 0.11.0

package/src/rules/lifecycle/no-dom-in-setup.ts

@@ -0,0 +1,53 @@
+import type { Rule, VisitorCallbacks } from "../../types"
+import { getSpan, isCallTo } from "../../utils/ast"
+
+const DOM_METHODS = new Set([
+  "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",
+    fixable: false,
+  },
+  create(context) {
+    let safeDepth = 0 // inside onMount or effect
+    const callbacks: VisitorCallbacks = {
+      CallExpression(node: any) {
+        if (isCallTo(node, "onMount") || isCallTo(node, "effect")) {
+          safeDepth++
+        }
+
+        if (safeDepth > 0) return
+
+        // 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" &&
+          DOM_METHODS.has(callee.property.name)
+        ) {
+          context.report({
+            message: `\`document.${callee.property.name}()\` outside \`onMount\`/\`effect\` — DOM is not available during SSR or setup phase.`,
+            span: getSpan(node),
+          })
+        }
+      },
+      "CallExpression:exit"(node: any) {
+        if (isCallTo(node, "onMount") || isCallTo(node, "effect")) {
+          safeDepth--
+        }
+      },
+    }
+    return callbacks
+  },
+}

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

@@ -0,0 +1,36 @@
+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",
+    description:
+      "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")) {
+          mountDepth++
+        }
+        if (mountDepth > 0 && isCallTo(node, "effect")) {
+          context.report({
+            message:
+              "`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")) {
+          mountDepth--
+        }
+      },
+    }
+    return callbacks
+  },
+}

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

@@ -0,0 +1,80 @@
+import type { Rule, VisitorCallbacks } from "../../types"
+import { getSpan, isCallTo } from "../../utils/ast"
+
+const NEEDS_CLEANUP = new Set(["setInterval", "addEventListener"])
+
+export const noMissingCleanup: Rule = {
+  meta: {
+    id: "pyreon/no-missing-cleanup",
+    category: "lifecycle",
+    description:
+      "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
+        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
+
+        const body = fn.body
+        if (!body) return
+
+        // Only check block bodies
+        if (body.type !== "BlockStatement") return
+
+        let hasCleanupTarget = false
+        let hasReturn = false
+
+        function walk(n: any) {
+          if (!n) return
+          if (n.type === "CallExpression") {
+            const callee = n.callee
+            if (callee?.type === "Identifier" && NEEDS_CLEANUP.has(callee.name)) {
+              hasCleanupTarget = true
+            }
+            if (
+              callee?.type === "MemberExpression" &&
+              callee.property?.type === "Identifier" &&
+              NEEDS_CLEANUP.has(callee.property.name)
+            ) {
+              hasCleanupTarget = true
+            }
+          }
+          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 (Array.isArray(child)) {
+                for (const item of child) {
+                  if (item && typeof item.type === "string") walk(item)
+                }
+              } else if (typeof child.type === "string") {
+                walk(child)
+              }
+            }
+          }
+        }
+
+        walk(body)
+
+        if (hasCleanupTarget && !hasReturn) {
+          context.report({
+            message:
+              "`onMount` uses `setInterval`/`addEventListener` without returning a cleanup function — this will cause a memory leak.",
+            span: getSpan(node),
+          })
+        }
+      },
+    }
+    return callbacks
+  },
+}

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

@@ -0,0 +1,35 @@
+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",
+    fixable: false,
+  },
+  create(context) {
+    let effectDepth = 0
+    const callbacks: VisitorCallbacks = {
+      CallExpression(node: any) {
+        if (isCallTo(node, "effect")) {
+          effectDepth++
+        }
+        if (effectDepth > 0 && isCallTo(node, "onMount")) {
+          context.report({
+            message:
+              "`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")) {
+          effectDepth--
+        }
+      },
+    }
+    return callbacks
+  },
+}

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

@@ -0,0 +1,28 @@
+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",
+    fixable: false,
+  },
+  create(context) {
+    const callbacks: VisitorCallbacks = {
+      ImportDeclaration(node: any) {
+        const source = node.source?.value as string
+        if (!source) return
+        if (HEAVY_PACKAGES.has(source)) {
+          context.report({
+            message: `Static import of \`${source}\` — consider using \`lazy()\` or dynamic \`import()\` to reduce initial bundle size.`,
+            span: getSpan(node),
+          })
+        }
+      },
+    }
+    return callbacks
+  },
+}

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

@@ -0,0 +1,41 @@
+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",
+    description:
+      "Warn when effect() is created inside <For> — creates effects per item on every reconciliation.",
+    severity: "warn",
+    fixable: false,
+  },
+  create(context) {
+    let forJsxDepth = 0
+    const callbacks: VisitorCallbacks = {
+      JSXOpeningElement(node: any) {
+        const name = node.name
+        if (name?.type === "JSXIdentifier" && name.name === "For") {
+          forJsxDepth++
+        }
+      },
+      JSXClosingElement(node: any) {
+        const name = node.name
+        if (name?.type === "JSXIdentifier" && name.name === "For") {
+          forJsxDepth--
+        }
+      },
+      CallExpression(node: any) {
+        if (forJsxDepth === 0) return
+        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.",
+            span: getSpan(node),
+          })
+        }
+      },
+    }
+    return callbacks
+  },
+}

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

@@ -0,0 +1,28 @@
+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",
+    description:
+      "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
+        context.report({
+          message:
+            "`<For>` without `by` prop — provide a key function for efficient reconciliation.",
+          span: getSpan(node),
+        })
+      },
+    }
+    return callbacks
+  },
+}

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

@@ -0,0 +1,47 @@
+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",
+    fixable: false,
+  },
+  create(context) {
+    const callbacks: VisitorCallbacks = {
+      JSXAttribute(node: any) {
+        if (node.name?.type !== "JSXIdentifier" || node.name.name !== "style") return
+        const value = node.value
+        if (!value || value.type !== "JSXExpressionContainer") return
+        const expr = value.expression
+        if (!expr || expr.type !== "ObjectExpression") return
+
+        for (const prop of expr.properties ?? []) {
+          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") {
+            // Check if the value is conditional
+            const val = prop.value
+            if (
+              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.",
+                span: getSpan(prop),
+              })
+            }
+          }
+        }
+      },
+    }
+    return callbacks
+  },
+}

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

@@ -0,0 +1,56 @@
+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",
+    description:
+      "Disallow bare signal calls in JSX text positions. Wrap in `() =>` for reactivity.",
+    severity: "error",
+    fixable: true,
+  },
+  create(context) {
+    let jsxDepth = 0
+    const callbacks: VisitorCallbacks = {
+      JSXElement() {
+        jsxDepth++
+      },
+      "JSXElement:exit"() {
+        jsxDepth--
+      },
+      JSXFragment() {
+        jsxDepth++
+      },
+      "JSXFragment:exit"() {
+        jsxDepth--
+      },
+      JSXExpressionContainer(node: any) {
+        if (jsxDepth === 0) return
+        const expr = node.expression
+        if (!expr || expr.type !== "CallExpression") return
+        const callee = expr.callee
+        if (!callee || callee.type !== "Identifier") return
+
+        const name: string = callee.name
+        if (SKIP_PREFIXES.test(name)) return
+
+        const span = getSpan(node)
+        const source = context.getSourceText()
+        const original = source.slice(span.start, span.end)
+        // {count()} → {() => count()}
+        const inner = original.slice(1, -1) // strip { }
+        const fixed = `{() => ${inner}}`
+
+        context.report({
+          message: `Bare signal call \`${name}()\` in JSX text — wrap in \`() => ${name}()\` for fine-grained reactivity.`,
+          span,
+          fix: { span, replacement: fixed },
+        })
+      },
+    }
+    return callbacks
+  },
+}

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

@@ -0,0 +1,65 @@
+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"
+  )
+}
+
+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",
+    fixable: false,
+  },
+  create(context) {
+    const callbacks: VisitorCallbacks = {
+      CallExpression(node: any) {
+        if (!isCallTo(node, "effect")) return
+        const args = node.arguments
+        if (!args || args.length === 0) return
+
+        const fn = args[0]
+        if (!fn) return
+
+        let body: any = null
+        if (fn.type === "ArrowFunctionExpression" || fn.type === "FunctionExpression") {
+          body = fn.body
+        }
+        if (!body) return
+
+        // Arrow with expression body
+        if (isUpdateCall(body)) {
+          context.report({
+            message:
+              "Effect contains a single `.update()` — consider using `computed()` for derived values.",
+            span: getSpan(node),
+          })
+          return
+        }
+
+        // Block body with single statement
+        if (body.type === "BlockStatement") {
+          const stmts = body.body
+          if (stmts && stmts.length === 1) {
+            const stmt = stmts[0]
+            if (stmt.type === "ExpressionStatement" && isUpdateCall(stmt.expression)) {
+              context.report({
+                message:
+                  "Effect contains a single `.update()` — consider using `computed()` for derived values.",
+                span: getSpan(node),
+              })
+            }
+          }
+        }
+      },
+    }
+    return callbacks
+  },
+}

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

@@ -0,0 +1,33 @@
+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",
+    fixable: false,
+  },
+  create(context) {
+    let effectDepth = 0
+    const callbacks: VisitorCallbacks = {
+      CallExpression(node: any) {
+        if (!isCallTo(node, "effect")) return
+        if (effectDepth > 0) {
+          context.report({
+            message: "Nested `effect()` — consider using `computed()` for derived values instead.",
+            span: getSpan(node),
+          })
+        }
+        effectDepth++
+      },
+      "CallExpression:exit"(node: any) {
+        if (isCallTo(node, "effect")) {
+          effectDepth--
+        }
+      },
+    }
+    return callbacks
+  },
+}

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

@@ -0,0 +1,35 @@
+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",
+    fixable: false,
+  },
+  create(context) {
+    let trackedDepth = 0
+    const callbacks: VisitorCallbacks = {
+      CallExpression(node: any) {
+        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.",
+            span: getSpan(node),
+          })
+        }
+      },
+      "CallExpression:exit"(node: any) {
+        if (isCallTo(node, "effect") || isCallTo(node, "computed")) {
+          trackedDepth--
+        }
+      },
+    }
+    return callbacks
+  },
+}

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

@@ -0,0 +1,59 @@
+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",
+    fixable: false,
+  },
+  create(context) {
+    let loopDepth = 0
+    const callbacks: VisitorCallbacks = {
+      ForStatement() {
+        loopDepth++
+      },
+      "ForStatement:exit"() {
+        loopDepth--
+      },
+      ForInStatement() {
+        loopDepth++
+      },
+      "ForInStatement:exit"() {
+        loopDepth--
+      },
+      ForOfStatement() {
+        loopDepth++
+      },
+      "ForOfStatement:exit"() {
+        loopDepth--
+      },
+      WhileStatement() {
+        loopDepth++
+      },
+      "WhileStatement:exit"() {
+        loopDepth--
+      },
+      DoWhileStatement() {
+        loopDepth++
+      },
+      "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") {
+          context.report({
+            message: `\`${callee.name}()\` inside a loop — signals should be created once at component setup, not on every iteration.`,
+            span: getSpan(node),
+          })
+        }
+      },
+    }
+    return callbacks
+  },
+}

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

@@ -0,0 +1,58 @@
+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",
+    fixable: false,
+  },
+  create(context) {
+    const signalDecls = new Map<
+      string,
+      { span: { start: number; end: number }; declStart: number; declEnd: number }
+    >()
+    const identifierOccurrences = new Map<string, Array<{ start: number; end: number }>>()
+
+    const callbacks: VisitorCallbacks = {
+      VariableDeclarator(node: any) {
+        const init = node.init
+        if (!init || !isCallTo(init, "signal")) return
+        const id = node.id
+        if (!id || id.type !== "Identifier") return
+        signalDecls.set(id.name, {
+          span: getSpan(node),
+          declStart: id.start as number,
+          declEnd: id.end as number,
+        })
+      },
+      Identifier(node: any) {
+        const name: string = node.name
+        const existing = identifierOccurrences.get(name)
+        if (existing) {
+          existing.push({ start: node.start as number, end: node.end as number })
+        } else {
+          identifierOccurrences.set(name, [
+            { start: node.start as number, end: node.end as number },
+          ])
+        }
+      },
+      "Program:exit"() {
+        for (const [name, { span, declStart, declEnd }] of signalDecls) {
+          const occurrences = identifierOccurrences.get(name) ?? []
+          // Filter out the declaration identifier itself
+          const usages = occurrences.filter((o) => o.start !== declStart || o.end !== declEnd)
+          if (usages.length === 0) {
+            context.report({
+              message: `Signal \`${name}\` is declared but never used — this may be a signal leak.`,
+              span,
+            })
+          }
+        }
+      },
+    }
+    return callbacks
+  },
+}