@pyreon/lint 0.11.4 → 0.11.6

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

package/src/rules/reactivity/prefer-computed.ts

@@ -1,18 +1,18 @@
-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'
 
 export const preferComputed: Rule = {
   meta: {
-    id: "pyreon/prefer-computed",
-    category: "reactivity",
-    description: "Suggest computed() when an effect only contains a single .set() call.",
-    severity: "warn",
+    id: 'pyreon/prefer-computed',
+    category: 'reactivity',
+    description: 'Suggest computed() when an effect only contains a single .set() 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
 
@@ -20,30 +20,30 @@ export const preferComputed: 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
 
         // Arrow with expression body: effect(() => x.set(y))
-        if (body.type === "CallExpression" && isSetCall(body)) {
+        if (body.type === 'CallExpression' && isSetCall(body)) {
           context.report({
             message:
-              "Effect contains a single `.set()` — consider using `computed()` instead for derived values.",
+              'Effect contains a single `.set()` — consider using `computed()` instead for derived values.',
             span: getSpan(node),
           })
           return
         }
 
         // Block body with single statement: effect(() => { x.set(y) })
-        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" && isSetCall(stmt.expression)) {
+            if (stmt.type === 'ExpressionStatement' && isSetCall(stmt.expression)) {
               context.report({
                 message:
-                  "Effect contains a single `.set()` — consider using `computed()` instead for derived values.",
+                  'Effect contains a single `.set()` — consider using `computed()` instead for derived values.',
                 span: getSpan(node),
               })
             }

package/src/rules/router/index.ts

@@ -1,4 +1,4 @@
-export { noHrefNavigation } from "./no-href-navigation"
-export { noImperativeNavigateInRender } from "./no-imperative-navigate-in-render"
-export { noMissingFallback } from "./no-missing-fallback"
-export { preferUseIsActive } from "./prefer-use-is-active"
+export { noHrefNavigation } from './no-href-navigation'
+export { noImperativeNavigateInRender } from './no-imperative-navigate-in-render'
+export { noMissingFallback } from './no-missing-fallback'
+export { preferUseIsActive } from './prefer-use-is-active'

package/src/rules/router/no-href-navigation.ts

@@ -1,16 +1,16 @@
-import type { Rule, VisitorCallbacks } from "../../types"
-import { getJSXAttribute, getSpan } from "../../utils/ast"
-import { extractImportInfo } from "../../utils/imports"
+import type { Rule, VisitorCallbacks } from '../../types'
+import { getJSXAttribute, getSpan } from '../../utils/ast'
+import { extractImportInfo } from '../../utils/imports'
 
-const EXTERNAL_PREFIXES = ["http://", "https://", "mailto:", "tel:"]
+const EXTERNAL_PREFIXES = ['http://', 'https://', 'mailto:', 'tel:']
 
 export const noHrefNavigation: Rule = {
   meta: {
-    id: "pyreon/no-href-navigation",
-    category: "router",
+    id: 'pyreon/no-href-navigation',
+    category: 'router',
     description:
-      "Warn when `<a href>` is used in files that import @pyreon/router — use `<Link>` instead.",
-    severity: "warn",
+      'Warn when `<a href>` is used in files that import @pyreon/router — use `<Link>` instead.',
+    severity: 'warn',
     fixable: false,
   },
   create(context) {
@@ -19,29 +19,29 @@ export const noHrefNavigation: Rule = {
     const callbacks: VisitorCallbacks = {
       ImportDeclaration(node: any) {
         const info = extractImportInfo(node)
-        if (info && info.source === "@pyreon/router") {
+        if (info && info.source === '@pyreon/router') {
           importsRouter = true
         }
       },
       JSXOpeningElement(node: any) {
         if (!importsRouter) return
         const name = node.name
-        if (!name || name.type !== "JSXIdentifier" || name.name !== "a") return
+        if (!name || name.type !== 'JSXIdentifier' || name.name !== 'a') return
 
-        const hrefAttr = getJSXAttribute(node, "href")
+        const hrefAttr = getJSXAttribute(node, 'href')
         if (!hrefAttr) return
 
         // Get the href value
         const value = hrefAttr.value
-        if (value?.type === "Literal" && typeof value.value === "string") {
+        if (value?.type === 'Literal' && typeof value.value === 'string') {
           const href: string = value.value
           // Skip external URLs and anchor links
-          if (href.startsWith("#") || EXTERNAL_PREFIXES.some((p) => href.startsWith(p))) return
+          if (href.startsWith('#') || EXTERNAL_PREFIXES.some((p) => href.startsWith(p))) return
         }
 
         context.report({
           message:
-            "`<a href>` in a router file — use `<Link>` or `<RouterLink>` for client-side navigation.",
+            '`<a href>` in a router file — use `<Link>` or `<RouterLink>` for client-side navigation.',
           span: getSpan(node),
         })
       },

package/src/rules/router/no-imperative-navigate-in-render.ts

@@ -1,13 +1,13 @@
-import type { Rule, VisitorCallbacks } from "../../types"
-import { getSpan, isCallTo, isMemberCallTo } from "../../utils/ast"
+import type { Rule, VisitorCallbacks } from '../../types'
+import { getSpan, isCallTo, isMemberCallTo } from '../../utils/ast'
 
 export const noImperativeNavigateInRender: Rule = {
   meta: {
-    id: "pyreon/no-imperative-navigate-in-render",
-    category: "router",
+    id: 'pyreon/no-imperative-navigate-in-render',
+    category: 'router',
     description:
-      "Error when navigate() or router.push() is called at the top level of a component — causes infinite render loops.",
-    severity: "error",
+      'Error when navigate() or router.push() is called at the top level of a component — causes infinite render loops.',
+    severity: 'error',
     fixable: false,
   },
   create(context) {
@@ -20,27 +20,27 @@ export const noImperativeNavigateInRender: Rule = {
 
     const callbacks: VisitorCallbacks = {
       FunctionDeclaration(node: any) {
-        const name: string = node.id?.name ?? ""
+        const name: string = node.id?.name ?? ''
         if (/^[A-Z]/.test(name)) {
           componentBodyDepth++
         }
       },
-      "FunctionDeclaration:exit"(node: any) {
-        const name: string = node.id?.name ?? ""
+      'FunctionDeclaration:exit'(node: any) {
+        const name: string = node.id?.name ?? ''
         if (/^[A-Z]/.test(name)) {
           componentBodyDepth--
         }
       },
       // For arrow functions, we use VariableDeclarator to detect component assignment
       VariableDeclarator(node: any) {
-        const name: string = node.id?.name ?? ""
-        if (/^[A-Z]/.test(name) && node.init?.type === "ArrowFunctionExpression") {
+        const name: string = node.id?.name ?? ''
+        if (/^[A-Z]/.test(name) && node.init?.type === 'ArrowFunctionExpression') {
           componentBodyDepth++
         }
       },
-      "VariableDeclarator:exit"(node: any) {
-        const name: string = node.id?.name ?? ""
-        if (/^[A-Z]/.test(name) && node.init?.type === "ArrowFunctionExpression") {
+      'VariableDeclarator:exit'(node: any) {
+        const name: string = node.id?.name ?? ''
+        if (/^[A-Z]/.test(name) && node.init?.type === 'ArrowFunctionExpression') {
           componentBodyDepth--
         }
       },
@@ -56,15 +56,15 @@ export const noImperativeNavigateInRender: Rule = {
         // Only report if we're in a component body and NOT inside a safe callback
         if (safeDepth > 0) return
 
-        if (isCallTo(node, "navigate") || isMemberCallTo(node, "router", "push")) {
+        if (isCallTo(node, 'navigate') || isMemberCallTo(node, 'router', 'push')) {
           context.report({
             message:
-              "Imperative navigation at the top level of a component — this runs on every render and causes infinite loops. Move inside `onMount`, `effect`, or an event handler.",
+              'Imperative navigation at the top level of a component — this runs on every render and causes infinite loops. Move inside `onMount`, `effect`, or an event handler.',
             span: getSpan(node),
           })
         }
       },
-      "CallExpression:exit"(node: any) {
+      'CallExpression:exit'(node: any) {
         if (componentBodyDepth <= 0) return
         if (isSafeWrapperCall(node)) {
           safeDepth--
@@ -77,7 +77,7 @@ export const noImperativeNavigateInRender: Rule = {
 
 function isSafeWrapperCall(node: any): boolean {
   const callee = node.callee
-  if (!callee || callee.type !== "Identifier") return false
+  if (!callee || callee.type !== 'Identifier') return false
   const name: string = callee.name
-  return name === "onMount" || name === "effect" || name === "onUnmount"
+  return name === 'onMount' || name === 'effect' || name === 'onUnmount'
 }

package/src/rules/router/no-missing-fallback.ts

@@ -1,27 +1,27 @@
-import type { Rule, VisitorCallbacks } from "../../types"
-import { getSpan } from "../../utils/ast"
-import { extractImportInfo } from "../../utils/imports"
+import type { Rule, VisitorCallbacks } from '../../types'
+import { getSpan } from '../../utils/ast'
+import { extractImportInfo } from '../../utils/imports'
 
 function isCatchAllPath(value: string): boolean {
-  return value === "*" || value.endsWith("*")
+  return value === '*' || value.endsWith('*')
 }
 
 function getPathValue(prop: any): string | null {
   const key = prop.key
   if (!key) return null
-  const keyName = key.type === "Identifier" ? key.name : null
-  if (keyName !== "path") return null
+  const keyName = key.type === 'Identifier' ? key.name : null
+  if (keyName !== 'path') return null
   const val = prop.value
-  if (val?.type === "Literal" && typeof val.value === "string") {
+  if (val?.type === 'Literal' && typeof val.value === 'string') {
     return val.value
   }
   return null
 }
 
 function hasPathProperty(obj: any): boolean {
-  if (!obj || obj.type !== "ObjectExpression") return false
+  if (!obj || obj.type !== 'ObjectExpression') return false
   for (const prop of obj.properties ?? []) {
-    if (prop.type !== "Property") continue
+    if (prop.type !== 'Property') continue
     if (getPathValue(prop) !== null) return true
   }
   return false
@@ -29,9 +29,9 @@ function hasPathProperty(obj: any): boolean {
 
 function hasCatchAllRoute(elements: any[]): boolean {
   for (const elem of elements) {
-    if (!elem || elem.type !== "ObjectExpression") continue
+    if (!elem || elem.type !== 'ObjectExpression') continue
     for (const prop of elem.properties ?? []) {
-      if (prop.type !== "Property") continue
+      if (prop.type !== 'Property') continue
       const pathVal = getPathValue(prop)
       if (pathVal !== null && isCatchAllPath(pathVal)) return true
     }
@@ -41,11 +41,11 @@ function hasCatchAllRoute(elements: any[]): boolean {
 
 export const noMissingFallback: Rule = {
   meta: {
-    id: "pyreon/no-missing-fallback",
-    category: "router",
+    id: 'pyreon/no-missing-fallback',
+    category: 'router',
     description:
       'Warn when route config has no catch-all route (`path: "*"` or `path: "/:rest*"`).',
-    severity: "warn",
+    severity: 'warn',
     fixable: false,
   },
   create(context) {
@@ -56,7 +56,7 @@ export const noMissingFallback: Rule = {
     const callbacks: VisitorCallbacks = {
       ImportDeclaration(node: any) {
         const info = extractImportInfo(node)
-        if (info && info.source === "@pyreon/router") {
+        if (info && info.source === '@pyreon/router') {
           importsRouter = true
         }
       },
@@ -73,7 +73,7 @@ export const noMissingFallback: Rule = {
           foundCatchAll = true
         }
       },
-      "Program:exit"() {
+      'Program:exit'() {
         if (!importsRouter || !routeArraySpan || foundCatchAll) return
         context.report({
           message:

package/src/rules/router/prefer-use-is-active.ts

@@ -1,25 +1,25 @@
-import type { Rule, VisitorCallbacks } from "../../types"
-import { getSpan } from "../../utils/ast"
+import type { Rule, VisitorCallbacks } from '../../types'
+import { getSpan } from '../../utils/ast'
 
 export const preferUseIsActive: Rule = {
   meta: {
-    id: "pyreon/prefer-use-is-active",
-    category: "router",
+    id: 'pyreon/prefer-use-is-active',
+    category: 'router',
     description:
       'Suggest useIsActive() instead of `location.pathname === "/foo"` or `route.path === "/foo"` patterns.',
-    severity: "info",
+    severity: 'info',
     fixable: false,
   },
   create(context) {
     const callbacks: VisitorCallbacks = {
       BinaryExpression(node: any) {
-        if (node.operator !== "===" && node.operator !== "==") return
+        if (node.operator !== '===' && node.operator !== '==') return
 
         // Check both sides for location.pathname or route.path
         if (isPathComparison(node.left) || isPathComparison(node.right)) {
           context.report({
             message:
-              "Manual path comparison — use `useIsActive()` for reactive route matching with segment-aware prefix matching.",
+              'Manual path comparison — use `useIsActive()` for reactive route matching with segment-aware prefix matching.',
             span: getSpan(node),
           })
         }
@@ -30,16 +30,16 @@ export const preferUseIsActive: Rule = {
 }
 
 function isPathComparison(node: any): boolean {
-  if (!node || node.type !== "MemberExpression") return false
+  if (!node || node.type !== 'MemberExpression') return false
   const obj = node.object
   const prop = node.property
-  if (!obj || !prop || prop.type !== "Identifier") return false
+  if (!obj || !prop || prop.type !== 'Identifier') return false
 
   // location.pathname
-  if (obj.type === "Identifier" && obj.name === "location" && prop.name === "pathname") return true
+  if (obj.type === 'Identifier' && obj.name === 'location' && prop.name === 'pathname') return true
 
   // route.path
-  if (obj.type === "Identifier" && obj.name === "route" && prop.name === "path") return true
+  if (obj.type === 'Identifier' && obj.name === 'route' && prop.name === 'path') return true
 
   return false
 }