typia 13.0.0-dev.20260501 → 13.0.0-dev.20260506

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.20260501",
+  "version": "13.0.0-dev.20260506",
   "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.20260501",
-    "@typia/utils": "^13.0.0-dev.20260501"
+    "@typia/interface": "^13.0.0-dev.20260506",
+    "@typia/utils": "^13.0.0-dev.20260506"
   },
   "devDependencies": {
     "@rollup/plugin-commonjs": "^29.0.0",
@@ -52,7 +52,7 @@
     "@types/node": "^25.3.0",
     "@typescript-eslint/eslint-plugin": "^8.1.0",
     "@typescript-eslint/parser": "^8.1.0",
-    "@typescript/native-preview": "7.0.0-dev.20260429.1",
+    "@typescript/native-preview": "7.0.0-dev.20260505.1",
     "chalk": "^4.0.0",
     "eslint-plugin-deprecation": "^3.0.0",
     "rimraf": "^6.1.2",
@@ -61,7 +61,7 @@
     "rollup-plugin-node-externals": "^8.1.2",
     "suppress-warnings": "^1.0.2",
     "tinyglobby": "^0.2.12",
-    "ttsc": "^0.7.2"
+    "ttsc": "^0.8.0"
   },
   "sideEffects": [
     "./lib/_virtual/*.mjs",

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> = (() => {

package/src/internal/_randomInteger.ts

@@ -8,8 +8,7 @@ export const _randomInteger = (schema: OpenApi.IJsonSchema.IInteger) => {
       (schema.maximum === undefined && schema.exclusiveMaximum === undefined
         ? 0
         : (schema.maximum ?? schema.exclusiveMaximum!) - 100);
-  if (schema.exclusiveMinimum !== undefined)
-    minimum++;
+  if (schema.exclusiveMinimum !== undefined) minimum++;
   let maximum: number =
     schema.maximum ??
     schema.exclusiveMaximum ??
@@ -17,8 +16,7 @@ export const _randomInteger = (schema: OpenApi.IJsonSchema.IInteger) => {
       (schema.minimum === undefined && schema.exclusiveMinimum === undefined
         ? 100
         : (schema.minimum ?? schema.exclusiveMinimum!) + 100);
-  if (schema.exclusiveMaximum !== undefined)
-    maximum--;
+  if (schema.exclusiveMaximum !== undefined) maximum--;
   if (minimum > maximum)
     throw new Error("Minimum value is greater than maximum value.");
   return schema.multipleOf === undefined
@@ -44,7 +42,9 @@ const multiple = (p: {
   const minimum = Math.ceil(p.minimum / p.multipleOf) * p.multipleOf;
   const maximum = Math.floor(p.maximum / p.multipleOf) * p.multipleOf;
   if (minimum > maximum)
-    throw new Error("The range of the integer is smaller than the multipleOf value.");
+    throw new Error(
+      "The range of the integer is smaller than the multipleOf value.",
+    );
   const value: number = scalar({
     minimum,
     maximum,

package/src/internal/_validateReport.ts

@@ -2,8 +2,7 @@ import { IValidation } from "@typia/interface";
 
 export const _validateReport = (array: IValidation.IError[]) => {
   const reportable = (path: string): boolean => {
-    if (array.length === 0)
-      return true;
+    if (array.length === 0) return true;
     const last: string = array[array.length - 1]!.path;
     return path.length > last.length || last.substring(0, path.length) !== path;
   };

package/src/transform.ts

@@ -1,6 +1,6 @@
-import type { ITtscPlugin, ITtscPluginFactoryContext } from "ttsc";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+import type { ITtscPlugin, ITtscPluginFactoryContext } from "ttsc";
 
 const filename: string = currentFilename();
 const dirname: string = path.dirname(filename);