@ttsc/lint 0.14.0-dev.20260529.2 → 0.14.1

package/linthost/rules_unicorn_prefer_default_parameters.go

@@ -22,63 +22,63 @@ import shimast "github.com/microsoft/typescript-go/shim/ast"
 type unicornPreferDefaultParameters struct{}
 
 func (unicornPreferDefaultParameters) Name() string {
-	return "unicorn/prefer-default-parameters"
+  return "unicorn/prefer-default-parameters"
 }
 func (unicornPreferDefaultParameters) Visits() []shimast.Kind {
-	return []shimast.Kind{
-		shimast.KindFunctionDeclaration,
-		shimast.KindArrowFunction,
-		shimast.KindFunctionExpression,
-		shimast.KindMethodDeclaration,
-	}
+  return []shimast.Kind{
+    shimast.KindFunctionDeclaration,
+    shimast.KindArrowFunction,
+    shimast.KindFunctionExpression,
+    shimast.KindMethodDeclaration,
+  }
 }
 func (unicornPreferDefaultParameters) Check(ctx *Context, node *shimast.Node) {
-	body := defaultParameterFunctionBody(node)
-	if body == nil {
-		return
-	}
-	if body.Statements == nil || len(body.Statements.Nodes) == 0 {
-		return
-	}
-	first := body.Statements.Nodes[0]
-	if first == nil || first.Kind != shimast.KindExpressionStatement {
-		return
-	}
-	exprStmt := first.AsExpressionStatement()
-	if exprStmt == nil || exprStmt.Expression == nil {
-		return
-	}
-	expr := stripParens(exprStmt.Expression)
-	if expr == nil || expr.Kind != shimast.KindBinaryExpression {
-		return
-	}
-	assign := expr.AsBinaryExpression()
-	if assign == nil || assign.OperatorToken == nil || assign.OperatorToken.Kind != shimast.KindEqualsToken {
-		return
-	}
-	target := identifierText(stripParens(assign.Left))
-	if target == "" {
-		return
-	}
-	if !functionHasParameterNamed(node, target) {
-		return
-	}
-	rhs := stripParens(assign.Right)
-	if rhs == nil || rhs.Kind != shimast.KindBinaryExpression {
-		return
-	}
-	coalesce := rhs.AsBinaryExpression()
-	if coalesce == nil || coalesce.OperatorToken == nil ||
-		coalesce.OperatorToken.Kind != shimast.KindQuestionQuestionToken {
-		return
-	}
-	if identifierText(stripParens(coalesce.Left)) != target {
-		return
-	}
-	if !isLiteralExpression(stripParens(coalesce.Right)) {
-		return
-	}
-	ctx.Report(expr, "Prefer default parameters over `param = param ?? default` reassignments.")
+  body := defaultParameterFunctionBody(node)
+  if body == nil {
+    return
+  }
+  if body.Statements == nil || len(body.Statements.Nodes) == 0 {
+    return
+  }
+  first := body.Statements.Nodes[0]
+  if first == nil || first.Kind != shimast.KindExpressionStatement {
+    return
+  }
+  exprStmt := first.AsExpressionStatement()
+  if exprStmt == nil || exprStmt.Expression == nil {
+    return
+  }
+  expr := stripParens(exprStmt.Expression)
+  if expr == nil || expr.Kind != shimast.KindBinaryExpression {
+    return
+  }
+  assign := expr.AsBinaryExpression()
+  if assign == nil || assign.OperatorToken == nil || assign.OperatorToken.Kind != shimast.KindEqualsToken {
+    return
+  }
+  target := identifierText(stripParens(assign.Left))
+  if target == "" {
+    return
+  }
+  if !functionHasParameterNamed(node, target) {
+    return
+  }
+  rhs := stripParens(assign.Right)
+  if rhs == nil || rhs.Kind != shimast.KindBinaryExpression {
+    return
+  }
+  coalesce := rhs.AsBinaryExpression()
+  if coalesce == nil || coalesce.OperatorToken == nil ||
+    coalesce.OperatorToken.Kind != shimast.KindQuestionQuestionToken {
+    return
+  }
+  if identifierText(stripParens(coalesce.Left)) != target {
+    return
+  }
+  if !isLiteralExpression(stripParens(coalesce.Right)) {
+    return
+  }
+  ctx.Report(expr, "Prefer default parameters over `param = param ?? default` reassignments.")
 }
 
 // defaultParameterFunctionBody returns the BlockStatement body of a
@@ -87,32 +87,32 @@ func (unicornPreferDefaultParameters) Check(ctx *Context, node *shimast.Node) {
 // rule only fires on statement-level reassignments, so a body-less
 // shape is a non-match by definition.
 func defaultParameterFunctionBody(node *shimast.Node) *shimast.Block {
-	if node == nil {
-		return nil
-	}
-	var body *shimast.Node
-	switch node.Kind {
-	case shimast.KindFunctionDeclaration:
-		if fn := node.AsFunctionDeclaration(); fn != nil {
-			body = fn.Body
-		}
-	case shimast.KindFunctionExpression:
-		if fn := node.AsFunctionExpression(); fn != nil {
-			body = fn.Body
-		}
-	case shimast.KindArrowFunction:
-		if fn := node.AsArrowFunction(); fn != nil {
-			body = fn.Body
-		}
-	case shimast.KindMethodDeclaration:
-		if fn := node.AsMethodDeclaration(); fn != nil {
-			body = fn.Body
-		}
-	}
-	if body == nil || body.Kind != shimast.KindBlock {
-		return nil
-	}
-	return body.AsBlock()
+  if node == nil {
+    return nil
+  }
+  var body *shimast.Node
+  switch node.Kind {
+  case shimast.KindFunctionDeclaration:
+    if fn := node.AsFunctionDeclaration(); fn != nil {
+      body = fn.Body
+    }
+  case shimast.KindFunctionExpression:
+    if fn := node.AsFunctionExpression(); fn != nil {
+      body = fn.Body
+    }
+  case shimast.KindArrowFunction:
+    if fn := node.AsArrowFunction(); fn != nil {
+      body = fn.Body
+    }
+  case shimast.KindMethodDeclaration:
+    if fn := node.AsMethodDeclaration(); fn != nil {
+      body = fn.Body
+    }
+  }
+  if body == nil || body.Kind != shimast.KindBlock {
+    return nil
+  }
+  return body.AsBlock()
 }
 
 // functionHasParameterNamed reports whether any parameter of the
@@ -121,24 +121,24 @@ func defaultParameterFunctionBody(node *shimast.Node) *shimast.Block {
 // cannot prove which inner binding a top-of-body reassignment refers to
 // without semantic analysis.
 func functionHasParameterNamed(node *shimast.Node, name string) bool {
-	if node == nil || name == "" {
-		return false
-	}
-	for _, p := range node.Parameters() {
-		if p == nil {
-			continue
-		}
-		decl := p.AsParameterDeclaration()
-		if decl == nil {
-			continue
-		}
-		if identifierText(decl.Name()) == name {
-			return true
-		}
-	}
-	return false
+  if node == nil || name == "" {
+    return false
+  }
+  for _, p := range node.Parameters() {
+    if p == nil {
+      continue
+    }
+    decl := p.AsParameterDeclaration()
+    if decl == nil {
+      continue
+    }
+    if identifierText(decl.Name()) == name {
+      return true
+    }
+  }
+  return false
 }
 
 func init() {
-	Register(unicornPreferDefaultParameters{})
+  Register(unicornPreferDefaultParameters{})
 }

package/linthost/rules_unicorn_prefer_dom_node_append.go

@@ -18,23 +18,23 @@ type unicornPreferDomNodeAppend struct{}
 
 func (unicornPreferDomNodeAppend) Name() string { return "unicorn/prefer-dom-node-append" }
 func (unicornPreferDomNodeAppend) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindCallExpression}
+  return []shimast.Kind{shimast.KindCallExpression}
 }
 func (unicornPreferDomNodeAppend) 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()) != "appendChild" {
-		return
-	}
-	ctx.Report(node, "Prefer `Node#append()` over `Node#appendChild()`.")
+  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()) != "appendChild" {
+    return
+  }
+  ctx.Report(node, "Prefer `Node#append()` over `Node#appendChild()`.")
 }
 
 func init() {
-	Register(unicornPreferDomNodeAppend{})
+  Register(unicornPreferDomNodeAppend{})
 }

package/linthost/rules_unicorn_prefer_dom_node_dataset.go

@@ -13,43 +13,43 @@
 package linthost
 
 import (
-	"strings"
+  "strings"
 
-	shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
 type unicornPreferDomNodeDataset struct{}
 
 func (unicornPreferDomNodeDataset) Name() string { return "unicorn/prefer-dom-node-dataset" }
 func (unicornPreferDomNodeDataset) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindCallExpression}
+  return []shimast.Kind{shimast.KindCallExpression}
 }
 func (unicornPreferDomNodeDataset) 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
-	}
-	method := identifierText(access.Name())
-	if method != "getAttribute" && method != "setAttribute" {
-		return
-	}
-	if call.Arguments == nil || len(call.Arguments.Nodes) == 0 {
-		return
-	}
-	first := call.Arguments.Nodes[0]
-	if first == nil || first.Kind != shimast.KindStringLiteral {
-		return
-	}
-	if !strings.HasPrefix(stringLiteralText(first), "data-") {
-		return
-	}
-	ctx.Report(node, "Prefer `.dataset` over `getAttribute` / `setAttribute` for `data-*` attributes.")
+  call := node.AsCallExpression()
+  if call == nil || call.Expression == nil || call.Expression.Kind != shimast.KindPropertyAccessExpression {
+    return
+  }
+  access := call.Expression.AsPropertyAccessExpression()
+  if access == nil {
+    return
+  }
+  method := identifierText(access.Name())
+  if method != "getAttribute" && method != "setAttribute" {
+    return
+  }
+  if call.Arguments == nil || len(call.Arguments.Nodes) == 0 {
+    return
+  }
+  first := call.Arguments.Nodes[0]
+  if first == nil || first.Kind != shimast.KindStringLiteral {
+    return
+  }
+  if !strings.HasPrefix(stringLiteralText(first), "data-") {
+    return
+  }
+  ctx.Report(node, "Prefer `.dataset` over `getAttribute` / `setAttribute` for `data-*` attributes.")
 }
 
 func init() {
-	Register(unicornPreferDomNodeDataset{})
+  Register(unicornPreferDomNodeDataset{})
 }

package/linthost/rules_unicorn_prefer_dom_node_remove.go

@@ -16,26 +16,26 @@ type unicornPreferDomNodeRemove struct{}
 
 func (unicornPreferDomNodeRemove) Name() string { return "unicorn/prefer-dom-node-remove" }
 func (unicornPreferDomNodeRemove) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindCallExpression}
+  return []shimast.Kind{shimast.KindCallExpression}
 }
 func (unicornPreferDomNodeRemove) 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()) != "removeChild" {
-		return
-	}
-	if call.Arguments == nil || len(call.Arguments.Nodes) != 1 {
-		return
-	}
-	ctx.Report(node, "Prefer `ChildNode#remove()` over `parentNode.removeChild(child)`.")
+  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()) != "removeChild" {
+    return
+  }
+  if call.Arguments == nil || len(call.Arguments.Nodes) != 1 {
+    return
+  }
+  ctx.Report(node, "Prefer `ChildNode#remove()` over `parentNode.removeChild(child)`.")
 }
 
 func init() {
-	Register(unicornPreferDomNodeRemove{})
+  Register(unicornPreferDomNodeRemove{})
 }

package/linthost/rules_unicorn_prefer_dom_node_text_content.go

@@ -16,22 +16,22 @@ import shimast "github.com/microsoft/typescript-go/shim/ast"
 type unicornPreferDomNodeTextContent struct{}
 
 func (unicornPreferDomNodeTextContent) Name() string {
-	return "unicorn/prefer-dom-node-text-content"
+  return "unicorn/prefer-dom-node-text-content"
 }
 func (unicornPreferDomNodeTextContent) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindPropertyAccessExpression}
+  return []shimast.Kind{shimast.KindPropertyAccessExpression}
 }
 func (unicornPreferDomNodeTextContent) Check(ctx *Context, node *shimast.Node) {
-	access := node.AsPropertyAccessExpression()
-	if access == nil {
-		return
-	}
-	if identifierText(access.Name()) != "innerText" {
-		return
-	}
-	ctx.Report(node, "Prefer `Node#textContent` over `HTMLElement#innerText`.")
+  access := node.AsPropertyAccessExpression()
+  if access == nil {
+    return
+  }
+  if identifierText(access.Name()) != "innerText" {
+    return
+  }
+  ctx.Report(node, "Prefer `Node#textContent` over `HTMLElement#innerText`.")
 }
 
 func init() {
-	Register(unicornPreferDomNodeTextContent{})
+  Register(unicornPreferDomNodeTextContent{})
 }

package/linthost/rules_unicorn_prefer_event_target.go

@@ -18,19 +18,19 @@ type unicornPreferEventTarget struct{}
 
 func (unicornPreferEventTarget) Name() string { return "unicorn/prefer-event-target" }
 func (unicornPreferEventTarget) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindNewExpression}
+  return []shimast.Kind{shimast.KindNewExpression}
 }
 func (unicornPreferEventTarget) Check(ctx *Context, node *shimast.Node) {
-	ne := node.AsNewExpression()
-	if ne == nil || ne.Expression == nil {
-		return
-	}
-	if identifierText(ne.Expression) != "EventEmitter" {
-		return
-	}
-	ctx.Report(node, "Prefer `EventTarget` over `EventEmitter` when sharing code between Node and the browser.")
+  ne := node.AsNewExpression()
+  if ne == nil || ne.Expression == nil {
+    return
+  }
+  if identifierText(ne.Expression) != "EventEmitter" {
+    return
+  }
+  ctx.Report(node, "Prefer `EventTarget` over `EventEmitter` when sharing code between Node and the browser.")
 }
 
 func init() {
-	Register(unicornPreferEventTarget{})
+  Register(unicornPreferEventTarget{})
 }

package/linthost/rules_unicorn_prefer_export_from.go

@@ -22,108 +22,108 @@ type unicornPreferExportFrom struct{}
 
 func (unicornPreferExportFrom) Name() string { return "unicorn/prefer-export-from" }
 func (unicornPreferExportFrom) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindSourceFile}
+  return []shimast.Kind{shimast.KindSourceFile}
 }
 func (unicornPreferExportFrom) Check(ctx *Context, node *shimast.Node) {
-	statements := node.Statements()
-	if len(statements) == 0 {
-		return
-	}
-	// Map of locally-imported simple binding name → true. Built on a
-	// first pass so a re-export earlier in the file does not accidentally
-	// match an import declared later; the upstream rule is anchored on
-	// "imported above, re-exported below" ordering.
-	imported := map[string]bool{}
-	for _, stmt := range statements {
-		if stmt == nil || stmt.Kind != shimast.KindImportDeclaration {
-			continue
-		}
-		decl := stmt.AsImportDeclaration()
-		if decl == nil || decl.ImportClause == nil {
-			continue
-		}
-		clause := decl.ImportClause.AsImportClause()
-		if clause == nil || clause.NamedBindings == nil ||
-			clause.NamedBindings.Kind != shimast.KindNamedImports {
-			continue
-		}
-		// A default-bound or namespace-mixed import is out of scope: the
-		// MVP only rewrites pure `import { X } from "Y"` pairs.
-		if clause.Name() != nil {
-			continue
-		}
-		named := clause.NamedBindings.AsNamedImports()
-		if named == nil || named.Elements == nil {
-			continue
-		}
-		for _, spec := range named.Elements.Nodes {
-			s := spec.AsImportSpecifier()
-			if s == nil {
-				continue
-			}
-			// PropertyName is set only when the specifier is renamed
-			// (`import { a as b }`); skip those — `export { b }` would
-			// require `export { b as b } from "Y"` which is itself a
-			// useless rename.
-			if s.PropertyName != nil {
-				continue
-			}
-			name := identifierText(s.Name())
-			if name == "" {
-				continue
-			}
-			imported[name] = true
-		}
-	}
-	if len(imported) == 0 {
-		return
-	}
-	for _, stmt := range statements {
-		if stmt == nil || stmt.Kind != shimast.KindExportDeclaration {
-			continue
-		}
-		decl := stmt.AsExportDeclaration()
-		if decl == nil || decl.ExportClause == nil {
-			continue
-		}
-		// Skip `export { X } from "Y"` — already in the target shape.
-		if decl.ModuleSpecifier != nil {
-			continue
-		}
-		if decl.ExportClause.Kind != shimast.KindNamedExports {
-			continue
-		}
-		named := decl.ExportClause.AsNamedExports()
-		if named == nil || named.Elements == nil || len(named.Elements.Nodes) == 0 {
-			continue
-		}
-		matched := false
-		for _, el := range named.Elements.Nodes {
-			spec := el.AsExportSpecifier()
-			if spec == nil {
-				continue
-			}
-			// PropertyName != nil means `export { a as b }` — a rename
-			// the from-clause rewrite cannot preserve without also
-			// touching the import side. Skip.
-			if spec.PropertyName != nil {
-				continue
-			}
-			name := identifierText(spec.Name())
-			if name == "" {
-				continue
-			}
-			if imported[name] {
-				matched = true
-				break
-			}
-		}
-		if matched {
-			ctx.Report(stmt, "Use `export { X } from \"Y\"` instead of importing then re-exporting.")
-		}
-	}
+  statements := node.Statements()
+  if len(statements) == 0 {
+    return
+  }
+  // Map of locally-imported simple binding name → true. Built on a
+  // first pass so a re-export earlier in the file does not accidentally
+  // match an import declared later; the upstream rule is anchored on
+  // "imported above, re-exported below" ordering.
+  imported := map[string]bool{}
+  for _, stmt := range statements {
+    if stmt == nil || stmt.Kind != shimast.KindImportDeclaration {
+      continue
+    }
+    decl := stmt.AsImportDeclaration()
+    if decl == nil || decl.ImportClause == nil {
+      continue
+    }
+    clause := decl.ImportClause.AsImportClause()
+    if clause == nil || clause.NamedBindings == nil ||
+      clause.NamedBindings.Kind != shimast.KindNamedImports {
+      continue
+    }
+    // A default-bound or namespace-mixed import is out of scope: the
+    // MVP only rewrites pure `import { X } from "Y"` pairs.
+    if clause.Name() != nil {
+      continue
+    }
+    named := clause.NamedBindings.AsNamedImports()
+    if named == nil || named.Elements == nil {
+      continue
+    }
+    for _, spec := range named.Elements.Nodes {
+      s := spec.AsImportSpecifier()
+      if s == nil {
+        continue
+      }
+      // PropertyName is set only when the specifier is renamed
+      // (`import { a as b }`); skip those — `export { b }` would
+      // require `export { b as b } from "Y"` which is itself a
+      // useless rename.
+      if s.PropertyName != nil {
+        continue
+      }
+      name := identifierText(s.Name())
+      if name == "" {
+        continue
+      }
+      imported[name] = true
+    }
+  }
+  if len(imported) == 0 {
+    return
+  }
+  for _, stmt := range statements {
+    if stmt == nil || stmt.Kind != shimast.KindExportDeclaration {
+      continue
+    }
+    decl := stmt.AsExportDeclaration()
+    if decl == nil || decl.ExportClause == nil {
+      continue
+    }
+    // Skip `export { X } from "Y"` — already in the target shape.
+    if decl.ModuleSpecifier != nil {
+      continue
+    }
+    if decl.ExportClause.Kind != shimast.KindNamedExports {
+      continue
+    }
+    named := decl.ExportClause.AsNamedExports()
+    if named == nil || named.Elements == nil || len(named.Elements.Nodes) == 0 {
+      continue
+    }
+    matched := false
+    for _, el := range named.Elements.Nodes {
+      spec := el.AsExportSpecifier()
+      if spec == nil {
+        continue
+      }
+      // PropertyName != nil means `export { a as b }` — a rename
+      // the from-clause rewrite cannot preserve without also
+      // touching the import side. Skip.
+      if spec.PropertyName != nil {
+        continue
+      }
+      name := identifierText(spec.Name())
+      if name == "" {
+        continue
+      }
+      if imported[name] {
+        matched = true
+        break
+      }
+    }
+    if matched {
+      ctx.Report(stmt, "Use `export { X } from \"Y\"` instead of importing then re-exporting.")
+    }
+  }
 }
 
 func init() {
-	Register(unicornPreferExportFrom{})
+  Register(unicornPreferExportFrom{})
 }