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

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

@@ -1,48 +1,48 @@
 package iterate
 
 import (
-	"strconv"
-	"strings"
+  "strconv"
+  "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_jsDocTags(schema JsonSchema, jsDocTags []nativemetadata.IJsDocTagInfo) JsonSchema {
-	for _, tag := range jsDocTags {
-		if strings.HasPrefix(tag.Name, "x-") == false {
-			continue
-		}
-		value, ok := json_schema_jsDocTags_value(tag)
-		if ok == false {
-			continue
-		}
-		schema[tag.Name] = json_schema_jsDocTags_cast(value)
-	}
-	return schema
+  for _, tag := range jsDocTags {
+    if strings.HasPrefix(tag.Name, "x-") == false {
+      continue
+    }
+    value, ok := json_schema_jsDocTags_value(tag)
+    if ok == false {
+      continue
+    }
+    schema[tag.Name] = json_schema_jsDocTags_cast(value)
+  }
+  return schema
 }
 
 func json_schema_jsDocTags_value(tag nativemetadata.IJsDocTagInfo) (string, bool) {
-	for _, text := range tag.Text {
-		if text.Kind != "text" {
-			continue
-		}
-		return strings.ReplaceAll(strings.TrimSpace(text.Text), "\r\n", "\n"), true
-	}
-	return "", false
+  for _, text := range tag.Text {
+    if text.Kind != "text" {
+      continue
+    }
+    return strings.ReplaceAll(strings.TrimSpace(text.Text), "\r\n", "\n"), true
+  }
+  return "", false
 }
 
 func json_schema_jsDocTags_cast(value string) any {
-	if value == "true" {
-		return true
-	}
-	if value == "false" {
-		return false
-	}
-	if num, err := strconv.ParseFloat(value, 64); err == nil {
-		return num
-	}
-	if value == "null" {
-		return nil
-	}
-	return value
+  if value == "true" {
+    return true
+  }
+  if value == "false" {
+    return false
+  }
+  if num, err := strconv.ParseFloat(value, 64); err == nil {
+    return num
+  }
+  if value == "null" {
+    return nil
+  }
+  return value
 }

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

@@ -3,57 +3,57 @@ package iterate
 import nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
 
 type OpenApi_IComponents struct {
-	Schemas map[string]JsonSchema
+  Schemas map[string]JsonSchema
 }
 
 type Json_schema_native_export_props struct {
-	Components *OpenApi_IComponents
-	Native     *nativemetadata.MetadataNative
+  Components *OpenApi_IComponents
+  Native     *nativemetadata.MetadataNative
 }
 
 func json_schema_native(props struct {
-	components *OpenApi_IComponents
-	native     *nativemetadata.MetadataNative
+  components *OpenApi_IComponents
+  native     *nativemetadata.MetadataNative
 }) []JsonSchema {
-	if props.native.Name == "Blob" || props.native.Name == "File" {
-		return json_schema_plugin(struct {
-			schema JsonSchema
-			tags   [][]nativemetadata.IMetadataTypeTag
-		}{
-			schema: JsonSchema{
-				"type":   "string",
-				"format": "binary",
-			},
-			tags: props.native.Tags,
-		})
-	}
-	if props.components.Schemas == nil {
-		props.components.Schemas = map[string]JsonSchema{}
-	}
-	if _, ok := props.components.Schemas[props.native.Name]; ok == false {
-		props.components.Schemas[props.native.Name] = JsonSchema{
-			"type":       "object",
-			"properties": JsonSchema{},
-			"required":   []string{},
-		}
-	}
-	return json_schema_plugin(struct {
-		schema JsonSchema
-		tags   [][]nativemetadata.IMetadataTypeTag
-	}{
-		schema: JsonSchema{
-			"$ref": "#/components/schemas/" + props.native.Name,
-		},
-		tags: props.native.Tags,
-	})
+  if props.native.Name == "Blob" || props.native.Name == "File" {
+    return json_schema_plugin(struct {
+      schema JsonSchema
+      tags   [][]nativemetadata.IMetadataTypeTag
+    }{
+      schema: JsonSchema{
+        "type":   "string",
+        "format": "binary",
+      },
+      tags: props.native.Tags,
+    })
+  }
+  if props.components.Schemas == nil {
+    props.components.Schemas = map[string]JsonSchema{}
+  }
+  if _, ok := props.components.Schemas[props.native.Name]; ok == false {
+    props.components.Schemas[props.native.Name] = JsonSchema{
+      "type":       "object",
+      "properties": JsonSchema{},
+      "required":   []string{},
+    }
+  }
+  return json_schema_plugin(struct {
+    schema JsonSchema
+    tags   [][]nativemetadata.IMetadataTypeTag
+  }{
+    schema: JsonSchema{
+      "$ref": "#/components/schemas/" + props.native.Name,
+    },
+    tags: props.native.Tags,
+  })
 }
 
 func Json_schema_native_export(props Json_schema_native_export_props) []JsonSchema {
-	return json_schema_native(struct {
-		components *OpenApi_IComponents
-		native     *nativemetadata.MetadataNative
-	}{
-		components: props.Components,
-		native:     props.Native,
-	})
+  return json_schema_native(struct {
+    components *OpenApi_IComponents
+    native     *nativemetadata.MetadataNative
+  }{
+    components: props.Components,
+    native:     props.Native,
+  })
 }

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

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

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

@@ -1,179 +1,179 @@
 package iterate
 
 import (
-	nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
-	nativeutils "github.com/samchon/typia/packages/typia/native/core/utils"
+  nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+  nativeutils "github.com/samchon/typia/packages/typia/native/core/utils"
 )
 
 func json_schema_object(props struct {
-	components *OpenApi_IComponents
-	object     *nativemetadata.MetadataObject
+  components *OpenApi_IComponents
+  object     *nativemetadata.MetadataObject
 }) []JsonSchema {
-	return json_schema_plugin(struct {
-		schema JsonSchema
-		tags   [][]nativemetadata.IMetadataTypeTag
-	}{
-		schema: json_schema_emplace_object(props),
-		tags:   props.object.Tags,
-	})
+  return json_schema_plugin(struct {
+    schema JsonSchema
+    tags   [][]nativemetadata.IMetadataTypeTag
+  }{
+    schema: json_schema_emplace_object(props),
+    tags:   props.object.Tags,
+  })
 }
 
 func json_schema_emplace_object(props struct {
-	components *OpenApi_IComponents
-	object     *nativemetadata.MetadataObject
+  components *OpenApi_IComponents
+  object     *nativemetadata.MetadataObject
 }) JsonSchema {
-	if props.object.Type.IsLiteral() {
-		return json_schema_create_object_schema(props)
-	}
-	key := props.object.Type.Name
-	ref := "#/components/schemas/" + key
-	if props.components.Schemas != nil {
-		if _, ok := props.components.Schemas[key]; ok {
-			return JsonSchema{"$ref": ref}
-		}
-	}
-	if props.components.Schemas == nil {
-		props.components.Schemas = map[string]JsonSchema{}
-	}
-	lazy := JsonSchema{}
-	props.components.Schemas[key] = lazy
-	json_schema_assign(lazy, json_schema_create_object_schema(props))
-	return JsonSchema{"$ref": ref}
+  if props.object.Type.IsLiteral() {
+    return json_schema_create_object_schema(props)
+  }
+  key := props.object.Type.Name
+  ref := "#/components/schemas/" + key
+  if props.components.Schemas != nil {
+    if _, ok := props.components.Schemas[key]; ok {
+      return JsonSchema{"$ref": ref}
+    }
+  }
+  if props.components.Schemas == nil {
+    props.components.Schemas = map[string]JsonSchema{}
+  }
+  lazy := JsonSchema{}
+  props.components.Schemas[key] = lazy
+  json_schema_assign(lazy, json_schema_create_object_schema(props))
+  return JsonSchema{"$ref": ref}
 }
 
 func json_schema_create_object_schema(props struct {
-	components *OpenApi_IComponents
-	object     *nativemetadata.MetadataObject
+  components *OpenApi_IComponents
+  object     *nativemetadata.MetadataObject
 }) JsonSchema {
-	properties := JsonSchema{}
-	extraMeta := json_schema_superfluous{
-		patternProperties: map[string]json_schema_metadata_schema_pair{},
-	}
-	required := []string{}
+  properties := JsonSchema{}
+  extraMeta := json_schema_superfluous{
+    patternProperties: map[string]json_schema_metadata_schema_pair{},
+  }
+  required := []string{}
 
-	for _, property := range props.object.Type.Properties {
-		if len(property.Value.Functions) != 0 &&
-			property.Value.Nullable == false &&
-			property.Value.IsRequired() &&
-			property.Value.Size() == 0 {
-			continue
-		}
-		if json_schema_has_any_tag(property.JsDocTags, []string{"hidden", "ignore", "internal"}) {
-			continue
-		}
+  for _, property := range props.object.Type.Properties {
+    if len(property.Value.Functions) != 0 &&
+      property.Value.Nullable == false &&
+      property.Value.IsRequired() &&
+      property.Value.Size() == 0 {
+      continue
+    }
+    if json_schema_has_any_tag(property.JsDocTags, []string{"hidden", "ignore", "internal"}) {
+      continue
+    }
 
-		attribute := JsonSchema{}
-		if json_schema_has_tag(property.JsDocTags, "deprecated") {
-			attribute["deprecated"] = true
-		}
-		if title := json_schema_title(struct {
-			description *string
-			jsDocTags   []nativemetadata.IJsDocTagInfo
-		}{description: property.Description, jsDocTags: property.JsDocTags}); title != nil {
-			attribute["title"] = *title
-		}
-		if description := json_schema_description(struct {
-			description *string
-			jsDocTags   []nativemetadata.IJsDocTagInfo
-		}{description: property.Description, jsDocTags: property.JsDocTags}); description != nil {
-			attribute["description"] = *description
-		}
-		if property.Mutability != nil && *property.Mutability == "readonly" {
-			attribute["readOnly"] = true
-		}
-		value := json_schema_station(json_schema_station_props{
-			blockNever: true,
-			components: props.components,
-			attribute:  attribute,
-			metadata:   property.Value,
-		})
-		if value == nil {
-			continue
-		}
-		json_schema_jsDocTags(value, property.JsDocTags)
+    attribute := JsonSchema{}
+    if json_schema_has_tag(property.JsDocTags, "deprecated") {
+      attribute["deprecated"] = true
+    }
+    if title := json_schema_title(struct {
+      description *string
+      jsDocTags   []nativemetadata.IJsDocTagInfo
+    }{description: property.Description, jsDocTags: property.JsDocTags}); title != nil {
+      attribute["title"] = *title
+    }
+    if description := json_schema_description(struct {
+      description *string
+      jsDocTags   []nativemetadata.IJsDocTagInfo
+    }{description: property.Description, jsDocTags: property.JsDocTags}); description != nil {
+      attribute["description"] = *description
+    }
+    if property.Mutability != nil && *property.Mutability == "readonly" {
+      attribute["readOnly"] = true
+    }
+    value := json_schema_station(json_schema_station_props{
+      blockNever: true,
+      components: props.components,
+      attribute:  attribute,
+      metadata:   property.Value,
+    })
+    if value == nil {
+      continue
+    }
+    json_schema_jsDocTags(value, property.JsDocTags)
 
-		key := property.Key.GetSoleLiteral()
-		if key != nil {
-			properties[*key] = value
-			if property.Value.IsRequired() {
-				required = append(required, *key)
-			}
-		} else {
-			pattern := metadata_to_pattern(struct {
-				top      bool
-				metadata *nativemetadata.MetadataSchema
-			}{top: true, metadata: property.Key})
-			pair := json_schema_metadata_schema_pair{metadata: property.Value, schema: value}
-			if pattern == nativeutils.PatternUtil.STRING {
-				extraMeta.additionalProperties = &pair
-			} else {
-				extraMeta.patternProperties[pattern] = pair
-			}
-		}
-	}
+    key := property.Key.GetSoleLiteral()
+    if key != nil {
+      properties[*key] = value
+      if property.Value.IsRequired() {
+        required = append(required, *key)
+      }
+    } else {
+      pattern := metadata_to_pattern(struct {
+        top      bool
+        metadata *nativemetadata.MetadataSchema
+      }{top: true, metadata: property.Key})
+      pair := json_schema_metadata_schema_pair{metadata: property.Value, schema: value}
+      if pattern == nativeutils.PatternUtil.STRING {
+        extraMeta.additionalProperties = &pair
+      } else {
+        extraMeta.patternProperties[pattern] = pair
+      }
+    }
+  }
 
-	schema := JsonSchema{
-		"type":                 "object",
-		"properties":           properties,
-		"required":             required,
-		"additionalProperties": false,
-	}
-	if title := json_schema_title(struct {
-		description *string
-		jsDocTags   []nativemetadata.IJsDocTagInfo
-	}{description: props.object.Type.Description, jsDocTags: props.object.Type.JsDocTags}); title != nil {
-		schema["title"] = *title
-	}
-	if description := json_schema_description(struct {
-		description *string
-		jsDocTags   []nativemetadata.IJsDocTagInfo
-	}{description: props.object.Type.Description, jsDocTags: props.object.Type.JsDocTags}); description != nil {
-		schema["description"] = *description
-	}
-	if additional := json_schema_join(struct {
-		components *OpenApi_IComponents
-		extra      json_schema_superfluous
-	}{components: props.components, extra: extraMeta}); additional != nil {
-		schema["additionalProperties"] = additional
-	}
-	return json_schema_jsDocTags(schema, props.object.Type.JsDocTags)
+  schema := JsonSchema{
+    "type":                 "object",
+    "properties":           properties,
+    "required":             required,
+    "additionalProperties": false,
+  }
+  if title := json_schema_title(struct {
+    description *string
+    jsDocTags   []nativemetadata.IJsDocTagInfo
+  }{description: props.object.Type.Description, jsDocTags: props.object.Type.JsDocTags}); title != nil {
+    schema["title"] = *title
+  }
+  if description := json_schema_description(struct {
+    description *string
+    jsDocTags   []nativemetadata.IJsDocTagInfo
+  }{description: props.object.Type.Description, jsDocTags: props.object.Type.JsDocTags}); description != nil {
+    schema["description"] = *description
+  }
+  if additional := json_schema_join(struct {
+    components *OpenApi_IComponents
+    extra      json_schema_superfluous
+  }{components: props.components, extra: extraMeta}); additional != nil {
+    schema["additionalProperties"] = additional
+  }
+  return json_schema_jsDocTags(schema, props.object.Type.JsDocTags)
 }
 
 func json_schema_join(props struct {
-	components *OpenApi_IComponents
-	extra      json_schema_superfluous
+  components *OpenApi_IComponents
+  extra      json_schema_superfluous
 }) JsonSchema {
-	elements := []json_schema_metadata_schema_pair{}
-	for _, value := range props.extra.patternProperties {
-		elements = append(elements, value)
-	}
-	if props.extra.additionalProperties != nil {
-		elements = append(elements, *props.extra.additionalProperties)
-	}
-	if len(elements) == 0 {
-		return nil
-	}
-	if len(elements) == 1 {
-		return elements[0].schema
-	}
-	metadata := elements[0].metadata
-	for i := 1; i < len(elements); i++ {
-		metadata = nativemetadata.MetadataSchema_merge(metadata, elements[i].metadata)
-	}
-	return json_schema_station(json_schema_station_props{
-		blockNever: true,
-		components: props.components,
-		attribute:  JsonSchema{},
-		metadata:   metadata,
-	})
+  elements := []json_schema_metadata_schema_pair{}
+  for _, value := range props.extra.patternProperties {
+    elements = append(elements, value)
+  }
+  if props.extra.additionalProperties != nil {
+    elements = append(elements, *props.extra.additionalProperties)
+  }
+  if len(elements) == 0 {
+    return nil
+  }
+  if len(elements) == 1 {
+    return elements[0].schema
+  }
+  metadata := elements[0].metadata
+  for i := 1; i < len(elements); i++ {
+    metadata = nativemetadata.MetadataSchema_merge(metadata, elements[i].metadata)
+  }
+  return json_schema_station(json_schema_station_props{
+    blockNever: true,
+    components: props.components,
+    attribute:  JsonSchema{},
+    metadata:   metadata,
+  })
 }
 
 type json_schema_superfluous struct {
-	additionalProperties *json_schema_metadata_schema_pair
-	patternProperties    map[string]json_schema_metadata_schema_pair
+  additionalProperties *json_schema_metadata_schema_pair
+  patternProperties    map[string]json_schema_metadata_schema_pair
 }
 
 type json_schema_metadata_schema_pair struct {
-	metadata *nativemetadata.MetadataSchema
-	schema   JsonSchema
+  metadata *nativemetadata.MetadataSchema
+  schema   JsonSchema
 }

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

@@ -5,43 +5,43 @@ import nativemetadata "github.com/samchon/typia/packages/typia/native/core/schem
 type JsonSchema map[string]any
 
 func json_schema_plugin(props struct {
-	schema JsonSchema
-	tags   [][]nativemetadata.IMetadataTypeTag
+  schema JsonSchema
+  tags   [][]nativemetadata.IMetadataTypeTag
 }) []JsonSchema {
-	plugins := make([][]nativemetadata.IMetadataTypeTag, 0)
-	for _, row := range props.tags {
-		filtered := make([]nativemetadata.IMetadataTypeTag, 0)
-		for _, tag := range row {
-			if tag.Schema != nil {
-				filtered = append(filtered, tag)
-			}
-		}
-		if len(filtered) != 0 {
-			plugins = append(plugins, filtered)
-		}
-	}
-	if len(plugins) == 0 {
-		return []JsonSchema{props.schema}
-	}
-	output := make([]JsonSchema, 0, len(plugins))
-	for _, row := range plugins {
-		base := cloneJsonSchema(props.schema)
-		for _, tag := range row {
-			if schema, ok := tag.Schema.(map[string]any); ok {
-				for key, value := range schema {
-					base[key] = value
-				}
-			}
-		}
-		output = append(output, base)
-	}
-	return output
+  plugins := make([][]nativemetadata.IMetadataTypeTag, 0)
+  for _, row := range props.tags {
+    filtered := make([]nativemetadata.IMetadataTypeTag, 0)
+    for _, tag := range row {
+      if tag.Schema != nil {
+        filtered = append(filtered, tag)
+      }
+    }
+    if len(filtered) != 0 {
+      plugins = append(plugins, filtered)
+    }
+  }
+  if len(plugins) == 0 {
+    return []JsonSchema{props.schema}
+  }
+  output := make([]JsonSchema, 0, len(plugins))
+  for _, row := range plugins {
+    base := cloneJsonSchema(props.schema)
+    for _, tag := range row {
+      if schema, ok := tag.Schema.(map[string]any); ok {
+        for key, value := range schema {
+          base[key] = value
+        }
+      }
+    }
+    output = append(output, base)
+  }
+  return output
 }
 
 func cloneJsonSchema(input JsonSchema) JsonSchema {
-	output := JsonSchema{}
-	for key, value := range input {
-		output[key] = value
-	}
-	return output
+  output := JsonSchema{}
+  for key, value := range input {
+    output[key] = value
+  }
+  return output
 }