typia 13.0.0-dev.20260514 → 13.0.0-dev.20260520

package/native/core/factories/internal/metadata/IMetadataIteratorProps.go

@@ -1,63 +1,63 @@
 package metadata
 
 import (
-	nativechecker "github.com/microsoft/typescript-go/shim/checker"
-	schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+  nativechecker "github.com/microsoft/typescript-go/shim/checker"
+  schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
 )
 
 type MetadataFactory_IOptions struct {
-	Escape     bool
-	Absorb     bool
-	Constant   bool
-	Functional bool
-	Validate   func(props struct {
-		Metadata *schemametadata.MetadataSchema
-		Explore  MetadataFactory_IExplore
-		Top      *schemametadata.MetadataSchema
-	}) []string
-	OnError func(node any, message string)
+  Escape     bool
+  Absorb     bool
+  Constant   bool
+  Functional bool
+  Validate   func(props struct {
+    Metadata *schemametadata.MetadataSchema
+    Explore  MetadataFactory_IExplore
+    Top      *schemametadata.MetadataSchema
+  }) []string
+  OnError func(node any, message string)
 }
 
 type MetadataFactory_IError struct {
-	Name     string
-	Explore  MetadataFactory_IExplore
-	Messages []string
+  Name     string
+  Explore  MetadataFactory_IExplore
+  Messages []string
 }
 
 type MetadataFactory_IExplore struct {
-	Top       bool
-	Object    *schemametadata.MetadataObjectType
-	Property  any
-	Parameter any
-	Nested    any
-	Aliased   bool
-	Escaped   bool
-	Output    bool
+  Top       bool
+  Object    *schemametadata.MetadataObjectType
+  Property  any
+  Parameter any
+  Nested    any
+  Aliased   bool
+  Escaped   bool
+  Output    bool
 }
 
 type MetadataFactory_IExplore_Function func(MetadataFactory_IExplore) MetadataFactory_IExplore
 
 type IMetadataIteratorProps struct {
-	Options     MetadataFactory_IOptions
-	Checker     *nativechecker.Checker
-	Components  *schemametadata.MetadataCollection
-	Errors      *[]MetadataFactory_IError
-	Metadata    *schemametadata.MetadataSchema
-	Type        *nativechecker.Type
-	Explore     MetadataFactory_IExplore
-	Intersected bool
+  Options     MetadataFactory_IOptions
+  Checker     *nativechecker.Checker
+  Components  *schemametadata.MetadataCollection
+  Errors      *[]MetadataFactory_IError
+  Metadata    *schemametadata.MetadataSchema
+  Type        *nativechecker.Type
+  Explore     MetadataFactory_IExplore
+  Intersected bool
 }
 
 var MetadataTypeTagAnalyzer func(props struct {
-	Errors  *[]MetadataFactory_IError
-	Type    string
-	Objects []*schemametadata.MetadataObjectType
-	Explore MetadataFactory_IExplore
+  Errors  *[]MetadataFactory_IError
+  Type    string
+  Objects []*schemametadata.MetadataObjectType
+  Explore MetadataFactory_IExplore
 }) []schemametadata.IMetadataTypeTag
 
 var MetadataCommentTagAnalyzer func(props struct {
-	Errors   *[]MetadataFactory_IError
-	Metadata *schemametadata.MetadataSchema
-	Tags     []schemametadata.IJsDocTagInfo
-	Explore  MetadataFactory_IExplore
+  Errors   *[]MetadataFactory_IError
+  Metadata *schemametadata.MetadataSchema
+  Tags     []schemametadata.IJsDocTagInfo
+  Explore  MetadataFactory_IExplore
 })

package/native/core/factories/internal/metadata/MetadataHelper.go

@@ -1,12 +1,12 @@
 package metadata
 
 import (
-	"strings"
+  "strings"
 
-	nativeast "github.com/microsoft/typescript-go/shim/ast"
-	nativechecker "github.com/microsoft/typescript-go/shim/checker"
-	nativescanner "github.com/microsoft/typescript-go/shim/scanner"
-	schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+  nativeast "github.com/microsoft/typescript-go/shim/ast"
+  nativechecker "github.com/microsoft/typescript-go/shim/checker"
+  nativescanner "github.com/microsoft/typescript-go/shim/scanner"
+  schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
 )
 
 type metadataHelperNamespace struct{}
@@ -14,245 +14,247 @@ type metadataHelperNamespace struct{}
 var MetadataHelper = metadataHelperNamespace{}
 
 func (metadataHelperNamespace) Literal_to_metadata(key string) *schemametadata.MetadataSchema {
-	metadata := schemametadata.MetadataSchema_initialize()
-	metadata.Constants = append(metadata.Constants, schemametadata.MetadataConstant_create(schemametadata.MetadataConstant{
-		Type: "string",
-		Values: []*schemametadata.MetadataConstantValue{
-			schemametadata.MetadataConstantValue_create(schemametadata.MetadataConstantValue{
-				Value: key,
-				Tags:  [][]schemametadata.IMetadataTypeTag{},
-			}),
-		},
-	}))
-	return metadata
+  metadata := schemametadata.MetadataSchema_initialize()
+  metadata.Constants = append(metadata.Constants, schemametadata.MetadataConstant_create(schemametadata.MetadataConstant{
+    Type: "string",
+    Values: []*schemametadata.MetadataConstantValue{
+      schemametadata.MetadataConstantValue_create(schemametadata.MetadataConstantValue{
+        Value: key,
+        Tags:  [][]schemametadata.IMetadataTypeTag{},
+      }),
+    },
+  }))
+  return metadata
 }
 
 func metadata_array_util_add_bool(array *[]bool, value bool) {
-	for _, elem := range *array {
-		if elem == value {
-			return
-		}
-	}
-	*array = append(*array, value)
+  for _, elem := range *array {
+    if elem == value {
+      return
+    }
+  }
+  *array = append(*array, value)
 }
 
 func metadata_type_full_name(checker *nativechecker.Checker, typ *nativechecker.Type) string {
-	if checker == nil || typ == nil {
-		return ""
-	}
-	if typ.IsUnion() || typ.IsIntersection() {
-		joiner := " | "
-		if typ.IsIntersection() {
-			joiner = " & "
-		}
-		children := typ.Types()
-		names := make([]string, 0, len(children))
-		for _, child := range children {
-			names = append(names, metadata_type_full_name(checker, child))
-		}
-		return strings.Join(names, joiner)
-	}
-	return checker.TypeToString(typ)
+  if checker == nil || typ == nil {
+    return ""
+  }
+  if typ.IsUnion() || typ.IsIntersection() {
+    joiner := " | "
+    if typ.IsIntersection() {
+      joiner = " & "
+    }
+    children := typ.Types()
+    names := make([]string, 0, len(children))
+    for _, child := range children {
+      names = append(names, metadata_type_full_name(checker, child))
+    }
+    return strings.Join(names, joiner)
+  }
+  return checker.TypeToString(typ)
 }
 
 func metadata_get_type_arguments(checker *nativechecker.Checker, typ *nativechecker.Type) (output []*nativechecker.Type) {
-	if checker == nil || typ == nil {
-		return nil
-	}
-	defer func() {
-		if recover() != nil {
-			output = nil
-		}
-	}()
-	return checker.GetTypeArguments(typ)
+  if checker == nil || typ == nil {
+    return nil
+  }
+  defer func() {
+    if recover() != nil {
+      output = nil
+    }
+  }()
+  return checker.GetTypeArguments(typ)
 }
 
 func metadata_get_function_node(typ *nativechecker.Type) *nativeast.Node {
-	if typ == nil {
-		return nil
-	}
-	symbol := typ.Symbol()
-	if symbol == nil || len(symbol.Declarations) == 0 {
-		return nil
-	}
-	node := symbol.Declarations[0]
-	if nativeast.IsFunctionLike(node) {
-		return node
-	}
-	if nativeast.IsPropertyAssignment(node) {
-		initializer := node.AsPropertyAssignment().Initializer
-		if nativeast.IsFunctionLike(initializer) {
-			return initializer
-		}
-		return nil
-	}
-	if nativeast.IsPropertyDeclaration(node) {
-		initializer := node.AsPropertyDeclaration().Initializer
-		if nativeast.IsFunctionLike(initializer) {
-			return initializer
-		}
-	}
-	return nil
+  if typ == nil {
+    return nil
+  }
+  symbol := typ.Symbol()
+  if symbol == nil || len(symbol.Declarations) == 0 {
+    return nil
+  }
+  node := symbol.Declarations[0]
+  if nativeast.IsFunctionLike(node) {
+    return node
+  }
+  if nativeast.IsPropertyAssignment(node) {
+    initializer := node.AsPropertyAssignment().Initializer
+    if nativeast.IsFunctionLike(initializer) {
+      return initializer
+    }
+    return nil
+  }
+  if nativeast.IsPropertyDeclaration(node) {
+    initializer := node.AsPropertyDeclaration().Initializer
+    if nativeast.IsFunctionLike(initializer) {
+      return initializer
+    }
+  }
+  return nil
 }
 
 func metadata_get_return_type_of_class_method(props struct {
-	Checker  *nativechecker.Checker
-	Class    *nativechecker.Type
-	Function string
+  Checker  *nativechecker.Checker
+  Class    *nativechecker.Type
+  Function string
 }) *nativechecker.Type {
-	if props.Checker == nil || props.Class == nil {
-		return nil
-	}
-	symbol := props.Checker.GetPropertyOfType(props.Class, props.Function)
-	if symbol == nil || symbol.ValueDeclaration == nil {
-		return nil
-	}
-	functor := props.Checker.GetTypeOfSymbolAtLocation(symbol, symbol.ValueDeclaration)
-	signatures := props.Checker.GetSignaturesOfType(functor, nativechecker.SignatureKindCall)
-	if len(signatures) == 0 {
-		return nil
-	}
-	return props.Checker.GetReturnTypeOfSignature(signatures[0])
+  if props.Checker == nil || props.Class == nil {
+    return nil
+  }
+  symbol := props.Checker.GetPropertyOfType(props.Class, props.Function)
+  if symbol == nil || symbol.ValueDeclaration == nil {
+    return nil
+  }
+  functor := props.Checker.GetTypeOfSymbolAtLocation(symbol, symbol.ValueDeclaration)
+  signatures := props.Checker.GetSignaturesOfType(functor, nativechecker.SignatureKindCall)
+  if len(signatures) == 0 {
+    return nil
+  }
+  return props.Checker.GetReturnTypeOfSignature(signatures[0])
 }
 
 func metadata_node_js_doc_tags(symbol *nativeast.Symbol) []schemametadata.IJsDocTagInfo {
-	output := []schemametadata.IJsDocTagInfo{}
-	for _, node := range metadata_node_declarations(symbol) {
-		for _, jsdoc := range node.JSDoc(nil) {
-			doc := jsdoc.AsJSDoc()
-			if doc == nil || doc.Tags == nil {
-				continue
-			}
-			for _, tag := range doc.Tags.Nodes {
-				if tag == nil || tag.TagName() == nil {
-					continue
-				}
-				texts := []schemametadata.IJsDocTagInfo_IText{}
-				if name := metadata_js_doc_parameter_name(tag); name != "" {
-					texts = append(texts, schemametadata.IJsDocTagInfo_IText{
-						Kind: "parameterName",
-						Text: name,
-					})
-				}
-				if text := metadata_js_doc_type_expression_text(tag); text != "" {
-					texts = append(texts, schemametadata.IJsDocTagInfo_IText{
-						Kind: "text",
-						Text: text,
-					})
-				}
-				if text := metadata_js_doc_comment_text(tag.CommentList()); text != "" {
-					texts = append(texts, schemametadata.IJsDocTagInfo_IText{
-						Kind: "text",
-						Text: text,
-					})
-				}
-				output = append(output, schemametadata.IJsDocTagInfo{
-					Name: tag.TagName().Text(),
-					Text: texts,
-				})
-			}
-		}
-	}
-	return output
+  output := []schemametadata.IJsDocTagInfo{}
+  for _, node := range metadata_node_declarations(symbol) {
+    for _, jsdoc := range node.JSDoc(nil) {
+      doc := jsdoc.AsJSDoc()
+      if doc == nil || doc.Tags == nil {
+        continue
+      }
+      for _, tag := range doc.Tags.Nodes {
+        if tag == nil || tag.TagName() == nil {
+          continue
+        }
+        texts := []schemametadata.IJsDocTagInfo_IText{}
+        if name := metadata_js_doc_parameter_name(tag); name != "" {
+          texts = append(texts, schemametadata.IJsDocTagInfo_IText{
+            Kind: "parameterName",
+            Text: name,
+          })
+        }
+        if text := metadata_js_doc_type_expression_text(tag); text != "" {
+          texts = append(texts, schemametadata.IJsDocTagInfo_IText{
+            Kind: "text",
+            Text: text,
+          })
+        }
+        if text := metadata_js_doc_comment_text(tag.CommentList()); text != "" {
+          texts = append(texts, schemametadata.IJsDocTagInfo_IText{
+            Kind: "text",
+            Text: text,
+          })
+        }
+        output = append(output, schemametadata.IJsDocTagInfo{
+          Name: tag.TagName().Text(),
+          Text: texts,
+        })
+      }
+    }
+  }
+  return output
 }
 
 func metadata_node_description(symbol *nativeast.Symbol) *string {
-	for _, node := range metadata_node_declarations(symbol) {
-		for _, jsdoc := range node.JSDoc(nil) {
-			doc := jsdoc.AsJSDoc()
-			if doc == nil {
-				continue
-			}
-			if text := metadata_js_doc_comment_text(doc.Comment); text != "" {
-				return &text
-			}
-		}
-	}
-	return nil
+  for _, node := range metadata_node_declarations(symbol) {
+    for _, jsdoc := range node.JSDoc(nil) {
+      doc := jsdoc.AsJSDoc()
+      if doc == nil {
+        continue
+      }
+      if text := metadata_js_doc_comment_text(doc.Comment); text != "" {
+        return &text
+      }
+    }
+  }
+  return nil
 }
 
 func metadata_is_internal(symbol *nativeast.Symbol) bool {
-	return false
+  return false
 }
 
 func metadata_node_declarations(symbol *nativeast.Symbol) []*nativeast.Node {
-	if symbol == nil {
-		return nil
-	}
-	output := []*nativeast.Node{}
-	visited := map[*nativeast.Node]bool{}
-	appendNode := func(node *nativeast.Node) {
-		if node != nil && visited[node] == false {
-			visited[node] = true
-			output = append(output, node)
-		}
-	}
-	appendNode(symbol.ValueDeclaration)
-	for _, node := range symbol.Declarations {
-		appendNode(node)
-	}
-	return output
+  if symbol == nil {
+    return nil
+  }
+  output := []*nativeast.Node{}
+  visited := map[*nativeast.Node]bool{}
+  appendNode := func(node *nativeast.Node) {
+    if node != nil && visited[node] == false {
+      visited[node] = true
+      output = append(output, node)
+    }
+  }
+  appendNode(symbol.ValueDeclaration)
+  for _, node := range symbol.Declarations {
+    appendNode(node)
+  }
+  return output
 }
 
 func metadata_js_doc_parameter_name(tag *nativeast.Node) string {
-	if tag == nil {
-		return ""
-	}
-	if tag.Kind.String() != "KindJSDocParameterTag" && tag.Kind.String() != "KindJSDocPropertyTag" {
-		return ""
-	}
-	name := tag.AsJSDocParameterOrPropertyTag().Name()
-	if name == nil {
-		return ""
-	}
-	return name.Text()
+  if tag == nil {
+    return ""
+  }
+  if tag.Kind.String() != "KindJSDocParameterTag" && tag.Kind.String() != "KindJSDocPropertyTag" {
+    return ""
+  }
+  // `name` is a DeclarationName: typically an Identifier, but for nested
+  // JSDoc parameter names like `@param obj.field description` the parser
+  // produces a QualifiedName, and upstream's (*Node).Text() panics with
+  // `Unhandled case in Node.Text: *ast.QualifiedName` if we call .Text()
+  // directly. NodeText in the ttsc shim covers QualifiedName and any
+  // other DeclarationName Kind that upstream's switch doesn't.
+  return nativeast.NodeText(tag.AsJSDocParameterOrPropertyTag().Name())
 }
 
 func metadata_js_doc_type_expression_text(tag *nativeast.Node) string {
-	if tag == nil {
-		return ""
-	}
-	switch tag.Kind {
-	case nativeast.KindJSDocTypeTag,
-		nativeast.KindJSDocParameterTag,
-		nativeast.KindJSDocPropertyTag,
-		nativeast.KindJSDocReturnTag,
-		nativeast.KindJSDocTypedefTag,
-		nativeast.KindJSDocSatisfiesTag,
-		nativeast.KindJSDocThrowsTag:
-	default:
-		return ""
-	}
-	expr := tag.TypeExpression()
-	if expr == nil {
-		return ""
-	}
-	typ := expr.Type()
-	if typ == nil {
-		return ""
-	}
-	return metadata_clean_js_doc_text(nativescanner.GetTextOfNode(typ))
+  if tag == nil {
+    return ""
+  }
+  switch tag.Kind {
+  case nativeast.KindJSDocTypeTag,
+    nativeast.KindJSDocParameterTag,
+    nativeast.KindJSDocPropertyTag,
+    nativeast.KindJSDocReturnTag,
+    nativeast.KindJSDocTypedefTag,
+    nativeast.KindJSDocSatisfiesTag,
+    nativeast.KindJSDocThrowsTag:
+  default:
+    return ""
+  }
+  expr := tag.TypeExpression()
+  if expr == nil {
+    return ""
+  }
+  typ := expr.Type()
+  if typ == nil {
+    return ""
+  }
+  return metadata_clean_js_doc_text(nativescanner.GetTextOfNode(typ))
 }
 
 func metadata_js_doc_comment_text(list *nativeast.NodeList) string {
-	if list == nil {
-		return ""
-	}
-	parts := []string{}
-	for _, node := range list.Nodes {
-		if node != nil {
-			parts = append(parts, node.Text())
-		}
-	}
-	return metadata_clean_js_doc_text(strings.Join(parts, ""))
+  if list == nil {
+    return ""
+  }
+  parts := []string{}
+  for _, node := range list.Nodes {
+    if node != nil {
+      parts = append(parts, node.Text())
+    }
+  }
+  return metadata_clean_js_doc_text(strings.Join(parts, ""))
 }
 
 func metadata_clean_js_doc_text(text string) string {
-	text = strings.ReplaceAll(text, "\r\n", "\n")
-	text = strings.ReplaceAll(text, "\r", "\n")
-	lines := strings.Split(text, "\n")
-	for i, line := range lines {
-		lines[i] = strings.TrimRight(line, " \t")
-	}
-	return strings.TrimSpace(strings.Join(lines, "\n"))
+  text = strings.ReplaceAll(text, "\r\n", "\n")
+  text = strings.ReplaceAll(text, "\r", "\n")
+  lines := strings.Split(text, "\n")
+  for i, line := range lines {
+    lines[i] = strings.TrimRight(line, " \t")
+  }
+  return strings.TrimSpace(strings.Join(lines, "\n"))
 }

package/native/core/factories/internal/metadata/iterate_metadata_comment_tags.go

@@ -3,32 +3,32 @@ package metadata
 import schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
 
 func Iterate_metadata_comment_tags(props struct {
-	Errors *[]MetadataFactory_IError
-	Object *schemametadata.MetadataObjectType
+  Errors *[]MetadataFactory_IError
+  Object *schemametadata.MetadataObjectType
 }) {
-	if props.Object == nil || props.Object.Tagged_ == true || MetadataCommentTagAnalyzer == nil {
-		return
-	}
-	props.Object.Tagged_ = true
+  if props.Object == nil || props.Object.Tagged_ == true || MetadataCommentTagAnalyzer == nil {
+    return
+  }
+  props.Object.Tagged_ = true
 
-	for _, property := range props.Object.Properties {
-		if property == nil || property.Value == nil || len(property.JsDocTags) == 0 {
-			continue
-		}
-		MetadataCommentTagAnalyzer(struct {
-			Errors   *[]MetadataFactory_IError
-			Metadata *schemametadata.MetadataSchema
-			Tags     []schemametadata.IJsDocTagInfo
-			Explore  MetadataFactory_IExplore
-		}{
-			Errors:   props.Errors,
-			Metadata: property.Value,
-			Tags:     property.JsDocTags,
-			Explore: MetadataFactory_IExplore{
-				Top:      false,
-				Object:   props.Object,
-				Property: property,
-			},
-		})
-	}
+  for _, property := range props.Object.Properties {
+    if property == nil || property.Value == nil || len(property.JsDocTags) == 0 {
+      continue
+    }
+    MetadataCommentTagAnalyzer(struct {
+      Errors   *[]MetadataFactory_IError
+      Metadata *schemametadata.MetadataSchema
+      Tags     []schemametadata.IJsDocTagInfo
+      Explore  MetadataFactory_IExplore
+    }{
+      Errors:   props.Errors,
+      Metadata: property.Value,
+      Tags:     property.JsDocTags,
+      Explore: MetadataFactory_IExplore{
+        Top:      false,
+        Object:   props.Object,
+        Property: property,
+      },
+    })
+  }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typia",
-  "version": "13.0.0-dev.20260514",
+  "version": "13.0.0-dev.20260520",
   "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.20260514",
-    "@typia/utils": "^13.0.0-dev.20260514"
+    "@typia/interface": "^13.0.0-dev.20260520",
+    "@typia/utils": "^13.0.0-dev.20260520"
   },
   "devDependencies": {
     "@rollup/plugin-commonjs": "^29.0.0",
@@ -54,7 +54,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.20260510.1",
+    "@typescript/native-preview": "7.0.0-dev.20260519.1",
     "chalk": "^4.0.0",
     "eslint-plugin-deprecation": "^3.0.0",
     "rimraf": "^6.1.2",
@@ -63,7 +63,7 @@
     "rollup-plugin-node-externals": "^8.1.2",
     "suppress-warnings": "^1.0.2",
     "tinyglobby": "^0.2.12",
-    "ttsc": "^0.10.2"
+    "ttsc": "^0.12.3"
   },
   "sideEffects": [
     "./lib/_virtual/*.mjs",