@ttsc/lint 0.14.0-dev.20260529.1 → 0.14.0

package/linthost/rules_max_classes_per_file.go

@@ -15,9 +15,9 @@
 package linthost
 
 import (
-	"fmt"
+  "fmt"
 
-	shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
 // maxClassesPerFileLimit is the class-count ceiling. Above this value
@@ -28,31 +28,31 @@ type maxClassesPerFile struct{}
 
 func (maxClassesPerFile) Name() string { return "max-classes-per-file" }
 func (maxClassesPerFile) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindSourceFile}
+  return []shimast.Kind{shimast.KindSourceFile}
 }
 func (maxClassesPerFile) Check(ctx *Context, node *shimast.Node) {
-	if node == nil {
-		return
-	}
-	var classes []*shimast.Node
-	walkDescendants(node, func(n *shimast.Node) {
-		if n == nil {
-			return
-		}
-		switch n.Kind {
-		case shimast.KindClassDeclaration, shimast.KindClassExpression:
-			classes = append(classes, n)
-		}
-	})
-	if len(classes) <= maxClassesPerFileLimit {
-		return
-	}
-	// Report at the first class that pushed the count over the limit,
-	// so the diagnostic anchors on the offending declaration rather
-	// than the file's opening byte.
-	ctx.Report(classes[maxClassesPerFileLimit], fmt.Sprintf("File has too many classes (%d). Maximum allowed is %d.", len(classes), maxClassesPerFileLimit))
+  if node == nil {
+    return
+  }
+  var classes []*shimast.Node
+  walkDescendants(node, func(n *shimast.Node) {
+    if n == nil {
+      return
+    }
+    switch n.Kind {
+    case shimast.KindClassDeclaration, shimast.KindClassExpression:
+      classes = append(classes, n)
+    }
+  })
+  if len(classes) <= maxClassesPerFileLimit {
+    return
+  }
+  // Report at the first class that pushed the count over the limit,
+  // so the diagnostic anchors on the offending declaration rather
+  // than the file's opening byte.
+  ctx.Report(classes[maxClassesPerFileLimit], fmt.Sprintf("File has too many classes (%d). Maximum allowed is %d.", len(classes), maxClassesPerFileLimit))
 }
 
 func init() {
-	Register(maxClassesPerFile{})
+  Register(maxClassesPerFile{})
 }

package/linthost/rules_max_depth.go

@@ -8,9 +8,9 @@
 package linthost
 
 import (
-	"fmt"
+  "fmt"
 
-	shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
 // maxDepthLimit is the block-nesting ceiling. Above this value the rule
@@ -22,22 +22,22 @@ type maxDepth struct{}
 
 func (maxDepth) Name() string { return "max-depth" }
 func (maxDepth) Visits() []shimast.Kind {
-	return []shimast.Kind{
-		shimast.KindFunctionDeclaration,
-		shimast.KindFunctionExpression,
-		shimast.KindArrowFunction,
-		shimast.KindMethodDeclaration,
-	}
+  return []shimast.Kind{
+    shimast.KindFunctionDeclaration,
+    shimast.KindFunctionExpression,
+    shimast.KindArrowFunction,
+    shimast.KindMethodDeclaration,
+  }
 }
 func (maxDepth) Check(ctx *Context, node *shimast.Node) {
-	if node == nil {
-		return
-	}
-	body := node.Body()
-	if body == nil || body.Kind != shimast.KindBlock {
-		return
-	}
-	walkMaxDepthBody(body, node, 0, ctx)
+  if node == nil {
+    return
+  }
+  body := node.Body()
+  if body == nil || body.Kind != shimast.KindBlock {
+    return
+  }
+  walkMaxDepthBody(body, node, 0, ctx)
 }
 
 // walkMaxDepthBody descends through `root` counting nested block-bearing
@@ -50,34 +50,34 @@ func (maxDepth) Check(ctx *Context, node *shimast.Node) {
 // recursive walk continues so independent over-limit branches each get
 // their own diagnostic.
 func walkMaxDepthBody(node *shimast.Node, fn *shimast.Node, depth int, ctx *Context) {
-	if node == nil {
-		return
-	}
-	if node != fn && isFunctionLikeKind(node) {
-		return
-	}
-	switch node.Kind {
-	case shimast.KindIfStatement,
-		shimast.KindForStatement,
-		shimast.KindForInStatement,
-		shimast.KindForOfStatement,
-		shimast.KindWhileStatement,
-		shimast.KindDoStatement,
-		shimast.KindSwitchStatement,
-		shimast.KindTryStatement,
-		shimast.KindCatchClause,
-		shimast.KindWithStatement:
-		depth++
-		if depth > maxDepthLimit {
-			ctx.Report(node, fmt.Sprintf("Blocks are nested too deeply (%d). Maximum allowed is %d.", depth, maxDepthLimit))
-		}
-	}
-	node.ForEachChild(func(child *shimast.Node) bool {
-		walkMaxDepthBody(child, fn, depth, ctx)
-		return false
-	})
+  if node == nil {
+    return
+  }
+  if node != fn && isFunctionLikeKind(node) {
+    return
+  }
+  switch node.Kind {
+  case shimast.KindIfStatement,
+    shimast.KindForStatement,
+    shimast.KindForInStatement,
+    shimast.KindForOfStatement,
+    shimast.KindWhileStatement,
+    shimast.KindDoStatement,
+    shimast.KindSwitchStatement,
+    shimast.KindTryStatement,
+    shimast.KindCatchClause,
+    shimast.KindWithStatement:
+    depth++
+    if depth > maxDepthLimit {
+      ctx.Report(node, fmt.Sprintf("Blocks are nested too deeply (%d). Maximum allowed is %d.", depth, maxDepthLimit))
+    }
+  }
+  node.ForEachChild(func(child *shimast.Node) bool {
+    walkMaxDepthBody(child, fn, depth, ctx)
+    return false
+  })
 }
 
 func init() {
-	Register(maxDepth{})
+  Register(maxDepth{})
 }

package/linthost/rules_max_lines.go

@@ -17,9 +17,9 @@
 package linthost
 
 import (
-	"fmt"
+  "fmt"
 
-	shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
 // maxLinesLimit is the line-count ceiling. Above this value the rule
@@ -30,72 +30,72 @@ type maxLines struct{}
 
 func (maxLines) Name() string { return "max-lines" }
 func (maxLines) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindSourceFile}
+  return []shimast.Kind{shimast.KindSourceFile}
 }
 func (maxLines) Check(ctx *Context, node *shimast.Node) {
-	if ctx.File == nil {
-		return
-	}
-	src := ctx.File.Text()
-	count := countSourceLines(src)
-	if count <= maxLinesLimit {
-		return
-	}
-	// Anchor at the start of line `max+1` — the first line that pushed
-	// the file past the limit. ESLint matches this anchor so editor
-	// squiggles land on the offending row.
-	pos := nthLineStart(src, maxLinesLimit)
-	if pos < 0 || pos >= len(src) {
-		pos = 0
-	}
-	end := pos + 1
-	if end > len(src) {
-		end = len(src)
-	}
-	if end <= pos {
-		end = pos + 1
-	}
-	ctx.ReportRange(pos, end, fmt.Sprintf("File has too many lines (%d). Maximum allowed is %d.", count, maxLinesLimit))
+  if ctx.File == nil {
+    return
+  }
+  src := ctx.File.Text()
+  count := countSourceLines(src)
+  if count <= maxLinesLimit {
+    return
+  }
+  // Anchor at the start of line `max+1` — the first line that pushed
+  // the file past the limit. ESLint matches this anchor so editor
+  // squiggles land on the offending row.
+  pos := nthLineStart(src, maxLinesLimit)
+  if pos < 0 || pos >= len(src) {
+    pos = 0
+  }
+  end := pos + 1
+  if end > len(src) {
+    end = len(src)
+  }
+  if end <= pos {
+    end = pos + 1
+  }
+  ctx.ReportRange(pos, end, fmt.Sprintf("File has too many lines (%d). Maximum allowed is %d.", count, maxLinesLimit))
 }
 
 // nthLineStart returns the byte offset where the (`n`+1)-th line
 // begins (0-indexed: passing 0 returns 0, passing 1 returns the byte
 // after the first `\n`). Returns -1 when the file has fewer lines.
 func nthLineStart(src string, n int) int {
-	if n <= 0 {
-		return 0
-	}
-	seen := 0
-	for i := 0; i < len(src); i++ {
-		if src[i] == '\n' {
-			seen++
-			if seen == n {
-				return i + 1
-			}
-		}
-	}
-	return -1
+  if n <= 0 {
+    return 0
+  }
+  seen := 0
+  for i := 0; i < len(src); i++ {
+    if src[i] == '\n' {
+      seen++
+      if seen == n {
+        return i + 1
+      }
+    }
+  }
+  return -1
 }
 
 // countSourceLines returns the number of lines in `src`. Every `\n`
 // terminates a line; a non-empty trailing fragment without a newline
 // counts as one additional line. An empty source has zero lines.
 func countSourceLines(src string) int {
-	if len(src) == 0 {
-		return 0
-	}
-	count := 0
-	for i := 0; i < len(src); i++ {
-		if src[i] == '\n' {
-			count++
-		}
-	}
-	if src[len(src)-1] != '\n' {
-		count++
-	}
-	return count
+  if len(src) == 0 {
+    return 0
+  }
+  count := 0
+  for i := 0; i < len(src); i++ {
+    if src[i] == '\n' {
+      count++
+    }
+  }
+  if src[len(src)-1] != '\n' {
+    count++
+  }
+  return count
 }
 
 func init() {
-	Register(maxLines{})
+  Register(maxLines{})
 }

package/linthost/rules_max_lines_per_function.go

@@ -9,10 +9,10 @@
 package linthost
 
 import (
-	"fmt"
+  "fmt"
 
-	shimast "github.com/microsoft/typescript-go/shim/ast"
-	shimscanner "github.com/microsoft/typescript-go/shim/scanner"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimscanner "github.com/microsoft/typescript-go/shim/scanner"
 )
 
 // maxLinesPerFunctionLimit is the line-span ceiling. Above this value
@@ -24,34 +24,34 @@ type maxLinesPerFunction struct{}
 
 func (maxLinesPerFunction) Name() string { return "max-lines-per-function" }
 func (maxLinesPerFunction) Visits() []shimast.Kind {
-	return []shimast.Kind{
-		shimast.KindFunctionDeclaration,
-		shimast.KindFunctionExpression,
-		shimast.KindArrowFunction,
-		shimast.KindMethodDeclaration,
-	}
+  return []shimast.Kind{
+    shimast.KindFunctionDeclaration,
+    shimast.KindFunctionExpression,
+    shimast.KindArrowFunction,
+    shimast.KindMethodDeclaration,
+  }
 }
 func (maxLinesPerFunction) Check(ctx *Context, node *shimast.Node) {
-	if node == nil || ctx == nil || ctx.File == nil {
-		return
-	}
-	body := node.Body()
-	if body == nil || body.Kind != shimast.KindBlock {
-		return
-	}
-	startPos := shimscanner.SkipTrivia(ctx.File.Text(), body.Pos())
-	endPos := body.End()
-	if endPos > startPos {
-		endPos--
-	}
-	startLine := shimscanner.GetECMALineOfPosition(ctx.File, startPos)
-	endLine := shimscanner.GetECMALineOfPosition(ctx.File, endPos)
-	lines := endLine - startLine + 1
-	if lines > maxLinesPerFunctionLimit {
-		ctx.Report(node, fmt.Sprintf("Function has too many lines (%d). Maximum allowed is %d.", lines, maxLinesPerFunctionLimit))
-	}
+  if node == nil || ctx == nil || ctx.File == nil {
+    return
+  }
+  body := node.Body()
+  if body == nil || body.Kind != shimast.KindBlock {
+    return
+  }
+  startPos := shimscanner.SkipTrivia(ctx.File.Text(), body.Pos())
+  endPos := body.End()
+  if endPos > startPos {
+    endPos--
+  }
+  startLine := shimscanner.GetECMALineOfPosition(ctx.File, startPos)
+  endLine := shimscanner.GetECMALineOfPosition(ctx.File, endPos)
+  lines := endLine - startLine + 1
+  if lines > maxLinesPerFunctionLimit {
+    ctx.Report(node, fmt.Sprintf("Function has too many lines (%d). Maximum allowed is %d.", lines, maxLinesPerFunctionLimit))
+  }
 }
 
 func init() {
-	Register(maxLinesPerFunction{})
+  Register(maxLinesPerFunction{})
 }

package/linthost/rules_max_nested_callbacks.go

@@ -15,9 +15,9 @@
 package linthost
 
 import (
-	"fmt"
+  "fmt"
 
-	shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
 // maxNestedCallbacksLimit is the callback-nesting ceiling. Above this
@@ -29,33 +29,33 @@ type maxNestedCallbacks struct{}
 
 func (maxNestedCallbacks) Name() string { return "max-nested-callbacks" }
 func (maxNestedCallbacks) Visits() []shimast.Kind {
-	return []shimast.Kind{
-		shimast.KindArrowFunction,
-		shimast.KindFunctionExpression,
-	}
+  return []shimast.Kind{
+    shimast.KindArrowFunction,
+    shimast.KindFunctionExpression,
+  }
 }
 func (maxNestedCallbacks) Check(ctx *Context, node *shimast.Node) {
-	if node == nil {
-		return
-	}
-	// Count this callback plus every callback ancestor up to the
-	// SourceFile. Only ArrowFunction and FunctionExpression
-	// contribute; FunctionDeclaration, methods, and accessors are
-	// transparent because ESLint never pushes or pops its callback
-	// stack on those node kinds.
-	depth := 1
-	for cur := node.Parent; cur != nil; cur = cur.Parent {
-		switch cur.Kind {
-		case shimast.KindArrowFunction, shimast.KindFunctionExpression:
-			depth++
-		}
-	}
-	if depth <= maxNestedCallbacksLimit {
-		return
-	}
-	ctx.Report(node, fmt.Sprintf("Too many nested callbacks (%d). Maximum allowed is %d.", depth, maxNestedCallbacksLimit))
+  if node == nil {
+    return
+  }
+  // Count this callback plus every callback ancestor up to the
+  // SourceFile. Only ArrowFunction and FunctionExpression
+  // contribute; FunctionDeclaration, methods, and accessors are
+  // transparent because ESLint never pushes or pops its callback
+  // stack on those node kinds.
+  depth := 1
+  for cur := node.Parent; cur != nil; cur = cur.Parent {
+    switch cur.Kind {
+    case shimast.KindArrowFunction, shimast.KindFunctionExpression:
+      depth++
+    }
+  }
+  if depth <= maxNestedCallbacksLimit {
+    return
+  }
+  ctx.Report(node, fmt.Sprintf("Too many nested callbacks (%d). Maximum allowed is %d.", depth, maxNestedCallbacksLimit))
 }
 
 func init() {
-	Register(maxNestedCallbacks{})
+  Register(maxNestedCallbacks{})
 }

package/linthost/rules_max_params.go

@@ -9,9 +9,9 @@
 package linthost
 
 import (
-	"fmt"
+  "fmt"
 
-	shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
 // maxParamsLimit is the parameter-count ceiling. Above this value the
@@ -23,27 +23,27 @@ type maxParams struct{}
 
 func (maxParams) Name() string { return "max-params" }
 func (maxParams) Visits() []shimast.Kind {
-	return []shimast.Kind{
-		shimast.KindFunctionDeclaration,
-		shimast.KindFunctionExpression,
-		shimast.KindArrowFunction,
-		shimast.KindMethodDeclaration,
-		shimast.KindGetAccessor,
-		shimast.KindSetAccessor,
-		shimast.KindConstructor,
-	}
+  return []shimast.Kind{
+    shimast.KindFunctionDeclaration,
+    shimast.KindFunctionExpression,
+    shimast.KindArrowFunction,
+    shimast.KindMethodDeclaration,
+    shimast.KindGetAccessor,
+    shimast.KindSetAccessor,
+    shimast.KindConstructor,
+  }
 }
 func (maxParams) Check(ctx *Context, node *shimast.Node) {
-	if node == nil {
-		return
-	}
-	params := node.Parameters()
-	if len(params) <= maxParamsLimit {
-		return
-	}
-	ctx.Report(node, fmt.Sprintf("Function has too many parameters (%d). Maximum allowed is %d.", len(params), maxParamsLimit))
+  if node == nil {
+    return
+  }
+  params := node.Parameters()
+  if len(params) <= maxParamsLimit {
+    return
+  }
+  ctx.Report(node, fmt.Sprintf("Function has too many parameters (%d). Maximum allowed is %d.", len(params), maxParamsLimit))
 }
 
 func init() {
-	Register(maxParams{})
+  Register(maxParams{})
 }

package/linthost/rules_max_statements.go

@@ -10,9 +10,9 @@
 package linthost
 
 import (
-	"fmt"
+  "fmt"
 
-	shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
 // maxStatementsLimit is the statement-count ceiling. Above this value
@@ -24,36 +24,36 @@ type maxStatements struct{}
 
 func (maxStatements) Name() string { return "max-statements" }
 func (maxStatements) Visits() []shimast.Kind {
-	return []shimast.Kind{
-		shimast.KindFunctionDeclaration,
-		shimast.KindFunctionExpression,
-		shimast.KindArrowFunction,
-		shimast.KindMethodDeclaration,
-	}
+  return []shimast.Kind{
+    shimast.KindFunctionDeclaration,
+    shimast.KindFunctionExpression,
+    shimast.KindArrowFunction,
+    shimast.KindMethodDeclaration,
+  }
 }
 func (maxStatements) Check(ctx *Context, node *shimast.Node) {
-	if node == nil {
-		return
-	}
-	body := node.Body()
-	if body == nil || body.Kind != shimast.KindBlock {
-		return
-	}
-	block := body.AsBlock()
-	if block == nil || block.Statements == nil {
-		return
-	}
-	count := 0
-	for _, stmt := range block.Statements.Nodes {
-		if stmt != nil {
-			count++
-		}
-	}
-	if count > maxStatementsLimit {
-		ctx.Report(node, fmt.Sprintf("Function has too many statements (%d). Maximum allowed is %d.", count, maxStatementsLimit))
-	}
+  if node == nil {
+    return
+  }
+  body := node.Body()
+  if body == nil || body.Kind != shimast.KindBlock {
+    return
+  }
+  block := body.AsBlock()
+  if block == nil || block.Statements == nil {
+    return
+  }
+  count := 0
+  for _, stmt := range block.Statements.Nodes {
+    if stmt != nil {
+      count++
+    }
+  }
+  if count > maxStatementsLimit {
+    ctx.Report(node, fmt.Sprintf("Function has too many statements (%d). Maximum allowed is %d.", count, maxStatementsLimit))
+  }
 }
 
 func init() {
-	Register(maxStatements{})
+  Register(maxStatements{})
 }

package/linthost/rules_nextjs.go

@@ -20,11 +20,11 @@ func (r nextjsRule) Visits() []shimast.Kind {
 func (r nextjsRule) Check(ctx *Context, node *shimast.Node) { r.check(ctx, node) }
 
 type nextjsImports struct {
-  headFromNextHead      map[string]bool
-  headFromNextDocument  map[string]bool
-  scriptFromNextScript  map[string]bool
-  importsNextDocument   []*shimast.Node
-  importsNextHead       []*shimast.Node
+  headFromNextHead     map[string]bool
+  headFromNextDocument map[string]bool
+  scriptFromNextScript map[string]bool
+  importsNextDocument  []*shimast.Node
+  importsNextHead      []*shimast.Node
 }
 
 func nextjsGoogleFontDisplay(ctx *Context, file *shimast.Node) {