@ttsc/lint 0.14.0-dev.20260529.2 → 0.14.1

package/linthost/rules_react_extras.go

@@ -1,7 +1,7 @@
 package linthost
 
 import (
-	shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
 // reactJSXNoUndef rejects JSX elements whose tag is a bare uppercase
@@ -15,27 +15,27 @@ type reactJSXNoUndef struct{}
 
 func (reactJSXNoUndef) Name() string { return "react/jsx-no-undef" }
 func (reactJSXNoUndef) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindJsxElement, shimast.KindJsxSelfClosingElement}
+  return []shimast.Kind{shimast.KindJsxElement, shimast.KindJsxSelfClosingElement}
 }
 
 func (reactJSXNoUndef) Check(ctx *Context, node *shimast.Node) {
-	info := reactJSXElementFromNode(node)
-	if info.opening == nil {
-		return
-	}
-	tagNode := reactExtrasOpeningTagNameNode(info.opening)
-	name := identifierText(tagNode)
-	if name == "" {
-		return
-	}
-	first := name[0]
-	if first < 'A' || first > 'Z' {
-		return
-	}
-	if reactExtrasFileHasDeclaration(ctx.File.AsNode(), name) {
-		return
-	}
-	ctx.Report(info.opening, "'"+name+"' is not defined.")
+  info := reactJSXElementFromNode(node)
+  if info.opening == nil {
+    return
+  }
+  tagNode := reactExtrasOpeningTagNameNode(info.opening)
+  name := identifierText(tagNode)
+  if name == "" {
+    return
+  }
+  first := name[0]
+  if first < 'A' || first > 'Z' {
+    return
+  }
+  if reactExtrasFileHasDeclaration(ctx.File.AsNode(), name) {
+    return
+  }
+  ctx.Report(info.opening, "'"+name+"' is not defined.")
 }
 
 // reactDisplayName rejects `React.memo(...)` / `forwardRef(...)`
@@ -46,60 +46,60 @@ func (reactJSXNoUndef) Check(ctx *Context, node *shimast.Node) {
 // Reference: https://github.com/jsx-eslint/eslint-plugin-react/blob/master/docs/rules/display-name.md
 type reactDisplayName struct{}
 
-func (reactDisplayName) Name() string                { return "react/display-name" }
-func (reactDisplayName) Visits() []shimast.Kind      { return []shimast.Kind{shimast.KindCallExpression} }
+func (reactDisplayName) Name() string           { return "react/display-name" }
+func (reactDisplayName) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindCallExpression} }
 
 func (reactDisplayName) Check(ctx *Context, node *shimast.Node) {
-	call := node.AsCallExpression()
-	if call == nil || call.Arguments == nil || len(call.Arguments.Nodes) == 0 {
-		return
-	}
-	if !reactExtrasIsDisplayNameWrapperCall(call) {
-		return
-	}
-	arg := stripParens(call.Arguments.Nodes[0])
-	if arg == nil {
-		return
-	}
-	switch arg.Kind {
-	case shimast.KindArrowFunction:
-		// arrow functions never carry an own name
-	case shimast.KindFunctionExpression:
-		fn := arg.AsFunctionExpression()
-		if fn != nil && identifierText(fn.Name()) != "" {
-			return
-		}
-	default:
-		return
-	}
-	if reactExtrasCallHasNamedHost(node) {
-		return
-	}
-	ctx.Report(node, "Component definition is missing display name.")
+  call := node.AsCallExpression()
+  if call == nil || call.Arguments == nil || len(call.Arguments.Nodes) == 0 {
+    return
+  }
+  if !reactExtrasIsDisplayNameWrapperCall(call) {
+    return
+  }
+  arg := stripParens(call.Arguments.Nodes[0])
+  if arg == nil {
+    return
+  }
+  switch arg.Kind {
+  case shimast.KindArrowFunction:
+    // arrow functions never carry an own name
+  case shimast.KindFunctionExpression:
+    fn := arg.AsFunctionExpression()
+    if fn != nil && identifierText(fn.Name()) != "" {
+      return
+    }
+  default:
+    return
+  }
+  if reactExtrasCallHasNamedHost(node) {
+    return
+  }
+  ctx.Report(node, "Component definition is missing display name.")
 }
 
 // reactExtrasOpeningTagNameNode returns the TagName node from either a
 // JsxOpeningElement (the node on a paired JsxElement) or a
 // JsxSelfClosingElement directly.
 func reactExtrasOpeningTagNameNode(opening *shimast.Node) *shimast.Node {
-	if opening == nil {
-		return nil
-	}
-	switch opening.Kind {
-	case shimast.KindJsxOpeningElement:
-		el := opening.AsJsxOpeningElement()
-		if el == nil {
-			return nil
-		}
-		return el.TagName
-	case shimast.KindJsxSelfClosingElement:
-		el := opening.AsJsxSelfClosingElement()
-		if el == nil {
-			return nil
-		}
-		return el.TagName
-	}
-	return nil
+  if opening == nil {
+    return nil
+  }
+  switch opening.Kind {
+  case shimast.KindJsxOpeningElement:
+    el := opening.AsJsxOpeningElement()
+    if el == nil {
+      return nil
+    }
+    return el.TagName
+  case shimast.KindJsxSelfClosingElement:
+    el := opening.AsJsxSelfClosingElement()
+    if el == nil {
+      return nil
+    }
+    return el.TagName
+  }
+  return nil
 }
 
 // reactExtrasFileHasDeclaration reports whether `name` is bound anywhere
@@ -108,71 +108,71 @@ func reactExtrasOpeningTagNameNode(opening *shimast.Node) *shimast.Node {
 // walk is whole-file because JSX names resolve lexically in the
 // surrounding closure, not against a single statement list.
 func reactExtrasFileHasDeclaration(root *shimast.Node, name string) bool {
-	if root == nil || name == "" {
-		return false
-	}
-	found := false
-	walkDescendants(root, func(child *shimast.Node) {
-		if found || child == nil {
-			return
-		}
-		switch child.Kind {
-		case shimast.KindFunctionDeclaration:
-			if fn := child.AsFunctionDeclaration(); fn != nil && identifierText(fn.Name()) == name {
-				found = true
-			}
-		case shimast.KindClassDeclaration:
-			if cl := child.AsClassDeclaration(); cl != nil && identifierText(cl.Name()) == name {
-				found = true
-			}
-		case shimast.KindVariableDeclaration:
-			if v := child.AsVariableDeclaration(); v != nil && identifierText(v.Name()) == name {
-				found = true
-			}
-		case shimast.KindParameter:
-			if p := child.AsParameterDeclaration(); p != nil && identifierText(p.Name()) == name {
-				found = true
-			}
-		case shimast.KindEnumDeclaration:
-			if e := child.AsEnumDeclaration(); e != nil && identifierText(e.Name()) == name {
-				found = true
-			}
-		case shimast.KindImportClause:
-			clause := child.AsImportClause()
-			if clause == nil {
-				return
-			}
-			if identifierText(clause.Name()) == name {
-				found = true
-				return
-			}
-			if clause.NamedBindings != nil {
-				switch clause.NamedBindings.Kind {
-				case shimast.KindNamespaceImport:
-					ns := clause.NamedBindings.AsNamespaceImport()
-					if ns != nil && identifierText(ns.Name()) == name {
-						found = true
-					}
-				case shimast.KindNamedImports:
-					named := clause.NamedBindings.AsNamedImports()
-					if named == nil || named.Elements == nil {
-						return
-					}
-					for _, spec := range named.Elements.Nodes {
-						s := spec.AsImportSpecifier()
-						if s == nil {
-							continue
-						}
-						if identifierText(s.Name()) == name {
-							found = true
-							return
-						}
-					}
-				}
-			}
-		}
-	})
-	return found
+  if root == nil || name == "" {
+    return false
+  }
+  found := false
+  walkDescendants(root, func(child *shimast.Node) {
+    if found || child == nil {
+      return
+    }
+    switch child.Kind {
+    case shimast.KindFunctionDeclaration:
+      if fn := child.AsFunctionDeclaration(); fn != nil && identifierText(fn.Name()) == name {
+        found = true
+      }
+    case shimast.KindClassDeclaration:
+      if cl := child.AsClassDeclaration(); cl != nil && identifierText(cl.Name()) == name {
+        found = true
+      }
+    case shimast.KindVariableDeclaration:
+      if v := child.AsVariableDeclaration(); v != nil && identifierText(v.Name()) == name {
+        found = true
+      }
+    case shimast.KindParameter:
+      if p := child.AsParameterDeclaration(); p != nil && identifierText(p.Name()) == name {
+        found = true
+      }
+    case shimast.KindEnumDeclaration:
+      if e := child.AsEnumDeclaration(); e != nil && identifierText(e.Name()) == name {
+        found = true
+      }
+    case shimast.KindImportClause:
+      clause := child.AsImportClause()
+      if clause == nil {
+        return
+      }
+      if identifierText(clause.Name()) == name {
+        found = true
+        return
+      }
+      if clause.NamedBindings != nil {
+        switch clause.NamedBindings.Kind {
+        case shimast.KindNamespaceImport:
+          ns := clause.NamedBindings.AsNamespaceImport()
+          if ns != nil && identifierText(ns.Name()) == name {
+            found = true
+          }
+        case shimast.KindNamedImports:
+          named := clause.NamedBindings.AsNamedImports()
+          if named == nil || named.Elements == nil {
+            return
+          }
+          for _, spec := range named.Elements.Nodes {
+            s := spec.AsImportSpecifier()
+            if s == nil {
+              continue
+            }
+            if identifierText(s.Name()) == name {
+              found = true
+              return
+            }
+          }
+        }
+      }
+    }
+  })
+  return found
 }
 
 // reactExtrasIsDisplayNameWrapperCall reports whether the call
@@ -180,15 +180,15 @@ func reactExtrasFileHasDeclaration(root *shimast.Node, name string) bool {
 // `forwardRef` invocation — the wrappers whose inner anonymous function
 // loses its name unless `displayName` is set explicitly.
 func reactExtrasIsDisplayNameWrapperCall(call *shimast.CallExpression) bool {
-	if call == nil {
-		return false
-	}
-	name := callCalleeName(call)
-	if name == "memo" || name == "forwardRef" {
-		return true
-	}
-	_, prop, ok := reactPropertyAccessParts(call.Expression)
-	return ok && (prop == "memo" || prop == "forwardRef")
+  if call == nil {
+    return false
+  }
+  name := callCalleeName(call)
+  if name == "memo" || name == "forwardRef" {
+    return true
+  }
+  _, prop, ok := reactPropertyAccessParts(call.Expression)
+  return ok && (prop == "memo" || prop == "forwardRef")
 }
 
 // reactExtrasCallHasNamedHost reports whether the call is initializing
@@ -198,30 +198,30 @@ func reactExtrasIsDisplayNameWrapperCall(call *shimast.CallExpression) bool {
 // `export default memo(...)`. In those shapes the wrapper still
 // produces a debuggable component, so the rule abstains.
 func reactExtrasCallHasNamedHost(node *shimast.Node) bool {
-	parent := node.Parent
-	for parent != nil && parent.Kind == shimast.KindParenthesizedExpression {
-		parent = parent.Parent
-	}
-	if parent == nil {
-		return false
-	}
-	switch parent.Kind {
-	case shimast.KindVariableDeclaration:
-		v := parent.AsVariableDeclaration()
-		if v != nil && identifierText(v.Name()) != "" {
-			return true
-		}
-	case shimast.KindPropertyAssignment:
-		return true
-	case shimast.KindPropertyDeclaration:
-		return true
-	case shimast.KindExportAssignment:
-		return true
-	}
-	return false
+  parent := node.Parent
+  for parent != nil && parent.Kind == shimast.KindParenthesizedExpression {
+    parent = parent.Parent
+  }
+  if parent == nil {
+    return false
+  }
+  switch parent.Kind {
+  case shimast.KindVariableDeclaration:
+    v := parent.AsVariableDeclaration()
+    if v != nil && identifierText(v.Name()) != "" {
+      return true
+    }
+  case shimast.KindPropertyAssignment:
+    return true
+  case shimast.KindPropertyDeclaration:
+    return true
+  case shimast.KindExportAssignment:
+    return true
+  }
+  return false
 }
 
 func init() {
-	Register(reactJSXNoUndef{})
-	Register(reactDisplayName{})
+  Register(reactJSXNoUndef{})
+  Register(reactDisplayName{})
 }

package/linthost/rules_react_hooks.go

@@ -431,7 +431,7 @@ func isReactComponentName(name string) bool {
   if name == "" {
     return false
   }
-	first, _ := reactHooksFirstRune(name)
+  first, _ := reactHooksFirstRune(name)
   return unicode.IsUpper(first)
 }
 
@@ -439,7 +439,7 @@ func isReactHookName(name string) bool {
   if len(name) < 4 || !strings.HasPrefix(name, "use") {
     return false
   }
-	r, _ := reactHooksFirstRune(name[3:])
+  r, _ := reactHooksFirstRune(name[3:])
   return unicode.IsUpper(r) || unicode.IsDigit(r)
 }