@ttsc/wasm 0.12.2 → 0.12.4

package/cmd/ttsc-wasm/main.go

@@ -9,122 +9,134 @@
 package main
 
 import (
-	"fmt"
-	"io"
-	"os"
-	"runtime"
+  "fmt"
+  "io"
+  "os"
+  "runtime"
 
-	"github.com/samchon/ttsc/packages/wasm/host"
+  "github.com/samchon/ttsc/packages/wasm/host"
 )
 
 // Build metadata. Overridden via -ldflags from build/build-wasm.cjs.
 var (
-	version = "0.0.0-dev"
-	commit  = "dev"
-	date    = "unknown"
+  version = "0.0.0-dev"
+  commit  = "dev"
+  date    = "unknown"
 )
 
 func main() {
-	os.Exit(run(os.Args[1:]))
+  os.Exit(run(os.Args[1:]))
 }
 
+// run is the testable core of main. It dispatches the first argument as a
+// subcommand and returns the OS exit code.
 func run(args []string) int {
-	if len(args) == 0 {
-		printHelp(os.Stdout)
-		return 0
-	}
-	switch args[0] {
-	case "-h", "--help", "help":
-		printHelp(os.Stdout)
-		return 0
-	case "-v", "--version", "version":
-		printVersion(os.Stdout)
-		return 0
-	case "build":
-		return runBuild(args[1:])
-	case "check":
-		return runCheck(args[1:])
-	case "transform":
-		return runTransform(args[1:])
-	default:
-		fmt.Fprintf(os.Stderr, "ttsc-wasm: unknown command %q\n", args[0])
-		printHelp(os.Stderr)
-		return 2
-	}
+  if len(args) == 0 {
+    printHelp(os.Stdout)
+    return 0
+  }
+  switch args[0] {
+  case "-h", "--help", "help":
+    printHelp(os.Stdout)
+    return 0
+  case "-v", "--version", "version":
+    printVersion(os.Stdout)
+    return 0
+  case "build":
+    return runBuild(args[1:])
+  case "check":
+    return runCheck(args[1:])
+  case "transform":
+    return runTransform(args[1:])
+  default:
+    fmt.Fprintf(os.Stderr, "ttsc-wasm: unknown command %q\n", args[0])
+    printHelp(os.Stderr)
+    return 2
+  }
 }
 
+// runBuild invokes host.Build and writes the JSON result to stdout.
 func runBuild(args []string) int {
-	cwd, tsconfig := parseProject(args)
-	data, code, err := host.Build(cwd, tsconfig)
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "ttsc-wasm build: %v\n", err)
-		return 2
-	}
-	_, _ = os.Stdout.Write(append(data, '\n'))
-	return code
+  cwd, tsconfig := parseProject(args)
+  data, code, err := host.Build(cwd, tsconfig)
+  if err != nil {
+    fmt.Fprintf(os.Stderr, "ttsc-wasm build: %v\n", err)
+    return 2
+  }
+  _, _ = os.Stdout.Write(append(data, '\n'))
+  return code
 }
 
+// runCheck invokes host.Check and writes the JSON result to stdout.
 func runCheck(args []string) int {
-	cwd, tsconfig := parseProject(args)
-	data, code, err := host.Check(cwd, tsconfig)
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "ttsc-wasm check: %v\n", err)
-		return 2
-	}
-	_, _ = os.Stdout.Write(append(data, '\n'))
-	return code
+  cwd, tsconfig := parseProject(args)
+  data, code, err := host.Check(cwd, tsconfig)
+  if err != nil {
+    fmt.Fprintf(os.Stderr, "ttsc-wasm check: %v\n", err)
+    return 2
+  }
+  _, _ = os.Stdout.Write(append(data, '\n'))
+  return code
 }
 
+// runTransform invokes host.Transform and writes the JSON result to stdout.
 func runTransform(args []string) int {
-	cwd, tsconfig := parseProject(args)
-	data, code, err := host.Transform(cwd, tsconfig)
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "ttsc-wasm transform: %v\n", err)
-		return 2
-	}
-	_, _ = os.Stdout.Write(append(data, '\n'))
-	return code
+  cwd, tsconfig := parseProject(args)
+  data, code, err := host.Transform(cwd, tsconfig)
+  if err != nil {
+    fmt.Fprintf(os.Stderr, "ttsc-wasm transform: %v\n", err)
+    return 2
+  }
+  _, _ = os.Stdout.Write(append(data, '\n'))
+  return code
 }
 
+// parseProject extracts --cwd and --tsconfig from args, defaulting to the
+// process working directory and "tsconfig.json" respectively. Both the
+// `--flag value` and `--flag=value` forms are accepted.
 func parseProject(args []string) (string, string) {
-	cwd, _ := os.Getwd()
-	tsconfig := "tsconfig.json"
-	for i := 0; i < len(args); i++ {
-		arg := args[i]
-		switch {
-		case arg == "--cwd" && i+1 < len(args):
-			cwd = args[i+1]
-			i++
-		case len(arg) > len("--cwd=") && arg[:6] == "--cwd=":
-			cwd = arg[6:]
-		case arg == "--tsconfig" && i+1 < len(args):
-			tsconfig = args[i+1]
-			i++
-		case len(arg) > len("--tsconfig=") && arg[:11] == "--tsconfig=":
-			tsconfig = arg[11:]
-		}
-	}
-	return cwd, tsconfig
+  cwd, _ := os.Getwd()
+  tsconfig := "tsconfig.json"
+  const cwdPrefix = "--cwd="
+  const tsconfigPrefix = "--tsconfig="
+  for i := 0; i < len(args); i++ {
+    arg := args[i]
+    switch {
+    case arg == "--cwd" && i+1 < len(args):
+      cwd = args[i+1]
+      i++
+    case len(arg) > len(cwdPrefix) && arg[:len(cwdPrefix)] == cwdPrefix:
+      cwd = arg[len(cwdPrefix):]
+    case arg == "--tsconfig" && i+1 < len(args):
+      tsconfig = args[i+1]
+      i++
+    case len(arg) > len(tsconfigPrefix) && arg[:len(tsconfigPrefix)] == tsconfigPrefix:
+      tsconfig = arg[len(tsconfigPrefix):]
+    }
+  }
+  return cwd, tsconfig
 }
 
+// printHelp writes the usage summary to w.
 func printHelp(w io.Writer) {
-	fmt.Fprintln(w, "Usage: ttsc-wasm <command> [--cwd=<dir>] [--tsconfig=<path>]")
-	fmt.Fprintln(w, "Commands:")
-	fmt.Fprintln(w, "  build       compile a project and print the JSON result")
-	fmt.Fprintln(w, "  check       type-check a project without emit")
-	fmt.Fprintln(w, "  transform   return every source file the program saw")
-	fmt.Fprintln(w, "  version     print version banner")
+  fmt.Fprintln(w, "Usage: ttsc-wasm <command> [--cwd=<dir>] [--tsconfig=<path>]")
+  fmt.Fprintln(w, "Commands:")
+  fmt.Fprintln(w, "  build       compile a project and print the JSON result")
+  fmt.Fprintln(w, "  check       type-check a project without emit")
+  fmt.Fprintln(w, "  transform   return every source file the program saw")
+  fmt.Fprintln(w, "  version     print version banner")
 }
 
+// printVersion writes the build metadata banner to w.
 func printVersion(w io.Writer) {
-	fmt.Fprintf(
-		w,
-		"ttsc-wasm %s (commit %s, built %s, %s/%s, go %s)\n",
-		version,
-		commit,
-		date,
-		runtime.GOOS,
-		runtime.GOARCH,
-		runtime.Version(),
-	)
+  fmt.Fprintf(
+    w,
+    "ttsc-wasm %s (commit %s, built %s, %s/%s, go %s)\n",
+    version,
+    commit,
+    date,
+    runtime.GOOS,
+    runtime.GOARCH,
+    runtime.Version(),
+  )
 }

package/cmd/ttsc-wasm/main_wasm.go

@@ -7,11 +7,13 @@
 package main
 
 import (
-	"github.com/samchon/ttsc/packages/wasm/host"
+  "github.com/samchon/ttsc/packages/wasm/host"
 )
 
+// main installs the base ttsc API on globalThis and blocks forever.
+// Expose never returns; the select{} inside it keeps the wasm runtime alive.
 func main() {
-	host.Expose("ttsc", host.Config{
-		Plugins: nil,
-	})
+  host.Expose("ttsc", host.Config{
+    Plugins: nil,
+  })
 }

package/host/api.go

@@ -6,14 +6,14 @@
 package host
 
 import (
-	"encoding/json"
-	"fmt"
-	"path/filepath"
-	"strings"
+  "encoding/json"
+  "fmt"
+  "path/filepath"
+  "strings"
 
-	shimcompiler "github.com/microsoft/typescript-go/shim/compiler"
+  shimcompiler "github.com/microsoft/typescript-go/shim/compiler"
 
-	"github.com/samchon/ttsc/packages/ttsc/driver"
+  "github.com/samchon/ttsc/packages/ttsc/driver"
 )
 
 // APIResult is the JSON shape every plugin-dispatch endpoint returns to the
@@ -21,185 +21,194 @@ import (
 // usage error, 3 runtime error). `stdout` / `stderr` are raw strings the
 // caller can render in a console panel.
 type APIResult struct {
-	Code   int    `json:"code"`
-	Stdout string `json:"stdout"`
-	Stderr string `json:"stderr"`
+  Code   int    `json:"code"`
+  Stdout string `json:"stdout"`
+  Stderr string `json:"stderr"`
 }
 
 // CompileResult mirrors `ttsc api-compile`. Field names are TypeScript-style
 // so JS callers can use it directly without remapping.
 type CompileResult struct {
-	Diagnostics []CompileDiagnostic `json:"diagnostics,omitempty"`
-	// Output maps cwd-relative paths to emitted JS / d.ts text. Empty when
-	// the program produced no files (e.g. `noEmit` projects).
-	Output map[string]string `json:"output"`
+  Diagnostics []CompileDiagnostic `json:"diagnostics,omitempty"`
+  // Output maps cwd-relative paths to emitted JS / d.ts text. Empty when
+  // the program produced no files (e.g. `noEmit` projects).
+  Output map[string]string `json:"output"`
 }
 
 // TransformResult is the no-emit companion. The `typescript` map keys files
 // the same way `output` does in compile mode.
 type TransformResult struct {
-	Diagnostics []CompileDiagnostic `json:"diagnostics,omitempty"`
-	TypeScript  map[string]string   `json:"typescript"`
+  Diagnostics []CompileDiagnostic `json:"diagnostics,omitempty"`
+  TypeScript  map[string]string   `json:"typescript"`
 }
 
 // CompileDiagnostic is the public TypeScript-side diagnostic DTO. Mirrors the
 // shape `ttsc api-compile` writes so the JS host can render it without
 // remapping fields.
 type CompileDiagnostic struct {
-	File        *string `json:"file"`
-	Category    string  `json:"category"`
-	Code        int32   `json:"code"`
-	Start       *int    `json:"start,omitempty"`
-	Length      *int    `json:"length,omitempty"`
-	Line        int     `json:"line,omitempty"`
-	Character   int     `json:"character,omitempty"`
-	MessageText string  `json:"messageText"`
+  File        *string `json:"file"`
+  Category    string  `json:"category"`
+  Code        int32   `json:"code"`
+  Start       *int    `json:"start,omitempty"`
+  Length      *int    `json:"length,omitempty"`
+  Line        int     `json:"line,omitempty"`
+  Character   int     `json:"character,omitempty"`
+  MessageText string  `json:"messageText"`
 }
 
 // Build runs `ttsc build`-shaped emit: load the project, emit JS, return the
 // emitted text map + diagnostics as JSON. `cwd` must be an absolute path
 // inside the host filesystem; `tsconfigPath` may be relative to cwd.
 func Build(cwd, tsconfigPath string) ([]byte, int, error) {
-	prog, diags, err := driver.LoadProgram(cwd, tsconfigPath, driver.LoadProgramOptions{
-		ForceEmit: true,
-	})
-	if err != nil {
-		return nil, 2, err
-	}
-	if prog != nil {
-		defer prog.Close()
-		diags = append(diags, prog.Diagnostics()...)
-	}
-	output := map[string]string{}
-	if prog != nil {
-		rewrites := driver.NewRewriteSet()
-		writeFile := shimcompiler.WriteFile(
-			func(fileName, text string, _ *shimcompiler.WriteFileData) error {
-				output[apiOutputKey(cwd, fileName)] = text
-				return nil
-			},
-		)
-		_, emitDiags, eerr := prog.EmitAll(rewrites, writeFile)
-		if eerr != nil {
-			return nil, 3, fmt.Errorf("emit failed: %w", eerr)
-		}
-		diags = append(diags, emitDiags...)
-	}
-	result := CompileResult{
-		Diagnostics: make([]CompileDiagnostic, 0, len(diags)),
-		Output:      output,
-	}
-	for _, d := range diags {
-		result.Diagnostics = append(result.Diagnostics, toAPIDiagnostic(d))
-	}
-	data, err := json.Marshal(result)
-	if err != nil {
-		return nil, 3, fmt.Errorf("result marshal failed: %w", err)
-	}
-	code := 0
-	if driver.CountErrors(diags) > 0 {
-		code = 2
-	}
-	return data, code, nil
+  prog, diags, err := driver.LoadProgram(cwd, tsconfigPath, driver.LoadProgramOptions{
+    ForceEmit: true,
+  })
+  if err != nil {
+    return nil, 2, err
+  }
+  if prog != nil {
+    defer prog.Close()
+    diags = append(diags, prog.Diagnostics()...)
+  }
+  output := map[string]string{}
+  if prog != nil {
+    rewrites := driver.NewRewriteSet()
+    writeFile := shimcompiler.WriteFile(
+      func(fileName, text string, _ *shimcompiler.WriteFileData) error {
+        output[apiOutputKey(cwd, fileName)] = text
+        return nil
+      },
+    )
+    _, emitDiags, eerr := prog.EmitAll(rewrites, writeFile)
+    if eerr != nil {
+      return nil, 3, fmt.Errorf("emit failed: %w", eerr)
+    }
+    diags = append(diags, emitDiags...)
+  }
+  result := CompileResult{
+    Diagnostics: make([]CompileDiagnostic, 0, len(diags)),
+    Output:      output,
+  }
+  for _, d := range diags {
+    result.Diagnostics = append(result.Diagnostics, toAPIDiagnostic(d))
+  }
+  data, err := json.Marshal(result)
+  if err != nil {
+    return nil, 3, fmt.Errorf("result marshal failed: %w", err)
+  }
+  code := 0
+  if driver.CountErrors(diags) > 0 {
+    code = 2
+  }
+  return data, code, nil
 }
 
 // Check runs the typecheck pipeline without emitting JS. The returned JSON
 // has the same shape as Build but with an empty `output` map.
 func Check(cwd, tsconfigPath string) ([]byte, int, error) {
-	prog, diags, err := driver.LoadProgram(cwd, tsconfigPath, driver.LoadProgramOptions{
-		ForceNoEmit: true,
-	})
-	if err != nil {
-		return nil, 2, err
-	}
-	if prog != nil {
-		defer prog.Close()
-		diags = append(diags, prog.Diagnostics()...)
-	}
-	result := CompileResult{
-		Diagnostics: make([]CompileDiagnostic, 0, len(diags)),
-		Output:      map[string]string{},
-	}
-	for _, d := range diags {
-		result.Diagnostics = append(result.Diagnostics, toAPIDiagnostic(d))
-	}
-	data, err := json.Marshal(result)
-	if err != nil {
-		return nil, 3, fmt.Errorf("result marshal failed: %w", err)
-	}
-	code := 0
-	if driver.CountErrors(diags) > 0 {
-		code = 2
-	}
-	return data, code, nil
+  prog, diags, err := driver.LoadProgram(cwd, tsconfigPath, driver.LoadProgramOptions{
+    ForceNoEmit: true,
+  })
+  if err != nil {
+    return nil, 2, err
+  }
+  if prog != nil {
+    defer prog.Close()
+    diags = append(diags, prog.Diagnostics()...)
+  }
+  result := CompileResult{
+    Diagnostics: make([]CompileDiagnostic, 0, len(diags)),
+    Output:      map[string]string{},
+  }
+  for _, d := range diags {
+    result.Diagnostics = append(result.Diagnostics, toAPIDiagnostic(d))
+  }
+  data, err := json.Marshal(result)
+  if err != nil {
+    return nil, 3, fmt.Errorf("result marshal failed: %w", err)
+  }
+  code := 0
+  if driver.CountErrors(diags) > 0 {
+    code = 2
+  }
+  return data, code, nil
 }
 
 // Transform returns every source file the program saw, keyed by
 // project-relative path. The playground uses this to render the TS view
 // after source rewrites (e.g. paths rewriting) have been applied.
 func Transform(cwd, tsconfigPath string) ([]byte, int, error) {
-	prog, diags, err := driver.LoadProgram(cwd, tsconfigPath, driver.LoadProgramOptions{
-		ForceNoEmit: true,
-	})
-	if err != nil {
-		return nil, 2, err
-	}
-	typescript := map[string]string{}
-	if prog != nil {
-		defer prog.Close()
-		for _, file := range prog.SourceFiles() {
-			typescript[apiOutputKey(cwd, file.FileName())] = file.Text()
-		}
-		diags = append(diags, prog.Diagnostics()...)
-	}
-	result := TransformResult{
-		Diagnostics: make([]CompileDiagnostic, 0, len(diags)),
-		TypeScript:  typescript,
-	}
-	for _, d := range diags {
-		result.Diagnostics = append(result.Diagnostics, toAPIDiagnostic(d))
-	}
-	data, err := json.Marshal(result)
-	if err != nil {
-		return nil, 3, fmt.Errorf("result marshal failed: %w", err)
-	}
-	code := 0
-	if driver.CountErrors(diags) > 0 {
-		code = 2
-	}
-	return data, code, nil
+  prog, diags, err := driver.LoadProgram(cwd, tsconfigPath, driver.LoadProgramOptions{
+    ForceNoEmit: true,
+  })
+  if err != nil {
+    return nil, 2, err
+  }
+  typescript := map[string]string{}
+  if prog != nil {
+    defer prog.Close()
+    for _, file := range prog.SourceFiles() {
+      typescript[apiOutputKey(cwd, file.FileName())] = file.Text()
+    }
+    diags = append(diags, prog.Diagnostics()...)
+  }
+  result := TransformResult{
+    Diagnostics: make([]CompileDiagnostic, 0, len(diags)),
+    TypeScript:  typescript,
+  }
+  for _, d := range diags {
+    result.Diagnostics = append(result.Diagnostics, toAPIDiagnostic(d))
+  }
+  data, err := json.Marshal(result)
+  if err != nil {
+    return nil, 3, fmt.Errorf("result marshal failed: %w", err)
+  }
+  code := 0
+  if driver.CountErrors(diags) > 0 {
+    code = 2
+  }
+  return data, code, nil
 }
 
+// toAPIDiagnostic converts a driver.Diagnostic into the JSON-serialisable
+// CompileDiagnostic. File paths are normalised to forward slashes so the JS
+// host can compare them against its own MemFS paths.
 func toAPIDiagnostic(diag driver.Diagnostic) CompileDiagnostic {
-	var file *string
-	if diag.File != "" {
-		value := filepath.ToSlash(diag.File)
-		file = &value
-	}
-	category := "error"
-	if diag.Severity == driver.SeverityWarning {
-		category = "warning"
-	}
-	return CompileDiagnostic{
-		File:        file,
-		Category:    category,
-		Code:        diag.Code,
-		Start:       diag.Start,
-		Length:      diag.Length,
-		Line:        diag.Line,
-		Character:   diag.Column,
-		MessageText: diag.Message,
-	}
+  var file *string
+  if diag.File != "" {
+    value := filepath.ToSlash(diag.File)
+    file = &value
+  }
+  category := "error"
+  if diag.Severity == driver.SeverityWarning {
+    category = "warning"
+  }
+  return CompileDiagnostic{
+    File:        file,
+    Category:    category,
+    Code:        diag.Code,
+    Start:       diag.Start,
+    Length:      diag.Length,
+    Line:        diag.Line,
+    Character:   diag.Column,
+    MessageText: diag.Message,
+  }
 }
 
+// apiOutputKey returns the map key used in CompileResult.Output and
+// TransformResult.TypeScript. Paths inside cwd are made project-relative;
+// paths outside cwd (e.g. lib files) are returned as absolute slash paths.
 func apiOutputKey(cwd, fileName string) string {
-	rel, err := filepath.Rel(cwd, fileName)
-	if err != nil || isOutsideRelativePath(rel) {
-		return filepath.ToSlash(fileName)
-	}
-	return filepath.ToSlash(rel)
+  rel, err := filepath.Rel(cwd, fileName)
+  if err != nil || isOutsideRelativePath(rel) {
+    return filepath.ToSlash(fileName)
+  }
+  return filepath.ToSlash(rel)
 }
 
+// isOutsideRelativePath reports whether rel escapes the base directory (i.e.
+// starts with ".."). Such paths should not be presented as project-relative
+// keys to the JS caller.
 func isOutsideRelativePath(rel string) bool {
-	return rel == ".." || strings.HasPrefix(rel, ".."+string(filepath.Separator))
+  return rel == ".." || strings.HasPrefix(rel, ".."+string(filepath.Separator))
 }

package/host/doc.go

@@ -3,20 +3,20 @@
 //
 // A consumer wasm looks like this:
 //
-//	//go:build js
-//	package main
+//  //go:build js
+//  package main
 //
-//	import (
-//	  "github.com/samchon/ttsc/packages/wasm/host"
-//	  yourplugin "example.com/your/plugin"
-//	)
+//  import (
+//    "github.com/samchon/ttsc/packages/wasm/host"
+//    yourplugin "example.com/your/plugin"
+//  )
 //
-//	func main() {
-//	  host.Expose("yourApi", host.Config{
-//	    Plugins: []host.Plugin{yourplugin.New()},
-//	  })
-//	  select {}
-//	}
+//  func main() {
+//    // Expose never returns; it installs the JS API and blocks forever.
+//    host.Expose("yourApi", host.Config{
+//      Plugins: []host.Plugin{yourplugin.New()},
+//    })
+//  }
 //
 // Expose binds `globalThis[name]` to an object that exposes ttsc's base
 // project commands (build, check, transform, version) plus a `plugin(name,