@pyreon/lint 0.11.5 → 0.11.7

package/src/rules/jsx/no-classname.ts

@@ -1,24 +1,24 @@
-import type { Rule, VisitorCallbacks } from "../../types"
-import { getSpan } from "../../utils/ast"
+import type { Rule, VisitorCallbacks } from '../../types'
+import { getSpan } from '../../utils/ast'
 
 export const noClassName: Rule = {
   meta: {
-    id: "pyreon/no-classname",
-    category: "jsx",
-    description: "Use `class` instead of `className` — Pyreon uses standard HTML attributes.",
-    severity: "error",
+    id: 'pyreon/no-classname',
+    category: 'jsx',
+    description: 'Use `class` instead of `className` — Pyreon uses standard HTML attributes.',
+    severity: 'error',
     fixable: true,
   },
   create(context) {
     const callbacks: VisitorCallbacks = {
       JSXAttribute(node: any) {
-        if (node.name?.type !== "JSXIdentifier") return
-        if (node.name.name !== "className") return
+        if (node.name?.type !== 'JSXIdentifier') return
+        if (node.name.name !== 'className') return
         const nameSpan = getSpan(node.name)
         context.report({
-          message: "Use `class` instead of `className` — Pyreon uses standard HTML attributes.",
+          message: 'Use `class` instead of `className` — Pyreon uses standard HTML attributes.',
           span: getSpan(node),
-          fix: { span: nameSpan, replacement: "class" },
+          fix: { span: nameSpan, replacement: 'class' },
         })
       },
     }

package/src/rules/jsx/no-htmlfor.ts

@@ -1,24 +1,24 @@
-import type { Rule, VisitorCallbacks } from "../../types"
-import { getSpan } from "../../utils/ast"
+import type { Rule, VisitorCallbacks } from '../../types'
+import { getSpan } from '../../utils/ast'
 
 export const noHtmlFor: Rule = {
   meta: {
-    id: "pyreon/no-htmlfor",
-    category: "jsx",
-    description: "Use `for` instead of `htmlFor` — Pyreon uses standard HTML attributes.",
-    severity: "error",
+    id: 'pyreon/no-htmlfor',
+    category: 'jsx',
+    description: 'Use `for` instead of `htmlFor` — Pyreon uses standard HTML attributes.',
+    severity: 'error',
     fixable: true,
   },
   create(context) {
     const callbacks: VisitorCallbacks = {
       JSXAttribute(node: any) {
-        if (node.name?.type !== "JSXIdentifier") return
-        if (node.name.name !== "htmlFor") return
+        if (node.name?.type !== 'JSXIdentifier') return
+        if (node.name.name !== 'htmlFor') return
         const nameSpan = getSpan(node.name)
         context.report({
-          message: "Use `for` instead of `htmlFor` — Pyreon uses standard HTML attributes.",
+          message: 'Use `for` instead of `htmlFor` — Pyreon uses standard HTML attributes.',
           span: getSpan(node),
-          fix: { span: nameSpan, replacement: "for" },
+          fix: { span: nameSpan, replacement: 'for' },
         })
       },
     }

package/src/rules/jsx/no-index-as-by.ts

@@ -1,62 +1,62 @@
-import type { Rule, VisitorCallbacks } from "../../types"
-import { getJSXAttribute, getSpan } from "../../utils/ast"
+import type { Rule, VisitorCallbacks } from '../../types'
+import { getJSXAttribute, getSpan } from '../../utils/ast'
 
 export const noIndexAsBy: Rule = {
   meta: {
-    id: "pyreon/no-index-as-by",
-    category: "jsx",
-    description: "Disallow using index as `by` prop on <For> — use a unique key instead.",
-    severity: "warn",
+    id: 'pyreon/no-index-as-by',
+    category: 'jsx',
+    description: 'Disallow using index as `by` prop on <For> — use a unique key instead.',
+    severity: 'warn',
     fixable: false,
   },
   create(context) {
     const callbacks: VisitorCallbacks = {
       JSXOpeningElement(node: any) {
         const name = node.name
-        if (!name || name.type !== "JSXIdentifier" || name.name !== "For") return
+        if (!name || name.type !== 'JSXIdentifier' || name.name !== 'For') return
 
-        const byAttr = getJSXAttribute(node, "by")
+        const byAttr = getJSXAttribute(node, 'by')
         if (!byAttr) return
 
         const value = byAttr.value
-        if (!value || value.type !== "JSXExpressionContainer") return
+        if (!value || value.type !== 'JSXExpressionContainer') return
 
         const expr = value.expression
         if (!expr) return
 
         // Detect: by={(_, i) => i} or by={(item, index) => index}
-        if (expr.type === "ArrowFunctionExpression" || expr.type === "FunctionExpression") {
+        if (expr.type === 'ArrowFunctionExpression' || expr.type === 'FunctionExpression') {
           const params = expr.params
           if (!params || params.length < 2) return
 
           const secondParam = params[1]
-          if (!secondParam || secondParam.type !== "Identifier") return
+          if (!secondParam || secondParam.type !== 'Identifier') return
 
           const indexName = secondParam.name
           const body = expr.body
 
           // Arrow expression body: (_, i) => i
-          if (body?.type === "Identifier" && body.name === indexName) {
+          if (body?.type === 'Identifier' && body.name === indexName) {
             context.report({
               message:
-                "Using index as `by` prop on `<For>` — use a unique key from the data instead.",
+                'Using index as `by` prop on `<For>` — use a unique key from the data instead.',
               span: getSpan(byAttr),
             })
           }
 
           // Block body: (_, i) => { return i }
-          if (body?.type === "BlockStatement") {
+          if (body?.type === 'BlockStatement') {
             const stmts = body.body
             if (stmts?.length === 1) {
               const stmt = stmts[0]
               if (
-                stmt.type === "ReturnStatement" &&
-                stmt.argument?.type === "Identifier" &&
+                stmt.type === 'ReturnStatement' &&
+                stmt.argument?.type === 'Identifier' &&
                 stmt.argument.name === indexName
               ) {
                 context.report({
                   message:
-                    "Using index as `by` prop on `<For>` — use a unique key from the data instead.",
+                    'Using index as `by` prop on `<For>` — use a unique key from the data instead.',
                   span: getSpan(byAttr),
                 })
               }

package/src/rules/jsx/no-map-in-jsx.ts

@@ -1,12 +1,12 @@
-import type { Rule, VisitorCallbacks } from "../../types"
-import { getSpan, isArrayMapCall } from "../../utils/ast"
+import type { Rule, VisitorCallbacks } from '../../types'
+import { getSpan, isArrayMapCall } from '../../utils/ast'
 
 export const noMapInJsx: Rule = {
   meta: {
-    id: "pyreon/no-map-in-jsx",
-    category: "jsx",
-    description: "Prefer <For> over .map() inside JSX for reactive list rendering.",
-    severity: "warn",
+    id: 'pyreon/no-map-in-jsx',
+    category: 'jsx',
+    description: 'Prefer <For> over .map() inside JSX for reactive list rendering.',
+    severity: 'warn',
     fixable: false,
   },
   create(context) {
@@ -15,13 +15,13 @@ export const noMapInJsx: Rule = {
       JSXElement() {
         jsxDepth++
       },
-      "JSXElement:exit"() {
+      'JSXElement:exit'() {
         jsxDepth--
       },
       JSXFragment() {
         jsxDepth++
       },
-      "JSXFragment:exit"() {
+      'JSXFragment:exit'() {
         jsxDepth--
       },
       CallExpression(node: any) {
@@ -33,7 +33,7 @@ export const noMapInJsx: Rule = {
         const callback = args[0]
         if (!callback) return
         context.report({
-          message: "`.map()` in JSX — use `<For>` for reactive list rendering instead.",
+          message: '`.map()` in JSX — use `<For>` for reactive list rendering instead.',
           span: getSpan(node),
         })
       },

package/src/rules/jsx/no-missing-for-by.ts

@@ -1,23 +1,23 @@
-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 noMissingForBy: Rule = {
   meta: {
-    id: "pyreon/no-missing-for-by",
-    category: "jsx",
-    description: "Warn when <For> is used without a `by` prop.",
-    severity: "warn",
+    id: 'pyreon/no-missing-for-by',
+    category: 'jsx',
+    description: 'Warn when <For> is used without a `by` prop.',
+    severity: 'warn',
     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/jsx/no-onchange.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 INPUT_TAGS = new Set(["input", "textarea", "select"])
+const INPUT_TAGS = new Set(['input', 'textarea', 'select'])
 
 export const noOnChange: Rule = {
   meta: {
-    id: "pyreon/no-onchange",
-    category: "jsx",
+    id: 'pyreon/no-onchange',
+    category: 'jsx',
     description:
-      "Prefer `onInput` over `onChange` on input elements for keypress-by-keypress updates.",
-    severity: "warn",
+      'Prefer `onInput` over `onChange` on input elements for keypress-by-keypress updates.',
+    severity: 'warn',
     fixable: true,
   },
   create(context) {
@@ -17,7 +17,7 @@ export const noOnChange: Rule = {
     const callbacks: VisitorCallbacks = {
       JSXOpeningElement(node: any) {
         const name = node.name
-        if (name?.type === "JSXIdentifier" && INPUT_TAGS.has(name.name)) {
+        if (name?.type === 'JSXIdentifier' && INPUT_TAGS.has(name.name)) {
           currentTag = name.name
         } else {
           currentTag = null
@@ -27,15 +27,15 @@ export const noOnChange: Rule = {
         const attrs = node.attributes ?? []
         for (const attr of attrs) {
           if (
-            attr.type === "JSXAttribute" &&
-            attr.name?.type === "JSXIdentifier" &&
-            attr.name.name === "onChange"
+            attr.type === 'JSXAttribute' &&
+            attr.name?.type === 'JSXIdentifier' &&
+            attr.name.name === 'onChange'
           ) {
             const nameSpan = getSpan(attr.name)
             context.report({
               message: `Use \`onInput\` instead of \`onChange\` on \`<${currentTag}>\` for keypress-by-keypress updates.`,
               span: getSpan(attr),
-              fix: { span: nameSpan, replacement: "onInput" },
+              fix: { span: nameSpan, replacement: 'onInput' },
             })
           }
         }

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

@@ -1,16 +1,16 @@
-import type { Rule, VisitorCallbacks } from "../../types"
-import { getSpan, isDestructuring } from "../../utils/ast"
+import type { Rule, VisitorCallbacks } from '../../types'
+import { getSpan, isDestructuring } from '../../utils/ast'
 
 function containsJSXReturn(node: any): boolean {
   if (!node) return false
   // Arrow with expression body returning JSX
-  if (node.type === "JSXElement" || node.type === "JSXFragment") return true
-  if (node.type === "ParenthesizedExpression") return containsJSXReturn(node.expression)
+  if (node.type === 'JSXElement' || node.type === 'JSXFragment') return true
+  if (node.type === 'ParenthesizedExpression') return containsJSXReturn(node.expression)
 
   // Block body — look for return statements with JSX
-  if (node.type === "BlockStatement") {
+  if (node.type === 'BlockStatement') {
     for (const stmt of node.body ?? []) {
-      if (stmt.type === "ReturnStatement" && containsJSXReturn(stmt.argument)) {
+      if (stmt.type === 'ReturnStatement' && containsJSXReturn(stmt.argument)) {
         return true
       }
     }
@@ -20,11 +20,11 @@ function containsJSXReturn(node: any): boolean {
 
 export const noPropsDestructure: Rule = {
   meta: {
-    id: "pyreon/no-props-destructure",
-    category: "jsx",
+    id: 'pyreon/no-props-destructure',
+    category: 'jsx',
     description:
-      "Disallow destructuring props in component functions — it breaks signal reactivity.",
-    severity: "error",
+      'Disallow destructuring props in component functions — it breaks signal reactivity.',
+    severity: 'error',
     fixable: false,
   },
   create(context) {
@@ -57,7 +57,7 @@ function checkFunction(node: any, context: any) {
   if (containsJSXReturn(body)) {
     context.report({
       message:
-        "Destructured props in a component function — this breaks signal reactivity. Use `props.x` or `splitProps()` instead.",
+        'Destructured props in a component function — this breaks signal reactivity. Use `props.x` or `splitProps()` instead.',
       span: getSpan(firstParam),
     })
   }

package/src/rules/jsx/no-ternary-conditional.ts

@@ -1,12 +1,12 @@
-import type { Rule, VisitorCallbacks } from "../../types"
-import { getSpan, isTernaryWithJSX } from "../../utils/ast"
+import type { Rule, VisitorCallbacks } from '../../types'
+import { getSpan, isTernaryWithJSX } from '../../utils/ast'
 
 export const noTernaryConditional: Rule = {
   meta: {
-    id: "pyreon/no-ternary-conditional",
-    category: "jsx",
-    description: "Prefer <Show> over ternary expressions with JSX branches.",
-    severity: "warn",
+    id: 'pyreon/no-ternary-conditional',
+    category: 'jsx',
+    description: 'Prefer <Show> over ternary expressions with JSX branches.',
+    severity: 'warn',
     fixable: false,
   },
   create(context) {
@@ -15,14 +15,14 @@ export const noTernaryConditional: Rule = {
       JSXExpressionContainer() {
         jsxExpressionDepth++
       },
-      "JSXExpressionContainer:exit"() {
+      'JSXExpressionContainer:exit'() {
         jsxExpressionDepth--
       },
       ConditionalExpression(node: any) {
         if (jsxExpressionDepth === 0) return
         if (!isTernaryWithJSX(node)) return
         context.report({
-          message: "Ternary with JSX — use `<Show>` for more efficient conditional rendering.",
+          message: 'Ternary with JSX — use `<Show>` for more efficient conditional rendering.',
           span: getSpan(node),
         })
       },

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