typia 13.0.0-dev.20260430 → 13.0.0-dev.20260502-2

package/native/transform/internal/GenericTransformer.go

@@ -1,14 +1,14 @@
 package internal
 
 import (
-	"encoding/json"
-	"strings"
-
-	shimast "github.com/microsoft/typescript-go/shim/ast"
-	shimchecker "github.com/microsoft/typescript-go/shim/checker"
-	shimscanner "github.com/microsoft/typescript-go/shim/scanner"
-	nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
-	nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+  "encoding/json"
+  "strings"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimchecker "github.com/microsoft/typescript-go/shim/checker"
+  shimscanner "github.com/microsoft/typescript-go/shim/scanner"
+  nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
+  nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
 )
 
 type genericTransformerNamespace struct{}
@@ -16,220 +16,220 @@ type genericTransformerNamespace struct{}
 var GenericTransformer = genericTransformerNamespace{}
 
 type ITransformProps struct {
-	Context    nativecontext.ITypiaContext
-	Modulo     *shimast.Node
-	Expression *shimast.CallExpression
+  Context    nativecontext.ITypiaContext
+  Modulo     *shimast.Node
+  Expression *shimast.CallExpression
 }
 
 type TransformerError struct {
-	Code    string
-	Message string
+  Code    string
+  Message string
 }
 
 func NewTransformerError(props TransformerError_IProps) *TransformerError {
-	return &TransformerError{
-		Code:    props.Code,
-		Message: props.Message,
-	}
+  return &TransformerError{
+    Code:    props.Code,
+    Message: props.Message,
+  }
 }
 
 func (err *TransformerError) Error() string {
-	return err.Message
+  return err.Message
 }
 
 type TransformerError_IProps struct {
-	Code    string
-	Message string
+  Code    string
+  Message string
 }
 
 type TransformerError_MetadataFactory_IError struct {
-	Name     string
-	Explore  TransformerError_MetadataFactory_IExplore
-	Messages []string
+  Name     string
+  Explore  TransformerError_MetadataFactory_IExplore
+  Messages []string
 }
 
 type TransformerError_MetadataFactory_IExplore struct {
-	Object    *nativemetadata.MetadataObjectType
-	Property  any
-	Parameter any
-	Output    bool
+  Object    *nativemetadata.MetadataObjectType
+  Property  any
+  Parameter any
+  Output    bool
 }
 
 func TransformerError_from(props struct {
-	Code   string
-	Errors []TransformerError_MetadataFactory_IError
+  Code   string
+  Errors []TransformerError_MetadataFactory_IError
 }) *TransformerError {
-	lines := make([]string, 0, len(props.Errors))
-	for _, err := range props.Errors {
-		subject := ""
-		if err.Explore.Object != nil {
-			subject = transformerError_join(err.Explore.Object, err.Explore.Property)
-		}
-		middle := ""
-		if err.Explore.Parameter != nil {
-			middle = "(parameter: " + transformerError_json(err.Explore.Parameter) + ")"
-		} else if err.Explore.Output {
-			middle = "(return type)"
-		}
-		typ := err.Name
-		if subject != "" {
-			typ = subject + ": " + typ
-		}
-		messages := make([]string, 0, len(err.Messages))
-		for _, msg := range err.Messages {
-			messages = append(messages, "  - "+msg)
-		}
-		lines = append(lines, "- "+typ+middle+"\n"+strings.Join(messages, "\n"))
-	}
-	return NewTransformerError(TransformerError_IProps{
-		Code:    props.Code,
-		Message: "unsupported type detected\n\n" + strings.Join(lines, "\n\n"),
-	})
+  lines := make([]string, 0, len(props.Errors))
+  for _, err := range props.Errors {
+    subject := ""
+    if err.Explore.Object != nil {
+      subject = transformerError_join(err.Explore.Object, err.Explore.Property)
+    }
+    middle := ""
+    if err.Explore.Parameter != nil {
+      middle = "(parameter: " + transformerError_json(err.Explore.Parameter) + ")"
+    } else if err.Explore.Output {
+      middle = "(return type)"
+    }
+    typ := err.Name
+    if subject != "" {
+      typ = subject + ": " + typ
+    }
+    messages := make([]string, 0, len(err.Messages))
+    for _, msg := range err.Messages {
+      messages = append(messages, "  - "+msg)
+    }
+    lines = append(lines, "- "+typ+middle+"\n"+strings.Join(messages, "\n"))
+  }
+  return NewTransformerError(TransformerError_IProps{
+    Code:    props.Code,
+    Message: "unsupported type detected\n\n" + strings.Join(lines, "\n\n"),
+  })
 }
 
 func transformerError_join(object *nativemetadata.MetadataObjectType, key any) string {
-	if key == nil {
-		return object.Name
-	}
-	if _, ok := key.(map[string]any); ok {
-		return object.Name + "[key]"
-	}
-	if str, ok := key.(string); ok {
-		if transformerError_variable(str) {
-			return object.Name + "." + str
-		}
-		return object.Name + "[" + transformerError_json(str) + "]"
-	}
-	return object.Name + "[key]"
+  if key == nil {
+    return object.Name
+  }
+  if _, ok := key.(map[string]any); ok {
+    return object.Name + "[key]"
+  }
+  if str, ok := key.(string); ok {
+    if transformerError_variable(str) {
+      return object.Name + "." + str
+    }
+    return object.Name + "[" + transformerError_json(str) + "]"
+  }
+  return object.Name + "[key]"
 }
 
 func transformerError_variable(str string) bool {
-	if str == "" {
-		return false
-	}
-	for i, ch := range str {
-		if i == 0 {
-			if ('A' <= ch && ch <= 'Z') || ('a' <= ch && ch <= 'z') || ch == '_' || ch == '$' {
-				continue
-			}
-			return false
-		}
-		if ('A' <= ch && ch <= 'Z') || ('a' <= ch && ch <= 'z') || ('0' <= ch && ch <= '9') || ch == '_' || ch == '$' {
-			continue
-		}
-		return false
-	}
-	return true
+  if str == "" {
+    return false
+  }
+  for i, ch := range str {
+    if i == 0 {
+      if ('A' <= ch && ch <= 'Z') || ('a' <= ch && ch <= 'z') || ch == '_' || ch == '$' {
+        continue
+      }
+      return false
+    }
+    if ('A' <= ch && ch <= 'Z') || ('a' <= ch && ch <= 'z') || ('0' <= ch && ch <= '9') || ch == '_' || ch == '$' {
+      continue
+    }
+    return false
+  }
+  return true
 }
 
 func transformerError_json(value any) string {
-	data, err := json.Marshal(value)
-	if err != nil {
-		return "null"
-	}
-	return string(data)
+  data, err := json.Marshal(value)
+  if err != nil {
+    return "null"
+  }
+  return string(data)
 }
 
 type GenericTransformer_IProps struct {
-	ITransformProps
-	Method string
-	Write  func(props nativecontext.IProgrammerProps) *shimast.Node
+  ITransformProps
+  Method string
+  Write  func(props nativecontext.IProgrammerProps) *shimast.Node
 }
 
 var genericTransformer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
 
 func (genericTransformerNamespace) Scalar(props GenericTransformer_IProps) *shimast.Node {
-	if props.Expression == nil || props.Expression.Arguments == nil || len(props.Expression.Arguments.Nodes) == 0 {
-		panic(NewTransformerError(TransformerError_IProps{
-			Code:    "typia." + props.Method,
-			Message: "no input value.",
-		}))
-	}
-
-	var typ = props.Context.Checker.GetTypeAtLocation(props.Expression.Arguments.Nodes[0])
-	var node *shimast.Node = props.Expression.Arguments.Nodes[0]
-	generic := false
-	if props.Expression.TypeArguments != nil && len(props.Expression.TypeArguments.Nodes) != 0 {
-		node = props.Expression.TypeArguments.Nodes[0]
-		typ = props.Context.Checker.GetTypeFromTypeNode(node)
-		generic = true
-	}
-	if typ != nil && typ.IsTypeParameter() {
-		panic(NewTransformerError(TransformerError_IProps{
-			Code:    "typia." + props.Method,
-			Message: "non-specified generic argument.",
-		}))
-	}
-
-	name := ""
-	if generic {
-		name = genericTransformer_node_text(node)
-	} else {
-		name = genericTransformer_getTypeName(genericTransformer_getTypeNameProps{
-			Context: props.Context,
-			Type:    typ,
-			Node:    node,
-		})
-	}
-	return genericTransformer_factory.NewCallExpression(
-		props.Write(nativecontext.IProgrammerProps{
-			Context: props.Context,
-			Modulo:  props.Modulo,
-			Type:    typ,
-			Name:    &name,
-		}),
-		nil,
-		nil,
-		props.Expression.Arguments,
-		shimast.NodeFlagsNone,
-	)
+  if props.Expression == nil || props.Expression.Arguments == nil || len(props.Expression.Arguments.Nodes) == 0 {
+    panic(NewTransformerError(TransformerError_IProps{
+      Code:    "typia." + props.Method,
+      Message: "no input value.",
+    }))
+  }
+
+  var typ = props.Context.Checker.GetTypeAtLocation(props.Expression.Arguments.Nodes[0])
+  var node *shimast.Node = props.Expression.Arguments.Nodes[0]
+  generic := false
+  if props.Expression.TypeArguments != nil && len(props.Expression.TypeArguments.Nodes) != 0 {
+    node = props.Expression.TypeArguments.Nodes[0]
+    typ = props.Context.Checker.GetTypeFromTypeNode(node)
+    generic = true
+  }
+  if typ != nil && typ.IsTypeParameter() {
+    panic(NewTransformerError(TransformerError_IProps{
+      Code:    "typia." + props.Method,
+      Message: "non-specified generic argument.",
+    }))
+  }
+
+  name := ""
+  if generic {
+    name = genericTransformer_node_text(node)
+  } else {
+    name = genericTransformer_getTypeName(genericTransformer_getTypeNameProps{
+      Context: props.Context,
+      Type:    typ,
+      Node:    node,
+    })
+  }
+  return genericTransformer_factory.NewCallExpression(
+    props.Write(nativecontext.IProgrammerProps{
+      Context: props.Context,
+      Modulo:  props.Modulo,
+      Type:    typ,
+      Name:    &name,
+    }),
+    nil,
+    nil,
+    props.Expression.Arguments,
+    shimast.NodeFlagsNone,
+  )
 }
 
 func (genericTransformerNamespace) Factory(props GenericTransformer_IProps) *shimast.Node {
-	if props.Expression == nil || props.Expression.TypeArguments == nil || len(props.Expression.TypeArguments.Nodes) == 0 {
-		panic(NewTransformerError(TransformerError_IProps{
-			Code:    "typia." + props.Method,
-			Message: "generic argument is not specified.",
-		}))
-	}
-	node := props.Expression.TypeArguments.Nodes[0]
-	typ := props.Context.Checker.GetTypeFromTypeNode(node)
-	if typ != nil && typ.IsTypeParameter() {
-		panic(NewTransformerError(TransformerError_IProps{
-			Code:    "typia." + props.Method,
-			Message: "non-specified generic argument.",
-		}))
-	}
-	name := genericTransformer_node_text(node)
-	var init *shimast.Node
-	if props.Expression.Arguments != nil && len(props.Expression.Arguments.Nodes) != 0 {
-		init = props.Expression.Arguments.Nodes[0]
-	}
-	return props.Write(nativecontext.IProgrammerProps{
-		Context: props.Context,
-		Modulo:  props.Modulo,
-		Type:    typ,
-		Name:    &name,
-		Init:    init,
-	})
+  if props.Expression == nil || props.Expression.TypeArguments == nil || len(props.Expression.TypeArguments.Nodes) == 0 {
+    panic(NewTransformerError(TransformerError_IProps{
+      Code:    "typia." + props.Method,
+      Message: "generic argument is not specified.",
+    }))
+  }
+  node := props.Expression.TypeArguments.Nodes[0]
+  typ := props.Context.Checker.GetTypeFromTypeNode(node)
+  if typ != nil && typ.IsTypeParameter() {
+    panic(NewTransformerError(TransformerError_IProps{
+      Code:    "typia." + props.Method,
+      Message: "non-specified generic argument.",
+    }))
+  }
+  name := genericTransformer_node_text(node)
+  var init *shimast.Node
+  if props.Expression.Arguments != nil && len(props.Expression.Arguments.Nodes) != 0 {
+    init = props.Expression.Arguments.Nodes[0]
+  }
+  return props.Write(nativecontext.IProgrammerProps{
+    Context: props.Context,
+    Modulo:  props.Modulo,
+    Type:    typ,
+    Name:    &name,
+    Init:    init,
+  })
 }
 
 func genericTransformer_node_text(node *shimast.Node) string {
-	if node == nil {
-		return ""
-	}
-	return strings.TrimSpace(shimscanner.GetTextOfNode(node))
+  if node == nil {
+    return ""
+  }
+  return strings.TrimSpace(shimscanner.GetTextOfNode(node))
 }
 
 type genericTransformer_getTypeNameProps struct {
-	Context nativecontext.ITypiaContext
-	Type    *shimchecker.Type
-	Node    *shimast.Node
+  Context nativecontext.ITypiaContext
+  Type    *shimchecker.Type
+  Node    *shimast.Node
 }
 
 func genericTransformer_getTypeName(props genericTransformer_getTypeNameProps) string {
-	if props.Context.Checker == nil || props.Type == nil {
-		return ""
-	}
-	return props.Context.Checker.TypeToString(props.Type)
+  if props.Context.Checker == nil || props.Type == nil {
+    return ""
+  }
+  return props.Context.Checker.TypeToString(props.Type)
 }

package/native/transform/transform.go

@@ -1,50 +1,50 @@
 package transform
 
 import (
-	shimast "github.com/microsoft/typescript-go/shim/ast"
-	shimcore "github.com/microsoft/typescript-go/shim/core"
-	"github.com/samchon/ttsc/packages/ttsc/driver"
-	nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimcore "github.com/microsoft/typescript-go/shim/core"
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+  nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
 )
 
 type TransformFactory func(file *shimast.SourceFile) *shimast.SourceFile
 
 func Transform(program *driver.Program, options *nativecontext.ITransformOptions, extras nativecontext.ITypiaContext_Extras) TransformFactory {
-	compilerOptions := transform_compilerOptions(program)
-	if transform_strict(compilerOptions) == false && extras.AddDiagnostic != nil {
-		extras.AddDiagnostic(&shimast.Diagnostic{})
-	}
-	opt := nativecontext.ITransformOptions{}
-	if options != nil {
-		opt = *options
-	}
-	return TransformFactory(FileTransformer.Transform(FileTransformer_IEnvironments{
-		Program:         program,
-		CompilerOptions: compilerOptions,
-		Checker:         transform_checker(program),
-		Printer:         nil,
-		Options:         opt,
-		Extras:          extras,
-	})(nil))
+  compilerOptions := transform_compilerOptions(program)
+  if transform_strict(compilerOptions) == false && extras.AddDiagnostic != nil {
+    extras.AddDiagnostic(&shimast.Diagnostic{})
+  }
+  opt := nativecontext.ITransformOptions{}
+  if options != nil {
+    opt = *options
+  }
+  return TransformFactory(FileTransformer.Transform(FileTransformer_IEnvironments{
+    Program:         program,
+    CompilerOptions: compilerOptions,
+    Checker:         transform_checker(program),
+    Printer:         nil,
+    Options:         opt,
+    Extras:          extras,
+  })(nil))
 }
 
 func transform_compilerOptions(program *driver.Program) *shimcore.CompilerOptions {
-	if program == nil || program.ParsedConfig == nil || program.ParsedConfig.ParsedConfig == nil {
-		return nil
-	}
-	return program.ParsedConfig.ParsedConfig.CompilerOptions
+  if program == nil || program.ParsedConfig == nil || program.ParsedConfig.ParsedConfig == nil {
+    return nil
+  }
+  return program.ParsedConfig.ParsedConfig.CompilerOptions
 }
 
 func transform_checker(program *driver.Program) any {
-	if program == nil {
-		return nil
-	}
-	return program.Checker
+  if program == nil {
+    return nil
+  }
+  return program.Checker
 }
 
 func transform_strict(options *shimcore.CompilerOptions) bool {
-	if options == nil {
-		return true
-	}
-	return options.GetStrictOptionValue(options.StrictNullChecks)
+  if options == nil {
+    return true
+  }
+  return options.GetStrictOptionValue(options.StrictNullChecks)
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typia",
-  "version": "13.0.0-dev.20260430",
+  "version": "13.0.0-dev.20260502-2",
   "description": "Superfast runtime validators with only one line",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -42,8 +42,8 @@
     "inquirer": "^8.2.5",
     "package-manager-detector": "^0.2.0",
     "randexp": "^0.5.3",
-    "@typia/interface": "^13.0.0-dev.20260430",
-    "@typia/utils": "^13.0.0-dev.20260430"
+    "@typia/interface": "^13.0.0-dev.20260502-2",
+    "@typia/utils": "^13.0.0-dev.20260502-2"
   },
   "devDependencies": {
     "@rollup/plugin-commonjs": "^29.0.0",
@@ -61,7 +61,7 @@
     "rollup-plugin-node-externals": "^8.1.2",
     "suppress-warnings": "^1.0.2",
     "tinyglobby": "^0.2.12",
-    "ttsc": "^0.6.0"
+    "ttsc": "^0.7.2"
   },
   "sideEffects": [
     "./lib/_virtual/*.mjs",

package/src/executable/TypiaGenerateWizard.ts

@@ -1,7 +1,11 @@
 import fs from "fs";
 import { createRequire } from "module";
 import path from "path";
-import { transform } from "ttsc";
+import {
+  type ITtscCompilerDiagnostic,
+  type ITtscCompilerTransformation,
+  TtscCompiler,
+} from "ttsc";
 
 import { ArgumentParser } from "./setup/ArgumentParser";
 import { PackageManager } from "./setup/PackageManager";
@@ -111,23 +115,51 @@ export namespace TypiaGenerateWizard {
       to: location.output,
     });
 
-    const cwd = path.dirname(location.project);
     const binary = resolveTsgoBinary();
+    const cwd = path.dirname(location.project);
+    const transformed = transformProject({
+      binary,
+      cwd,
+      tsconfig: location.project,
+    });
     for (const file of files) {
       const relative = path.relative(location.input, file);
       const target = path.join(location.output, relative);
-      const output = transform({
-        binary,
-        cwd,
-        file,
-        tsconfig: location.project,
-        plugins: [{ transform: "typia/lib/transform" }],
-      });
+      const output = transformed[projectKey(cwd, file)];
+      if (output === undefined) {
+        throw new URIError(
+          `Error on TypiaGenerateWizard.generate(): no transformed output for ${file}`,
+        );
+      }
       await fs.promises.mkdir(path.dirname(target), { recursive: true });
       await fs.promises.writeFile(target, formatOutput(output), "utf8");
     }
   }
 
+  function transformProject(props: {
+    binary: string;
+    cwd: string;
+    tsconfig: string;
+  }): Record<string, string> {
+    const result: ITtscCompilerTransformation = new TtscCompiler({
+      binary: props.binary,
+      cwd: props.cwd,
+      plugins: [{ transform: "typia/lib/transform" }],
+      tsconfig: props.tsconfig,
+    }).transform();
+    if (result.type === "success") {
+      return result.typescript;
+    }
+    if (result.type === "failure") {
+      throw new URIError(
+        `Error on TypiaGenerateWizard.generate(): ${formatDiagnostics(result.diagnostics)}`,
+      );
+    }
+    throw new URIError(
+      `Error on TypiaGenerateWizard.generate(): ${formatUnknownError(result.error)}`,
+    );
+  }
+
   function resolveTsgoBinary(): string {
     const explicit: string | undefined = process.env.TTSC_TSGO_BINARY;
     if (explicit !== undefined && explicit.length !== 0) {
@@ -256,6 +288,43 @@ export namespace TypiaGenerateWizard {
       ? output
       : `// @ts-nocheck\n${output}`;
   }
+
+  function projectKey(root: string, file: string): string {
+    return path.relative(root, file).replace(/\\/g, "/");
+  }
+
+  function formatDiagnostics(diagnostics: ITtscCompilerDiagnostic[]): string {
+    return diagnostics.length === 0
+      ? "transformation failed"
+      : diagnostics
+          .map((diag) =>
+            [
+              diag.file ?? "ttsc",
+              diag.line === undefined
+                ? undefined
+                : `${diag.line}:${diag.character ?? 1}`,
+              diag.messageText,
+            ]
+              .filter((part) => part !== undefined && part !== "")
+              .join(": "),
+          )
+          .join("\n");
+  }
+
+  function formatUnknownError(error: unknown): string {
+    if (error instanceof Error) {
+      return error.message;
+    }
+    if (
+      typeof error === "object" &&
+      error !== null &&
+      "message" in error &&
+      typeof error.message === "string"
+    ) {
+      return error.message;
+    }
+    return String(error);
+  }
 }
 
 const TS_PATTERN = /\.[cm]?tsx?$/;

package/src/executable/generate/ttsc.ts

@@ -1,6 +1,5 @@
-const { spawnSync } = require(
-  "node:child_process",
-) as typeof import("node:child_process");
+const { spawnSync } =
+  require("node:child_process") as typeof import("node:child_process");
 const fs = require("node:fs") as typeof import("node:fs");
 const path = require("node:path") as typeof import("node:path");
 

package/src/executable/setup/PluginConfigurator.ts

@@ -13,9 +13,8 @@ export namespace PluginConfigurator {
     const config: comments.CommentObject = comments.parse(
       await fs.promises.readFile(args.project!, "utf8"),
     ) as comments.CommentObject;
-    const compilerOptions = (
-      config.compilerOptions ??= {} as comments.CommentObject
-    ) as comments.CommentObject;
+    const compilerOptions = (config.compilerOptions ??=
+      {} as comments.CommentObject) as comments.CommentObject;
 
     // PREPARE PLUGINS
     const plugins: comments.CommentArray<comments.CommentObject> = (() => {