typia 13.0.0-dev.20260511 → 13.0.0-dev.20260514

package/README.md

@@ -1,4 +1,5 @@
 # Typia
+
 ![Typia Logo](https://typia.io/logo.png)
 
 [![GitHub license](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/samchon/typia/blob/master/LICENSE)
@@ -57,7 +58,30 @@ export function random<T>(g?: Partial<IRandomGenerator>): T;
 > - JSON serialization is **200x faster** than `class-transformer`
 > - LLM function calling harness turns **6.75% → 100%** accuracy
 
+<!--
+## Setup
+
+Install `typia@next` with the [`ttsc`](https://github.com/samchon/ttsc) toolchain.
+
+```bash
+# install
+npm i typia@next
+npm i -D ttsc @typescript/native-preview
+
+# build
+npx ttsc
+
+# run a script directly
+npx ttsx src/index.ts
+```
+
+You **must** use `ttsc` and `ttsx`. The stock `tsc`, `ts-node`, and `tsx` cannot apply the `typia` transform, so they will not work.
+
+For bundler integration (Vite, Next.js, Webpack, Rollup, esbuild, ...), use [`@ttsc/unplugin`](https://github.com/samchon/ttsc/tree/master/packages/unplugin).
+-->
+
 ## Transformation
+
 If you call `typia` function, it would be compiled like below.
 
 This is the key concept of `typia`, transforming TypeScript type to a runtime function. The `typia.is<T>()` function is transformed to a dedicated type checker by analyzing the target type `T` in the compilation level.
@@ -80,37 +104,34 @@ export const checkString = (() => {
 })();
 ```
 
-
-
 ## Sponsors
-Thanks for your support.
-
-Your donation encourages `typia` development.
-
-Also, `typia` is re-distributing quarter of donations to [`nonara/ts-patch`](https://github.com/nonara/ts-patch).
-
-[![Sponsors](https://opencollective.com/typia/badge.svg?avatarHeight=75&width=600)](https://opencollective.com/typia)
 
+[![Backers](https://opencollective.com/typia/backers.svg?avatarHeight=75&width=600)](https://opencollective.com/typia)
 
+Thanks for your support.
 
+Your [donation](https://opencollective.com/typia) encourages `typia` development.
 
 ## Playground
-You can experience how typia works by [playground website](https://typia.io/playground):
-
-  - 💻 https://typia.io/playground
-
 
+You can experience how typia works by [playground website](https://typia.io/playground):
 
+- 💻 https://typia.io/playground
 
 ## Guide Documents
+
 Check out the document in the [website](https://typia.io/docs/):
 
 ### 🏠 Home
+
 - [Introduction](https://typia.io/docs/)
 - [Setup](https://typia.io/docs/setup/)
+  - [Legacy (TypeScript v6)](https://typia.io/docs/setup/legacy)
+  - [TSGO (TypeScript v7)](https://typia.io/docs/setup/tsgo)
 - [Pure TypeScript](https://typia.io/docs/pure/)
   
 ### 📖 Features
+
 - Runtime Validators
   - [`assert()` function](https://typia.io/docs/validators/assert/)
   - [`is()` function](https://typia.io/docs/validators/is/)
@@ -134,6 +155,7 @@ Check out the document in the [website](https://typia.io/docs/):
 - [Miscellaneous](https://typia.io/docs/misc/)
 
 ### 🔗 Appendix
+
 - [API Documents](https://typia.io/api)
 - Utilization Cases
   - [MCP](https://typia.io/docs/utilization/mcp/)
@@ -144,9 +166,6 @@ Check out the document in the [website](https://typia.io/docs/):
 - [⇲ Benchmark Result](https://github.com/samchon/typia/tree/master/benchmark/results/11th%20Gen%20Intel(R)%20Core(TM)%20i5-1135G7%20%40%202.40GHz)
 - [⇲ `dev.to` Articles](https://dev.to/samchon/series/22474)
 
-
-
-
 ## Inspired By
+
 - [`typescript-is`](https://github.com/woutervh-/typescript-is)
-- [`ts-patch`](https://github.com/nonara/ts-patch)

package/native/adapter/adapter.go

@@ -79,10 +79,20 @@ func emitCallWithOptions(program *driver.Program, site CallSite, plugin PluginOp
       }
     }
   }()
-  node := nativetransform.CallExpressionTransformer.Transform(nativetransform.CallExpressionTransformer_TransformProps{
-    Context:    context,
-    Expression: site.Call,
-  })
+  var node *shimast.Node
+  if site.Module != "" && site.Method != "" {
+    node = nativetransform.CallExpressionTransformer.TransformKnown(nativetransform.CallExpressionTransformer_TransformKnownProps{
+      Context:    context,
+      Expression: site.Call,
+      Module:     site.Module,
+      Method:     site.Method,
+    })
+  } else {
+    node = nativetransform.CallExpressionTransformer.Transform(nativetransform.CallExpressionTransformer_TransformProps{
+      Context:    context,
+      Expression: site.Call,
+    })
+  }
   if node == nil || node == site.Call.AsNode() {
     return "", false, nil
   }

package/native/adapter/imports.go

@@ -4,15 +4,25 @@ import (
   "path/filepath"
   "strconv"
   "strings"
+  "sync"
   "unicode"
 
   shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
+type commonJSImportIdentifierSubstitutionsCacheEntry struct {
+  value map[string]string
+}
+
+var commonJSImportIdentifierSubstitutionsCache sync.Map
+
 func commonJSImportIdentifierSubstitutions(file *shimast.SourceFile) map[string]string {
   if file == nil || file.Statements == nil {
     return nil
   }
+  if cached, ok := commonJSImportIdentifierSubstitutionsCache.Load(file); ok {
+    return cached.(commonJSImportIdentifierSubstitutionsCacheEntry).value
+  }
   output := map[string]string{}
   counts := map[string]int{}
   for _, stmt := range file.Statements.Nodes {
@@ -61,8 +71,9 @@ func commonJSImportIdentifierSubstitutions(file *shimast.SourceFile) map[string]
     }
   }
   if len(output) == 0 {
-    return nil
+    output = nil
   }
+  commonJSImportIdentifierSubstitutionsCache.Store(file, commonJSImportIdentifierSubstitutionsCacheEntry{value: output})
   return output
 }
 

package/native/cmd/ttsc-typia/main.go

@@ -1,3 +1,5 @@
+//go:build !js
+
 package main
 
 import (

package/native/cmd/ttsc-typia/main_wasm.go

@@ -0,0 +1,226 @@
+//go:build js && wasm
+
+package main
+
+import (
+  "bytes"
+  "fmt"
+  "io"
+  "os"
+  "runtime"
+  "syscall/js"
+  "time"
+)
+
+// Reuse the same package-level identifiers the native CLI declares. Under
+// `js && wasm`, the native `main.go` is excluded, so we re-declare them here.
+var (
+  version = "0.1.0-dev"
+  commit  = "dev"
+  date    = "unknown"
+)
+
+var (
+  stdout io.Writer = os.Stdout
+  stderr io.Writer = os.Stderr
+)
+
+// main keeps the Go runtime alive forever after registering the JS entry
+// points. JS code calls `globalThis.ttscTypia.transform({...})` repeatedly;
+// each call reuses the same Go process (no re-instantiation cost).
+func main() {
+  api := map[string]any{
+    "transform": js.FuncOf(jsTransform),
+    "build":     js.FuncOf(jsBuild),
+    "version":   js.FuncOf(jsVersion),
+  }
+  js.Global().Set("ttscTypia", js.ValueOf(api))
+
+  // Signal readiness so the JS host can resolve a "ready" promise.
+  if ready := js.Global().Get("ttscTypiaReady"); ready.Type() == js.TypeFunction {
+    ready.Invoke()
+  }
+
+  // A perpetual idle goroutine prevents Go's wasm deadlock detector from
+  // tripping while syscall.fsCall callbacks are in flight. `select {}` alone
+  // is wrongly classified as "all goroutines asleep" the moment the FS path
+  // hands the request off to JS.
+  go func() {
+    for {
+      time.Sleep(time.Hour)
+    }
+  }()
+  select {}
+}
+
+// jsVersion returns the build metadata for this wasm binary.
+func jsVersion(this js.Value, args []js.Value) any {
+  return js.ValueOf(map[string]any{
+    "version": version,
+    "commit":  commit,
+    "date":    date,
+    "go":      runtime.Version(),
+    "goos":    runtime.GOOS,
+    "goarch":  runtime.GOARCH,
+  })
+}
+
+// jsTransform runs the project transform pipeline on a single file.
+//
+// JS input shape:
+//   {
+//     cwd:      string,   // absolute virtual path
+//     tsconfig: string,   // absolute path to tsconfig.json
+//     file?:    string,   // absolute path of the .ts file to rewrite. Omit
+//                         // for project-wide JSON output.
+//     output?:  "ts"|"js",
+//   }
+//
+// JS output: Promise<{ code: number, stdout: string, stderr: string }>.
+//
+// The handler returns a Promise so the JS event loop can drain while Go
+// services its own asynchronous file-system callbacks. Returning a synchronous
+// value would re-enter JS and deadlock on `fs.stat` callbacks.
+//
+// Caller is responsible for populating an in-memory filesystem (via the
+// `globalThis.fs` shim picked up by wasm_exec.js) with every path referenced
+// here before invoking transform.
+func jsTransform(this js.Value, args []js.Value) any {
+  if len(args) == 0 || args[0].Type() != js.TypeObject {
+    return errorPromise(2, "ttsc-typia: transform requires an options object")
+  }
+  argv := transformArgs(args[0])
+  return makePromise(func() any {
+    return runWithCapturedIO(func() int { return runTransform(argv) })
+  })
+}
+
+// jsBuild runs the project build pipeline. JS input mirrors jsTransform but
+// has no `file`/`output`. Returns a Promise.
+func jsBuild(this js.Value, args []js.Value) any {
+  if len(args) == 0 || args[0].Type() != js.TypeObject {
+    return errorPromise(2, "ttsc-typia: build requires an options object")
+  }
+  argv := buildArgs(args[0])
+  return makePromise(func() any {
+    return runWithCapturedIO(func() int { return runBuild(argv) })
+  })
+}
+
+// makePromise wraps a Go computation as a JS Promise. The returned object is
+// `new Promise((resolve, reject) => { ... })`. The executor synchronously
+// captures the callbacks; the work itself runs in a goroutine so the JS event
+// loop can drive `fs.stat` and friends to completion before we ask Go to
+// receive the callback.
+func makePromise(work func() any) js.Value {
+  var executor js.Func
+  executor = js.FuncOf(func(this js.Value, args []js.Value) any {
+    resolve := args[0]
+    reject := args[1]
+    go func() {
+      defer func() {
+        if r := recover(); r != nil {
+          err := js.Global().Get("Error").New(fmt.Sprintf("%v", r))
+          reject.Invoke(err)
+        }
+        executor.Release()
+      }()
+      resolve.Invoke(work())
+    }()
+    return nil
+  })
+  return js.Global().Get("Promise").New(executor)
+}
+
+func errorPromise(code int, message string) js.Value {
+  return makePromise(func() any { return errorResponse(code, message) })
+}
+
+func transformArgs(opts js.Value) []string {
+  out := []string{}
+  if v := stringProp(opts, "cwd"); v != "" {
+    out = append(out, "--cwd="+v)
+  }
+  if v := stringProp(opts, "tsconfig"); v != "" {
+    out = append(out, "--tsconfig="+v)
+  } else {
+    out = append(out, "--tsconfig=tsconfig.json")
+  }
+  if v := stringProp(opts, "file"); v != "" {
+    out = append(out, "--file="+v)
+  }
+  if v := stringProp(opts, "output"); v != "" {
+    out = append(out, "--output="+v)
+  } else {
+    out = append(out, "--output=ts")
+  }
+  return out
+}
+
+func buildArgs(opts js.Value) []string {
+  out := []string{}
+  if v := stringProp(opts, "cwd"); v != "" {
+    out = append(out, "--cwd="+v)
+  }
+  if v := stringProp(opts, "tsconfig"); v != "" {
+    out = append(out, "--tsconfig="+v)
+  } else {
+    out = append(out, "--tsconfig=tsconfig.json")
+  }
+  if outDir := stringProp(opts, "outDir"); outDir != "" {
+    out = append(out, "--outDir="+outDir)
+  }
+  if boolProp(opts, "emit") {
+    out = append(out, "--emit")
+  }
+  if boolProp(opts, "noEmit") {
+    out = append(out, "--noEmit")
+  }
+  return out
+}
+
+func runWithCapturedIO(task func() int) any {
+  // Swap the package-level writers so the inner Go functions feel like a
+  // normal CLI invocation but their output lands in JS-visible buffers.
+  // This is safe under the contract that JS calls are serialized (no
+  // concurrent invocations from JS).
+  oldOut, oldErr := stdout, stderr
+  var outBuf, errBuf bytes.Buffer
+  stdout = &outBuf
+  stderr = &errBuf
+  defer func() {
+    stdout = oldOut
+    stderr = oldErr
+  }()
+
+  code := task()
+  return js.ValueOf(map[string]any{
+    "code":   code,
+    "stdout": outBuf.String(),
+    "stderr": errBuf.String(),
+  })
+}
+
+func errorResponse(code int, message string) any {
+  return js.ValueOf(map[string]any{
+    "code":   code,
+    "stdout": "",
+    "stderr": fmt.Sprintf("%s\n", message),
+  })
+}
+
+func stringProp(obj js.Value, key string) string {
+  v := obj.Get(key)
+  if v.Type() != js.TypeString {
+    return ""
+  }
+  return v.String()
+}
+
+func boolProp(obj js.Value, key string) bool {
+  v := obj.Get(key)
+  if v.Type() != js.TypeBoolean {
+    return false
+  }
+  return v.Bool()
+}