@pyreon/lint 0.11.5 → 0.11.6

package/src/types.ts

@@ -1,6 +1,6 @@
 // ── Severity & Diagnostics ──────────────────────────────────────────────────
 
-export type Severity = "error" | "warn" | "info" | "off"
+export type Severity = 'error' | 'warn' | 'info' | 'off'
 
 export interface SourceLocation {
   line: number
@@ -29,18 +29,18 @@ export interface Diagnostic {
 // ── Rule Metadata ───────────────────────────────────────────────────────────
 
 export type RuleCategory =
-  | "reactivity"
-  | "jsx"
-  | "lifecycle"
-  | "performance"
-  | "ssr"
-  | "architecture"
-  | "store"
-  | "form"
-  | "styling"
-  | "hooks"
-  | "accessibility"
-  | "router"
+  | 'reactivity'
+  | 'jsx'
+  | 'lifecycle'
+  | 'performance'
+  | 'ssr'
+  | 'architecture'
+  | 'store'
+  | 'form'
+  | 'styling'
+  | 'hooks'
+  | 'accessibility'
+  | 'router'
 
 export interface RuleMeta {
   id: string
@@ -53,7 +53,7 @@ export interface RuleMeta {
 // ── Rule Context & Visitor ──────────────────────────────────────────────────
 
 export interface RuleContext {
-  report(diagnostic: Omit<Diagnostic, "ruleId" | "severity" | "loc">): void
+  report(diagnostic: Omit<Diagnostic, 'ruleId' | 'severity' | 'loc'>): void
   getSourceText(): string
   getFilePath(): string
 }
@@ -86,7 +86,7 @@ export interface LintConfigFile {
   exclude?: string[] | undefined
 }
 
-export type PresetName = "recommended" | "strict" | "app" | "lib"
+export type PresetName = 'recommended' | 'strict' | 'app' | 'lib'
 
 // ── Results ─────────────────────────────────────────────────────────────────
 

package/src/utils/ast.ts

@@ -1,11 +1,11 @@
-import type { Span } from "../types"
-import { BROWSER_GLOBALS } from "./imports"
+import type { Span } from '../types'
+import { BROWSER_GLOBALS } from './imports'
 
 /** Check if a node is a call expression to a specific function name. */
 export function isCallTo(node: any, name: string): boolean {
   return (
-    node.type === "CallExpression" &&
-    node.callee?.type === "Identifier" &&
+    node.type === 'CallExpression' &&
+    node.callee?.type === 'Identifier' &&
     node.callee.name === name
   )
 }
@@ -13,8 +13,8 @@ export function isCallTo(node: any, name: string): boolean {
 /** Check if a node is a call expression to any of the given function names. */
 export function isCallToAny(node: any, names: Set<string>): boolean {
   return (
-    node.type === "CallExpression" &&
-    node.callee?.type === "Identifier" &&
+    node.type === 'CallExpression' &&
+    node.callee?.type === 'Identifier' &&
     names.has(node.callee.name)
   )
 }
@@ -22,29 +22,29 @@ export function isCallToAny(node: any, names: Set<string>): boolean {
 /** Check if a node is a member call like `obj.method()`. */
 export function isMemberCallTo(node: any, objectName: string, methodName: string): boolean {
   return (
-    node.type === "CallExpression" &&
-    node.callee?.type === "MemberExpression" &&
-    node.callee.object?.type === "Identifier" &&
+    node.type === 'CallExpression' &&
+    node.callee?.type === 'MemberExpression' &&
+    node.callee.object?.type === 'Identifier' &&
     node.callee.object.name === objectName &&
-    node.callee.property?.type === "Identifier" &&
+    node.callee.property?.type === 'Identifier' &&
     node.callee.property.name === methodName
   )
 }
 
 /** Check if a node is a JSX element (opening or self-closing). */
 export function isJSXElement(node: any): boolean {
-  return node.type === "JSXElement" || node.type === "JSXFragment"
+  return node.type === 'JSXElement' || node.type === 'JSXFragment'
 }
 
 /** Get the tag name of a JSX element. */
 export function getJSXTagName(node: any): string | null {
-  if (node.type === "JSXElement") {
+  if (node.type === 'JSXElement') {
     const opening = node.openingElement
     if (!opening) return null
     const name = opening.name
-    if (name?.type === "JSXIdentifier") return name.name
-    if (name?.type === "JSXMemberExpression") {
-      return `${name.object?.name ?? ""}.${name.property?.name ?? ""}`
+    if (name?.type === 'JSXIdentifier') return name.name
+    if (name?.type === 'JSXMemberExpression') {
+      return `${name.object?.name ?? ''}.${name.property?.name ?? ''}`
     }
   }
   return null
@@ -55,8 +55,8 @@ export function getJSXAttribute(openingElement: any, attrName: string): any | nu
   const attrs = openingElement.attributes ?? []
   for (const attr of attrs) {
     if (
-      attr.type === "JSXAttribute" &&
-      attr.name?.type === "JSXIdentifier" &&
+      attr.type === 'JSXAttribute' &&
+      attr.name?.type === 'JSXIdentifier' &&
       attr.name.name === attrName
     ) {
       return attr
@@ -74,90 +74,90 @@ export function hasJSXAttribute(openingElement: any, attrName: string): boolean
 export function isInsideFunction(ancestors: any[]): boolean {
   return ancestors.some(
     (a) =>
-      a.type === "FunctionDeclaration" ||
-      a.type === "FunctionExpression" ||
-      a.type === "ArrowFunctionExpression",
+      a.type === 'FunctionDeclaration' ||
+      a.type === 'FunctionExpression' ||
+      a.type === 'ArrowFunctionExpression',
   )
 }
 
 /** Check if a node is inside JSX. */
 export function isInsideJSX(ancestors: any[]): boolean {
-  return ancestors.some((a) => a.type === "JSXElement" || a.type === "JSXFragment")
+  return ancestors.some((a) => a.type === 'JSXElement' || a.type === 'JSXFragment')
 }
 
 /** Check if a node is an array .map() call. */
 export function isArrayMapCall(node: any): boolean {
   return (
-    node.type === "CallExpression" &&
-    node.callee?.type === "MemberExpression" &&
-    node.callee.property?.type === "Identifier" &&
-    node.callee.property.name === "map"
+    node.type === 'CallExpression' &&
+    node.callee?.type === 'MemberExpression' &&
+    node.callee.property?.type === 'Identifier' &&
+    node.callee.property.name === 'map'
   )
 }
 
 /** Check if a node is a function expression or arrow function. */
 export function isFunction(node: any): boolean {
   return (
-    node.type === "FunctionDeclaration" ||
-    node.type === "FunctionExpression" ||
-    node.type === "ArrowFunctionExpression"
+    node.type === 'FunctionDeclaration' ||
+    node.type === 'FunctionExpression' ||
+    node.type === 'ArrowFunctionExpression'
   )
 }
 
 /** Check if a node is a destructuring pattern. */
 export function isDestructuring(node: any): boolean {
-  return node.type === "ObjectPattern" || node.type === "ArrayPattern"
+  return node.type === 'ObjectPattern' || node.type === 'ArrayPattern'
 }
 
 /** Check if a node is a ternary with JSX in either branch. */
 export function isTernaryWithJSX(node: any): boolean {
-  if (node.type !== "ConditionalExpression") return false
+  if (node.type !== 'ConditionalExpression') return false
   return containsJSX(node.consequent) || containsJSX(node.alternate)
 }
 
 /** Check if a node contains JSX anywhere. */
 function containsJSX(node: any): boolean {
   if (!node) return false
-  if (node.type === "JSXElement" || node.type === "JSXFragment") return true
-  if (node.type === "ParenthesizedExpression") return containsJSX(node.expression)
+  if (node.type === 'JSXElement' || node.type === 'JSXFragment') return true
+  if (node.type === 'ParenthesizedExpression') return containsJSX(node.expression)
   return false
 }
 
 /** Check if a JSX element has JSX children. */
 export function hasJSXChild(node: any): boolean {
-  if (node.type !== "JSXElement") return false
-  return (node.children ?? []).some((c: any) => c.type === "JSXElement" || c.type === "JSXFragment")
+  if (node.type !== 'JSXElement') return false
+  return (node.children ?? []).some((c: any) => c.type === 'JSXElement' || c.type === 'JSXFragment')
 }
 
 /** Check if a node is a logical AND with JSX. */
 export function isLogicalAndWithJSX(node: any): boolean {
-  if (node.type !== "LogicalExpression" || node.operator !== "&&") return false
+  if (node.type !== 'LogicalExpression' || node.operator !== '&&') return false
   return containsJSX(node.right)
 }
 
 /** Check if a node is a .peek() call. */
 export function isPeekCall(node: any): boolean {
   return (
-    node.type === "CallExpression" &&
-    node.callee?.type === "MemberExpression" &&
-    node.callee.property?.type === "Identifier" &&
-    node.callee.property.name === "peek"
+    node.type === 'CallExpression' &&
+    node.callee?.type === 'MemberExpression' &&
+    node.callee.property?.type === 'Identifier' &&
+    node.callee.property.name === 'peek'
   )
 }
 
 /** Check if a node is a .set() call. */
 export function isSetCall(node: any): boolean {
   return (
-    node.type === "CallExpression" &&
-    node.callee?.type === "MemberExpression" &&
-    node.callee.property?.type === "Identifier" &&
-    node.callee.property.name === "set"
+    node.type === 'CallExpression' &&
+    node.callee?.type === 'MemberExpression' &&
+    node.callee.property?.type === 'Identifier' &&
+    node.callee.property.name === 'set'
   )
 }
 
 /** Check if a node references a browser global. */
 export function isBrowserGlobal(node: any): boolean {
-  return node.type === "Identifier" && BROWSER_GLOBALS.has(node.name)
+  return node.type === 'Identifier' && BROWSER_GLOBALS.has(node.name)
 }
 
 /** Get the span (byte offsets) of a node. */
@@ -168,7 +168,7 @@ export function getSpan(node: any): Span {
 /** Check if a node is inside a `if (__DEV__)` guard. */
 export function isInsideDevGuard(ancestors: any[]): boolean {
   return ancestors.some(
-    (a) => a.type === "IfStatement" && a.test?.type === "Identifier" && a.test.name === "__DEV__",
+    (a) => a.type === 'IfStatement' && a.test?.type === 'Identifier' && a.test.name === '__DEV__',
   )
 }
 
@@ -176,7 +176,7 @@ export function isInsideDevGuard(ancestors: any[]): boolean {
 export function isInsideOnMount(ancestors: any[]): boolean {
   return ancestors.some(
     (a) =>
-      a.type === "CallExpression" && a.callee?.type === "Identifier" && a.callee.name === "onMount",
+      a.type === 'CallExpression' && a.callee?.type === 'Identifier' && a.callee.name === 'onMount',
   )
 }
 
@@ -184,9 +184,9 @@ export function isInsideOnMount(ancestors: any[]): boolean {
 export function isInsideTypeofGuard(ancestors: any[]): boolean {
   return ancestors.some(
     (a) =>
-      a.type === "IfStatement" &&
-      a.test?.type === "BinaryExpression" &&
-      a.test.left?.type === "UnaryExpression" &&
-      a.test.left.operator === "typeof",
+      a.type === 'IfStatement' &&
+      a.test?.type === 'BinaryExpression' &&
+      a.test.left?.type === 'UnaryExpression' &&
+      a.test.left.operator === 'typeof',
   )
 }

package/src/utils/imports.ts

@@ -1,65 +1,65 @@
-import type { ImportInfo } from "../types"
+import type { ImportInfo } from '../types'
 
 export type { ImportInfo }
 
 // ── Constants ───────────────────────────────────────────────────────────────
 
-export const PYREON_PREFIX = "@pyreon/"
+export const PYREON_PREFIX = '@pyreon/'
 
 export const REACTIVITY_APIS = new Set([
-  "signal",
-  "computed",
-  "effect",
-  "batch",
-  "onCleanup",
-  "createSelector",
-  "createStore",
-  "untrack",
+  'signal',
+  'computed',
+  'effect',
+  'batch',
+  'onCleanup',
+  'createSelector',
+  'createStore',
+  'untrack',
 ])
 
-export const LIFECYCLE_APIS = new Set(["onMount", "onUnmount"])
+export const LIFECYCLE_APIS = new Set(['onMount', 'onUnmount'])
 
-export const CONTEXT_APIS = new Set(["createContext", "provide", "pushContext", "popContext"])
+export const CONTEXT_APIS = new Set(['createContext', 'provide', 'pushContext', 'popContext'])
 
 export const JSX_COMPONENTS = new Set([
-  "For",
-  "Show",
-  "Switch",
-  "Match",
-  "Dynamic",
-  "ErrorBoundary",
-  "Suspense",
-  "Portal",
+  'For',
+  'Show',
+  'Switch',
+  'Match',
+  'Dynamic',
+  'ErrorBoundary',
+  'Suspense',
+  'Portal',
 ])
 
 export const HEAVY_PACKAGES = new Set([
-  "@pyreon/charts",
-  "@pyreon/code",
-  "@pyreon/document",
-  "@pyreon/flow",
+  '@pyreon/charts',
+  '@pyreon/code',
+  '@pyreon/document',
+  '@pyreon/flow',
 ])
 
 export const BROWSER_GLOBALS = new Set([
-  "window",
-  "document",
-  "navigator",
-  "location",
-  "history",
-  "localStorage",
-  "sessionStorage",
-  "indexedDB",
-  "fetch",
-  "XMLHttpRequest",
-  "WebSocket",
-  "requestAnimationFrame",
-  "cancelAnimationFrame",
-  "IntersectionObserver",
-  "MutationObserver",
-  "ResizeObserver",
-  "matchMedia",
-  "getComputedStyle",
-  "addEventListener",
-  "removeEventListener",
+  'window',
+  'document',
+  'navigator',
+  'location',
+  'history',
+  'localStorage',
+  'sessionStorage',
+  'indexedDB',
+  'fetch',
+  'XMLHttpRequest',
+  'WebSocket',
+  'requestAnimationFrame',
+  'cancelAnimationFrame',
+  'IntersectionObserver',
+  'MutationObserver',
+  'ResizeObserver',
+  'matchMedia',
+  'getComputedStyle',
+  'addEventListener',
+  'removeEventListener',
 ])
 
 // ── Functions ───────────────────────────────────────────────────────────────
@@ -73,26 +73,26 @@ export function isPyreonPackage(source: string): boolean {
 }
 
 export function extractImportInfo(node: any): ImportInfo | null {
-  if (node.type !== "ImportDeclaration") return null
+  if (node.type !== 'ImportDeclaration') return null
 
   const source = node.source?.value as string
   if (!source) return null
 
-  const specifiers: ImportInfo["specifiers"] = []
+  const specifiers: ImportInfo['specifiers'] = []
   let isDefault = false
   let isNamespace = false
 
   for (const spec of node.specifiers ?? []) {
-    if (spec.type === "ImportDefaultSpecifier") {
+    if (spec.type === 'ImportDefaultSpecifier') {
       isDefault = true
-      specifiers.push({ imported: "default", local: spec.local?.name ?? "" })
-    } else if (spec.type === "ImportNamespaceSpecifier") {
+      specifiers.push({ imported: 'default', local: spec.local?.name ?? '' })
+    } else if (spec.type === 'ImportNamespaceSpecifier') {
       isNamespace = true
-      specifiers.push({ imported: "*", local: spec.local?.name ?? "" })
-    } else if (spec.type === "ImportSpecifier") {
+      specifiers.push({ imported: '*', local: spec.local?.name ?? '' })
+    } else if (spec.type === 'ImportSpecifier') {
       const imported =
-        spec.imported?.type === "Identifier" ? spec.imported.name : (spec.imported?.value ?? "")
-      specifiers.push({ imported, local: spec.local?.name ?? "" })
+        spec.imported?.type === 'Identifier' ? spec.imported.name : (spec.imported?.value ?? '')
+      specifiers.push({ imported, local: spec.local?.name ?? '' })
     }
   }
 

package/src/utils/index.ts

@@ -21,7 +21,7 @@ export {
   isPeekCall,
   isSetCall,
   isTernaryWithJSX,
-} from "./ast"
+} from './ast'
 export {
   BROWSER_GLOBALS,
   CONTEXT_APIS,
@@ -35,14 +35,14 @@ export {
   LIFECYCLE_APIS,
   PYREON_PREFIX,
   REACTIVITY_APIS,
-} from "./imports"
-export { LineIndex } from "./source"
+} from './imports'
+export { LineIndex } from './source'
 
 /** Supported JS/TS file extensions for linting. */
-export const JS_EXTENSIONS = new Set([".ts", ".tsx", ".js", ".jsx", ".mts", ".mjs"])
+export const JS_EXTENSIONS = new Set(['.ts', '.tsx', '.js', '.jsx', '.mts', '.mjs'])
 
 /** Check if a file path has a supported JS/TS extension. */
 export function hasJsExtension(filePath: string): boolean {
-  const ext = filePath.slice(filePath.lastIndexOf("."))
+  const ext = filePath.slice(filePath.lastIndexOf('.'))
   return JS_EXTENSIONS.has(ext)
 }

package/src/utils/source.ts

@@ -1,4 +1,4 @@
-import type { SourceLocation } from "../types"
+import type { SourceLocation } from '../types'
 
 /**
  * Fast offset→line/column conversion using binary search over precomputed line starts.
@@ -9,7 +9,7 @@ export class LineIndex {
   constructor(sourceText: string) {
     this.lineStarts = [0]
     for (let i = 0; i < sourceText.length; i++) {
-      if (sourceText[i] === "\n") {
+      if (sourceText[i] === '\n') {
         this.lineStarts.push(i + 1)
       }
     }

package/src/watcher.ts

@@ -1,17 +1,17 @@
-import { readFileSync, watch } from "node:fs"
-import { resolve } from "node:path"
-import { AstCache } from "./cache"
-import { createIgnoreFilter } from "./config/ignore"
-import { getPreset } from "./config/presets"
-import { formatCompact, formatJSON, formatText } from "./reporter"
-import { allRules } from "./rules/index"
-import { lintFile } from "./runner"
-import type { LintConfig, LintOptions, LintResult, Severity } from "./types"
-import { hasJsExtension } from "./utils/index"
+import { readFileSync, watch } from 'node:fs'
+import { resolve } from 'node:path'
+import { AstCache } from './cache'
+import { createIgnoreFilter } from './config/ignore'
+import { getPreset } from './config/presets'
+import { formatCompact, formatJSON, formatText } from './reporter'
+import { allRules } from './rules/index'
+import { lintFile } from './runner'
+import type { LintConfig, LintOptions, LintResult, Severity } from './types'
+import { hasJsExtension } from './utils/index'
 
 function formatOutput(result: LintResult, format: string): string {
-  if (format === "json") return formatJSON(result)
-  if (format === "compact") return formatCompact(result)
+  if (format === 'json') return formatJSON(result)
+  if (format === 'compact') return formatCompact(result)
   return formatText(result)
 }
 
@@ -30,12 +30,12 @@ function formatOutput(result: LintResult, format: string): string {
  */
 export function watchAndLint(options: LintOptions & { format: string }): void {
   const cache = new AstCache()
-  const preset = options.preset ?? "recommended"
+  const preset = options.preset ?? 'recommended'
   const config = getPreset(preset)
 
   applyOverrides(config, options.ruleOverrides)
 
-  const cwd = resolve(".")
+  const cwd = resolve('.')
   const isIgnored = createIgnoreFilter(cwd, options.ignore)
 
   // Debounce map: filePath -> timeout
@@ -84,7 +84,7 @@ function applyOverrides(
 function relintFile(filePath: string, config: LintConfig, cache: AstCache, format: string): void {
   let source: string
   try {
-    source = readFileSync(filePath, "utf-8")
+    source = readFileSync(filePath, 'utf-8')
   } catch {
     return
   }
@@ -101,12 +101,12 @@ function relintFile(filePath: string, config: LintConfig, cache: AstCache, forma
   }
 
   for (const d of fileResult.diagnostics) {
-    if (d.severity === "error") result.totalErrors++
-    else if (d.severity === "warn") result.totalWarnings++
-    else if (d.severity === "info") result.totalInfos++
+    if (d.severity === 'error') result.totalErrors++
+    else if (d.severity === 'warn') result.totalWarnings++
+    else if (d.severity === 'info') result.totalInfos++
   }
 
   // Clear screen and print
-  process.stdout.write("\x1b[2J\x1b[H")
+  process.stdout.write('\x1b[2J\x1b[H')
   console.log(formatOutput(result, format))
 }