@ttsc/lint 0.14.0-dev.20260529.1 → 0.14.0

package/linthost/rules_unicorn_number_literal_case.go

@@ -15,55 +15,55 @@
 package linthost
 
 import (
-	"strings"
+  "strings"
 
-	shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
 type unicornNumberLiteralCase struct{}
 
 func (unicornNumberLiteralCase) Name() string { return "unicorn/number-literal-case" }
 func (unicornNumberLiteralCase) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindNumericLiteral, shimast.KindBigIntLiteral}
+  return []shimast.Kind{shimast.KindNumericLiteral, shimast.KindBigIntLiteral}
 }
 func (unicornNumberLiteralCase) Check(ctx *Context, node *shimast.Node) {
-	source := strings.TrimSpace(nodeText(ctx.File, node))
-	if len(source) < 2 || source[0] != '0' {
-		return
-	}
-	prefix := source[1]
-	switch prefix {
-	case 'x', 'X':
-		if unicornNumberLiteralCaseHexNeedsFix(source, prefix) {
-			ctx.Report(node, "Number literals should use a lowercase prefix and uppercase digits — e.g. `0xFF` instead of `0xff`.")
-		}
-	case 'b', 'B', 'o', 'O':
-		// Binary / octal digits are 0-1 / 0-7; only the prefix letter
-		// can be in the wrong case.
-		if prefix == 'B' || prefix == 'O' {
-			ctx.Report(node, "Number literals should use a lowercase prefix and uppercase digits — e.g. `0xFF` instead of `0xff`.")
-		}
-	}
+  source := strings.TrimSpace(nodeText(ctx.File, node))
+  if len(source) < 2 || source[0] != '0' {
+    return
+  }
+  prefix := source[1]
+  switch prefix {
+  case 'x', 'X':
+    if unicornNumberLiteralCaseHexNeedsFix(source, prefix) {
+      ctx.Report(node, "Number literals should use a lowercase prefix and uppercase digits — e.g. `0xFF` instead of `0xff`.")
+    }
+  case 'b', 'B', 'o', 'O':
+    // Binary / octal digits are 0-1 / 0-7; only the prefix letter
+    // can be in the wrong case.
+    if prefix == 'B' || prefix == 'O' {
+      ctx.Report(node, "Number literals should use a lowercase prefix and uppercase digits — e.g. `0xFF` instead of `0xff`.")
+    }
+  }
 }
 
 // unicornNumberLiteralCaseHexNeedsFix reports whether the hex literal's
 // raw source text deviates from `0x` + uppercase digits. The trailing
 // `n` of a hex bigint literal (`0xFFn`) is allowed.
 func unicornNumberLiteralCaseHexNeedsFix(source string, prefix byte) bool {
-	if prefix != 'x' {
-		return true
-	}
-	digits := source[2:]
-	digits = strings.TrimSuffix(digits, "n")
-	for i := 0; i < len(digits); i++ {
-		ch := digits[i]
-		if ch >= 'a' && ch <= 'f' {
-			return true
-		}
-	}
-	return false
+  if prefix != 'x' {
+    return true
+  }
+  digits := source[2:]
+  digits = strings.TrimSuffix(digits, "n")
+  for i := 0; i < len(digits); i++ {
+    ch := digits[i]
+    if ch >= 'a' && ch <= 'f' {
+      return true
+    }
+  }
+  return false
 }
 
 func init() {
-	Register(unicornNumberLiteralCase{})
+  Register(unicornNumberLiteralCase{})
 }

package/linthost/rules_unicorn_numeric_separators_style.go

@@ -20,56 +20,56 @@
 package linthost
 
 import (
-	"regexp"
-	"strings"
+  "regexp"
+  "strings"
 
-	shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
 var (
-	unicornNumericSeparatorsDecimal = regexp.MustCompile(`^[0-9]{1,3}(_[0-9]{3})*$`)
-	unicornNumericSeparatorsRadix4  = regexp.MustCompile(`^[0-9A-Fa-f]{1,4}(_[0-9A-Fa-f]{4})*$`)
+  unicornNumericSeparatorsDecimal = regexp.MustCompile(`^[0-9]{1,3}(_[0-9]{3})*$`)
+  unicornNumericSeparatorsRadix4  = regexp.MustCompile(`^[0-9A-Fa-f]{1,4}(_[0-9A-Fa-f]{4})*$`)
 )
 
 type unicornNumericSeparatorsStyle struct{}
 
 func (unicornNumericSeparatorsStyle) Name() string { return "unicorn/numeric-separators-style" }
 func (unicornNumericSeparatorsStyle) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindNumericLiteral, shimast.KindBigIntLiteral}
+  return []shimast.Kind{shimast.KindNumericLiteral, shimast.KindBigIntLiteral}
 }
 func (unicornNumericSeparatorsStyle) Check(ctx *Context, node *shimast.Node) {
-	source := strings.TrimSpace(nodeText(ctx.File, node))
-	if source == "" || !strings.Contains(source, "_") {
-		return
-	}
-	// Strip a trailing BigInt `n` so the digit-grouping regex doesn't see it.
-	source = strings.TrimSuffix(source, "n")
+  source := strings.TrimSpace(nodeText(ctx.File, node))
+  if source == "" || !strings.Contains(source, "_") {
+    return
+  }
+  // Strip a trailing BigInt `n` so the digit-grouping regex doesn't see it.
+  source = strings.TrimSuffix(source, "n")
 
-	// Pick the integer portion and the canonical grouping pattern based
-	// on prefix; floats fall through to the decimal rule applied to the
-	// leading integer digits before the `.` or `e`/`E`.
-	integer := source
-	pattern := unicornNumericSeparatorsDecimal
-	if len(source) >= 2 && source[0] == '0' {
-		switch source[1] {
-		case 'x', 'X', 'b', 'B', 'o', 'O':
-			integer = source[2:]
-			pattern = unicornNumericSeparatorsRadix4
-		}
-	}
-	if pattern == unicornNumericSeparatorsDecimal {
-		if dot := strings.IndexAny(integer, ".eE"); dot >= 0 {
-			integer = integer[:dot]
-		}
-	}
-	if !strings.Contains(integer, "_") {
-		return
-	}
-	if !pattern.MatchString(integer) {
-		ctx.Report(node, "Use canonical separator grouping for numeric literals (3 digits for decimal, 4 for hex).")
-	}
+  // Pick the integer portion and the canonical grouping pattern based
+  // on prefix; floats fall through to the decimal rule applied to the
+  // leading integer digits before the `.` or `e`/`E`.
+  integer := source
+  pattern := unicornNumericSeparatorsDecimal
+  if len(source) >= 2 && source[0] == '0' {
+    switch source[1] {
+    case 'x', 'X', 'b', 'B', 'o', 'O':
+      integer = source[2:]
+      pattern = unicornNumericSeparatorsRadix4
+    }
+  }
+  if pattern == unicornNumericSeparatorsDecimal {
+    if dot := strings.IndexAny(integer, ".eE"); dot >= 0 {
+      integer = integer[:dot]
+    }
+  }
+  if !strings.Contains(integer, "_") {
+    return
+  }
+  if !pattern.MatchString(integer) {
+    ctx.Report(node, "Use canonical separator grouping for numeric literals (3 digits for decimal, 4 for hex).")
+  }
 }
 
 func init() {
-	Register(unicornNumericSeparatorsStyle{})
+  Register(unicornNumericSeparatorsStyle{})
 }

package/linthost/rules_unicorn_prefer_add_event_listener.go

@@ -21,29 +21,29 @@ type unicornPreferAddEventListener struct{}
 
 func (unicornPreferAddEventListener) Name() string { return "unicorn/prefer-add-event-listener" }
 func (unicornPreferAddEventListener) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindBinaryExpression}
+  return []shimast.Kind{shimast.KindBinaryExpression}
 }
 func (unicornPreferAddEventListener) Check(ctx *Context, node *shimast.Node) {
-	bin := node.AsBinaryExpression()
-	if bin == nil || bin.OperatorToken == nil {
-		return
-	}
-	if bin.OperatorToken.Kind != shimast.KindEqualsToken {
-		return
-	}
-	lhs := stripParens(bin.Left)
-	if lhs == nil || lhs.Kind != shimast.KindPropertyAccessExpression {
-		return
-	}
-	access := lhs.AsPropertyAccessExpression()
-	if access == nil {
-		return
-	}
-	name := identifierText(access.Name())
-	if !isUnicornOnEventName(name) {
-		return
-	}
-	ctx.Report(node, "Prefer `addEventListener` / `removeEventListener` over assigning to `on*` properties.")
+  bin := node.AsBinaryExpression()
+  if bin == nil || bin.OperatorToken == nil {
+    return
+  }
+  if bin.OperatorToken.Kind != shimast.KindEqualsToken {
+    return
+  }
+  lhs := stripParens(bin.Left)
+  if lhs == nil || lhs.Kind != shimast.KindPropertyAccessExpression {
+    return
+  }
+  access := lhs.AsPropertyAccessExpression()
+  if access == nil {
+    return
+  }
+  name := identifierText(access.Name())
+  if !isUnicornOnEventName(name) {
+    return
+  }
+  ctx.Report(node, "Prefer `addEventListener` / `removeEventListener` over assigning to `on*` properties.")
 }
 
 // isUnicornOnEventName reports whether `name` is `on<lower>...` of at
@@ -51,16 +51,16 @@ func (unicornPreferAddEventListener) Check(ctx *Context, node *shimast.Node) {
 // matches on `onClick`, `onnxruntime`, and other names that begin with
 // `on` but are not DOM event handlers.
 func isUnicornOnEventName(name string) bool {
-	if len(name) < 3 {
-		return false
-	}
-	if name[0] != 'o' || name[1] != 'n' {
-		return false
-	}
-	c := name[2]
-	return c >= 'a' && c <= 'z'
+  if len(name) < 3 {
+    return false
+  }
+  if name[0] != 'o' || name[1] != 'n' {
+    return false
+  }
+  c := name[2]
+  return c >= 'a' && c <= 'z'
 }
 
 func init() {
-	Register(unicornPreferAddEventListener{})
+  Register(unicornPreferAddEventListener{})
 }

package/linthost/rules_unicorn_prefer_array_find.go

@@ -16,36 +16,36 @@ type unicornPreferArrayFind struct{}
 
 func (unicornPreferArrayFind) Name() string { return "unicorn/prefer-array-find" }
 func (unicornPreferArrayFind) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindElementAccessExpression}
+  return []shimast.Kind{shimast.KindElementAccessExpression}
 }
 func (unicornPreferArrayFind) Check(ctx *Context, node *shimast.Node) {
-	access := node.AsElementAccessExpression()
-	if access == nil || access.Expression == nil || access.ArgumentExpression == nil {
-		return
-	}
-	index := stripParens(access.ArgumentExpression)
-	if index == nil || index.Kind != shimast.KindNumericLiteral {
-		return
-	}
-	if numericLiteralText(index) != "0" {
-		return
-	}
-	receiver := stripParens(access.Expression)
-	if receiver == nil || receiver.Kind != shimast.KindCallExpression {
-		return
-	}
-	call := receiver.AsCallExpression()
-	if call == nil || call.Expression == nil ||
-		call.Expression.Kind != shimast.KindPropertyAccessExpression {
-		return
-	}
-	prop := call.Expression.AsPropertyAccessExpression()
-	if prop == nil || identifierText(prop.Name()) != "filter" {
-		return
-	}
-	ctx.Report(node, "Prefer `Array#find()` over `Array#filter(...)[0]`.")
+  access := node.AsElementAccessExpression()
+  if access == nil || access.Expression == nil || access.ArgumentExpression == nil {
+    return
+  }
+  index := stripParens(access.ArgumentExpression)
+  if index == nil || index.Kind != shimast.KindNumericLiteral {
+    return
+  }
+  if numericLiteralText(index) != "0" {
+    return
+  }
+  receiver := stripParens(access.Expression)
+  if receiver == nil || receiver.Kind != shimast.KindCallExpression {
+    return
+  }
+  call := receiver.AsCallExpression()
+  if call == nil || call.Expression == nil ||
+    call.Expression.Kind != shimast.KindPropertyAccessExpression {
+    return
+  }
+  prop := call.Expression.AsPropertyAccessExpression()
+  if prop == nil || identifierText(prop.Name()) != "filter" {
+    return
+  }
+  ctx.Report(node, "Prefer `Array#find()` over `Array#filter(...)[0]`.")
 }
 
 func init() {
-	Register(unicornPreferArrayFind{})
+  Register(unicornPreferArrayFind{})
 }

package/linthost/rules_unicorn_prefer_array_flat.go

@@ -19,34 +19,34 @@ type unicornPreferArrayFlat struct{}
 
 func (unicornPreferArrayFlat) Name() string { return "unicorn/prefer-array-flat" }
 func (unicornPreferArrayFlat) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindCallExpression}
+  return []shimast.Kind{shimast.KindCallExpression}
 }
 func (unicornPreferArrayFlat) Check(ctx *Context, node *shimast.Node) {
-	call := node.AsCallExpression()
-	if call == nil || call.Expression == nil || call.Expression.Kind != shimast.KindPropertyAccessExpression {
-		return
-	}
-	access := call.Expression.AsPropertyAccessExpression()
-	if access == nil {
-		return
-	}
-	if identifierText(access.Name()) != "concat" {
-		return
-	}
-	receiver := stripParens(access.Expression)
-	if receiver == nil || receiver.Kind != shimast.KindArrayLiteralExpression {
-		return
-	}
-	arr := receiver.AsArrayLiteralExpression()
-	if arr == nil || arr.Elements == nil || len(arr.Elements.Nodes) != 0 {
-		return
-	}
-	if call.Arguments == nil || len(call.Arguments.Nodes) == 0 {
-		return
-	}
-	ctx.Report(node, "Prefer `Array#flat()` over `[].concat(...arrays)`.")
+  call := node.AsCallExpression()
+  if call == nil || call.Expression == nil || call.Expression.Kind != shimast.KindPropertyAccessExpression {
+    return
+  }
+  access := call.Expression.AsPropertyAccessExpression()
+  if access == nil {
+    return
+  }
+  if identifierText(access.Name()) != "concat" {
+    return
+  }
+  receiver := stripParens(access.Expression)
+  if receiver == nil || receiver.Kind != shimast.KindArrayLiteralExpression {
+    return
+  }
+  arr := receiver.AsArrayLiteralExpression()
+  if arr == nil || arr.Elements == nil || len(arr.Elements.Nodes) != 0 {
+    return
+  }
+  if call.Arguments == nil || len(call.Arguments.Nodes) == 0 {
+    return
+  }
+  ctx.Report(node, "Prefer `Array#flat()` over `[].concat(...arrays)`.")
 }
 
 func init() {
-	Register(unicornPreferArrayFlat{})
+  Register(unicornPreferArrayFlat{})
 }

package/linthost/rules_unicorn_prefer_array_flat_map.go

@@ -18,46 +18,46 @@ type unicornPreferArrayFlatMap struct{}
 
 func (unicornPreferArrayFlatMap) Name() string { return "unicorn/prefer-array-flat-map" }
 func (unicornPreferArrayFlatMap) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindCallExpression}
+  return []shimast.Kind{shimast.KindCallExpression}
 }
 func (unicornPreferArrayFlatMap) Check(ctx *Context, node *shimast.Node) {
-	call := node.AsCallExpression()
-	if call == nil || call.Expression == nil ||
-		call.Expression.Kind != shimast.KindPropertyAccessExpression {
-		return
-	}
-	outerAccess := call.Expression.AsPropertyAccessExpression()
-	if outerAccess == nil || identifierText(outerAccess.Name()) != "flat" {
-		return
-	}
-	// `.flat(2)` and deeper are NOT equivalent to `.flatMap` — only the
-	// default depth (no arg) or explicit depth 1 collapse cleanly.
-	if call.Arguments != nil && len(call.Arguments.Nodes) > 0 {
-		if len(call.Arguments.Nodes) != 1 {
-			return
-		}
-		arg := stripParens(call.Arguments.Nodes[0])
-		if arg == nil || arg.Kind != shimast.KindNumericLiteral ||
-			numericLiteralText(arg) != "1" {
-			return
-		}
-	}
-	receiver := stripParens(outerAccess.Expression)
-	if receiver == nil || receiver.Kind != shimast.KindCallExpression {
-		return
-	}
-	innerCall := receiver.AsCallExpression()
-	if innerCall == nil || innerCall.Expression == nil ||
-		innerCall.Expression.Kind != shimast.KindPropertyAccessExpression {
-		return
-	}
-	innerAccess := innerCall.Expression.AsPropertyAccessExpression()
-	if innerAccess == nil || identifierText(innerAccess.Name()) != "map" {
-		return
-	}
-	ctx.Report(node, "Prefer `Array#flatMap` over `Array#map().flat()`.")
+  call := node.AsCallExpression()
+  if call == nil || call.Expression == nil ||
+    call.Expression.Kind != shimast.KindPropertyAccessExpression {
+    return
+  }
+  outerAccess := call.Expression.AsPropertyAccessExpression()
+  if outerAccess == nil || identifierText(outerAccess.Name()) != "flat" {
+    return
+  }
+  // `.flat(2)` and deeper are NOT equivalent to `.flatMap` — only the
+  // default depth (no arg) or explicit depth 1 collapse cleanly.
+  if call.Arguments != nil && len(call.Arguments.Nodes) > 0 {
+    if len(call.Arguments.Nodes) != 1 {
+      return
+    }
+    arg := stripParens(call.Arguments.Nodes[0])
+    if arg == nil || arg.Kind != shimast.KindNumericLiteral ||
+      numericLiteralText(arg) != "1" {
+      return
+    }
+  }
+  receiver := stripParens(outerAccess.Expression)
+  if receiver == nil || receiver.Kind != shimast.KindCallExpression {
+    return
+  }
+  innerCall := receiver.AsCallExpression()
+  if innerCall == nil || innerCall.Expression == nil ||
+    innerCall.Expression.Kind != shimast.KindPropertyAccessExpression {
+    return
+  }
+  innerAccess := innerCall.Expression.AsPropertyAccessExpression()
+  if innerAccess == nil || identifierText(innerAccess.Name()) != "map" {
+    return
+  }
+  ctx.Report(node, "Prefer `Array#flatMap` over `Array#map().flat()`.")
 }
 
 func init() {
-	Register(unicornPreferArrayFlatMap{})
+  Register(unicornPreferArrayFlatMap{})
 }