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

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

@@ -1,56 +1,56 @@
 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

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

@@ -1,11 +1,11 @@
 package metadata
 
 import (
-	"strings"
+  "strings"
 
-	nativeast "github.com/microsoft/typescript-go/shim/ast"
-	nativechecker "github.com/microsoft/typescript-go/shim/checker"
-	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"
+  schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
 )
 
 type metadataHelperNamespace struct{}
@@ -13,213 +13,213 @@ 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_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_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 := tag.AsJSDocParameterOrPropertyTag().Name()
+  if name == nil {
+    return ""
+  }
+  return name.Text()
 }
 
 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/emend_metadata_atomics.go

@@ -3,78 +3,78 @@ package metadata
 import schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
 
 func Emend_metadata_atomics(meta *schemametadata.MetadataSchema) {
-	for _, atomic := range meta.Atomics {
-		if is_not_pure(atomic) {
-			continue
-		}
-		index := -1
-		for i, constant := range meta.Constants {
-			if constant.Type == atomic.Type {
-				index = i
-				break
-			}
-		}
-		if index != -1 {
-			meta.Constants = append(meta.Constants[:index], meta.Constants[index+1:]...)
-		}
-	}
+  for _, atomic := range meta.Atomics {
+    if is_not_pure(atomic) {
+      continue
+    }
+    index := -1
+    for i, constant := range meta.Constants {
+      if constant.Type == atomic.Type {
+        index = i
+        break
+      }
+    }
+    if index != -1 {
+      meta.Constants = append(meta.Constants[:index], meta.Constants[index+1:]...)
+    }
+  }
 
-	index := -1
-	for i, constant := range meta.Constants {
-		if constant.Type == "boolean" {
-			index = i
-			break
-		}
-	}
-	if index != -1 && len(meta.Constants[index].Values) == 2 {
-		temp := meta.Constants[index]
-		meta.Constants = append(meta.Constants[:index], meta.Constants[index+1:]...)
-		found := false
-		for _, atomic := range meta.Atomics {
-			if atomic.Type == "boolean" {
-				found = true
-				break
-			}
-		}
-		if found == false {
-			tags := [][]schemametadata.IMetadataTypeTag{}
-			if len(temp.Values) != 0 && temp.Values[0] != nil {
-				tags = temp.Values[0].Tags
-			}
-			meta.Atomics = append(meta.Atomics, schemametadata.MetadataAtomic_create(schemametadata.MetadataAtomic{
-				Type: "boolean",
-				Tags: tags,
-			}))
-		}
-	}
+  index := -1
+  for i, constant := range meta.Constants {
+    if constant.Type == "boolean" {
+      index = i
+      break
+    }
+  }
+  if index != -1 && len(meta.Constants[index].Values) == 2 {
+    temp := meta.Constants[index]
+    meta.Constants = append(meta.Constants[:index], meta.Constants[index+1:]...)
+    found := false
+    for _, atomic := range meta.Atomics {
+      if atomic.Type == "boolean" {
+        found = true
+        break
+      }
+    }
+    if found == false {
+      tags := [][]schemametadata.IMetadataTypeTag{}
+      if len(temp.Values) != 0 && temp.Values[0] != nil {
+        tags = temp.Values[0].Tags
+      }
+      meta.Atomics = append(meta.Atomics, schemametadata.MetadataAtomic_create(schemametadata.MetadataAtomic{
+        Type: "boolean",
+        Tags: tags,
+      }))
+    }
+  }
 
-	if len(meta.Templates) != 0 {
-		var atomic *schemametadata.MetadataAtomic
-		for _, candidate := range meta.Atomics {
-			if candidate.Type == "string" {
-				atomic = candidate
-				break
-			}
-		}
-		if atomic != nil && is_not_pure(atomic) == false {
-			meta.Templates = meta.Templates[:0]
-		}
-	}
+  if len(meta.Templates) != 0 {
+    var atomic *schemametadata.MetadataAtomic
+    for _, candidate := range meta.Atomics {
+      if candidate.Type == "string" {
+        atomic = candidate
+        break
+      }
+    }
+    if atomic != nil && is_not_pure(atomic) == false {
+      meta.Templates = meta.Templates[:0]
+    }
+  }
 }
 
 func is_not_pure(atomic *schemametadata.MetadataAtomic) bool {
-	if len(atomic.Tags) == 0 {
-		return false
-	}
-	for _, row := range atomic.Tags {
-		if len(row) == 0 {
-			return false
-		}
-		for _, tag := range row {
-			if tag.Validate == "" {
-				return false
-			}
-		}
-	}
-	return true
+  if len(atomic.Tags) == 0 {
+    return false
+  }
+  for _, row := range atomic.Tags {
+    if len(row) == 0 {
+      return false
+    }
+    for _, tag := range row {
+      if tag.Validate == "" {
+        return false
+      }
+    }
+  }
+  return true
 }