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

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

@@ -0,0 +1,63 @@
+package metadata
+
+import (
+	nativechecker "github.com/microsoft/typescript-go/shim/checker"
+	schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+)
+
+func Iterate_metadata_atomic(props struct {
+	Metadata *schemametadata.MetadataSchema
+	Type     *nativechecker.Type
+}) bool {
+	filter := func(flag nativechecker.TypeFlags) bool {
+		return props.Type.Flags()&flag != 0
+	}
+	for _, info := range iterate_metadata_atomic_atomcs {
+		if filter(info.atomic) || filter(info.literal) {
+			found := false
+			for _, atomic := range props.Metadata.Atomics {
+				if atomic.Type == info.name {
+					found = true
+					break
+				}
+			}
+			if found == false {
+				props.Metadata.Atomics = append(props.Metadata.Atomics, schemametadata.MetadataAtomic_create(schemametadata.MetadataAtomic{
+					Type: info.name,
+					Tags: [][]schemametadata.IMetadataTypeTag{},
+				}))
+			}
+			return true
+		}
+	}
+	return false
+}
+
+type iterate_metadata_atomic_info struct {
+	name    string
+	atomic  nativechecker.TypeFlags
+	literal nativechecker.TypeFlags
+}
+
+var iterate_metadata_atomic_atomcs = []iterate_metadata_atomic_info{
+	{
+		name:    "boolean",
+		atomic:  nativechecker.TypeFlagsBooleanLike,
+		literal: nativechecker.TypeFlagsBooleanLiteral,
+	},
+	{
+		name:    "number",
+		atomic:  nativechecker.TypeFlagsNumberLike,
+		literal: nativechecker.TypeFlagsNumberLiteral,
+	},
+	{
+		name:    "bigint",
+		atomic:  nativechecker.TypeFlagsBigIntLike,
+		literal: nativechecker.TypeFlagsBigIntLiteral,
+	},
+	{
+		name:    "string",
+		atomic:  nativechecker.TypeFlagsStringLike,
+		literal: nativechecker.TypeFlagsStringLiteral,
+	},
+}

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

@@ -0,0 +1,30 @@
+package metadata
+
+import (
+	nativechecker "github.com/microsoft/typescript-go/shim/checker"
+	schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+)
+
+func Iterate_metadata_coalesce(props struct {
+	Metadata *schemametadata.MetadataSchema
+	Type     *nativechecker.Type
+}) bool {
+	filter := func(flag nativechecker.TypeFlags) bool {
+		return props.Type.Flags()&flag != 0
+	}
+	if filter(nativechecker.TypeFlagsUnknown) || filter(nativechecker.TypeFlagsAny) {
+		props.Metadata.Any = true
+		return true
+	}
+	if filter(nativechecker.TypeFlagsNull) {
+		props.Metadata.Nullable = true
+		return true
+	}
+	if filter(nativechecker.TypeFlagsUndefined) ||
+		filter(nativechecker.TypeFlagsNever) ||
+		filter(nativechecker.TypeFlagsVoid) {
+		props.Metadata.Required = false
+		return true
+	}
+	return false
+}

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

@@ -0,0 +1,247 @@
+package metadata
+
+import schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+
+func Iterate_metadata_collection(props struct {
+	Errors     *[]MetadataFactory_IError
+	Collection *schemametadata.MetadataCollection
+}) {
+	for _, array := range props.Collection.Arrays() {
+		if array.Recursive == false {
+			props.Collection.SetArrayRecursive(array, iterate_metadata_collection_is_array_recursive(struct {
+				Visited  map[*schemametadata.MetadataSchema]bool
+				Array    *schemametadata.MetadataArrayType
+				Metadata *schemametadata.MetadataSchema
+			}{
+				Visited:  map[*schemametadata.MetadataSchema]bool{},
+				Array:    array,
+				Metadata: array.Value,
+			}))
+		}
+	}
+	for _, tuple := range props.Collection.Tuples() {
+		if tuple.Recursive == false {
+			visited := map[*schemametadata.MetadataSchema]bool{}
+			recursive := false
+			for _, element := range tuple.Elements {
+				if iterate_metadata_collection_is_tuple_recursive(struct {
+					Visited  map[*schemametadata.MetadataSchema]bool
+					Tuple    *schemametadata.MetadataTupleType
+					Metadata *schemametadata.MetadataSchema
+				}{
+					Visited:  visited,
+					Tuple:    tuple,
+					Metadata: element,
+				}) {
+					recursive = true
+					break
+				}
+			}
+			props.Collection.SetTupleRecursive(tuple, recursive)
+		}
+	}
+	for _, object := range props.Collection.Objects() {
+		Iterate_metadata_comment_tags(struct {
+			Errors *[]MetadataFactory_IError
+			Object *schemametadata.MetadataObjectType
+		}{
+			Errors: props.Errors,
+			Object: object,
+		})
+		if object.Recursive == false {
+			visited := map[*schemametadata.MetadataSchema]bool{}
+			recursive := false
+			for _, property := range object.Properties {
+				if iterate_metadata_collection_is_object_recursive(struct {
+					Visited  map[*schemametadata.MetadataSchema]bool
+					Object   *schemametadata.MetadataObjectType
+					Metadata *schemametadata.MetadataSchema
+				}{
+					Visited:  visited,
+					Object:   object,
+					Metadata: property.Value,
+				}) {
+					recursive = true
+					break
+				}
+			}
+			props.Collection.SetObjectRecursive(object, recursive)
+		}
+	}
+}
+
+func iterate_metadata_collection_is_array_recursive(props struct {
+	Visited  map[*schemametadata.MetadataSchema]bool
+	Array    *schemametadata.MetadataArrayType
+	Metadata *schemametadata.MetadataSchema
+}) bool {
+	if props.Metadata == nil || props.Visited[props.Metadata] {
+		return false
+	}
+	props.Visited[props.Metadata] = true
+	next := func(metadata *schemametadata.MetadataSchema) bool {
+		return iterate_metadata_collection_is_array_recursive(struct {
+			Visited  map[*schemametadata.MetadataSchema]bool
+			Array    *schemametadata.MetadataArrayType
+			Metadata *schemametadata.MetadataSchema
+		}{
+			Visited:  props.Visited,
+			Array:    props.Array,
+			Metadata: metadata,
+		})
+	}
+	for _, array := range props.Metadata.Arrays {
+		if array.Type == props.Array || next(array.Type.Value) {
+			return true
+		}
+	}
+	for _, alias := range props.Metadata.Aliases {
+		if next(alias.Type.Value) {
+			return true
+		}
+	}
+	for _, tuple := range props.Metadata.Tuples {
+		if tuple.Type.Recursive == false {
+			for _, elem := range tuple.Type.Elements {
+				if next(elem) {
+					return true
+				}
+			}
+		}
+	}
+	for _, m := range props.Metadata.Maps {
+		if next(m.Value) {
+			return true
+		}
+	}
+	for _, set := range props.Metadata.Sets {
+		if next(set.Value) {
+			return true
+		}
+	}
+	if props.Metadata.Escaped != nil && next(props.Metadata.Escaped.Returns) {
+		return true
+	}
+	return props.Metadata.Rest != nil && next(props.Metadata.Rest)
+}
+
+func iterate_metadata_collection_is_tuple_recursive(props struct {
+	Visited  map[*schemametadata.MetadataSchema]bool
+	Tuple    *schemametadata.MetadataTupleType
+	Metadata *schemametadata.MetadataSchema
+}) bool {
+	if props.Metadata == nil || props.Visited[props.Metadata] {
+		return false
+	}
+	props.Visited[props.Metadata] = true
+	next := func(metadata *schemametadata.MetadataSchema) bool {
+		return iterate_metadata_collection_is_tuple_recursive(struct {
+			Visited  map[*schemametadata.MetadataSchema]bool
+			Tuple    *schemametadata.MetadataTupleType
+			Metadata *schemametadata.MetadataSchema
+		}{
+			Visited:  props.Visited,
+			Tuple:    props.Tuple,
+			Metadata: metadata,
+		})
+	}
+	for _, tuple := range props.Metadata.Tuples {
+		if tuple.Type == props.Tuple {
+			return true
+		}
+		for _, elem := range tuple.Type.Elements {
+			if next(elem) {
+				return true
+			}
+		}
+	}
+	for _, array := range props.Metadata.Arrays {
+		if array.Type.Recursive == false && next(array.Type.Value) {
+			return true
+		}
+	}
+	for _, m := range props.Metadata.Maps {
+		if next(m.Value) {
+			return true
+		}
+	}
+	for _, set := range props.Metadata.Sets {
+		if next(set.Value) {
+			return true
+		}
+	}
+	for _, alias := range props.Metadata.Aliases {
+		if next(alias.Type.Value) {
+			return true
+		}
+	}
+	if props.Metadata.Escaped != nil && next(props.Metadata.Escaped.Returns) {
+		return true
+	}
+	return props.Metadata.Rest != nil && next(props.Metadata.Rest)
+}
+
+func iterate_metadata_collection_is_object_recursive(props struct {
+	Visited  map[*schemametadata.MetadataSchema]bool
+	Object   *schemametadata.MetadataObjectType
+	Metadata *schemametadata.MetadataSchema
+}) bool {
+	if props.Metadata == nil || props.Visited[props.Metadata] {
+		return false
+	}
+	props.Visited[props.Metadata] = true
+	next := func(metadata *schemametadata.MetadataSchema) bool {
+		return iterate_metadata_collection_is_object_recursive(struct {
+			Visited  map[*schemametadata.MetadataSchema]bool
+			Object   *schemametadata.MetadataObjectType
+			Metadata *schemametadata.MetadataSchema
+		}{
+			Visited:  props.Visited,
+			Object:   props.Object,
+			Metadata: metadata,
+		})
+	}
+	for _, object := range props.Metadata.Objects {
+		if object.Type == props.Object {
+			return true
+		}
+		for _, property := range object.Type.Properties {
+			if next(property.Value) {
+				return true
+			}
+		}
+	}
+	for _, alias := range props.Metadata.Aliases {
+		if next(alias.Type.Value) {
+			return true
+		}
+	}
+	for _, array := range props.Metadata.Arrays {
+		if array.Type.Recursive == false && next(array.Type.Value) {
+			return true
+		}
+	}
+	for _, tuple := range props.Metadata.Tuples {
+		if tuple.Type.Recursive == false {
+			for _, elem := range tuple.Type.Elements {
+				if next(elem) {
+					return true
+				}
+			}
+		}
+	}
+	for _, m := range props.Metadata.Maps {
+		if next(m.Value) {
+			return true
+		}
+	}
+	for _, set := range props.Metadata.Sets {
+		if next(set.Value) {
+			return true
+		}
+	}
+	if props.Metadata.Escaped != nil && next(props.Metadata.Escaped.Returns) {
+		return true
+	}
+	return props.Metadata.Rest != nil && next(props.Metadata.Rest)
+}

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

@@ -0,0 +1,20 @@
+package metadata
+
+import schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+
+func Iterate_metadata_comment_tags(props struct {
+	Errors *[]MetadataFactory_IError
+	Object *schemametadata.MetadataObjectType
+}) {
+	if props.Object == nil || props.Object.Tagged_ == true {
+		return
+	}
+	props.Object.Tagged_ = true
+
+	for _, property := range props.Object.Properties {
+		_ = property
+		// JSDoc extraction through the TypeScript-Go shim is not yet complete.
+		// The traversal point is kept in the original file location so the
+		// MetadataCommentTagFactory port can be wired without changing callers.
+	}
+}

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

@@ -0,0 +1,86 @@
+package metadata
+
+import (
+	"fmt"
+
+	nativechecker "github.com/microsoft/typescript-go/shim/checker"
+	schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+)
+
+func Iterate_metadata_constant(props IMetadataIteratorProps) bool {
+	if props.Options.Constant == false {
+		return false
+	}
+	filter := func(flag nativechecker.TypeFlags) bool {
+		return props.Type.Flags()&flag != 0
+	}
+	comment := func() struct {
+		description *string
+		jsDocTags   []schemametadata.IJsDocTagInfo
+	} {
+		return struct {
+			description *string
+			jsDocTags   []schemametadata.IJsDocTagInfo
+		}{}
+	}
+
+	if filter(nativechecker.TypeFlagsStringLiteral) ||
+		filter(nativechecker.TypeFlagsNumberLiteral) ||
+		filter(nativechecker.TypeFlagsBigIntLiteral) {
+		value := props.Type.AsLiteralType().Value()
+		typ := "string"
+		if filter(nativechecker.TypeFlagsNumberLiteral) {
+			typ = "number"
+		} else if filter(nativechecker.TypeFlagsBigIntLiteral) {
+			typ = "bigint"
+		}
+		constant := iterate_metadata_constant_take(props.Metadata, typ)
+		info := comment()
+		iterate_metadata_constant_add(constant, schemametadata.MetadataConstantValue_create(schemametadata.MetadataConstantValue{
+			Value:       value,
+			Tags:        [][]schemametadata.IMetadataTypeTag{},
+			Description: info.description,
+			JsDocTags:   info.jsDocTags,
+		}))
+		return true
+	}
+	if filter(nativechecker.TypeFlagsBooleanLiteral) {
+		value := false
+		if props.Checker != nil && props.Checker.TypeToString(props.Type) == "true" {
+			value = true
+		}
+		constant := iterate_metadata_constant_take(props.Metadata, "boolean")
+		info := comment()
+		iterate_metadata_constant_add(constant, schemametadata.MetadataConstantValue_create(schemametadata.MetadataConstantValue{
+			Value:       value,
+			Tags:        [][]schemametadata.IMetadataTypeTag{},
+			Description: info.description,
+			JsDocTags:   info.jsDocTags,
+		}))
+		return true
+	}
+	return false
+}
+
+func iterate_metadata_constant_take(metadata *schemametadata.MetadataSchema, typ string) *schemametadata.MetadataConstant {
+	for _, constant := range metadata.Constants {
+		if constant.Type == typ {
+			return constant
+		}
+	}
+	constant := schemametadata.MetadataConstant_create(schemametadata.MetadataConstant{
+		Type:   typ,
+		Values: []*schemametadata.MetadataConstantValue{},
+	})
+	metadata.Constants = append(metadata.Constants, constant)
+	return constant
+}
+
+func iterate_metadata_constant_add(constant *schemametadata.MetadataConstant, value *schemametadata.MetadataConstantValue) {
+	for _, oldbie := range constant.Values {
+		if fmt.Sprint(oldbie.Value) == fmt.Sprint(value.Value) {
+			return
+		}
+	}
+	constant.Values = append(constant.Values, value)
+}

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

@@ -0,0 +1,56 @@
+package metadata
+
+import (
+	nativechecker "github.com/microsoft/typescript-go/shim/checker"
+	schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+)
+
+func Iterate_metadata_escape(props IMetadataIteratorProps) bool {
+	if props.Options.Escape == false || props.Explore.Escaped == true {
+		return false
+	}
+	escaped := metadata_get_return_type_of_class_method(struct {
+		Checker  *nativechecker.Checker
+		Class    *nativechecker.Type
+		Function string
+	}{
+		Checker:  props.Checker,
+		Class:    props.Type,
+		Function: "toJSON",
+	})
+	if escaped == nil {
+		return false
+	}
+
+	if props.Metadata.Escaped == nil {
+		props.Metadata.Escaped = schemametadata.MetadataEscaped_create(schemametadata.MetadataEscaped{
+			Original: schemametadata.MetadataSchema_initialize(),
+			Returns:  schemametadata.MetadataSchema_initialize(),
+		})
+	}
+	originExplore := props.Explore
+	originExplore.Escaped = true
+	Iterate_metadata(IMetadataIteratorProps{
+		Options:     props.Options,
+		Checker:     props.Checker,
+		Components:  props.Components,
+		Errors:      props.Errors,
+		Metadata:    props.Metadata.Escaped.Original,
+		Type:        props.Type,
+		Explore:     originExplore,
+		Intersected: props.Intersected,
+	})
+	returnExplore := props.Explore
+	returnExplore.Escaped = true
+	Iterate_metadata(IMetadataIteratorProps{
+		Options:     props.Options,
+		Checker:     props.Checker,
+		Components:  props.Components,
+		Errors:      props.Errors,
+		Metadata:    props.Metadata.Escaped.Returns,
+		Type:        escaped,
+		Explore:     returnExplore,
+		Intersected: props.Intersected,
+	})
+	return true
+}

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

@@ -0,0 +1,93 @@
+package metadata
+
+import (
+	nativechecker "github.com/microsoft/typescript-go/shim/checker"
+	schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+)
+
+func Iterate_metadata_function(props IMetadataIteratorProps) bool {
+	declaration := metadata_get_function_node(props.Type)
+	if declaration == nil {
+		return false
+	}
+	if props.Options.Functional == false {
+		if len(props.Metadata.Functions) == 0 {
+			props.Metadata.Functions = append(props.Metadata.Functions, schemametadata.MetadataFunction_create(schemametadata.MetadataFunction{
+				Parameters: []*schemametadata.MetadataParameter{},
+				Output:     schemametadata.MetadataSchema_initialize(),
+				Async:      false,
+			}))
+		}
+		return true
+	}
+
+	signatures := []*nativechecker.Signature{}
+	if props.Checker != nil {
+		signatures = props.Checker.GetSignaturesOfType(props.Type, nativechecker.SignatureKindCall)
+	}
+	if len(signatures) == 0 || signatures[0].Declaration() == nil {
+		props.Metadata.Functions = append(props.Metadata.Functions, schemametadata.MetadataFunction_create(schemametadata.MetadataFunction{
+			Parameters: []*schemametadata.MetadataParameter{},
+			Output:     schemametadata.MetadataSchema_initialize(),
+			Async:      false,
+		}))
+		return true
+	}
+
+	signature := signatures[0]
+	returnType := props.Checker.GetReturnTypeOfSignature(signature)
+	async := false
+	if returnType != nil {
+		if symbol := returnType.Symbol(); symbol != nil && symbol.Name == "Promise" {
+			generic := metadata_get_type_arguments(props.Checker, returnType)
+			if len(generic) != 0 {
+				returnType = generic[0]
+			}
+			async = true
+		}
+	}
+
+	parameters := make([]*schemametadata.MetadataParameter, 0, len(signature.Parameters()))
+	for _, p := range signature.Parameters() {
+		paramType := props.Checker.GetTypeOfSymbol(p)
+		explore := props.Explore
+		explore.Top = false
+		explore.Parameter = p.Name
+		parameters = append(parameters, schemametadata.MetadataParameter_create(schemametadata.MetadataParameter{
+			Name: p.Name,
+			Type: Explore_metadata(Explore_metadata_IProps{
+				Options:     props.Options,
+				Checker:     props.Checker,
+				Components:  props.Components,
+				Errors:      props.Errors,
+				Type:        paramType,
+				Explore:     explore,
+				Intersected: false,
+			}),
+			TsType:      paramType,
+			Description: metadata_node_description(p),
+			JsDocTags:   metadata_node_js_doc_tags(p),
+		}))
+	}
+
+	outputExplore := props.Explore
+	outputExplore.Top = false
+	outputExplore.Output = true
+	outputOptions := props.Options
+	outputOptions.Functional = false
+	output := Explore_metadata(Explore_metadata_IProps{
+		Options:     outputOptions,
+		Checker:     props.Checker,
+		Components:  props.Components,
+		Errors:      props.Errors,
+		Type:        returnType,
+		Explore:     outputExplore,
+		Intersected: false,
+	})
+	props.Metadata.Functions = append(props.Metadata.Functions, schemametadata.MetadataFunction_create(schemametadata.MetadataFunction{
+		Parameters: parameters,
+		Output:     output,
+		Async:      async,
+	}))
+	return true
+}