@ttsc/lint 0.14.0-dev.20260529.2 → 0.14.0

package/linthost/rules_sort_imports.go

@@ -18,52 +18,52 @@
 package linthost
 
 import (
-	shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
 type sortImports struct{}
 
 func (sortImports) Name() string { return "sort-imports" }
 func (sortImports) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindImportDeclaration}
+  return []shimast.Kind{shimast.KindImportDeclaration}
 }
 func (sortImports) Check(ctx *Context, node *shimast.Node) {
-	decl := node.AsImportDeclaration()
-	if decl == nil || decl.ImportClause == nil {
-		return
-	}
-	clause := decl.ImportClause.AsImportClause()
-	if clause == nil || clause.NamedBindings == nil {
-		return
-	}
-	if clause.NamedBindings.Kind != shimast.KindNamedImports {
-		return
-	}
-	named := clause.NamedBindings.AsNamedImports()
-	if named == nil || named.Elements == nil || len(named.Elements.Nodes) < 2 {
-		return
-	}
-	previous := ""
-	for i, spec := range named.Elements.Nodes {
-		if spec == nil {
-			return
-		}
-		s := spec.AsImportSpecifier()
-		if s == nil {
-			return
-		}
-		name := identifierText(s.Name())
-		if name == "" {
-			return
-		}
-		if i > 0 && name < previous {
-			ctx.Report(spec, "Member '"+name+"' of the import declaration should be sorted alphabetically.")
-			return
-		}
-		previous = name
-	}
+  decl := node.AsImportDeclaration()
+  if decl == nil || decl.ImportClause == nil {
+    return
+  }
+  clause := decl.ImportClause.AsImportClause()
+  if clause == nil || clause.NamedBindings == nil {
+    return
+  }
+  if clause.NamedBindings.Kind != shimast.KindNamedImports {
+    return
+  }
+  named := clause.NamedBindings.AsNamedImports()
+  if named == nil || named.Elements == nil || len(named.Elements.Nodes) < 2 {
+    return
+  }
+  previous := ""
+  for i, spec := range named.Elements.Nodes {
+    if spec == nil {
+      return
+    }
+    s := spec.AsImportSpecifier()
+    if s == nil {
+      return
+    }
+    name := identifierText(s.Name())
+    if name == "" {
+      return
+    }
+    if i > 0 && name < previous {
+      ctx.Report(spec, "Member '"+name+"' of the import declaration should be sorted alphabetically.")
+      return
+    }
+    previous = name
+  }
 }
 
 func init() {
-	Register(sortImports{})
+  Register(sortImports{})
 }

package/linthost/rules_sort_keys.go

@@ -17,7 +17,7 @@
 package linthost
 
 import (
-	shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
 type sortKeys struct{}
@@ -25,37 +25,37 @@ type sortKeys struct{}
 func (sortKeys) Name() string           { return "sort-keys" }
 func (sortKeys) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindObjectLiteralExpression} }
 func (sortKeys) Check(ctx *Context, node *shimast.Node) {
-	obj := node.AsObjectLiteralExpression()
-	if obj == nil || obj.Properties == nil {
-		return
-	}
-	previous := ""
-	hasPrevious := false
-	for _, prop := range obj.Properties.Nodes {
-		if prop == nil {
-			continue
-		}
-		// A spread divider resets the sort baseline; keys after the
-		// spread restart their own ordered group.
-		if prop.Kind == shimast.KindSpreadAssignment {
-			previous = ""
-			hasPrevious = false
-			continue
-		}
-		key := sortKeysName(prop)
-		if key == "" {
-			// Dynamic computed key (`[expr]`) — cannot compare; reset
-			// the baseline so the next static key starts a fresh group.
-			previous = ""
-			hasPrevious = false
-			continue
-		}
-		if hasPrevious && key < previous {
-			ctx.Report(prop, "Expected object keys to be in ascending order. '"+key+"' should be before '"+previous+"'.")
-		}
-		previous = key
-		hasPrevious = true
-	}
+  obj := node.AsObjectLiteralExpression()
+  if obj == nil || obj.Properties == nil {
+    return
+  }
+  previous := ""
+  hasPrevious := false
+  for _, prop := range obj.Properties.Nodes {
+    if prop == nil {
+      continue
+    }
+    // A spread divider resets the sort baseline; keys after the
+    // spread restart their own ordered group.
+    if prop.Kind == shimast.KindSpreadAssignment {
+      previous = ""
+      hasPrevious = false
+      continue
+    }
+    key := sortKeysName(prop)
+    if key == "" {
+      // Dynamic computed key (`[expr]`) — cannot compare; reset
+      // the baseline so the next static key starts a fresh group.
+      previous = ""
+      hasPrevious = false
+      continue
+    }
+    if hasPrevious && key < previous {
+      ctx.Report(prop, "Expected object keys to be in ascending order. '"+key+"' should be before '"+previous+"'.")
+    }
+    previous = key
+    hasPrevious = true
+  }
 }
 
 // sortKeysName returns the comparable name for a property in an object
@@ -64,35 +64,35 @@ func (sortKeys) Check(ctx *Context, node *shimast.Node) {
 // (dynamic computed names) return "" so the caller resets the sort
 // baseline.
 func sortKeysName(prop *shimast.Node) string {
-	if prop == nil {
-		return ""
-	}
-	var name *shimast.Node
-	switch prop.Kind {
-	case shimast.KindPropertyAssignment:
-		if a := prop.AsPropertyAssignment(); a != nil {
-			name = a.Name()
-		}
-	case shimast.KindShorthandPropertyAssignment:
-		if a := prop.AsShorthandPropertyAssignment(); a != nil {
-			name = a.Name()
-		}
-	case shimast.KindMethodDeclaration:
-		if a := prop.AsMethodDeclaration(); a != nil {
-			name = a.Name()
-		}
-	case shimast.KindGetAccessor:
-		if a := prop.AsGetAccessorDeclaration(); a != nil {
-			name = a.Name()
-		}
-	case shimast.KindSetAccessor:
-		if a := prop.AsSetAccessorDeclaration(); a != nil {
-			name = a.Name()
-		}
-	default:
-		return ""
-	}
-	return propertyNameText(name)
+  if prop == nil {
+    return ""
+  }
+  var name *shimast.Node
+  switch prop.Kind {
+  case shimast.KindPropertyAssignment:
+    if a := prop.AsPropertyAssignment(); a != nil {
+      name = a.Name()
+    }
+  case shimast.KindShorthandPropertyAssignment:
+    if a := prop.AsShorthandPropertyAssignment(); a != nil {
+      name = a.Name()
+    }
+  case shimast.KindMethodDeclaration:
+    if a := prop.AsMethodDeclaration(); a != nil {
+      name = a.Name()
+    }
+  case shimast.KindGetAccessor:
+    if a := prop.AsGetAccessorDeclaration(); a != nil {
+      name = a.Name()
+    }
+  case shimast.KindSetAccessor:
+    if a := prop.AsSetAccessorDeclaration(); a != nil {
+      name = a.Name()
+    }
+  default:
+    return ""
+  }
+  return propertyNameText(name)
 }
 
 // propertyNameText extracts a comparable string from a property-name
@@ -101,34 +101,34 @@ func sortKeysName(prop *shimast.Node) string {
 // Dynamic computed expressions return "" so the caller treats the
 // property as a sort-baseline reset.
 func propertyNameText(name *shimast.Node) string {
-	if name == nil {
-		return ""
-	}
-	switch name.Kind {
-	case shimast.KindIdentifier:
-		return identifierText(name)
-	case shimast.KindStringLiteral, shimast.KindNoSubstitutionTemplateLiteral:
-		return stringLiteralText(name)
-	case shimast.KindNumericLiteral, shimast.KindBigIntLiteral:
-		return numericLiteralText(name)
-	case shimast.KindComputedPropertyName:
-		// Only static literal payloads are comparable; dynamic
-		// expressions yield "" so the caller resets the sort baseline.
-		computed := name.AsComputedPropertyName()
-		if computed == nil || computed.Expression == nil {
-			return ""
-		}
-		inner := computed.Expression
-		switch inner.Kind {
-		case shimast.KindStringLiteral, shimast.KindNoSubstitutionTemplateLiteral:
-			return stringLiteralText(inner)
-		case shimast.KindNumericLiteral, shimast.KindBigIntLiteral:
-			return numericLiteralText(inner)
-		}
-	}
-	return ""
+  if name == nil {
+    return ""
+  }
+  switch name.Kind {
+  case shimast.KindIdentifier:
+    return identifierText(name)
+  case shimast.KindStringLiteral, shimast.KindNoSubstitutionTemplateLiteral:
+    return stringLiteralText(name)
+  case shimast.KindNumericLiteral, shimast.KindBigIntLiteral:
+    return numericLiteralText(name)
+  case shimast.KindComputedPropertyName:
+    // Only static literal payloads are comparable; dynamic
+    // expressions yield "" so the caller resets the sort baseline.
+    computed := name.AsComputedPropertyName()
+    if computed == nil || computed.Expression == nil {
+      return ""
+    }
+    inner := computed.Expression
+    switch inner.Kind {
+    case shimast.KindStringLiteral, shimast.KindNoSubstitutionTemplateLiteral:
+      return stringLiteralText(inner)
+    case shimast.KindNumericLiteral, shimast.KindBigIntLiteral:
+      return numericLiteralText(inner)
+    }
+  }
+  return ""
 }
 
 func init() {
-	Register(sortKeys{})
+  Register(sortKeys{})
 }

package/linthost/rules_suggestions.go

@@ -1255,6 +1255,13 @@ func renderConcatAsTemplate(src string, operands []*shimast.Node) (string, bool)
 // terminate or interpolate a template literal body: backslash, backtick,
 // and the `${` sequence. Matches the canonical ESLint `prefer-template`
 // fixer escape set.
+//
+// The input is the COOKED string value, so it carries decoded line
+// terminators. A raw CR (or CRLF) emitted into a template body is
+// normalized to LF by the ECMAScript template-literal grammar, and a raw
+// LF/TAB would change the literal's whitespace layout, so those control
+// characters are emitted as backslash escapes (`\r`, `\n`, `\t`) to keep
+// the template's cooked value byte-for-byte identical to the original.
 func escapeTemplateLiteralBody(text string) string {
   var sb strings.Builder
   sb.Grow(len(text))
@@ -1264,6 +1271,12 @@ func escapeTemplateLiteralBody(text string) string {
     case '\\', '`':
       sb.WriteByte('\\')
       sb.WriteByte(ch)
+    case '\r':
+      sb.WriteString("\\r")
+    case '\n':
+      sb.WriteString("\\n")
+    case '\t':
+      sb.WriteString("\\t")
     case '$':
       if i+1 < len(text) && text[i+1] == '{' {
         sb.WriteString("\\$")

package/linthost/rules_ts.go

@@ -250,8 +250,8 @@ func (noRequireImports) Check(ctx *Context, node *shimast.Node) {
   }
 }
 
-// banTsComment: `// @ts-ignore` / `// @ts-nocheck` / `// @ts-expect-error`
-// silence the type checker. Default mode flags every variant.
+// banTsComment: `// @ts-ignore` / `// @ts-expect-error` silence the type
+// checker. The rule flags `@ts-ignore` and `@ts-expect-error`.
 type banTsComment struct{}
 
 func (banTsComment) Name() string           { return "typescript/ban-ts-comment" }