typia 13.0.0-dev.20260510 → 13.0.0-dev.20260514

package/native/internal/printer/printer.go

@@ -1,229 +1,229 @@
 package printer
 
 import (
-	shimast "github.com/microsoft/typescript-go/shim/ast"
-	shimprinter "github.com/microsoft/typescript-go/shim/printer"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimprinter "github.com/microsoft/typescript-go/shim/printer"
 )
 
 const kindColonToken = shimast.KindQuestionToken + 1
 
 func EmitWithIdentifierSubstitutions(node *shimast.Node, sourceFile *shimast.SourceFile, substitutions map[string]string) string {
-	node = stripTypeSyntax(node)
-	node = rewriteIdentifiers(node, substitutions)
-	normalizeSyntheticTokens(node)
-	return emit(node, sourceFile)
+  node = stripTypeSyntax(node)
+  node = rewriteIdentifiers(node, substitutions)
+  normalizeSyntheticTokens(node)
+  return emit(node, sourceFile)
 }
 
 func EmitPreservingTypesWithIdentifierSubstitutions(node *shimast.Node, sourceFile *shimast.SourceFile, substitutions map[string]string) string {
-	node = rewriteIdentifiers(node, substitutions)
-	normalizeSyntheticTokens(node)
-	return emit(node, sourceFile)
+  node = rewriteIdentifiers(node, substitutions)
+  normalizeSyntheticTokens(node)
+  return emit(node, sourceFile)
 }
 
 func emit(node *shimast.Node, sourceFile *shimast.SourceFile) string {
-	return shimprinter.NewPrinter(shimprinter.PrinterOptions{
-		RemoveComments: true,
-		NewLine:        2,
-	}, shimprinter.PrintHandlers{}, nil).Emit(node, sourceFile)
+  return shimprinter.NewPrinter(shimprinter.PrinterOptions{
+    RemoveComments: true,
+    NewLine:        2,
+  }, shimprinter.PrintHandlers{}, nil).Emit(node, sourceFile)
 }
 
 func stripTypeSyntax(node *shimast.Node) *shimast.Node {
-	if node == nil {
-		return nil
-	}
-	factory := shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-	var visitor *shimast.NodeVisitor
-	visitor = shimast.NewNodeVisitor(func(current *shimast.Node) *shimast.Node {
-		if current == nil {
-			return nil
-		}
-		switch current.Kind {
-		case shimast.KindAsExpression, shimast.KindSatisfiesExpression, shimast.KindTypeAssertionExpression, shimast.KindNonNullExpression:
-			return visitor.VisitNode(current.Expression())
-		case shimast.KindVariableDeclaration:
-			decl := current.AsVariableDeclaration()
-			return factory.UpdateVariableDeclaration(
-				decl,
-				visitor.VisitNode(decl.Name()),
-				nil,
-				nil,
-				visitor.VisitNode(decl.Initializer),
-			)
-		case shimast.KindParameter:
-			parameter := current.AsParameterDeclaration()
-			return factory.UpdateParameterDeclaration(
-				parameter,
-				visitor.VisitModifiers(parameter.Modifiers()),
-				visitor.VisitNode(parameter.DotDotDotToken),
-				visitor.VisitNode(parameter.Name()),
-				nil,
-				nil,
-				visitor.VisitNode(parameter.Initializer),
-			)
-		case shimast.KindArrowFunction:
-			arrow := current.AsArrowFunction()
-			return factory.UpdateArrowFunction(
-				arrow,
-				visitor.VisitModifiers(arrow.Modifiers()),
-				nil,
-				visitor.VisitNodes(arrow.Parameters),
-				nil,
-				nil,
-				visitor.VisitNode(arrow.EqualsGreaterThanToken),
-				visitor.VisitNode(arrow.Body),
-			)
-		case shimast.KindCallExpression:
-			call := current.AsCallExpression()
-			return factory.UpdateCallExpression(
-				call,
-				visitor.VisitNode(call.Expression),
-				visitor.VisitNode(call.QuestionDotToken),
-				nil,
-				visitor.VisitNodes(call.Arguments),
-				call.Flags,
-			)
-		case shimast.KindNewExpression:
-			expr := current.AsNewExpression()
-			return factory.UpdateNewExpression(
-				expr,
-				visitor.VisitNode(expr.Expression),
-				nil,
-				visitor.VisitNodes(expr.Arguments),
-			)
-		default:
-			return visitor.VisitEachChild(current)
-		}
-	}, factory, shimast.NodeVisitorHooks{})
-	return visitor.VisitNode(node)
+  if node == nil {
+    return nil
+  }
+  factory := shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
+  var visitor *shimast.NodeVisitor
+  visitor = shimast.NewNodeVisitor(func(current *shimast.Node) *shimast.Node {
+    if current == nil {
+      return nil
+    }
+    switch current.Kind {
+    case shimast.KindAsExpression, shimast.KindSatisfiesExpression, shimast.KindTypeAssertionExpression, shimast.KindNonNullExpression:
+      return visitor.VisitNode(current.Expression())
+    case shimast.KindVariableDeclaration:
+      decl := current.AsVariableDeclaration()
+      return factory.UpdateVariableDeclaration(
+        decl,
+        visitor.VisitNode(decl.Name()),
+        nil,
+        nil,
+        visitor.VisitNode(decl.Initializer),
+      )
+    case shimast.KindParameter:
+      parameter := current.AsParameterDeclaration()
+      return factory.UpdateParameterDeclaration(
+        parameter,
+        visitor.VisitModifiers(parameter.Modifiers()),
+        visitor.VisitNode(parameter.DotDotDotToken),
+        visitor.VisitNode(parameter.Name()),
+        nil,
+        nil,
+        visitor.VisitNode(parameter.Initializer),
+      )
+    case shimast.KindArrowFunction:
+      arrow := current.AsArrowFunction()
+      return factory.UpdateArrowFunction(
+        arrow,
+        visitor.VisitModifiers(arrow.Modifiers()),
+        nil,
+        visitor.VisitNodes(arrow.Parameters),
+        nil,
+        nil,
+        visitor.VisitNode(arrow.EqualsGreaterThanToken),
+        visitor.VisitNode(arrow.Body),
+      )
+    case shimast.KindCallExpression:
+      call := current.AsCallExpression()
+      return factory.UpdateCallExpression(
+        call,
+        visitor.VisitNode(call.Expression),
+        visitor.VisitNode(call.QuestionDotToken),
+        nil,
+        visitor.VisitNodes(call.Arguments),
+        call.Flags,
+      )
+    case shimast.KindNewExpression:
+      expr := current.AsNewExpression()
+      return factory.UpdateNewExpression(
+        expr,
+        visitor.VisitNode(expr.Expression),
+        nil,
+        visitor.VisitNodes(expr.Arguments),
+      )
+    default:
+      return visitor.VisitEachChild(current)
+    }
+  }, factory, shimast.NodeVisitorHooks{})
+  return visitor.VisitNode(node)
 }
 
 func rewriteIdentifiers(node *shimast.Node, substitutions map[string]string) *shimast.Node {
-	if node == nil || len(substitutions) == 0 {
-		return node
-	}
-	factory := shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-	var visitor *shimast.NodeVisitor
-	visitor = shimast.NewNodeVisitor(func(current *shimast.Node) *shimast.Node {
-		if current == nil {
-			return nil
-		}
-		switch current.Kind {
-		case shimast.KindIdentifier:
-			if replacement, ok := substitutions[current.Text()]; ok {
-				return rewriteIdentifierExpression(factory, replacement)
-			}
-			return current
-		case shimast.KindVariableDeclaration:
-			decl := current.AsVariableDeclaration()
-			return factory.UpdateVariableDeclaration(
-				decl,
-				decl.Name(),
-				nil,
-				nil,
-				visitor.VisitNode(decl.Initializer),
-			)
-		case shimast.KindParameter:
-			parameter := current.AsParameterDeclaration()
-			return factory.UpdateParameterDeclaration(
-				parameter,
-				parameter.Modifiers(),
-				parameter.DotDotDotToken,
-				parameter.Name(),
-				nil,
-				nil,
-				visitor.VisitNode(parameter.Initializer),
-			)
-		case shimast.KindPropertyAssignment:
-			assignment := current.AsPropertyAssignment()
-			return factory.UpdatePropertyAssignment(
-				assignment,
-				assignment.Modifiers(),
-				assignment.Name(),
-				assignment.PostfixToken,
-				nil,
-				visitor.VisitNode(assignment.Initializer),
-			)
-		case shimast.KindShorthandPropertyAssignment:
-			assignment := current.AsShorthandPropertyAssignment()
-			name := assignment.Name()
-			if name != nil && name.Kind == shimast.KindIdentifier {
-				if replacement, ok := substitutions[name.Text()]; ok && assignment.ObjectAssignmentInitializer == nil {
-					return factory.NewPropertyAssignment(
-						assignment.Modifiers(),
-						name,
-						assignment.PostfixToken,
-						nil,
-						rewriteIdentifierExpression(factory, replacement),
-					)
-				}
-			}
-			return factory.UpdateShorthandPropertyAssignment(
-				assignment,
-				assignment.Modifiers(),
-				name,
-				assignment.PostfixToken,
-				nil,
-				nil,
-				visitor.VisitNode(assignment.ObjectAssignmentInitializer),
-			)
-		case shimast.KindPropertyAccessExpression:
-			access := current.AsPropertyAccessExpression()
-			return factory.UpdatePropertyAccessExpression(
-				access,
-				visitor.VisitNode(access.Expression),
-				access.QuestionDotToken,
-				access.Name(),
-				access.Flags,
-			)
-		default:
-			return visitor.VisitEachChild(current)
-		}
-	}, factory, shimast.NodeVisitorHooks{})
-	return visitor.VisitNode(node)
+  if node == nil || len(substitutions) == 0 {
+    return node
+  }
+  factory := shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
+  var visitor *shimast.NodeVisitor
+  visitor = shimast.NewNodeVisitor(func(current *shimast.Node) *shimast.Node {
+    if current == nil {
+      return nil
+    }
+    switch current.Kind {
+    case shimast.KindIdentifier:
+      if replacement, ok := substitutions[current.Text()]; ok {
+        return rewriteIdentifierExpression(factory, replacement)
+      }
+      return current
+    case shimast.KindVariableDeclaration:
+      decl := current.AsVariableDeclaration()
+      return factory.UpdateVariableDeclaration(
+        decl,
+        decl.Name(),
+        nil,
+        nil,
+        visitor.VisitNode(decl.Initializer),
+      )
+    case shimast.KindParameter:
+      parameter := current.AsParameterDeclaration()
+      return factory.UpdateParameterDeclaration(
+        parameter,
+        parameter.Modifiers(),
+        parameter.DotDotDotToken,
+        parameter.Name(),
+        nil,
+        nil,
+        visitor.VisitNode(parameter.Initializer),
+      )
+    case shimast.KindPropertyAssignment:
+      assignment := current.AsPropertyAssignment()
+      return factory.UpdatePropertyAssignment(
+        assignment,
+        assignment.Modifiers(),
+        assignment.Name(),
+        assignment.PostfixToken,
+        nil,
+        visitor.VisitNode(assignment.Initializer),
+      )
+    case shimast.KindShorthandPropertyAssignment:
+      assignment := current.AsShorthandPropertyAssignment()
+      name := assignment.Name()
+      if name != nil && name.Kind == shimast.KindIdentifier {
+        if replacement, ok := substitutions[name.Text()]; ok && assignment.ObjectAssignmentInitializer == nil {
+          return factory.NewPropertyAssignment(
+            assignment.Modifiers(),
+            name,
+            assignment.PostfixToken,
+            nil,
+            rewriteIdentifierExpression(factory, replacement),
+          )
+        }
+      }
+      return factory.UpdateShorthandPropertyAssignment(
+        assignment,
+        assignment.Modifiers(),
+        name,
+        assignment.PostfixToken,
+        nil,
+        nil,
+        visitor.VisitNode(assignment.ObjectAssignmentInitializer),
+      )
+    case shimast.KindPropertyAccessExpression:
+      access := current.AsPropertyAccessExpression()
+      return factory.UpdatePropertyAccessExpression(
+        access,
+        visitor.VisitNode(access.Expression),
+        access.QuestionDotToken,
+        access.Name(),
+        access.Flags,
+      )
+    default:
+      return visitor.VisitEachChild(current)
+    }
+  }, factory, shimast.NodeVisitorHooks{})
+  return visitor.VisitNode(node)
 }
 
 func rewriteIdentifierExpression(factory *shimast.NodeFactory, replacement string) *shimast.Node {
-	parts := []string{}
-	start := 0
-	for i := 0; i <= len(replacement); i++ {
-		if i == len(replacement) || replacement[i] == '.' {
-			if start < i {
-				parts = append(parts, replacement[start:i])
-			}
-			start = i + 1
-		}
-	}
-	if len(parts) == 0 {
-		return factory.NewIdentifier(replacement)
-	}
-	output := factory.NewIdentifier(parts[0])
-	for _, part := range parts[1:] {
-		output = factory.NewPropertyAccessExpression(
-			output,
-			nil,
-			factory.NewIdentifier(part),
-			shimast.NodeFlagsNone,
-		)
-	}
-	return output
+  parts := []string{}
+  start := 0
+  for i := 0; i <= len(replacement); i++ {
+    if i == len(replacement) || replacement[i] == '.' {
+      if start < i {
+        parts = append(parts, replacement[start:i])
+      }
+      start = i + 1
+    }
+  }
+  if len(parts) == 0 {
+    return factory.NewIdentifier(replacement)
+  }
+  output := factory.NewIdentifier(parts[0])
+  for _, part := range parts[1:] {
+    output = factory.NewPropertyAccessExpression(
+      output,
+      nil,
+      factory.NewIdentifier(part),
+      shimast.NodeFlagsNone,
+    )
+  }
+  return output
 }
 
 func normalizeSyntheticTokens(node *shimast.Node) {
-	if node == nil {
-		return
-	}
-	if node.Kind == shimast.KindConditionalExpression {
-		conditional := node.AsConditionalExpression()
-		factory := shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-		if conditional.QuestionToken == nil {
-			conditional.QuestionToken = factory.NewToken(shimast.KindQuestionToken)
-		}
-		if conditional.ColonToken == nil {
-			conditional.ColonToken = factory.NewToken(kindColonToken)
-		}
-	}
-	node.ForEachChild(func(child *shimast.Node) bool {
-		normalizeSyntheticTokens(child)
-		return false
-	})
+  if node == nil {
+    return
+  }
+  if node.Kind == shimast.KindConditionalExpression {
+    conditional := node.AsConditionalExpression()
+    factory := shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
+    if conditional.QuestionToken == nil {
+      conditional.QuestionToken = factory.NewToken(shimast.KindQuestionToken)
+    }
+    if conditional.ColonToken == nil {
+      conditional.ColonToken = factory.NewToken(kindColonToken)
+    }
+  }
+  node.ForEachChild(func(child *shimast.Node) bool {
+    normalizeSyntheticTokens(child)
+    return false
+  })
 }

package/native/transform/CallExpressionTransformer.go

@@ -29,10 +29,19 @@ type CallExpressionTransformer_TransformProps struct {
   Expression *shimast.CallExpression
 }
 
+type CallExpressionTransformer_TransformKnownProps struct {
+  Context    nativecontext.ITypiaContext
+  Expression *shimast.CallExpression
+  Module     string
+  Method     string
+}
+
 type callExpressionTransformerTask func(props ITransformProps) *shimast.Node
 
 type callExpressionTransformerFunctor func() callExpressionTransformerTask
 
+var callExpressionTransformer_functors = callExpressionTransformer_createFunctors()
+
 func (callExpressionTransformerNamespace) Transform(props CallExpressionTransformer_TransformProps) *shimast.Node {
   if props.Expression == nil {
     return nil
@@ -59,8 +68,20 @@ func (callExpressionTransformerNamespace) Transform(props CallExpressionTransfor
     return props.Expression.AsNode()
   }
   name := typ.Symbol().Name
+  return CallExpressionTransformer.TransformKnown(CallExpressionTransformer_TransformKnownProps{
+    Context:    props.Context,
+    Expression: props.Expression,
+    Module:     module,
+    Method:     name,
+  })
+}
+
+func (callExpressionTransformerNamespace) TransformKnown(props CallExpressionTransformer_TransformKnownProps) *shimast.Node {
+  if props.Expression == nil {
+    return nil
+  }
   functors := callExpressionTransformer_FUNCTORS()
-  functor, ok := functors[module][name]
+  functor, ok := functors[props.Module][props.Method]
   if ok == false {
     return props.Expression.AsNode()
   }
@@ -101,6 +122,10 @@ func callExpressionTransformer_sourceFile(node *shimast.Node) *shimast.SourceFil
 }
 
 func callExpressionTransformer_FUNCTORS() map[string]map[string]callExpressionTransformerFunctor {
+  return callExpressionTransformer_functors
+}
+
+func callExpressionTransformer_createFunctors() map[string]map[string]callExpressionTransformerFunctor {
   return map[string]map[string]callExpressionTransformerFunctor{
     "module": {
       "assert": func() callExpressionTransformerTask {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typia",
-  "version": "13.0.0-dev.20260510",
+  "version": "13.0.0-dev.20260514",
   "description": "Superfast runtime validators with only one line",
   "main": "lib/index.js",
   "exports": {
@@ -44,8 +44,8 @@
     "commander": "^10.0.0",
     "inquirer": "^8.2.5",
     "randexp": "^0.5.3",
-    "@typia/interface": "^13.0.0-dev.20260510",
-    "@typia/utils": "^13.0.0-dev.20260510"
+    "@typia/interface": "^13.0.0-dev.20260514",
+    "@typia/utils": "^13.0.0-dev.20260514"
   },
   "devDependencies": {
     "@rollup/plugin-commonjs": "^29.0.0",
@@ -63,7 +63,7 @@
     "rollup-plugin-node-externals": "^8.1.2",
     "suppress-warnings": "^1.0.2",
     "tinyglobby": "^0.2.12",
-    "ttsc": "^0.10.0"
+    "ttsc": "^0.10.2"
   },
   "sideEffects": [
     "./lib/_virtual/*.mjs",

package/src/executable/typia.ts

@@ -43,7 +43,7 @@ const main = async (): Promise<void> => {
   const type: string | undefined = process.argv[2];
   if (type === "generate") {
     loadNativePreview();
-    const { TypiaGenerateWizard } = await import("./TypiaGenerateWizard");
+    const { TypiaGenerateWizard } = await import("./TypiaGenerateWizard.js");
     await TypiaGenerateWizard.generate();
   } else halt(USAGE);
 };