typia 13.0.0-dev.20260430 → 13.0.0-dev.20260502-2

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

@@ -3,39 +3,39 @@ package iterate
 import nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
 
 func json_schema_tuple(props struct {
-	components *OpenApi_IComponents
-	tuple      *nativemetadata.MetadataTuple
+  components *OpenApi_IComponents
+  tuple      *nativemetadata.MetadataTuple
 }) JsonSchema {
-	var tail *nativemetadata.MetadataSchema
-	if len(props.tuple.Type.Elements) != 0 {
-		tail = props.tuple.Type.Elements[len(props.tuple.Type.Elements)-1].Rest
-	}
-	prefixItems := props.tuple.Type.Elements
-	if props.tuple.Type.IsRest() && len(prefixItems) != 0 {
-		prefixItems = prefixItems[:len(prefixItems)-1]
-	}
-	items := []JsonSchema{}
-	for _, metadata := range prefixItems {
-		items = append(items, json_schema_station(json_schema_station_props{
-			blockNever: false,
-			components: props.components,
-			metadata:   metadata,
-			attribute:  JsonSchema{},
-		}))
-	}
-	schema := JsonSchema{
-		"type":        "array",
-		"prefixItems": items,
-	}
-	if tail != nil {
-		schema["additionalItems"] = json_schema_station(json_schema_station_props{
-			blockNever: false,
-			components: props.components,
-			metadata:   tail,
-			attribute:  JsonSchema{},
-		})
-	} else {
-		schema["additionalItems"] = false
-	}
-	return schema
+  var tail *nativemetadata.MetadataSchema
+  if len(props.tuple.Type.Elements) != 0 {
+    tail = props.tuple.Type.Elements[len(props.tuple.Type.Elements)-1].Rest
+  }
+  prefixItems := props.tuple.Type.Elements
+  if props.tuple.Type.IsRest() && len(prefixItems) != 0 {
+    prefixItems = prefixItems[:len(prefixItems)-1]
+  }
+  items := []JsonSchema{}
+  for _, metadata := range prefixItems {
+    items = append(items, json_schema_station(json_schema_station_props{
+      blockNever: false,
+      components: props.components,
+      metadata:   metadata,
+      attribute:  JsonSchema{},
+    }))
+  }
+  schema := JsonSchema{
+    "type":        "array",
+    "prefixItems": items,
+  }
+  if tail != nil {
+    schema["additionalItems"] = json_schema_station(json_schema_station_props{
+      blockNever: false,
+      components: props.components,
+      metadata:   tail,
+      attribute:  JsonSchema{},
+    })
+  } else {
+    schema["additionalItems"] = false
+  }
+  return schema
 }

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

@@ -1,64 +1,64 @@
 package iterate
 
 import (
-	"fmt"
-	"strings"
+  "fmt"
+  "strings"
 
-	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 metadata_to_pattern(props struct {
-	top      bool
-	metadata *nativemetadata.MetadataSchema
+  top      bool
+  metadata *nativemetadata.MetadataSchema
 }) string {
-	for _, atomic := range props.metadata.Atomics {
-		if atomic.Type == "string" {
-			return "(.*)"
-		}
-	}
+  for _, atomic := range props.metadata.Atomics {
+    if atomic.Type == "string" {
+      return "(.*)"
+    }
+  }
 
-	values := []string{}
-	for _, constant := range props.metadata.Constants {
-		if constant.Type != "string" {
-			for _, value := range constant.Values {
-				values = append(values, fmt.Sprint(value.Value))
-			}
-			continue
-		}
-		for _, value := range constant.Values {
-			if str, ok := value.Value.(string); ok {
-				values = append(values, nativeutils.PatternUtil.Escape(str))
-			} else {
-				values = append(values, nativeutils.PatternUtil.Escape(fmt.Sprint(value.Value)))
-			}
-		}
-	}
-	for _, atomic := range props.metadata.Atomics {
-		if atomic.Type == "number" || atomic.Type == "bigint" {
-			values = append(values, nativeutils.PatternUtil.NUMBER)
-		} else if atomic.Type == "boolean" {
-			values = append(values, nativeutils.PatternUtil.BOOLEAN)
-		}
-	}
-	for _, template := range props.metadata.Templates {
-		values = append(values, "("+template_to_pattern(struct {
-			top      bool
-			template []*nativemetadata.MetadataSchema
-		}{
-			top:      false,
-			template: template.Row,
-		})+")")
-	}
+  values := []string{}
+  for _, constant := range props.metadata.Constants {
+    if constant.Type != "string" {
+      for _, value := range constant.Values {
+        values = append(values, fmt.Sprint(value.Value))
+      }
+      continue
+    }
+    for _, value := range constant.Values {
+      if str, ok := value.Value.(string); ok {
+        values = append(values, nativeutils.PatternUtil.Escape(str))
+      } else {
+        values = append(values, nativeutils.PatternUtil.Escape(fmt.Sprint(value.Value)))
+      }
+    }
+  }
+  for _, atomic := range props.metadata.Atomics {
+    if atomic.Type == "number" || atomic.Type == "bigint" {
+      values = append(values, nativeutils.PatternUtil.NUMBER)
+    } else if atomic.Type == "boolean" {
+      values = append(values, nativeutils.PatternUtil.BOOLEAN)
+    }
+  }
+  for _, template := range props.metadata.Templates {
+    values = append(values, "("+template_to_pattern(struct {
+      top      bool
+      template []*nativemetadata.MetadataSchema
+    }{
+      top:      false,
+      template: template.Row,
+    })+")")
+  }
 
-	pattern := ""
-	if len(values) == 1 {
-		pattern = values[0]
-	} else {
-		pattern = "(" + strings.Join(values, "|") + ")"
-	}
-	if props.top {
-		return nativeutils.PatternUtil.Fix(pattern)
-	}
-	return pattern
+  pattern := ""
+  if len(values) == 1 {
+    pattern = values[0]
+  } else {
+    pattern = "(" + strings.Join(values, "|") + ")"
+  }
+  if props.top {
+    return nativeutils.PatternUtil.Fix(pattern)
+  }
+  return pattern
 }

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

@@ -1,12 +1,12 @@
 package iterate
 
 func postfix_of_tuple(str string) string {
-	if len(str) > 0 && str[len(str)-1] == '"' {
-		return str[:len(str)-1]
-	}
-	return str + " + \""
+  if len(str) > 0 && str[len(str)-1] == '"' {
+    return str[:len(str)-1]
+  }
+  return str + " + \""
 }
 
 func Postfix_of_tuple_export(str string) string {
-	return postfix_of_tuple(str)
+  return postfix_of_tuple(str)
 }

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

@@ -1,101 +1,101 @@
 package iterate
 
 import (
-	shimast "github.com/microsoft/typescript-go/shim/ast"
-	nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
 )
 
 func Prune_object_properties(object *nativemetadata.MetadataObjectType) *shimast.Node {
-	input := prune_object_properties_factory.NewIdentifier("input")
-	key := prune_object_properties_factory.NewIdentifier("key")
+  input := prune_object_properties_factory.NewIdentifier("input")
+  key := prune_object_properties_factory.NewIdentifier("key")
 
-	conditions := []*shimast.Node{}
-	for _, prop := range object.Properties {
-		name := prop.Key.GetSoleLiteral()
-		if name != nil {
-			conditions = append(conditions, prune_object_properties_factory.NewBinaryExpression(
-				nil,
-				prune_object_properties_factory.NewStringLiteral(*name, shimast.TokenFlagsNone),
-				nil,
-				prune_object_properties_factory.NewToken(shimast.KindEqualsEqualsEqualsToken),
-				prune_object_properties_factory.NewIdentifier("key"),
-			))
-			continue
-		}
-		conditions = append(conditions, prune_object_properties_factory.NewCallExpression(
-			prune_object_properties_factory.NewIdentifier("RegExp(/"+metadata_to_pattern(struct {
-				top      bool
-				metadata *nativemetadata.MetadataSchema
-			}{
-				top:      true,
-				metadata: prop.Key,
-			})+"/).test"),
-			nil,
-			nil,
-			prune_object_properties_factory.NewNodeList([]*shimast.Node{key}),
-			shimast.NodeFlagsNone,
-		))
-	}
+  conditions := []*shimast.Node{}
+  for _, prop := range object.Properties {
+    name := prop.Key.GetSoleLiteral()
+    if name != nil {
+      conditions = append(conditions, prune_object_properties_factory.NewBinaryExpression(
+        nil,
+        prune_object_properties_factory.NewStringLiteral(*name, shimast.TokenFlagsNone),
+        nil,
+        prune_object_properties_factory.NewToken(shimast.KindEqualsEqualsEqualsToken),
+        prune_object_properties_factory.NewIdentifier("key"),
+      ))
+      continue
+    }
+    conditions = append(conditions, prune_object_properties_factory.NewCallExpression(
+      prune_object_properties_factory.NewIdentifier("RegExp(/"+metadata_to_pattern(struct {
+        top      bool
+        metadata *nativemetadata.MetadataSchema
+      }{
+        top:      true,
+        metadata: prop.Key,
+      })+"/).test"),
+      nil,
+      nil,
+      prune_object_properties_factory.NewNodeList([]*shimast.Node{key}),
+      shimast.NodeFlagsNone,
+    ))
+  }
 
-	statements := []*shimast.Node{}
-	if len(conditions) != 0 {
-		statements = append(statements, prune_object_properties_factory.NewIfStatement(
-			prune_object_properties_reduce(conditions, shimast.KindBarBarToken),
-			prune_object_properties_factory.NewContinueStatement(nil),
-			nil,
-		))
-	}
-	statements = append(statements, prune_object_properties_factory.NewExpressionStatement(
-		prune_object_properties_factory.NewDeleteExpression(
-			prune_object_properties_factory.NewElementAccessExpression(input, nil, key, shimast.NodeFlagsNone),
-		),
-	))
+  statements := []*shimast.Node{}
+  if len(conditions) != 0 {
+    statements = append(statements, prune_object_properties_factory.NewIfStatement(
+      prune_object_properties_reduce(conditions, shimast.KindBarBarToken),
+      prune_object_properties_factory.NewContinueStatement(nil),
+      nil,
+    ))
+  }
+  statements = append(statements, prune_object_properties_factory.NewExpressionStatement(
+    prune_object_properties_factory.NewDeleteExpression(
+      prune_object_properties_factory.NewElementAccessExpression(input, nil, key, shimast.NodeFlagsNone),
+    ),
+  ))
 
-	statement := statements[0]
-	if len(statements) != 1 {
-		statement = prune_object_properties_factory.NewBlock(
-			prune_object_properties_factory.NewNodeList(statements),
-			true,
-		)
-	}
+  statement := statements[0]
+  if len(statements) != 1 {
+    statement = prune_object_properties_factory.NewBlock(
+      prune_object_properties_factory.NewNodeList(statements),
+      true,
+    )
+  }
 
-	return prune_object_properties_factory.NewForInOrOfStatement(
-		shimast.KindForOfStatement,
-		nil,
-		prune_object_properties_factory.NewVariableDeclarationList(
-			prune_object_properties_factory.NewNodeList([]*shimast.Node{
-				prune_object_properties_factory.NewVariableDeclaration(
-					prune_object_properties_factory.NewIdentifier("key"),
-					nil,
-					nil,
-					nil,
-				),
-			}),
-			shimast.NodeFlagsConst,
-		),
-		prune_object_properties_factory.NewCallExpression(
-			prune_object_properties_factory.NewIdentifier("Object.keys"),
-			nil,
-			nil,
-			prune_object_properties_factory.NewNodeList([]*shimast.Node{input}),
-			shimast.NodeFlagsNone,
-		),
-		statement,
-	)
+  return prune_object_properties_factory.NewForInOrOfStatement(
+    shimast.KindForOfStatement,
+    nil,
+    prune_object_properties_factory.NewVariableDeclarationList(
+      prune_object_properties_factory.NewNodeList([]*shimast.Node{
+        prune_object_properties_factory.NewVariableDeclaration(
+          prune_object_properties_factory.NewIdentifier("key"),
+          nil,
+          nil,
+          nil,
+        ),
+      }),
+      shimast.NodeFlagsConst,
+    ),
+    prune_object_properties_factory.NewCallExpression(
+      prune_object_properties_factory.NewIdentifier("Object.keys"),
+      nil,
+      nil,
+      prune_object_properties_factory.NewNodeList([]*shimast.Node{input}),
+      shimast.NodeFlagsNone,
+    ),
+    statement,
+  )
 }
 
 func prune_object_properties_reduce(expressions []*shimast.Node, operator shimast.Kind) *shimast.Node {
-	output := expressions[0]
-	for _, next := range expressions[1:] {
-		output = prune_object_properties_factory.NewBinaryExpression(
-			nil,
-			output,
-			nil,
-			prune_object_properties_factory.NewToken(operator),
-			next,
-		)
-	}
-	return output
+  output := expressions[0]
+  for _, next := range expressions[1:] {
+    output = prune_object_properties_factory.NewBinaryExpression(
+      nil,
+      output,
+      nil,
+      prune_object_properties_factory.NewToken(operator),
+      next,
+    )
+  }
+  return output
 }
 
 var prune_object_properties_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})