@ttsc/strip 0.7.3 → 0.8.0-dev.20260506

package/README.md

@@ -9,7 +9,7 @@
 [![Guide Documents](https://img.shields.io/badge/Guide-Documents-forestgreen)](https://github.com/samchon/ttsc/tree/master/docs)
 [![Discord Badge](https://img.shields.io/badge/discord-samchon-d91965?style=flat&labelColor=5866f2&logo=discord&logoColor=white&link=https://discord.gg/E94XhzrUCZ)](https://discord.gg/E94XhzrUCZ)
 
-`@ttsc/strip` removes configured call-expression statements and debugger statements from emitted JavaScript.
+`@ttsc/strip` removes configured call-expression statements and debugger statements from TypeScript source before emit.
 
 ## Setup
 
@@ -28,10 +28,10 @@ Open your project's `tsconfig.json`, then add this entry under `compilerOptions.
       {
         "transform": "@ttsc/strip",
         "calls": ["console.log", "console.debug", "assert.*"],
-        "statements": ["debugger"]
-      }
-    ]
-  }
+        "statements": ["debugger"],
+      },
+    ],
+  },
 }
 ```
 
@@ -54,15 +54,15 @@ Call patterns match statement-level calls such as `console.log("debug")` or `ass
       // Keep lint first.
       { "transform": "@ttsc/lint", "config": { "no-var": "error" } },
 
-      // Output plugins run after emit, in order.
-      { "transform": "@ttsc/banner", "banner": "/*! @license MIT */" },
+      // First-party utilities use their documented transform order.
+      { "transform": "@ttsc/banner", "banner": "License MIT" },
       { "transform": "@ttsc/paths" },
       {
         "transform": "@ttsc/strip",
         "calls": ["console.log", "console.debug", "assert.*"],
-        "statements": ["debugger"]
-      }
-    ]
-  }
+        "statements": ["debugger"],
+      },
+    ],
+  },
 }
 ```

package/go.mod

@@ -2,11 +2,7 @@ module github.com/samchon/ttsc/packages/strip
 
 go 1.26
 
-require (
-	github.com/microsoft/typescript-go/shim/ast v0.0.0
-	github.com/microsoft/typescript-go/shim/core v0.0.0
-	github.com/microsoft/typescript-go/shim/parser v0.0.0
-)
+require github.com/samchon/ttsc/packages/ttsc v0.0.0
 
 require (
 	github.com/go-json-experiment/json v0.0.0-20260214004413-d219187c3433 // indirect

package/package.json

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

package/plugin/main.go

@@ -1,13 +1,11 @@
 // 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"
+
+  "github.com/samchon/ttsc/packages/ttsc/utility"
 )
 
 const version = "0.0.1"
@@ -18,19 +16,19 @@ func main() {
 
 func run(args []string) int {
   if len(args) == 0 {
-    fmt.Fprintln(os.Stderr, "@ttsc/strip: command required (expected output|version)")
+    fmt.Fprintln(os.Stderr, "@ttsc/strip: command required (expected build|transform|check|version)")
     return 2
   }
   switch args[0] {
   case "-v", "--version", "version":
     fmt.Fprintf(os.Stdout, "@ttsc/strip %s\n", version)
     return 0
+  case "build":
+    return utility.RunBuild(args[1:])
+  case "transform":
+    return utility.RunTransform(args[1:])
   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,385 +1,3 @@
-// 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"
-
-  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 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 stores dotted call patterns such as console.log or invariant.*.
-  // stripDebugger controls DebuggerStatement removal independently.
-  calls         []callPattern
-  stripDebugger bool
-}
-
-type callPattern struct {
-  // 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
-}
-
-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
-}
-
-func Apply(fileName string, text string, config map[string]any) (string, error) {
-  // 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
-}
-
-func (s *stripTransform) apply(fileName string, text string) (string, error) {
-  // 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
-}
-
-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 {
-      // 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)
-}
-
-func callExpressionName(expr *shimast.Node) (string, bool) {
-  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
-  }
-}
-
-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)
-}
-
-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
-}
-
-func statementRemovalRange(text string, node *shimast.Node) (int, int) {
-  // 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 {
-      // 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")
-}
-
-func isJavaScriptOutput(fileName string) bool {
-  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
-}
-
-func clamp(value int, min int, max int) int {
-  if value < min {
-    return min
-  }
-  if value > max {
-    return max
-  }
-  return value
-}
+// Strip transform logic lives in github.com/samchon/ttsc/packages/ttsc/utility.

package/src/index.cjs

@@ -7,6 +7,6 @@ module.exports = function createTtscStrip() {
   return {
     name: "@ttsc/strip",
     source: path.resolve(__dirname, "..", "plugin"),
-    stage: "output",
+    stage: "transform",
   };
 };