@nestia/core 12.0.0-dev.20260520.1 → 12.0.0-dev.20260521.2

package/native/cmd/ttsc-nestia/sdk_metadata_json.go

@@ -1,327 +0,0 @@
-package main
-
-import schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
-
-func nestiaSDKMetadataComponentsLiteral(
-	components schemametadata.IMetadataComponents,
-) map[string]any {
-	return map[string]any{
-		"objects": nestiaSDKMetadataObjectTypes(components.Objects),
-		"aliases": nestiaSDKMetadataAliasTypes(components.Aliases),
-		"arrays":  nestiaSDKMetadataArrayTypes(components.Arrays),
-		"tuples":  nestiaSDKMetadataTupleTypes(components.Tuples),
-	}
-}
-
-func nestiaSDKMetadataSchemaLiteral(meta *schemametadata.IMetadataSchema) any {
-	if meta == nil {
-		return nestiaSDKLiteralNull
-	}
-	return map[string]any{
-		"any":       meta.Any,
-		"required":  meta.Required,
-		"optional":  meta.Optional,
-		"nullable":  meta.Nullable,
-		"functions": nestiaSDKMetadataFunctions(meta.Functions),
-		"atomics":   nestiaSDKMetadataAtomics(meta.Atomics),
-		"constants": nestiaSDKMetadataConstants(meta.Constants),
-		"templates": nestiaSDKMetadataTemplates(meta.Templates),
-		"escaped":   nestiaSDKMetadataEscaped(meta.Escaped),
-		"rest":      nestiaSDKMetadataSchemaLiteral(meta.Rest),
-		"arrays":    nestiaSDKMetadataReferences(meta.Arrays),
-		"tuples":    nestiaSDKMetadataReferences(meta.Tuples),
-		"objects":   nestiaSDKMetadataReferences(meta.Objects),
-		"aliases":   nestiaSDKMetadataReferences(meta.Aliases),
-		"natives":   nestiaSDKMetadataReferences(meta.Natives),
-		"sets":      nestiaSDKMetadataSets(meta.Sets),
-		"maps":      nestiaSDKMetadataMaps(meta.Maps),
-	}
-}
-
-func nestiaSDKMetadataFunctions(
-	input []*schemametadata.IMetadataSchema_IFunction,
-) []any {
-	output := []any{}
-	for _, fn := range input {
-		if fn == nil {
-			continue
-		}
-		output = append(output, map[string]any{
-			"parameters": nestiaSDKMetadataParameters(fn.Parameters),
-			"output":     nestiaSDKMetadataSchemaLiteral(fn.Output),
-			"async":      fn.Async,
-		})
-	}
-	return output
-}
-
-func nestiaSDKMetadataParameters(
-	input []*schemametadata.IMetadataSchema_IParameter,
-) []any {
-	output := []any{}
-	for _, param := range input {
-		if param == nil {
-			continue
-		}
-		output = append(output, map[string]any{
-			"name":        param.Name,
-			"type":        nestiaSDKMetadataSchemaLiteral(param.Type),
-			"description": nestiaSDKOptionalString(param.Description),
-			"jsDocTags":   nestiaSDKJSDocTags(param.JsDocTags),
-		})
-	}
-	return output
-}
-
-func nestiaSDKMetadataAtomics(
-	input []schemametadata.IMetadataSchema_IAtomic,
-) []any {
-	output := []any{}
-	for _, atomic := range input {
-		output = append(output, map[string]any{
-			"type": atomic.Type,
-			"tags": nestiaSDKMetadataTagMatrix(atomic.Tags),
-		})
-	}
-	return output
-}
-
-func nestiaSDKMetadataConstants(
-	input []schemametadata.IMetadataSchema_IConstant,
-) []any {
-	output := []any{}
-	for _, constant := range input {
-		values := []any{}
-		for _, value := range constant.Values {
-			values = append(values, map[string]any{
-				"value":       value.Value,
-				"tags":        nestiaSDKMetadataTagMatrix(value.Tags),
-				"description": nestiaSDKOptionalString(value.Description),
-				"jsDocTags":   nestiaSDKJSDocTags(value.JsDocTags),
-			})
-		}
-		output = append(output, map[string]any{
-			"type":   constant.Type,
-			"values": values,
-		})
-	}
-	return output
-}
-
-func nestiaSDKMetadataTemplates(
-	input []schemametadata.IMetadataSchema_ITemplate,
-) []any {
-	output := []any{}
-	for _, template := range input {
-		row := []any{}
-		for _, child := range template.Row {
-			row = append(row, nestiaSDKMetadataSchemaLiteral(child))
-		}
-		output = append(output, map[string]any{
-			"row":  row,
-			"tags": nestiaSDKMetadataTagMatrix(template.Tags),
-		})
-	}
-	return output
-}
-
-func nestiaSDKMetadataEscaped(
-	input *schemametadata.IMetadataSchema_IEscaped,
-) any {
-	if input == nil {
-		return nestiaSDKLiteralNull
-	}
-	return map[string]any{
-		"original": nestiaSDKMetadataSchemaLiteral(input.Original),
-		"returns":  nestiaSDKMetadataSchemaLiteral(input.Returns),
-	}
-}
-
-func nestiaSDKMetadataReferences(
-	input []schemametadata.IMetadataSchema_IReference,
-) []any {
-	output := []any{}
-	for _, ref := range input {
-		output = append(output, map[string]any{
-			"name": ref.Name,
-			"tags": nestiaSDKMetadataTagMatrix(ref.Tags),
-		})
-	}
-	return output
-}
-
-func nestiaSDKMetadataSets(input []schemametadata.IMetadataSchema_ISet) []any {
-	output := []any{}
-	for _, set := range input {
-		output = append(output, map[string]any{
-			"value": nestiaSDKMetadataSchemaLiteral(set.Value),
-			"tags":  nestiaSDKMetadataTagMatrix(set.Tags),
-		})
-	}
-	return output
-}
-
-func nestiaSDKMetadataMaps(input []schemametadata.IMetadataSchema_IMap) []any {
-	output := []any{}
-	for _, entry := range input {
-		output = append(output, map[string]any{
-			"key":   nestiaSDKMetadataSchemaLiteral(entry.Key),
-			"value": nestiaSDKMetadataSchemaLiteral(entry.Value),
-			"tags":  nestiaSDKMetadataTagMatrix(entry.Tags),
-		})
-	}
-	return output
-}
-
-func nestiaSDKMetadataObjectTypes(
-	input []schemametadata.IMetadataSchema_IObjectType,
-) []any {
-	output := []any{}
-	for _, object := range input {
-		properties := []any{}
-		for _, property := range object.Properties {
-			if property == nil {
-				continue
-			}
-			properties = append(properties, map[string]any{
-				"key":         nestiaSDKMetadataSchemaLiteral(property.Key),
-				"value":       nestiaSDKMetadataSchemaLiteral(property.Value),
-				"description": nestiaSDKOptionalString(property.Description),
-				"jsDocTags":   nestiaSDKJSDocTags(property.JsDocTags),
-				"mutability":  nestiaSDKOptionalString(property.Mutability),
-			})
-		}
-		output = append(output, map[string]any{
-			"name":        object.Name,
-			"properties":  properties,
-			"description": nestiaSDKOptionalString(object.Description),
-			"jsDocTags":   nestiaSDKJSDocTags(object.JsDocTags),
-			"index":       object.Index,
-			"recursive":   object.Recursive,
-			"nullables":   nestiaSDKBoolArray(object.Nullables),
-		})
-	}
-	return output
-}
-
-func nestiaSDKMetadataAliasTypes(
-	input []schemametadata.IMetadataSchema_IAliasType,
-) []any {
-	output := []any{}
-	for _, alias := range input {
-		output = append(output, map[string]any{
-			"name":        alias.Name,
-			"value":       nestiaSDKMetadataSchemaLiteral(alias.Value),
-			"description": nestiaSDKOptionalString(alias.Description),
-			"jsDocTags":   nestiaSDKJSDocTags(alias.JsDocTags),
-			"recursive":   alias.Recursive,
-			"nullables":   nestiaSDKBoolArray(alias.Nullables),
-		})
-	}
-	return output
-}
-
-func nestiaSDKMetadataArrayTypes(
-	input []schemametadata.IMetadataSchema_IArrayType,
-) []any {
-	output := []any{}
-	for _, array := range input {
-		output = append(output, map[string]any{
-			"name":      array.Name,
-			"value":     nestiaSDKMetadataSchemaLiteral(array.Value),
-			"nullables": nestiaSDKBoolArray(array.Nullables),
-			"recursive": array.Recursive,
-			"index":     nestiaSDKOptionalInt(array.Index),
-		})
-	}
-	return output
-}
-
-func nestiaSDKMetadataTupleTypes(
-	input []schemametadata.IMetadataSchema_ITupleType,
-) []any {
-	output := []any{}
-	for _, tuple := range input {
-		elements := []any{}
-		for _, elem := range tuple.Elements {
-			elements = append(elements, nestiaSDKMetadataSchemaLiteral(elem))
-		}
-		output = append(output, map[string]any{
-			"name":      tuple.Name,
-			"elements":  elements,
-			"index":     nestiaSDKOptionalInt(tuple.Index),
-			"recursive": tuple.Recursive,
-			"nullables": nestiaSDKBoolArray(tuple.Nullables),
-		})
-	}
-	return output
-}
-
-func nestiaSDKMetadataTagMatrix(
-	input [][]schemametadata.IMetadataTypeTag,
-) []any {
-	output := []any{}
-	for _, row := range input {
-		items := []any{}
-		for _, tag := range row {
-			items = append(items, nestiaSDKMetadataTypeTag(tag))
-		}
-		output = append(output, items)
-	}
-	return output
-}
-
-func nestiaSDKMetadataTypeTag(tag schemametadata.IMetadataTypeTag) map[string]any {
-	output := map[string]any{
-		"target":    tag.Target,
-		"name":      tag.Name,
-		"kind":      tag.Kind,
-		"exclusive": tag.Exclusive,
-		"value":     tag.Value,
-		"schema":    tag.Schema,
-	}
-	if tag.Validate != "" {
-		output["validate"] = tag.Validate
-	}
-	return output
-}
-
-func nestiaSDKJSDocTags(input []schemametadata.IJsDocTagInfo) []any {
-	output := []any{}
-	for _, tag := range input {
-		text := []any{}
-		for _, item := range tag.Text {
-			text = append(text, map[string]any{
-				"text": item.Text,
-				"kind": item.Kind,
-			})
-		}
-		output = append(output, map[string]any{
-			"name": tag.Name,
-			"text": text,
-		})
-	}
-	return output
-}
-
-func nestiaSDKBoolArray(input []bool) []any {
-	output := []any{}
-	for _, value := range input {
-		output = append(output, value)
-	}
-	return output
-}
-
-func nestiaSDKOptionalString(input *string) any {
-	if input == nil {
-		return nestiaSDKLiteralNull
-	}
-	return *input
-}
-
-func nestiaSDKOptionalInt(input *int) any {
-	if input == nil {
-		return nestiaSDKLiteralNull
-	}
-	return *input
-}