@ttsc/lint 0.14.0-dev.20260529.2 → 0.14.1

package/linthost/rules_unicorn_prevent_abbreviations.go

@@ -23,9 +23,9 @@
 package linthost
 
 import (
-	"strings"
+  "strings"
 
-	shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
 // unicornPreventAbbreviationsDictionary is the MVP allowlist of
@@ -34,47 +34,47 @@ import (
 // — picks the abbreviations universally agreed across upstream
 // presets so the rule doesn't flap on neutral words.
 var unicornPreventAbbreviationsDictionary = map[string]struct{}{
-	"arr":    {},
-	"args":   {},
-	"attr":   {},
-	"btn":    {},
-	"cb":     {},
-	"cmd":    {},
-	"ctx":    {},
-	"db":     {},
-	"dest":   {},
-	"dir":    {},
-	"doc":    {},
-	"el":     {},
-	"elem":   {},
-	"env":    {},
-	"err":    {},
-	"evt":    {},
-	"fn":     {},
-	"func":   {},
-	"idx":    {},
-	"len":    {},
-	"lib":    {},
-	"mgr":    {},
-	"mod":    {},
-	"msg":    {},
-	"num":    {},
-	"obj":    {},
-	"opts":   {},
-	"param":  {},
-	"params": {},
-	"pkg":    {},
-	"prev":   {},
-	"prop":   {},
-	"props":  {},
-	"ref":    {},
-	"res":    {},
-	"ret":    {},
-	"src":    {},
-	"str":    {},
-	"tmp":    {},
-	"val":    {},
-	"var":    {},
+  "arr":    {},
+  "args":   {},
+  "attr":   {},
+  "btn":    {},
+  "cb":     {},
+  "cmd":    {},
+  "ctx":    {},
+  "db":     {},
+  "dest":   {},
+  "dir":    {},
+  "doc":    {},
+  "el":     {},
+  "elem":   {},
+  "env":    {},
+  "err":    {},
+  "evt":    {},
+  "fn":     {},
+  "func":   {},
+  "idx":    {},
+  "len":    {},
+  "lib":    {},
+  "mgr":    {},
+  "mod":    {},
+  "msg":    {},
+  "num":    {},
+  "obj":    {},
+  "opts":   {},
+  "param":  {},
+  "params": {},
+  "pkg":    {},
+  "prev":   {},
+  "prop":   {},
+  "props":  {},
+  "ref":    {},
+  "res":    {},
+  "ret":    {},
+  "src":    {},
+  "str":    {},
+  "tmp":    {},
+  "val":    {},
+  "var":    {},
 }
 
 // unicornPreventAbbreviationsMaxLen is the longest dictionary key
@@ -86,25 +86,25 @@ type unicornPreventAbbreviations struct{}
 
 func (unicornPreventAbbreviations) Name() string { return "unicorn/prevent-abbreviations" }
 func (unicornPreventAbbreviations) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindIdentifier}
+  return []shimast.Kind{shimast.KindIdentifier}
 }
 func (unicornPreventAbbreviations) Check(ctx *Context, node *shimast.Node) {
-	name := identifierText(node)
-	if name == "" || len(name) > unicornPreventAbbreviationsMaxLen {
-		return
-	}
-	// Fast path: dictionary keys are pre-lowercased, so an
-	// already-lower-case identifier avoids `strings.ToLower`'s
-	// allocation entirely. The Check is invoked once per identifier
-	// in the file, so the saved allocations multiply.
-	lookup := name
-	if !isAllLowerASCII(name) {
-		lookup = strings.ToLower(name)
-	}
-	if _, ok := unicornPreventAbbreviationsDictionary[lookup]; !ok {
-		return
-	}
-	ctx.Report(node, "Prefer the long form over abbreviated identifiers (e.g. `error` over `err`).")
+  name := identifierText(node)
+  if name == "" || len(name) > unicornPreventAbbreviationsMaxLen {
+    return
+  }
+  // Fast path: dictionary keys are pre-lowercased, so an
+  // already-lower-case identifier avoids `strings.ToLower`'s
+  // allocation entirely. The Check is invoked once per identifier
+  // in the file, so the saved allocations multiply.
+  lookup := name
+  if !isAllLowerASCII(name) {
+    lookup = strings.ToLower(name)
+  }
+  if _, ok := unicornPreventAbbreviationsDictionary[lookup]; !ok {
+    return
+  }
+  ctx.Report(node, "Prefer the long form over abbreviated identifiers (e.g. `error` over `err`).")
 }
 
 // isAllLowerASCII reports whether `s` is a non-empty ASCII string
@@ -113,15 +113,15 @@ func (unicornPreventAbbreviations) Check(ctx *Context, node *shimast.Node) {
 // equivalent to `s == strings.ToLower(s)` for all-ASCII inputs but
 // avoids the lowercase allocation.
 func isAllLowerASCII(s string) bool {
-	for i := 0; i < len(s); i++ {
-		c := s[i]
-		if c >= 'A' && c <= 'Z' {
-			return false
-		}
-	}
-	return true
+  for i := 0; i < len(s); i++ {
+    c := s[i]
+    if c >= 'A' && c <= 'Z' {
+      return false
+    }
+  }
+  return true
 }
 
 func init() {
-	Register(unicornPreventAbbreviations{})
+  Register(unicornPreventAbbreviations{})
 }

package/linthost/rules_unicorn_relative_url_style.go

@@ -15,35 +15,35 @@
 package linthost
 
 import (
-	"strings"
+  "strings"
 
-	shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
 type unicornRelativeURLStyle struct{}
 
 func (unicornRelativeURLStyle) Name() string { return "unicorn/relative-url-style" }
 func (unicornRelativeURLStyle) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindNewExpression}
+  return []shimast.Kind{shimast.KindNewExpression}
 }
 func (unicornRelativeURLStyle) Check(ctx *Context, node *shimast.Node) {
-	expr := node.AsNewExpression()
-	if expr == nil || identifierText(expr.Expression) != "URL" {
-		return
-	}
-	if expr.Arguments == nil || len(expr.Arguments.Nodes) == 0 {
-		return
-	}
-	arg := expr.Arguments.Nodes[0]
-	text := stringLiteralText(arg)
-	if text == "" {
-		return
-	}
-	if strings.HasPrefix(text, "./") {
-		ctx.Report(arg, "Drop the leading `./` from relative URLs passed to `new URL`.")
-	}
+  expr := node.AsNewExpression()
+  if expr == nil || identifierText(expr.Expression) != "URL" {
+    return
+  }
+  if expr.Arguments == nil || len(expr.Arguments.Nodes) == 0 {
+    return
+  }
+  arg := expr.Arguments.Nodes[0]
+  text := stringLiteralText(arg)
+  if text == "" {
+    return
+  }
+  if strings.HasPrefix(text, "./") {
+    ctx.Report(arg, "Drop the leading `./` from relative URLs passed to `new URL`.")
+  }
 }
 
 func init() {
-	Register(unicornRelativeURLStyle{})
+  Register(unicornRelativeURLStyle{})
 }

package/linthost/rules_unicorn_require_array_join_separator.go

@@ -17,29 +17,29 @@ import shimast "github.com/microsoft/typescript-go/shim/ast"
 type unicornRequireArrayJoinSeparator struct{}
 
 func (unicornRequireArrayJoinSeparator) Name() string {
-	return "unicorn/require-array-join-separator"
+  return "unicorn/require-array-join-separator"
 }
 func (unicornRequireArrayJoinSeparator) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindCallExpression}
+  return []shimast.Kind{shimast.KindCallExpression}
 }
 func (unicornRequireArrayJoinSeparator) 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()) != "join" {
-		return
-	}
-	if call.Arguments != nil && len(call.Arguments.Nodes) > 0 {
-		return
-	}
-	ctx.Report(node, "Pass an explicit separator argument to `Array#join()`.")
+  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()) != "join" {
+    return
+  }
+  if call.Arguments != nil && len(call.Arguments.Nodes) > 0 {
+    return
+  }
+  ctx.Report(node, "Pass an explicit separator argument to `Array#join()`.")
 }
 
 func init() {
-	Register(unicornRequireArrayJoinSeparator{})
+  Register(unicornRequireArrayJoinSeparator{})
 }

package/linthost/rules_unicorn_require_module_attributes.go

@@ -19,36 +19,36 @@ import shimast "github.com/microsoft/typescript-go/shim/ast"
 type unicornRequireModuleAttributes struct{}
 
 func (unicornRequireModuleAttributes) Name() string {
-	return "unicorn/require-module-attributes"
+  return "unicorn/require-module-attributes"
 }
 func (unicornRequireModuleAttributes) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindImportDeclaration, shimast.KindExportDeclaration}
+  return []shimast.Kind{shimast.KindImportDeclaration, shimast.KindExportDeclaration}
 }
 func (unicornRequireModuleAttributes) Check(ctx *Context, node *shimast.Node) {
-	var attrs *shimast.Node
-	switch node.Kind {
-	case shimast.KindImportDeclaration:
-		if decl := node.AsImportDeclaration(); decl != nil {
-			attrs = decl.Attributes
-		}
-	case shimast.KindExportDeclaration:
-		if decl := node.AsExportDeclaration(); decl != nil {
-			attrs = decl.Attributes
-		}
-	}
-	if attrs == nil {
-		return
-	}
-	imp := attrs.AsImportAttributes()
-	if imp == nil {
-		return
-	}
-	if imp.Attributes != nil && len(imp.Attributes.Nodes) > 0 {
-		return
-	}
-	ctx.Report(node, "Import/export `with {}` should have at least one attribute.")
+  var attrs *shimast.Node
+  switch node.Kind {
+  case shimast.KindImportDeclaration:
+    if decl := node.AsImportDeclaration(); decl != nil {
+      attrs = decl.Attributes
+    }
+  case shimast.KindExportDeclaration:
+    if decl := node.AsExportDeclaration(); decl != nil {
+      attrs = decl.Attributes
+    }
+  }
+  if attrs == nil {
+    return
+  }
+  imp := attrs.AsImportAttributes()
+  if imp == nil {
+    return
+  }
+  if imp.Attributes != nil && len(imp.Attributes.Nodes) > 0 {
+    return
+  }
+  ctx.Report(node, "Import/export `with {}` should have at least one attribute.")
 }
 
 func init() {
-	Register(unicornRequireModuleAttributes{})
+  Register(unicornRequireModuleAttributes{})
 }

package/linthost/rules_unicorn_require_module_specifiers.go

@@ -17,39 +17,39 @@ import shimast "github.com/microsoft/typescript-go/shim/ast"
 type unicornRequireModuleSpecifiers struct{}
 
 func (unicornRequireModuleSpecifiers) Name() string {
-	return "unicorn/require-module-specifiers"
+  return "unicorn/require-module-specifiers"
 }
 func (unicornRequireModuleSpecifiers) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindImportDeclaration, shimast.KindExportDeclaration}
+  return []shimast.Kind{shimast.KindImportDeclaration, shimast.KindExportDeclaration}
 }
 func (unicornRequireModuleSpecifiers) Check(ctx *Context, node *shimast.Node) {
-	switch node.Kind {
-	case shimast.KindImportDeclaration:
-		decl := node.AsImportDeclaration()
-		if decl == nil {
-			return
-		}
-		// `import "x"` parses with a nil ImportClause; any binding shape
-		// (`import x`, `import {a}`, `import * as ns`) installs a clause.
-		if decl.ImportClause == nil {
-			ctx.Report(node, "Empty import/export specifier list is not allowed.")
-		}
-	case shimast.KindExportDeclaration:
-		decl := node.AsExportDeclaration()
-		if decl == nil || decl.ExportClause == nil {
-			return
-		}
-		if decl.ExportClause.Kind != shimast.KindNamedExports {
-			return
-		}
-		named := decl.ExportClause.AsNamedExports()
-		if named == nil || named.Elements == nil || len(named.Elements.Nodes) > 0 {
-			return
-		}
-		ctx.Report(node, "Empty import/export specifier list is not allowed.")
-	}
+  switch node.Kind {
+  case shimast.KindImportDeclaration:
+    decl := node.AsImportDeclaration()
+    if decl == nil {
+      return
+    }
+    // `import "x"` parses with a nil ImportClause; any binding shape
+    // (`import x`, `import {a}`, `import * as ns`) installs a clause.
+    if decl.ImportClause == nil {
+      ctx.Report(node, "Empty import/export specifier list is not allowed.")
+    }
+  case shimast.KindExportDeclaration:
+    decl := node.AsExportDeclaration()
+    if decl == nil || decl.ExportClause == nil {
+      return
+    }
+    if decl.ExportClause.Kind != shimast.KindNamedExports {
+      return
+    }
+    named := decl.ExportClause.AsNamedExports()
+    if named == nil || named.Elements == nil || len(named.Elements.Nodes) > 0 {
+      return
+    }
+    ctx.Report(node, "Empty import/export specifier list is not allowed.")
+  }
 }
 
 func init() {
-	Register(unicornRequireModuleSpecifiers{})
+  Register(unicornRequireModuleSpecifiers{})
 }

package/linthost/rules_unicorn_require_number_to_fixed_digits_argument.go

@@ -15,29 +15,29 @@ import shimast "github.com/microsoft/typescript-go/shim/ast"
 type unicornRequireNumberToFixedDigitsArgument struct{}
 
 func (unicornRequireNumberToFixedDigitsArgument) Name() string {
-	return "unicorn/require-number-to-fixed-digits-argument"
+  return "unicorn/require-number-to-fixed-digits-argument"
 }
 func (unicornRequireNumberToFixedDigitsArgument) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindCallExpression}
+  return []shimast.Kind{shimast.KindCallExpression}
 }
 func (unicornRequireNumberToFixedDigitsArgument) 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()) != "toFixed" {
-		return
-	}
-	if call.Arguments != nil && len(call.Arguments.Nodes) > 0 {
-		return
-	}
-	ctx.Report(node, "Pass an explicit digits argument to `Number#toFixed()`.")
+  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()) != "toFixed" {
+    return
+  }
+  if call.Arguments != nil && len(call.Arguments.Nodes) > 0 {
+    return
+  }
+  ctx.Report(node, "Pass an explicit digits argument to `Number#toFixed()`.")
 }
 
 func init() {
-	Register(unicornRequireNumberToFixedDigitsArgument{})
+  Register(unicornRequireNumberToFixedDigitsArgument{})
 }

package/linthost/rules_unicorn_require_post_message_target_origin.go

@@ -16,29 +16,29 @@ import shimast "github.com/microsoft/typescript-go/shim/ast"
 type unicornRequirePostMessageTargetOrigin struct{}
 
 func (unicornRequirePostMessageTargetOrigin) Name() string {
-	return "unicorn/require-post-message-target-origin"
+  return "unicorn/require-post-message-target-origin"
 }
 func (unicornRequirePostMessageTargetOrigin) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindCallExpression}
+  return []shimast.Kind{shimast.KindCallExpression}
 }
 func (unicornRequirePostMessageTargetOrigin) 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()) != "postMessage" {
-		return
-	}
-	if call.Arguments == nil || len(call.Arguments.Nodes) != 1 {
-		return
-	}
-	ctx.Report(node, "Pass an explicit `targetOrigin` argument to `postMessage`.")
+  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()) != "postMessage" {
+    return
+  }
+  if call.Arguments == nil || len(call.Arguments.Nodes) != 1 {
+    return
+  }
+  ctx.Report(node, "Pass an explicit `targetOrigin` argument to `postMessage`.")
 }
 
 func init() {
-	Register(unicornRequirePostMessageTargetOrigin{})
+  Register(unicornRequirePostMessageTargetOrigin{})
 }

package/linthost/rules_unicorn_string_content.go

@@ -23,5 +23,5 @@ func (unicornStringContent) Check(_ *Context, _ *shimast.Node) {
 }
 
 func init() {
-	Register(unicornStringContent{})
+  Register(unicornStringContent{})
 }

package/linthost/rules_unicorn_switch_case_braces.go

@@ -18,25 +18,25 @@ type unicornSwitchCaseBraces struct{}
 
 func (unicornSwitchCaseBraces) Name() string { return "unicorn/switch-case-braces" }
 func (unicornSwitchCaseBraces) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindCaseClause, shimast.KindDefaultClause}
+  return []shimast.Kind{shimast.KindCaseClause, shimast.KindDefaultClause}
 }
 func (unicornSwitchCaseBraces) Check(ctx *Context, node *shimast.Node) {
-	clause := node.AsCaseOrDefaultClause()
-	if clause == nil || clause.Statements == nil {
-		return
-	}
-	stmts := clause.Statements.Nodes
-	if len(stmts) == 0 {
-		// Empty fall-through (`case "a":` followed immediately by another
-		// clause) is not the "missing braces" shape the rule targets.
-		return
-	}
-	if len(stmts) == 1 && stmts[0] != nil && stmts[0].Kind == shimast.KindBlock {
-		return
-	}
-	ctx.Report(node, "Wrap `case` clause body in a block (`case x: { ... }`).")
+  clause := node.AsCaseOrDefaultClause()
+  if clause == nil || clause.Statements == nil {
+    return
+  }
+  stmts := clause.Statements.Nodes
+  if len(stmts) == 0 {
+    // Empty fall-through (`case "a":` followed immediately by another
+    // clause) is not the "missing braces" shape the rule targets.
+    return
+  }
+  if len(stmts) == 1 && stmts[0] != nil && stmts[0].Kind == shimast.KindBlock {
+    return
+  }
+  ctx.Report(node, "Wrap `case` clause body in a block (`case x: { ... }`).")
 }
 
 func init() {
-	Register(unicornSwitchCaseBraces{})
+  Register(unicornSwitchCaseBraces{})
 }

package/linthost/rules_unicorn_switch_case_break_position.go

@@ -19,13 +19,13 @@ import shimast "github.com/microsoft/typescript-go/shim/ast"
 type unicornSwitchCaseBreakPosition struct{}
 
 func (unicornSwitchCaseBreakPosition) Name() string {
-	return "unicorn/switch-case-break-position"
+  return "unicorn/switch-case-break-position"
 }
 func (unicornSwitchCaseBreakPosition) Visits() []shimast.Kind { return nil }
 func (unicornSwitchCaseBreakPosition) Check(*Context, *shimast.Node) {
-	// Intentionally empty; see file-level comment.
+  // Intentionally empty; see file-level comment.
 }
 
 func init() {
-	Register(unicornSwitchCaseBreakPosition{})
+  Register(unicornSwitchCaseBreakPosition{})
 }

package/linthost/rules_unicorn_template_indent.go

@@ -24,5 +24,5 @@ func (unicornTemplateIndent) Check(_ *Context, _ *shimast.Node) {
 }
 
 func init() {
-	Register(unicornTemplateIndent{})
+  Register(unicornTemplateIndent{})
 }