@pyreon/lint 0.11.5 → 0.11.6

package/src/rules/store/no-store-outside-provider.ts

@@ -1,22 +1,22 @@
-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'
 
 export const noStoreOutsideProvider: Rule = {
   meta: {
-    id: "pyreon/no-store-outside-provider",
-    category: "store",
-    description: "Warn when store hooks are used in SSR files without a provider import.",
-    severity: "warn",
+    id: 'pyreon/no-store-outside-provider',
+    category: 'store',
+    description: 'Warn when store hooks are used in SSR files without a provider import.',
+    severity: 'warn',
     fixable: false,
   },
   create(context) {
     const filePath = context.getFilePath()
     const isServerFile =
-      filePath.includes("server") ||
-      filePath.includes(".server.") ||
-      filePath.endsWith("server.ts") ||
-      filePath.endsWith("server.tsx")
+      filePath.includes('server') ||
+      filePath.includes('.server.') ||
+      filePath.endsWith('server.ts') ||
+      filePath.endsWith('server.tsx')
 
     if (!isServerFile) return {}
 
@@ -30,7 +30,7 @@ export const noStoreOutsideProvider: Rule = {
         if (
           info.specifiers.some(
             (s) =>
-              s.imported === "setStoreRegistryProvider" || s.imported === "runWithRequestContext",
+              s.imported === 'setStoreRegistryProvider' || s.imported === 'runWithRequestContext',
           )
         ) {
           hasProviderImport = true
@@ -38,13 +38,13 @@ export const noStoreOutsideProvider: Rule = {
       },
       CallExpression(node: any) {
         const callee = node.callee
-        if (!callee || callee.type !== "Identifier") return
+        if (!callee || callee.type !== 'Identifier') return
         const name: string = callee.name
-        if (name.endsWith("Store") && name.startsWith("use")) {
+        if (name.endsWith('Store') && name.startsWith('use')) {
           storeHookCalls.push({ name, span: getSpan(node) })
         }
       },
-      "Program:exit"() {
+      'Program:exit'() {
         if (hasProviderImport) return
         for (const call of storeHookCalls) {
           context.report({

package/src/rules/styling/no-dynamic-styled.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 noDynamicStyled: Rule = {
   meta: {
-    id: "pyreon/no-dynamic-styled",
-    category: "styling",
+    id: 'pyreon/no-dynamic-styled',
+    category: 'styling',
     description:
-      "Warn when styled() is called inside a function — it creates new CSS on every render.",
-    severity: "warn",
+      'Warn when styled() is called inside a function — it creates new CSS on every render.',
+    severity: 'warn',
     fixable: false,
   },
   create(context) {
@@ -16,27 +16,27 @@ export const noDynamicStyled: Rule = {
       FunctionDeclaration() {
         functionDepth++
       },
-      "FunctionDeclaration:exit"() {
+      'FunctionDeclaration:exit'() {
         functionDepth--
       },
       FunctionExpression() {
         functionDepth++
       },
-      "FunctionExpression:exit"() {
+      'FunctionExpression:exit'() {
         functionDepth--
       },
       ArrowFunctionExpression() {
         functionDepth++
       },
-      "ArrowFunctionExpression:exit"() {
+      'ArrowFunctionExpression:exit'() {
         functionDepth--
       },
       CallExpression(node: any) {
         if (functionDepth === 0) return
-        if (isCallTo(node, "styled")) {
+        if (isCallTo(node, 'styled')) {
           context.report({
             message:
-              "`styled()` inside a function — this creates new CSS rules on every render. Move `styled()` to module scope.",
+              '`styled()` inside a function — this creates new CSS rules on every render. Move `styled()` to module scope.',
             span: getSpan(node),
           })
         }
@@ -46,10 +46,10 @@ export const noDynamicStyled: Rule = {
         const tag = node.tag
         if (!tag) return
         // styled('div')`...` — tag is a CallExpression of styled
-        if (tag.type === "CallExpression" && isCallTo(tag, "styled")) {
+        if (tag.type === 'CallExpression' && isCallTo(tag, 'styled')) {
           context.report({
             message:
-              "`styled()` tagged template inside a function — this creates new CSS rules on every render. Move to module scope.",
+              '`styled()` tagged template inside a function — this creates new CSS rules on every render. Move to module scope.',
             span: getSpan(node),
           })
         }

package/src/rules/styling/no-inline-style-object.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 noInlineStyleObject: Rule = {
   meta: {
-    id: "pyreon/no-inline-style-object",
-    category: "styling",
-    description: "Warn against inline style objects in JSX — prefer styled() or css``.",
-    severity: "warn",
+    id: 'pyreon/no-inline-style-object',
+    category: 'styling',
+    description: 'Warn against inline style objects in JSX — prefer styled() or css``.',
+    severity: 'warn',
     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?.type === "ObjectExpression") {
+        if (expr?.type === 'ObjectExpression') {
           context.report({
             message:
-              "Inline style object in JSX — consider using `styled()` or `css\\`...\\`` for better performance and caching.",
+              'Inline style object in JSX — consider using `styled()` or `css\\`...\\`` for better performance and caching.',
             span: getSpan(node),
           })
         }

package/src/rules/styling/no-theme-outside-provider.ts

@@ -1,13 +1,13 @@
-import type { Rule, VisitorCallbacks } from "../../types"
-import { getSpan, isCallTo } from "../../utils/ast"
-import { extractImportInfo } from "../../utils/imports"
+import type { Rule, VisitorCallbacks } from '../../types'
+import { getSpan, isCallTo } from '../../utils/ast'
+import { extractImportInfo } from '../../utils/imports'
 
 export const noThemeOutsideProvider: Rule = {
   meta: {
-    id: "pyreon/no-theme-outside-provider",
-    category: "styling",
-    description: "Warn when useTheme() is used without PyreonUI or ThemeProvider in the same file.",
-    severity: "warn",
+    id: 'pyreon/no-theme-outside-provider',
+    category: 'styling',
+    description: 'Warn when useTheme() is used without PyreonUI or ThemeProvider in the same file.',
+    severity: 'warn',
     fixable: false,
   },
   create(context) {
@@ -19,22 +19,22 @@ export const noThemeOutsideProvider: Rule = {
         const info = extractImportInfo(node)
         if (!info) return
         if (
-          info.specifiers.some((s) => s.imported === "PyreonUI" || s.imported === "ThemeProvider")
+          info.specifiers.some((s) => s.imported === 'PyreonUI' || s.imported === 'ThemeProvider')
         ) {
           hasProviderImport = true
         }
       },
       CallExpression(node: any) {
-        if (isCallTo(node, "useTheme")) {
+        if (isCallTo(node, 'useTheme')) {
           themeCalls.push({ span: getSpan(node) })
         }
       },
-      "Program:exit"() {
+      'Program:exit'() {
         if (hasProviderImport) return
         for (const call of themeCalls) {
           context.report({
             message:
-              "`useTheme()` without a `PyreonUI` or `ThemeProvider` import — the theme context may not be available.",
+              '`useTheme()` without a `PyreonUI` or `ThemeProvider` import — the theme context may not be available.',
             span: call.span,
           })
         }

package/src/rules/styling/prefer-cx.ts

@@ -1,39 +1,39 @@
-import type { Rule, VisitorCallbacks } from "../../types"
-import { getSpan } from "../../utils/ast"
+import type { Rule, VisitorCallbacks } from '../../types'
+import { getSpan } from '../../utils/ast'
 
 export const preferCx: Rule = {
   meta: {
-    id: "pyreon/prefer-cx",
-    category: "styling",
+    id: 'pyreon/prefer-cx',
+    category: 'styling',
     description:
-      "Suggest cx() for class composition instead of string concatenation or template literals.",
-    severity: "info",
+      'Suggest cx() for class composition instead of string concatenation or template literals.',
+    severity: 'info',
     fixable: false,
   },
   create(context) {
     const callbacks: VisitorCallbacks = {
       JSXAttribute(node: any) {
-        if (node.name?.type !== "JSXIdentifier" || node.name.name !== "class") return
+        if (node.name?.type !== 'JSXIdentifier' || node.name.name !== 'class') return
         const value = node.value
-        if (!value || value.type !== "JSXExpressionContainer") return
+        if (!value || value.type !== 'JSXExpressionContainer') return
         const expr = value.expression
         if (!expr) return
 
         // String concatenation: "foo " + bar
-        if (expr.type === "BinaryExpression" && expr.operator === "+") {
+        if (expr.type === 'BinaryExpression' && expr.operator === '+') {
           context.report({
             message:
-              "String concatenation in `class` attribute — use `cx()` for cleaner class composition.",
+              'String concatenation in `class` attribute — use `cx()` for cleaner class composition.',
             span: getSpan(expr),
           })
           return
         }
 
         // Template literal: `foo ${bar}`
-        if (expr.type === "TemplateLiteral" && expr.expressions?.length > 0) {
+        if (expr.type === 'TemplateLiteral' && expr.expressions?.length > 0) {
           context.report({
             message:
-              "Template literal in `class` attribute — use `cx()` for cleaner class composition.",
+              'Template literal in `class` attribute — use `cx()` for cleaner class composition.',
             span: getSpan(expr),
           })
         }

package/src/runner.ts

@@ -1,5 +1,5 @@
-import { parseSync, Visitor } from "oxc-parser"
-import type { AstCache } from "./cache"
+import { parseSync, Visitor } from 'oxc-parser'
+import type { AstCache } from './cache'
 import type {
   Diagnostic,
   LintConfig,
@@ -8,21 +8,21 @@ import type {
   RuleContext,
   Severity,
   VisitorCallbacks,
-} from "./types"
-import { JS_EXTENSIONS } from "./utils/index"
-import { LineIndex } from "./utils/source"
+} from './types'
+import { JS_EXTENSIONS } from './utils/index'
+import { LineIndex } from './utils/source'
 
 function getExtension(filePath: string): string {
-  const lastDot = filePath.lastIndexOf(".")
-  return lastDot === -1 ? "" : filePath.slice(lastDot)
+  const lastDot = filePath.lastIndexOf('.')
+  return lastDot === -1 ? '' : filePath.slice(lastDot)
 }
 
-type OxcLang = "jsx" | "tsx" | "ts" | "js" | "dts"
+type OxcLang = 'jsx' | 'tsx' | 'ts' | 'js' | 'dts'
 
 function getLang(ext: string): OxcLang {
-  if (ext === ".tsx" || ext === ".jsx") return "tsx"
-  if (ext === ".ts" || ext === ".mts") return "ts"
-  return "js"
+  if (ext === '.tsx' || ext === '.jsx') return 'tsx'
+  if (ext === '.ts' || ext === '.mts') return 'ts'
+  return 'js'
 }
 
 function createRuleContext(
@@ -113,7 +113,7 @@ export function lintFile(
     lineIndex = new LineIndex(sourceText)
     try {
       const result = parseSync(filePath, sourceText, {
-        sourceType: "module",
+        sourceType: 'module',
         lang: getLang(ext),
       })
       program = result.program
@@ -129,7 +129,7 @@ export function lintFile(
   const allCallbacks: VisitorCallbacks[] = []
   for (const rule of rules) {
     const severity = config.rules[rule.meta.id]
-    if (severity === undefined || severity === "off") continue
+    if (severity === undefined || severity === 'off') continue
     const ctx = createRuleContext(rule, severity, diagnostics, lineIndex, sourceText, filePath)
     allCallbacks.push(rule.create(ctx))
   }

package/src/tests/lsp.test.ts

@@ -0,0 +1,88 @@
+import { getPreset } from '../config/presets'
+import { allRules } from '../rules/index'
+import { lintFile } from '../runner'
+
+describe('LSP diagnostic conversion', () => {
+  const config = getPreset('recommended')
+
+  it('converts lint diagnostics to LSP format', () => {
+    const source = `
+import { useContext } from '@pyreon/core'
+const { mode } = useContext(ThemeCtx)
+`
+    const result = lintFile('test.tsx', source, allRules, config)
+    const diag = result.diagnostics.find(
+      (d) => d.ruleId === 'pyreon/no-context-destructure',
+    )
+    expect(diag).toBeDefined()
+    expect(diag!.loc.line).toBeGreaterThan(0)
+    expect(diag!.loc.column).toBeGreaterThan(0)
+    expect(diag!.span.start).toBeLessThan(diag!.span.end)
+  })
+
+  it('LSP severity mapping — error=1, warn=2, info=3', () => {
+    const severityMap: Record<string, number> = {
+      error: 1,
+      warn: 2,
+      info: 3,
+    }
+    expect(severityMap.error).toBe(1)
+    expect(severityMap.warn).toBe(2)
+    expect(severityMap.info).toBe(3)
+  })
+
+  it('source diagnostics use 1-based lines (LSP layer converts to 0-based)', () => {
+    const source = `import { signal } from '@pyreon/reactivity'\nconst x = signal(0)\n{x}\n`
+    const result = lintFile('test.tsx', source, allRules, config)
+
+    for (const d of result.diagnostics) {
+      expect(d.loc.line).toBeGreaterThanOrEqual(1)
+      expect(d.loc.column).toBeGreaterThanOrEqual(1)
+    }
+  })
+
+  it('handles empty source without crashing', () => {
+    const result = lintFile('test.tsx', '', allRules, config)
+    expect(result.diagnostics).toEqual([])
+  })
+
+  it('handles non-JS file gracefully', () => {
+    const result = lintFile('test.css', 'body { color: red }', allRules, config)
+    expect(result.diagnostics).toEqual([])
+  })
+
+  it('handles syntax errors gracefully', () => {
+    const result = lintFile('test.tsx', 'const x = {{{', allRules, config)
+    // Should not throw — returns empty or partial diagnostics
+    expect(result.diagnostics).toBeDefined()
+  })
+
+  it('multiple diagnostics are sorted by position', () => {
+    const source = `
+import { useContext } from '@pyreon/core'
+const { a } = useContext(Ctx1)
+const { b } = useContext(Ctx2)
+`
+    const result = lintFile('test.tsx', source, allRules, config)
+    const ctxDiags = result.diagnostics.filter(
+      (d) => d.ruleId === 'pyreon/no-context-destructure',
+    )
+    expect(ctxDiags.length).toBe(2)
+    expect(ctxDiags[0]!.span.start).toBeLessThan(ctxDiags[1]!.span.start)
+  })
+
+  it('diagnostic span covers the destructured pattern', () => {
+    const source = `
+import { useContext } from '@pyreon/core'
+const { mode, theme } = useContext(ThemeCtx)
+`
+    const result = lintFile('test.tsx', source, allRules, config)
+    const diag = result.diagnostics.find(
+      (d) => d.ruleId === 'pyreon/no-context-destructure',
+    )
+    expect(diag).toBeDefined()
+    const spanned = source.slice(diag!.span.start, diag!.span.end)
+    expect(spanned).toContain('mode')
+    expect(spanned).toContain('theme')
+  })
+})