@ttsc/strip 0.7.1 → 0.7.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ttsc/strip",
-  "version": "0.7.1",
+  "version": "0.7.3",
   "description": "First-party ttsc plugin that removes configured calls and statements from emitted JavaScript.",
   "main": "src/index.cjs",
   "exports": {

package/plugin/main.go

@@ -1,31 +1,38 @@
+// Native sidecar entrypoint for `@ttsc/strip`.
+//
+// The sidecar implements an output-stage transform for JavaScript emit. It
+// removes configured call statements and optional debugger statements after
+// TypeScript-Go prints JS, leaving typechecking and project loading to ttsc.
 package main
 
 import (
-	"fmt"
-	"os"
+  "fmt"
+  "os"
 )
 
 const version = "0.0.1"
 
 func main() {
-	os.Exit(run(os.Args[1:]))
+  os.Exit(run(os.Args[1:]))
 }
 
 func run(args []string) int {
-	if len(args) == 0 {
-		fmt.Fprintln(os.Stderr, "@ttsc/strip: command required (expected output|version)")
-		return 2
-	}
-	switch args[0] {
-	case "-v", "--version", "version":
-		fmt.Fprintf(os.Stdout, "@ttsc/strip %s\n", version)
-		return 0
-	case "check":
-		return 0
-	case "output":
-		return RunOutput(args[1:])
-	default:
-		fmt.Fprintf(os.Stderr, "@ttsc/strip: unknown command %q\n", args[0])
-		return 2
-	}
+  if len(args) == 0 {
+    fmt.Fprintln(os.Stderr, "@ttsc/strip: command required (expected output|version)")
+    return 2
+  }
+  switch args[0] {
+  case "-v", "--version", "version":
+    fmt.Fprintf(os.Stdout, "@ttsc/strip %s\n", version)
+    return 0
+  case "check":
+    // Strip rewriting is output-only; configuration is validated when output
+    // text is actually transformed.
+    return 0
+  case "output":
+    return RunOutput(args[1:])
+  default:
+    fmt.Fprintf(os.Stderr, "@ttsc/strip: unknown command %q\n", args[0])
+    return 2
+  }
 }

package/plugin/strip.go

@@ -1,359 +1,385 @@
+// Output transformer for `@ttsc/strip`.
+//
+// The transform parses emitted JavaScript, removes complete statements that
+// match configured call patterns, and preserves all other text. It operates on
+// JS output rather than TS source so the runtime file shape remains consistent
+// with TypeScript-Go's printer.
 package main
 
 import (
-	"encoding/json"
-	"flag"
-	"fmt"
-	"os"
-	"path/filepath"
-	"sort"
-	"strings"
+  "encoding/json"
+  "flag"
+  "fmt"
+  "os"
+  "path/filepath"
+  "sort"
+  "strings"
 
-	shimast "github.com/microsoft/typescript-go/shim/ast"
-	shimcore "github.com/microsoft/typescript-go/shim/core"
-	shimparser "github.com/microsoft/typescript-go/shim/parser"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimcore "github.com/microsoft/typescript-go/shim/core"
+  shimparser "github.com/microsoft/typescript-go/shim/parser"
 )
 
 type pluginEntry struct {
-	Config map[string]any `json:"config"`
-	Name   string         `json:"name"`
-	Stage  string         `json:"stage"`
+  // Config is the plugin-specific entry from compilerOptions.plugins[] once
+  // the sidecar locates the `@ttsc/strip` descriptor in the ordered manifest.
+  Config map[string]any `json:"config"`
+  Name   string         `json:"name"`
+  Stage  string         `json:"stage"`
 }
 
 type stripTransform struct {
-	calls         []callPattern
-	stripDebugger bool
+  // calls stores dotted call patterns such as console.log or invariant.*.
+  // stripDebugger controls DebuggerStatement removal independently.
+  calls         []callPattern
+  stripDebugger bool
 }
 
 type callPattern struct {
-	parts    []string
-	wildcard bool
+  // parts contains the dotted name split on '.'. wildcard means the final
+  // source token was '*' and therefore matches any deeper property call.
+  parts    []string
+  wildcard bool
 }
 
 type textEdit struct {
-	start int
-	end   int
-	text  string
+  start int
+  end   int
+  text  string
 }
 
 func RunOutput(args []string) int {
-	fs := flag.NewFlagSet("output", flag.ContinueOnError)
-	fs.SetOutput(os.Stderr)
-	file := fs.String("file", "", "emitted file to transform")
-	out := fs.String("out", "", "write transformed text to this file instead of updating --file")
-	_ = fs.String("cwd", "", "project directory")
-	_ = fs.String("outDir", "", "emit directory override")
-	pluginsJSON := fs.String("plugins-json", "", "ttsc plugin manifest JSON")
-	_ = fs.String("tsconfig", "tsconfig.json", "project tsconfig")
-	if err := fs.Parse(args); err != nil {
-		return 2
-	}
-	if *file == "" {
-		fmt.Fprintln(os.Stderr, "@ttsc/strip: output requires --file")
-		return 2
-	}
-	config, err := findConfig(*pluginsJSON)
-	if err != nil {
-		fmt.Fprintln(os.Stderr, err)
-		return 2
-	}
-	text, err := os.ReadFile(*file)
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "@ttsc/strip: read %s: %v\n", *file, err)
-		return 2
-	}
-	patched, err := Apply(*file, string(text), config)
-	if err != nil {
-		fmt.Fprintln(os.Stderr, err)
-		return 2
-	}
-	target := *file
-	if *out != "" {
-		target = *out
-	}
-	if err := os.MkdirAll(filepath.Dir(target), 0o755); err != nil {
-		fmt.Fprintf(os.Stderr, "@ttsc/strip: mkdir: %v\n", err)
-		return 2
-	}
-	if err := os.WriteFile(target, []byte(patched), 0o644); err != nil {
-		fmt.Fprintf(os.Stderr, "@ttsc/strip: write %s: %v\n", target, err)
-		return 2
-	}
-	return 0
+  fs := flag.NewFlagSet("output", flag.ContinueOnError)
+  fs.SetOutput(os.Stderr)
+  file := fs.String("file", "", "emitted file to transform")
+  out := fs.String("out", "", "write transformed text to this file instead of updating --file")
+  _ = fs.String("cwd", "", "project directory")
+  _ = fs.String("outDir", "", "emit directory override")
+  pluginsJSON := fs.String("plugins-json", "", "ttsc plugin manifest JSON")
+  _ = fs.String("tsconfig", "tsconfig.json", "project tsconfig")
+  if err := fs.Parse(args); err != nil {
+    return 2
+  }
+  if *file == "" {
+    fmt.Fprintln(os.Stderr, "@ttsc/strip: output requires --file")
+    return 2
+  }
+  config, err := findConfig(*pluginsJSON)
+  if err != nil {
+    fmt.Fprintln(os.Stderr, err)
+    return 2
+  }
+  text, err := os.ReadFile(*file)
+  if err != nil {
+    fmt.Fprintf(os.Stderr, "@ttsc/strip: read %s: %v\n", *file, err)
+    return 2
+  }
+  patched, err := Apply(*file, string(text), config)
+  if err != nil {
+    fmt.Fprintln(os.Stderr, err)
+    return 2
+  }
+  target := *file
+  if *out != "" {
+    target = *out
+  }
+  if err := os.MkdirAll(filepath.Dir(target), 0o755); err != nil {
+    fmt.Fprintf(os.Stderr, "@ttsc/strip: mkdir: %v\n", err)
+    return 2
+  }
+  if err := os.WriteFile(target, []byte(patched), 0o644); err != nil {
+    fmt.Fprintf(os.Stderr, "@ttsc/strip: write %s: %v\n", target, err)
+    return 2
+  }
+  return 0
 }
 
 func Apply(fileName string, text string, config map[string]any) (string, error) {
-	strip, err := parseStrip(config)
-	if err != nil {
-		return "", err
-	}
-	return strip.apply(fileName, text)
+  // Apply is deterministic and has no filesystem side effects. RunOutput owns
+  // file reads/writes so unit tests can exercise the transform directly.
+  strip, err := parseStrip(config)
+  if err != nil {
+    return "", err
+  }
+  return strip.apply(fileName, text)
 }
 
 func parseStrip(config map[string]any) (*stripTransform, error) {
-	calls, err := stringArrayConfig(config, "calls")
-	if err != nil {
-		return nil, fmt.Errorf("@ttsc/strip: %w", err)
-	}
-	statements, err := stringArrayConfig(config, "statements")
-	if err != nil {
-		return nil, fmt.Errorf("@ttsc/strip: %w", err)
-	}
-	out := &stripTransform{}
-	for _, call := range calls {
-		pattern, err := parseCallPattern(call)
-		if err != nil {
-			return nil, fmt.Errorf("@ttsc/strip: %w", err)
-		}
-		out.calls = append(out.calls, pattern)
-	}
-	for _, statement := range statements {
-		switch statement {
-		case "debugger":
-			out.stripDebugger = true
-		default:
-			return nil, fmt.Errorf("@ttsc/strip: unsupported statement pattern %q", statement)
-		}
-	}
-	return out, nil
+  calls, err := stringArrayConfig(config, "calls")
+  if err != nil {
+    return nil, fmt.Errorf("@ttsc/strip: %w", err)
+  }
+  statements, err := stringArrayConfig(config, "statements")
+  if err != nil {
+    return nil, fmt.Errorf("@ttsc/strip: %w", err)
+  }
+  out := &stripTransform{}
+  for _, call := range calls {
+    pattern, err := parseCallPattern(call)
+    if err != nil {
+      return nil, fmt.Errorf("@ttsc/strip: %w", err)
+    }
+    out.calls = append(out.calls, pattern)
+  }
+  for _, statement := range statements {
+    switch statement {
+    case "debugger":
+      out.stripDebugger = true
+    default:
+      return nil, fmt.Errorf("@ttsc/strip: unsupported statement pattern %q", statement)
+    }
+  }
+  return out, nil
 }
 
 func (s *stripTransform) apply(fileName string, text string) (string, error) {
-	if s == nil || !isJavaScriptOutput(fileName) || (len(s.calls) == 0 && !s.stripDebugger) {
-		return text, nil
-	}
-	file := parseJS(fileName, text)
-	if file == nil {
-		return text, nil
-	}
-	edits := make([]textEdit, 0)
-	var walk func(*shimast.Node)
-	walk = func(node *shimast.Node) {
-		if node == nil {
-			return
-		}
-		switch node.Kind {
-		case shimast.KindDebuggerStatement:
-			if s.stripDebugger {
-				start, end := statementRemovalRange(text, node)
-				edits = append(edits, textEdit{start: start, end: end})
-			}
-		case shimast.KindExpressionStatement:
-			expr := node.AsExpressionStatement().Expression
-			name, ok := callExpressionName(expr)
-			if ok && s.matchesCall(name) {
-				start, end := statementRemovalRange(text, node)
-				edits = append(edits, textEdit{start: start, end: end})
-			}
-		}
-		node.ForEachChild(func(child *shimast.Node) bool {
-			walk(child)
-			return false
-		})
-	}
-	for _, stmt := range file.Statements.Nodes {
-		walk(stmt)
-	}
-	return applyTextEdits(text, edits), nil
+  // Declaration files and maps are intentionally skipped. Strip patterns are
+  // JavaScript runtime statements, not type-level declarations.
+  if s == nil || !isJavaScriptOutput(fileName) || (len(s.calls) == 0 && !s.stripDebugger) {
+    return text, nil
+  }
+  file := parseJS(fileName, text)
+  if file == nil {
+    return text, nil
+  }
+  edits := make([]textEdit, 0)
+  // The AST tells us which statements are safe to remove; the original text is
+  // still used for editing so comments, whitespace, and unrelated printer
+  // details remain untouched.
+  var walk func(*shimast.Node)
+  walk = func(node *shimast.Node) {
+    if node == nil {
+      return
+    }
+    switch node.Kind {
+    case shimast.KindDebuggerStatement:
+      if s.stripDebugger {
+        start, end := statementRemovalRange(text, node)
+        edits = append(edits, textEdit{start: start, end: end})
+      }
+    case shimast.KindExpressionStatement:
+      expr := node.AsExpressionStatement().Expression
+      name, ok := callExpressionName(expr)
+      if ok && s.matchesCall(name) {
+        start, end := statementRemovalRange(text, node)
+        edits = append(edits, textEdit{start: start, end: end})
+      }
+    }
+    node.ForEachChild(func(child *shimast.Node) bool {
+      walk(child)
+      return false
+    })
+  }
+  for _, stmt := range file.Statements.Nodes {
+    walk(stmt)
+  }
+  return applyTextEdits(text, edits), nil
 }
 
 func (s *stripTransform) matchesCall(name string) bool {
-	for _, pattern := range s.calls {
-		if pattern.matches(name) {
-			return true
-		}
-	}
-	return false
+  for _, pattern := range s.calls {
+    if pattern.matches(name) {
+      return true
+    }
+  }
+  return false
 }
 
 func parseCallPattern(text string) (callPattern, error) {
-	parts := strings.Split(text, ".")
-	if len(parts) == 0 {
-		return callPattern{}, fmt.Errorf("empty call pattern")
-	}
-	for i, part := range parts {
-		if part == "" {
-			return callPattern{}, fmt.Errorf("invalid call pattern %q", text)
-		}
-		if part == "*" && i != len(parts)-1 {
-			return callPattern{}, fmt.Errorf("wildcard is only supported at the end of call pattern %q", text)
-		}
-	}
-	wildcard := parts[len(parts)-1] == "*"
-	if wildcard {
-		parts = parts[:len(parts)-1]
-	}
-	return callPattern{parts: parts, wildcard: wildcard}, nil
+  parts := strings.Split(text, ".")
+  if len(parts) == 0 {
+    return callPattern{}, fmt.Errorf("empty call pattern")
+  }
+  for i, part := range parts {
+    if part == "" {
+      return callPattern{}, fmt.Errorf("invalid call pattern %q", text)
+    }
+    if part == "*" && i != len(parts)-1 {
+      // Only terminal wildcards have a clear statement-level meaning:
+      // logger.* matches logger.info(), logger.warn(), etc.
+      return callPattern{}, fmt.Errorf("wildcard is only supported at the end of call pattern %q", text)
+    }
+  }
+  wildcard := parts[len(parts)-1] == "*"
+  if wildcard {
+    parts = parts[:len(parts)-1]
+  }
+  return callPattern{parts: parts, wildcard: wildcard}, nil
 }
 
 func (p callPattern) matches(name string) bool {
-	parts := strings.Split(name, ".")
-	if p.wildcard {
-		if len(parts) <= len(p.parts) {
-			return false
-		}
-		return equalStringSlices(parts[:len(p.parts)], p.parts)
-	}
-	return equalStringSlices(parts, p.parts)
+  parts := strings.Split(name, ".")
+  if p.wildcard {
+    if len(parts) <= len(p.parts) {
+      return false
+    }
+    return equalStringSlices(parts[:len(p.parts)], p.parts)
+  }
+  return equalStringSlices(parts, p.parts)
 }
 
 func callExpressionName(expr *shimast.Node) (string, bool) {
-	if expr == nil || expr.Kind != shimast.KindCallExpression {
-		return "", false
-	}
-	call := expr.AsCallExpression()
-	return dottedName(call.Expression)
+  if expr == nil || expr.Kind != shimast.KindCallExpression {
+    return "", false
+  }
+  call := expr.AsCallExpression()
+  return dottedName(call.Expression)
 }
 
 func dottedName(expr *shimast.Node) (string, bool) {
-	if expr == nil {
-		return "", false
-	}
-	switch expr.Kind {
-	case shimast.KindIdentifier:
-		return expr.Text(), true
-	case shimast.KindPropertyAccessExpression:
-		prop := expr.AsPropertyAccessExpression()
-		left, ok := dottedName(prop.Expression)
-		if !ok || prop.Name() == nil {
-			return "", false
-		}
-		return left + "." + prop.Name().Text(), true
-	default:
-		return "", false
-	}
+  if expr == nil {
+    return "", false
+  }
+  switch expr.Kind {
+  case shimast.KindIdentifier:
+    return expr.Text(), true
+  case shimast.KindPropertyAccessExpression:
+    prop := expr.AsPropertyAccessExpression()
+    left, ok := dottedName(prop.Expression)
+    if !ok || prop.Name() == nil {
+      return "", false
+    }
+    return left + "." + prop.Name().Text(), true
+  default:
+    return "", false
+  }
 }
 
 func parseJS(fileName string, text string) *shimast.SourceFile {
-	normalized := filepath.ToSlash(fileName)
-	if !filepath.IsAbs(normalized) {
-		if abs, err := filepath.Abs(normalized); err == nil {
-			normalized = filepath.ToSlash(abs)
-		}
-	}
-	opts := shimast.SourceFileParseOptions{FileName: normalized}
-	return shimparser.ParseSourceFile(opts, text, shimcore.ScriptKindJS)
+  normalized := filepath.ToSlash(fileName)
+  if !filepath.IsAbs(normalized) {
+    if abs, err := filepath.Abs(normalized); err == nil {
+      normalized = filepath.ToSlash(abs)
+    }
+  }
+  opts := shimast.SourceFileParseOptions{FileName: normalized}
+  return shimparser.ParseSourceFile(opts, text, shimcore.ScriptKindJS)
 }
 
 func stringArrayConfig(config map[string]any, key string) ([]string, error) {
-	raw, ok := config[key]
-	if !ok || raw == nil {
-		return nil, nil
-	}
-	values, ok := raw.([]any)
-	if !ok {
-		return nil, fmt.Errorf("%q must be an array of strings", key)
-	}
-	out := make([]string, 0, len(values))
-	for i, value := range values {
-		text, ok := value.(string)
-		if !ok || strings.TrimSpace(text) == "" {
-			return nil, fmt.Errorf("%q[%d] must be a non-empty string", key, i)
-		}
-		out = append(out, text)
-	}
-	return out, nil
+  raw, ok := config[key]
+  if !ok || raw == nil {
+    return nil, nil
+  }
+  values, ok := raw.([]any)
+  if !ok {
+    return nil, fmt.Errorf("%q must be an array of strings", key)
+  }
+  out := make([]string, 0, len(values))
+  for i, value := range values {
+    text, ok := value.(string)
+    if !ok || strings.TrimSpace(text) == "" {
+      return nil, fmt.Errorf("%q[%d] must be a non-empty string", key, i)
+    }
+    out = append(out, text)
+  }
+  return out, nil
 }
 
 func statementRemovalRange(text string, node *shimast.Node) (int, int) {
-	start := clamp(node.Pos(), 0, len(text))
-	end := clamp(node.End(), start, len(text))
-	lineStart := start
-	for lineStart > 0 && text[lineStart-1] != '\n' && text[lineStart-1] != '\r' {
-		lineStart--
-	}
-	if strings.TrimSpace(text[lineStart:start]) == "" {
-		start = lineStart
-	}
-	if end < len(text) && text[end] == ';' {
-		end++
-	}
-	for end < len(text) && (text[end] == ' ' || text[end] == '\t') {
-		end++
-	}
-	if end < len(text) && text[end] == '\r' {
-		end++
-	}
-	if end < len(text) && text[end] == '\n' {
-		end++
-	}
-	return start, end
+  // Remove the whole physical statement line when the statement starts after
+  // indentation. This keeps blank-line churn small for common one-statement
+  // debug calls.
+  start := clamp(node.Pos(), 0, len(text))
+  end := clamp(node.End(), start, len(text))
+  lineStart := start
+  for lineStart > 0 && text[lineStart-1] != '\n' && text[lineStart-1] != '\r' {
+    lineStart--
+  }
+  if strings.TrimSpace(text[lineStart:start]) == "" {
+    start = lineStart
+  }
+  if end < len(text) && text[end] == ';' {
+    end++
+  }
+  for end < len(text) && (text[end] == ' ' || text[end] == '\t') {
+    end++
+  }
+  if end < len(text) && text[end] == '\r' {
+    end++
+  }
+  if end < len(text) && text[end] == '\n' {
+    end++
+  }
+  return start, end
 }
 
 func applyTextEdits(text string, edits []textEdit) string {
-	if len(edits) == 0 {
-		return text
-	}
-	sort.SliceStable(edits, func(i, j int) bool {
-		if edits[i].start == edits[j].start {
-			return edits[i].end > edits[j].end
-		}
-		return edits[i].start > edits[j].start
-	})
-	out := text
-	lastStart := len(text) + 1
-	for _, edit := range edits {
-		if edit.start < 0 || edit.end < edit.start || edit.start > len(out) {
-			continue
-		}
-		if edit.end > lastStart {
-			edit.end = lastStart
-		}
-		if edit.end > len(out) {
-			edit.end = len(out)
-		}
-		out = out[:edit.start] + edit.text + out[edit.end:]
-		lastStart = edit.start
-	}
-	return out
+  if len(edits) == 0 {
+    return text
+  }
+  sort.SliceStable(edits, func(i, j int) bool {
+    if edits[i].start == edits[j].start {
+      return edits[i].end > edits[j].end
+    }
+    return edits[i].start > edits[j].start
+  })
+  out := text
+  lastStart := len(text) + 1
+  for _, edit := range edits {
+    if edit.start < 0 || edit.end < edit.start || edit.start > len(out) {
+      continue
+    }
+    if edit.end > lastStart {
+      // Nested edits are collapsed by letting the earlier source range own the
+      // bytes. This keeps repeated rule matches from corrupting offsets.
+      edit.end = lastStart
+    }
+    if edit.end > len(out) {
+      edit.end = len(out)
+    }
+    out = out[:edit.start] + edit.text + out[edit.end:]
+    lastStart = edit.start
+  }
+  return out
 }
 
 func findConfig(pluginsJSON string) (map[string]any, error) {
-	if strings.TrimSpace(pluginsJSON) == "" {
-		return nil, fmt.Errorf("@ttsc/strip: missing --plugins-json")
-	}
-	var entries []pluginEntry
-	if err := json.Unmarshal([]byte(pluginsJSON), &entries); err != nil {
-		return nil, fmt.Errorf("@ttsc/strip: invalid --plugins-json: %w", err)
-	}
-	for _, entry := range entries {
-		if entry.Name == "@ttsc/strip" {
-			if entry.Config == nil {
-				return map[string]any{}, nil
-			}
-			return entry.Config, nil
-		}
-	}
-	return nil, fmt.Errorf("@ttsc/strip: plugin entry not found")
+  if strings.TrimSpace(pluginsJSON) == "" {
+    return nil, fmt.Errorf("@ttsc/strip: missing --plugins-json")
+  }
+  var entries []pluginEntry
+  if err := json.Unmarshal([]byte(pluginsJSON), &entries); err != nil {
+    return nil, fmt.Errorf("@ttsc/strip: invalid --plugins-json: %w", err)
+  }
+  for _, entry := range entries {
+    if entry.Name == "@ttsc/strip" {
+      if entry.Config == nil {
+        return map[string]any{}, nil
+      }
+      return entry.Config, nil
+    }
+  }
+  return nil, fmt.Errorf("@ttsc/strip: plugin entry not found")
 }
 
 func isJavaScriptOutput(fileName string) bool {
-	switch strings.ToLower(filepath.Ext(fileName)) {
-	case ".js", ".mjs", ".cjs":
-		return true
-	default:
-		return false
-	}
+  switch strings.ToLower(filepath.Ext(fileName)) {
+  case ".js", ".mjs", ".cjs":
+    return true
+  default:
+    return false
+  }
 }
 
 func equalStringSlices(a []string, b []string) bool {
-	if len(a) != len(b) {
-		return false
-	}
-	for i := range a {
-		if a[i] != b[i] {
-			return false
-		}
-	}
-	return true
+  if len(a) != len(b) {
+    return false
+  }
+  for i := range a {
+    if a[i] != b[i] {
+      return false
+    }
+  }
+  return true
 }
 
 func clamp(value int, min int, max int) int {
-	if value < min {
-		return min
-	}
-	if value > max {
-		return max
-	}
-	return value
+  if value < min {
+    return min
+  }
+  if value > max {
+    return max
+  }
+  return value
 }