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

package/native/core/programmers/iterate/json_schema_station.go

@@ -1,251 +1,251 @@
 package iterate
 
 import (
-	nativehelpers "github.com/samchon/typia/packages/typia/native/core/programmers/helpers"
-	nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+  nativehelpers "github.com/samchon/typia/packages/typia/native/core/programmers/helpers"
+  nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
 )
 
 type json_schema_station_props struct {
-	blockNever bool
-	components *OpenApi_IComponents
-	attribute  JsonSchema
-	metadata   *nativemetadata.MetadataSchema
+  blockNever bool
+  components *OpenApi_IComponents
+  attribute  JsonSchema
+  metadata   *nativemetadata.MetadataSchema
 }
 
 type Json_schema_station_props struct {
-	BlockNever bool
-	Components *OpenApi_IComponents
-	Attribute  JsonSchema
-	Metadata   *nativemetadata.MetadataSchema
+  BlockNever bool
+  Components *OpenApi_IComponents
+  Attribute  JsonSchema
+  Metadata   *nativemetadata.MetadataSchema
 }
 
 func Json_schema_station(props Json_schema_station_props) JsonSchema {
-	return json_schema_station(json_schema_station_props{
-		blockNever: props.BlockNever,
-		components: props.Components,
-		attribute:  props.Attribute,
-		metadata:   props.Metadata,
-	})
+  return json_schema_station(json_schema_station_props{
+    blockNever: props.BlockNever,
+    components: props.Components,
+    attribute:  props.Attribute,
+    metadata:   props.Metadata,
+  })
 }
 
 func json_schema_station(props json_schema_station_props) JsonSchema {
-	if props.metadata.Any {
-		output := cloneJsonSchema(props.attribute)
-		if _, ok := output["type"]; ok == false {
-			output["type"] = nil
-		}
-		return output
-	}
+  if props.metadata.Any {
+    output := cloneJsonSchema(props.attribute)
+    if _, ok := output["type"]; ok == false {
+      output["type"] = nil
+    }
+    return output
+  }
 
-	union := []JsonSchema{}
-	insert := func(schema JsonSchema) {
-		if schema != nil {
-			union = append(union, schema)
-		}
-	}
+  union := []JsonSchema{}
+  insert := func(schema JsonSchema) {
+    if schema != nil {
+      union = append(union, schema)
+    }
+  }
 
-	if props.metadata.Nullable {
-		insert(JsonSchema{"type": "null"})
-	}
-	if props.metadata.Escaped != nil {
-		for _, schema := range json_schema_escaped(struct {
-			components *OpenApi_IComponents
-			escaped    *nativemetadata.MetadataEscaped
-		}{components: props.components, escaped: props.metadata.Escaped}) {
-			insert(schema)
-		}
-	}
-	if len(props.metadata.Templates) != 0 && nativehelpers.AtomicPredicator.Template(props.metadata) {
-		for _, schema := range json_schema_templates(props.metadata) {
-			insert(schema)
-		}
-	}
-	for _, constant := range props.metadata.Constants {
-		if nativehelpers.AtomicPredicator.Constant(struct {
-			Metadata *nativemetadata.MetadataSchema
-			Name     string
-		}{Metadata: props.metadata, Name: constant.Type}) == false {
-			continue
-		}
-		for _, schema := range json_schema_constant(constant) {
-			insert(schema)
-		}
-	}
-	for _, atomic := range props.metadata.Atomics {
-		if atomic.Type == "boolean" {
-			for _, schema := range json_schema_boolean(atomic) {
-				insert(schema)
-			}
-		} else if atomic.Type == "bigint" {
-			for _, schema := range json_schema_bigint(atomic) {
-				insert(schema)
-			}
-		} else if atomic.Type == "number" {
-			for _, schema := range json_schema_number(atomic) {
-				insert(schema)
-			}
-		} else if atomic.Type == "string" {
-			for _, schema := range json_schema_string(atomic) {
-				insert(schema)
-			}
-		}
-	}
-	for _, array := range props.metadata.Arrays {
-		for _, schema := range json_schema_array(struct {
-			components *OpenApi_IComponents
-			array      *nativemetadata.MetadataArray
-		}{components: props.components, array: array}) {
-			insert(schema)
-		}
-	}
-	for _, tuple := range props.metadata.Tuples {
-		insert(json_schema_tuple(struct {
-			components *OpenApi_IComponents
-			tuple      *nativemetadata.MetadataTuple
-		}{components: props.components, tuple: tuple}))
-	}
-	for _, native := range props.metadata.Natives {
-		if nativehelpers.AtomicPredicator.Native(native.Name) {
-			typ := lowerAscii(native.Name)
-			if json_schema_station_has_atomic(props.metadata, typ) {
-				continue
-			}
-			atomic := nativemetadata.MetadataAtomic_create(nativemetadata.MetadataAtomic{Type: typ, Tags: [][]nativemetadata.IMetadataTypeTag{}})
-			if typ == "boolean" {
-				for _, schema := range json_schema_boolean(atomic) {
-					insert(schema)
-				}
-			} else if typ == "bigint" {
-				for _, schema := range json_schema_bigint(atomic) {
-					insert(schema)
-				}
-			} else if typ == "number" {
-				for _, schema := range json_schema_number(atomic) {
-					insert(schema)
-				}
-			} else if typ == "string" {
-				for _, schema := range json_schema_string(atomic) {
-					insert(schema)
-				}
-			}
-		} else {
-			for _, schema := range json_schema_native(struct {
-				components *OpenApi_IComponents
-				native     *nativemetadata.MetadataNative
-			}{components: props.components, native: native}) {
-				insert(schema)
-			}
-		}
-	}
-	if len(props.metadata.Sets) != 0 {
-		for _, schema := range json_schema_native(struct {
-			components *OpenApi_IComponents
-			native     *nativemetadata.MetadataNative
-		}{components: props.components, native: nativemetadata.MetadataNative_create(nativemetadata.MetadataNative{Name: "Set", Tags: [][]nativemetadata.IMetadataTypeTag{}})}) {
-			insert(schema)
-		}
-	}
-	if len(props.metadata.Maps) != 0 {
-		for _, schema := range json_schema_native(struct {
-			components *OpenApi_IComponents
-			native     *nativemetadata.MetadataNative
-		}{components: props.components, native: nativemetadata.MetadataNative_create(nativemetadata.MetadataNative{Name: "Map", Tags: [][]nativemetadata.IMetadataTypeTag{}})}) {
-			insert(schema)
-		}
-	}
-	for _, object := range props.metadata.Objects {
-		for _, schema := range json_schema_object(struct {
-			components *OpenApi_IComponents
-			object     *nativemetadata.MetadataObject
-		}{components: props.components, object: object}) {
-			insert(schema)
-		}
-	}
-	for _, alias := range props.metadata.Aliases {
-		for _, schema := range json_schema_alias(struct {
-			blockNever bool
-			components *OpenApi_IComponents
-			alias      *nativemetadata.MetadataAlias
-		}{blockNever: props.blockNever, components: props.components, alias: alias}) {
-			insert(schema)
-		}
-	}
+  if props.metadata.Nullable {
+    insert(JsonSchema{"type": "null"})
+  }
+  if props.metadata.Escaped != nil {
+    for _, schema := range json_schema_escaped(struct {
+      components *OpenApi_IComponents
+      escaped    *nativemetadata.MetadataEscaped
+    }{components: props.components, escaped: props.metadata.Escaped}) {
+      insert(schema)
+    }
+  }
+  if len(props.metadata.Templates) != 0 && nativehelpers.AtomicPredicator.Template(props.metadata) {
+    for _, schema := range json_schema_templates(props.metadata) {
+      insert(schema)
+    }
+  }
+  for _, constant := range props.metadata.Constants {
+    if nativehelpers.AtomicPredicator.Constant(struct {
+      Metadata *nativemetadata.MetadataSchema
+      Name     string
+    }{Metadata: props.metadata, Name: constant.Type}) == false {
+      continue
+    }
+    for _, schema := range json_schema_constant(constant) {
+      insert(schema)
+    }
+  }
+  for _, atomic := range props.metadata.Atomics {
+    if atomic.Type == "boolean" {
+      for _, schema := range json_schema_boolean(atomic) {
+        insert(schema)
+      }
+    } else if atomic.Type == "bigint" {
+      for _, schema := range json_schema_bigint(atomic) {
+        insert(schema)
+      }
+    } else if atomic.Type == "number" {
+      for _, schema := range json_schema_number(atomic) {
+        insert(schema)
+      }
+    } else if atomic.Type == "string" {
+      for _, schema := range json_schema_string(atomic) {
+        insert(schema)
+      }
+    }
+  }
+  for _, array := range props.metadata.Arrays {
+    for _, schema := range json_schema_array(struct {
+      components *OpenApi_IComponents
+      array      *nativemetadata.MetadataArray
+    }{components: props.components, array: array}) {
+      insert(schema)
+    }
+  }
+  for _, tuple := range props.metadata.Tuples {
+    insert(json_schema_tuple(struct {
+      components *OpenApi_IComponents
+      tuple      *nativemetadata.MetadataTuple
+    }{components: props.components, tuple: tuple}))
+  }
+  for _, native := range props.metadata.Natives {
+    if nativehelpers.AtomicPredicator.Native(native.Name) {
+      typ := lowerAscii(native.Name)
+      if json_schema_station_has_atomic(props.metadata, typ) {
+        continue
+      }
+      atomic := nativemetadata.MetadataAtomic_create(nativemetadata.MetadataAtomic{Type: typ, Tags: [][]nativemetadata.IMetadataTypeTag{}})
+      if typ == "boolean" {
+        for _, schema := range json_schema_boolean(atomic) {
+          insert(schema)
+        }
+      } else if typ == "bigint" {
+        for _, schema := range json_schema_bigint(atomic) {
+          insert(schema)
+        }
+      } else if typ == "number" {
+        for _, schema := range json_schema_number(atomic) {
+          insert(schema)
+        }
+      } else if typ == "string" {
+        for _, schema := range json_schema_string(atomic) {
+          insert(schema)
+        }
+      }
+    } else {
+      for _, schema := range json_schema_native(struct {
+        components *OpenApi_IComponents
+        native     *nativemetadata.MetadataNative
+      }{components: props.components, native: native}) {
+        insert(schema)
+      }
+    }
+  }
+  if len(props.metadata.Sets) != 0 {
+    for _, schema := range json_schema_native(struct {
+      components *OpenApi_IComponents
+      native     *nativemetadata.MetadataNative
+    }{components: props.components, native: nativemetadata.MetadataNative_create(nativemetadata.MetadataNative{Name: "Set", Tags: [][]nativemetadata.IMetadataTypeTag{}})}) {
+      insert(schema)
+    }
+  }
+  if len(props.metadata.Maps) != 0 {
+    for _, schema := range json_schema_native(struct {
+      components *OpenApi_IComponents
+      native     *nativemetadata.MetadataNative
+    }{components: props.components, native: nativemetadata.MetadataNative_create(nativemetadata.MetadataNative{Name: "Map", Tags: [][]nativemetadata.IMetadataTypeTag{}})}) {
+      insert(schema)
+    }
+  }
+  for _, object := range props.metadata.Objects {
+    for _, schema := range json_schema_object(struct {
+      components *OpenApi_IComponents
+      object     *nativemetadata.MetadataObject
+    }{components: props.components, object: object}) {
+      insert(schema)
+    }
+  }
+  for _, alias := range props.metadata.Aliases {
+    for _, schema := range json_schema_alias(struct {
+      blockNever bool
+      components *OpenApi_IComponents
+      alias      *nativemetadata.MetadataAlias
+    }{blockNever: props.blockNever, components: props.components, alias: alias}) {
+      insert(schema)
+    }
+  }
 
-	if len(union) == 0 && props.blockNever {
-		return nil
-	}
-	var schema JsonSchema
-	if len(union) == 0 {
-		schema = JsonSchema{"type": nil}
-	} else if len(union) == 1 {
-		schema = union[0]
-	} else {
-		schema = JsonSchema{"oneOf": union}
-		if discriminator := json_schema_discriminator(props.metadata); discriminator != nil {
-			schema["discriminator"] = discriminator
-		}
-	}
-	return json_schema_station_mergeAttribute(schema, props.attribute)
+  if len(union) == 0 && props.blockNever {
+    return nil
+  }
+  var schema JsonSchema
+  if len(union) == 0 {
+    schema = JsonSchema{"type": nil}
+  } else if len(union) == 1 {
+    schema = union[0]
+  } else {
+    schema = JsonSchema{"oneOf": union}
+    if discriminator := json_schema_discriminator(props.metadata); discriminator != nil {
+      schema["discriminator"] = discriminator
+    }
+  }
+  return json_schema_station_mergeAttribute(schema, props.attribute)
 }
 
 func json_schema_station_has_atomic(metadata *nativemetadata.MetadataSchema, typ string) bool {
-	for _, atomic := range metadata.Atomics {
-		if atomic.Type == typ {
-			return true
-		}
-	}
-	return false
+  for _, atomic := range metadata.Atomics {
+    if atomic.Type == typ {
+      return true
+    }
+  }
+  return false
 }
 
 func json_schema_station_mergeAttribute(schema JsonSchema, attribute JsonSchema) JsonSchema {
-	output := cloneJsonSchema(schema)
-	for key, value := range attribute {
-		output[key] = value
-	}
-	for _, key := range []string{"title", "description", "deprecated"} {
-		if _, ok := attribute[key]; ok == false {
-			if value, ok := schema[key]; ok {
-				output[key] = value
-			}
-		}
-	}
-	return output
+  output := cloneJsonSchema(schema)
+  for key, value := range attribute {
+    output[key] = value
+  }
+  for _, key := range []string{"title", "description", "deprecated"} {
+    if _, ok := attribute[key]; ok == false {
+      if value, ok := schema[key]; ok {
+        output[key] = value
+      }
+    }
+  }
+  return output
 }
 
 func json_schema_assign(target JsonSchema, source JsonSchema) {
-	for key, value := range source {
-		target[key] = value
-	}
+  for key, value := range source {
+    target[key] = value
+  }
 }
 
 func json_schema_is_string(schema JsonSchema) bool {
-	return schema["type"] == "string"
+  return schema["type"] == "string"
 }
 
 func json_schema_has_tag(tags []nativemetadata.IJsDocTagInfo, name string) bool {
-	for _, tag := range tags {
-		if tag.Name == name {
-			return true
-		}
-	}
-	return false
+  for _, tag := range tags {
+    if tag.Name == name {
+      return true
+    }
+  }
+  return false
 }
 
 func json_schema_has_any_tag(tags []nativemetadata.IJsDocTagInfo, names []string) bool {
-	for _, name := range names {
-		if json_schema_has_tag(tags, name) {
-			return true
-		}
-	}
-	return false
+  for _, name := range names {
+    if json_schema_has_tag(tags, name) {
+      return true
+    }
+  }
+  return false
 }
 
 func lowerAscii(str string) string {
-	bytes := []byte(str)
-	for i, ch := range bytes {
-		if 'A' <= ch && ch <= 'Z' {
-			bytes[i] = ch + ('a' - 'A')
-		}
-	}
-	return string(bytes)
+  bytes := []byte(str)
+  for i, ch := range bytes {
+    if 'A' <= ch && ch <= 'Z' {
+      bytes[i] = ch + ('a' - 'A')
+    }
+  }
+  return string(bytes)
 }

package/native/core/programmers/iterate/json_schema_string.go

@@ -3,15 +3,15 @@ package iterate
 import nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
 
 func json_schema_string(atomic *nativemetadata.MetadataAtomic) []JsonSchema {
-	return json_schema_plugin(struct {
-		schema JsonSchema
-		tags   [][]nativemetadata.IMetadataTypeTag
-	}{
-		schema: JsonSchema{"type": "string"},
-		tags:   atomic.Tags,
-	})
+  return json_schema_plugin(struct {
+    schema JsonSchema
+    tags   [][]nativemetadata.IMetadataTypeTag
+  }{
+    schema: JsonSchema{"type": "string"},
+    tags:   atomic.Tags,
+  })
 }
 
 func Json_schema_string_export(atomic *nativemetadata.MetadataAtomic) []JsonSchema {
-	return json_schema_string(atomic)
+  return json_schema_string(atomic)
 }

package/native/core/programmers/iterate/json_schema_template.go

@@ -3,61 +3,61 @@ package iterate
 import nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
 
 func json_schema_templates(metadata *nativemetadata.MetadataSchema) []JsonSchema {
-	pureTemplates := []*nativemetadata.MetadataTemplate{}
-	taggedTemplates := []*nativemetadata.MetadataTemplate{}
-	for _, tpl := range metadata.Templates {
-		if json_schema_template_isPure(tpl.Tags) {
-			pureTemplates = append(pureTemplates, tpl)
-		} else {
-			taggedTemplates = append(taggedTemplates, tpl)
-		}
-	}
+  pureTemplates := []*nativemetadata.MetadataTemplate{}
+  taggedTemplates := []*nativemetadata.MetadataTemplate{}
+  for _, tpl := range metadata.Templates {
+    if json_schema_template_isPure(tpl.Tags) {
+      pureTemplates = append(pureTemplates, tpl)
+    } else {
+      taggedTemplates = append(taggedTemplates, tpl)
+    }
+  }
 
-	output := []JsonSchema{}
-	if len(pureTemplates) != 0 {
-		meta := nativemetadata.MetadataSchema_initialize()
-		meta.Templates = pureTemplates
-		output = append(output, JsonSchema{
-			"type": "string",
-			"pattern": metadata_to_pattern(struct {
-				top      bool
-				metadata *nativemetadata.MetadataSchema
-			}{
-				top:      true,
-				metadata: meta,
-			}),
-		})
-	}
-	for _, tpl := range taggedTemplates {
-		meta := nativemetadata.MetadataSchema_initialize()
-		meta.Templates = []*nativemetadata.MetadataTemplate{tpl}
-		output = append(output, json_schema_plugin(struct {
-			schema JsonSchema
-			tags   [][]nativemetadata.IMetadataTypeTag
-		}{
-			schema: JsonSchema{
-				"type": "string",
-				"pattern": metadata_to_pattern(struct {
-					top      bool
-					metadata *nativemetadata.MetadataSchema
-				}{
-					top:      false,
-					metadata: meta,
-				}),
-			},
-			tags: tpl.Tags,
-		})...)
-	}
-	return output
+  output := []JsonSchema{}
+  if len(pureTemplates) != 0 {
+    meta := nativemetadata.MetadataSchema_initialize()
+    meta.Templates = pureTemplates
+    output = append(output, JsonSchema{
+      "type": "string",
+      "pattern": metadata_to_pattern(struct {
+        top      bool
+        metadata *nativemetadata.MetadataSchema
+      }{
+        top:      true,
+        metadata: meta,
+      }),
+    })
+  }
+  for _, tpl := range taggedTemplates {
+    meta := nativemetadata.MetadataSchema_initialize()
+    meta.Templates = []*nativemetadata.MetadataTemplate{tpl}
+    output = append(output, json_schema_plugin(struct {
+      schema JsonSchema
+      tags   [][]nativemetadata.IMetadataTypeTag
+    }{
+      schema: JsonSchema{
+        "type": "string",
+        "pattern": metadata_to_pattern(struct {
+          top      bool
+          metadata *nativemetadata.MetadataSchema
+        }{
+          top:      false,
+          metadata: meta,
+        }),
+      },
+      tags: tpl.Tags,
+    })...)
+  }
+  return output
 }
 
 func json_schema_template_isPure(matrix [][]nativemetadata.IMetadataTypeTag) bool {
-	for _, tags := range matrix {
-		for _, tag := range tags {
-			if tag.Schema != nil {
-				return false
-			}
-		}
-	}
-	return true
+  for _, tags := range matrix {
+    for _, tag := range tags {
+      if tag.Schema != nil {
+        return false
+      }
+    }
+  }
+  return true
 }

package/native/core/programmers/iterate/json_schema_title.go

@@ -1,25 +1,25 @@
 package iterate
 
 import (
-	"strings"
+  "strings"
 
-	nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+  nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
 )
 
 func json_schema_title(schema struct {
-	description *string
-	jsDocTags   []nativemetadata.IJsDocTagInfo
+  description *string
+  jsDocTags   []nativemetadata.IJsDocTagInfo
 }) *string {
-	for _, tag := range schema.jsDocTags {
-		if tag.Name != "title" || len(tag.Text) == 0 {
-			continue
-		}
-		parts := make([]string, 0, len(tag.Text))
-		for _, part := range tag.Text {
-			parts = append(parts, strings.ReplaceAll(part.Text, "\r\n", "\n"))
-		}
-		output := strings.Join(parts, "")
-		return &output
-	}
-	return nil
+  for _, tag := range schema.jsDocTags {
+    if tag.Name != "title" || len(tag.Text) == 0 {
+      continue
+    }
+    parts := make([]string, 0, len(tag.Text))
+    for _, part := range tag.Text {
+      parts = append(parts, strings.ReplaceAll(part.Text, "\r\n", "\n"))
+    }
+    output := strings.Join(parts, "")
+    return &output
+  }
+  return nil
 }