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

package/native/core/schemas/metadata/MetadataConstantValue.go

@@ -0,0 +1,97 @@
+package metadata
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+)
+
+type IJsDocTagInfo struct {
+	Name string
+	Text []IJsDocTagInfo_IText
+}
+
+type IJsDocTagInfo_IText struct {
+	Text string
+	Kind string
+}
+
+type IMetadataSchema_IConstant_IValue struct {
+	Value       any
+	Tags        [][]IMetadataTypeTag
+	Description *string
+	JsDocTags   []IJsDocTagInfo
+}
+
+type MetadataConstantValue struct {
+	Value       any
+	Tags        [][]IMetadataTypeTag
+	Description *string
+	JsDocTags   []IJsDocTagInfo
+	name_       string
+}
+
+func MetadataConstantValue_create(props MetadataConstantValue) *MetadataConstantValue {
+	return &MetadataConstantValue{
+		Value:       props.Value,
+		Tags:        props.Tags,
+		Description: props.Description,
+		JsDocTags:   props.JsDocTags,
+	}
+}
+
+func MetadataConstantValue_from(json IMetadataSchema_IConstant_IValue) *MetadataConstantValue {
+	return MetadataConstantValue_create(MetadataConstantValue{
+		Value:       json.Value,
+		Tags:        json.Tags,
+		Description: json.Description,
+		JsDocTags:   json.JsDocTags,
+	})
+}
+
+func (obj *MetadataConstantValue) GetName() string {
+	if obj.name_ == "" {
+		obj.name_ = metadataConstantValue_getName(obj)
+	}
+	return obj.name_
+}
+
+func (obj *MetadataConstantValue) ToJSON() IMetadataSchema_IConstant_IValue {
+	return IMetadataSchema_IConstant_IValue{
+		Value:       obj.Value,
+		Tags:        obj.Tags,
+		Description: obj.Description,
+		JsDocTags:   obj.JsDocTags,
+	}
+}
+
+func metadataConstantValue_getName(obj *MetadataConstantValue) string {
+	base := metadataConstantValue_base(obj.Value)
+	if len(obj.Tags) == 0 {
+		return base
+	}
+	rows := make([]string, 0, len(obj.Tags))
+	for _, row := range obj.Tags {
+		names := make([]string, 0, len(row))
+		for _, tag := range row {
+			names = append(names, tag.Name)
+		}
+		str := strings.Join(names, " & ")
+		if len(row) == 1 {
+			rows = append(rows, str)
+		} else {
+			rows = append(rows, "("+str+")")
+		}
+	}
+	return "(" + base + " & (" + strings.Join(rows, " | ") + "))"
+}
+
+func metadataConstantValue_base(value any) string {
+	if str, ok := value.(string); ok {
+		data, err := json.Marshal(str)
+		if err == nil {
+			return string(data)
+		}
+	}
+	return fmt.Sprint(value)
+}

package/native/core/schemas/metadata/MetadataEscaped.go

@@ -0,0 +1,36 @@
+package metadata
+
+type IMetadataSchema_IEscaped struct {
+	Original *IMetadataSchema
+	Returns  *IMetadataSchema
+}
+
+type MetadataEscaped struct {
+	Original *MetadataSchema
+	Returns  *MetadataSchema
+}
+
+func MetadataEscaped_from(props IMetadataSchema_IEscaped, dict IMetadataDictionary) *MetadataEscaped {
+	return MetadataEscaped_create(MetadataEscaped{
+		Original: MetadataSchema_from(props.Original, dict),
+		Returns:  MetadataSchema_from(props.Returns, dict),
+	})
+}
+
+func MetadataEscaped_create(props MetadataEscaped) *MetadataEscaped {
+	return &MetadataEscaped{
+		Original: props.Original,
+		Returns:  props.Returns,
+	}
+}
+
+func (obj *MetadataEscaped) GetName() string {
+	return obj.Returns.GetName()
+}
+
+func (obj *MetadataEscaped) ToJSON() IMetadataSchema_IEscaped {
+	return IMetadataSchema_IEscaped{
+		Original: obj.Original.ToJSON(),
+		Returns:  obj.Returns.ToJSON(),
+	}
+}

package/native/core/schemas/metadata/MetadataFunction.go

@@ -0,0 +1,46 @@
+package metadata
+
+type IMetadataSchema_IFunction struct {
+	Parameters []*IMetadataSchema_IParameter
+	Output     *IMetadataSchema
+	Async      bool
+}
+
+type MetadataFunction struct {
+	Parameters []*MetadataParameter
+	Output     *MetadataSchema
+	Async      bool
+}
+
+func MetadataFunction_create(props MetadataFunction) *MetadataFunction {
+	return &MetadataFunction{
+		Parameters: props.Parameters,
+		Output:     props.Output,
+		Async:      props.Async,
+	}
+}
+
+func MetadataFunction_from(json IMetadataSchema_IFunction, dict IMetadataDictionary) *MetadataFunction {
+	parameters := make([]*MetadataParameter, 0, len(json.Parameters))
+	for _, p := range json.Parameters {
+		parameters = append(parameters, MetadataParameter_from(*p, dict))
+	}
+	return MetadataFunction_create(MetadataFunction{
+		Parameters: parameters,
+		Output:     MetadataSchema_from(json.Output, dict),
+		Async:      json.Async,
+	})
+}
+
+func (obj *MetadataFunction) ToJSON() IMetadataSchema_IFunction {
+	parameters := make([]*IMetadataSchema_IParameter, 0, len(obj.Parameters))
+	for _, p := range obj.Parameters {
+		json := p.ToJSON()
+		parameters = append(parameters, &json)
+	}
+	return IMetadataSchema_IFunction{
+		Parameters: parameters,
+		Output:     obj.Output.ToJSON(),
+		Async:      obj.Async,
+	}
+}

package/native/core/schemas/metadata/MetadataMap.go

@@ -0,0 +1,37 @@
+package metadata
+
+type IMetadataSchema_IMap struct {
+	Key   *IMetadataSchema
+	Value *IMetadataSchema
+	Tags  [][]IMetadataTypeTag
+}
+
+type MetadataMap struct {
+	Key   *MetadataSchema
+	Value *MetadataSchema
+	Tags  [][]IMetadataTypeTag
+	name_ string
+}
+
+func MetadataMap_create(props MetadataMap) *MetadataMap {
+	return &MetadataMap{
+		Key:   props.Key,
+		Value: props.Value,
+		Tags:  cloneTagMatrix(props.Tags),
+	}
+}
+
+func (obj *MetadataMap) GetName() string {
+	if obj.name_ == "" {
+		obj.name_ = taggedName("Map<"+safeMetadataName(obj.Key)+", "+safeMetadataName(obj.Value)+">", obj.Tags)
+	}
+	return obj.name_
+}
+
+func (obj *MetadataMap) ToJSON() IMetadataSchema_IMap {
+	return IMetadataSchema_IMap{
+		Key:   obj.Key.ToJSON(),
+		Value: obj.Value.ToJSON(),
+		Tags:  cloneTagMatrix(obj.Tags),
+	}
+}

package/native/core/schemas/metadata/MetadataNative.go

@@ -0,0 +1,72 @@
+package metadata
+
+import "strings"
+
+type IMetadataTypeTag struct {
+	Target    string
+	Name      string
+	Kind      string
+	Exclusive any
+	Value     any
+	Validate  string
+	Schema    any
+}
+
+type IMetadataSchema_IReference struct {
+	Name string
+	Tags [][]IMetadataTypeTag
+}
+
+type MetadataNative struct {
+	Name      string
+	Tags      [][]IMetadataTypeTag
+	typeName_ string
+}
+
+func MetadataNative_create(props MetadataNative) *MetadataNative {
+	return &MetadataNative{
+		Name: props.Name,
+		Tags: props.Tags,
+	}
+}
+
+func (obj *MetadataNative) GetName() string {
+	if obj.typeName_ == "" {
+		obj.typeName_ = metadataNative_getName(obj)
+	}
+	return obj.typeName_
+}
+
+func (obj *MetadataNative) ToJSON() IMetadataSchema_IReference {
+	return IMetadataSchema_IReference{
+		Name: obj.Name,
+		Tags: obj.Tags,
+	}
+}
+
+func metadataNative_getName(obj *MetadataNative) string {
+	if len(obj.Tags) == 0 {
+		return obj.Name
+	}
+	if len(obj.Tags) == 1 {
+		row := []string{obj.Name}
+		for _, tag := range obj.Tags[0] {
+			row = append(row, tag.Name)
+		}
+		return "(" + strings.Join(row, " & ") + ")"
+	}
+	rows := make([]string, 0, len(obj.Tags))
+	for _, row := range obj.Tags {
+		names := make([]string, 0, len(row))
+		for _, tag := range row {
+			names = append(names, tag.Name)
+		}
+		str := strings.Join(names, " & ")
+		if len(row) == 1 {
+			rows = append(rows, str)
+		} else {
+			rows = append(rows, "("+str+")")
+		}
+	}
+	return "(" + obj.Name + " & (" + strings.Join(rows, " | ") + "))"
+}

package/native/core/schemas/metadata/MetadataObject.go

@@ -0,0 +1,28 @@
+package metadata
+
+type MetadataObject struct {
+	Type  *MetadataObjectType
+	Tags  [][]IMetadataTypeTag
+	name_ string
+}
+
+func MetadataObject_create(props MetadataObject) *MetadataObject {
+	return &MetadataObject{
+		Type: props.Type,
+		Tags: cloneTagMatrix(props.Tags),
+	}
+}
+
+func (obj *MetadataObject) GetName() string {
+	if obj.name_ == "" {
+		obj.name_ = taggedName(obj.Type.Name, obj.Tags)
+	}
+	return obj.name_
+}
+
+func (obj *MetadataObject) ToJSON() IMetadataSchema_IReference {
+	return IMetadataSchema_IReference{
+		Name: obj.Type.Name,
+		Tags: cloneTagMatrix(obj.Tags),
+	}
+}

package/native/core/schemas/metadata/MetadataObjectType.go

@@ -0,0 +1,146 @@
+package metadata
+
+import "strings"
+
+type IMetadataSchema_IObjectType struct {
+	Name        string
+	Properties  []*IMetadataSchema_IProperty
+	Description *string
+	JsDocTags   []IJsDocTagInfo
+	Index       int
+	Recursive   bool
+	Nullables   []bool
+}
+
+type MetadataObjectType struct {
+	Name        string
+	Properties  []*MetadataProperty
+	Description *string
+	JsDocTags   []IJsDocTagInfo
+	Index       int
+	Validated   bool
+	Recursive   bool
+	Nullables   []bool
+	Tagged_     bool
+	literal_    *bool
+}
+
+func MetadataObjectType_create(props MetadataObjectType) *MetadataObjectType {
+	name := strings.ToValidUTF8(props.Name, "__")
+	name = strings.ReplaceAll(name, "\uFFFD", "__")
+	return &MetadataObjectType{
+		Name:        name,
+		Properties:  props.Properties,
+		Description: props.Description,
+		JsDocTags:   append([]IJsDocTagInfo{}, props.JsDocTags...),
+		Index:       props.Index,
+		Validated:   props.Validated,
+		Recursive:   props.Recursive,
+		Nullables:   append([]bool{}, props.Nullables...),
+		Tagged_:     false,
+	}
+}
+
+func MetadataObjectType__From_without_properties(obj IMetadataSchema_IObjectType) *MetadataObjectType {
+	return MetadataObjectType_create(MetadataObjectType{
+		Name:        obj.Name,
+		Properties:  []*MetadataProperty{},
+		Description: obj.Description,
+		JsDocTags:   obj.JsDocTags,
+		Index:       obj.Index,
+		Validated:   false,
+		Recursive:   obj.Recursive,
+		Nullables:   obj.Nullables,
+	})
+}
+
+func (obj *MetadataObjectType) IsPlain(level ...int) bool {
+	lv := 0
+	if len(level) > 0 {
+		lv = level[0]
+	}
+	if obj.Recursive || len(obj.Properties) >= 10 {
+		return false
+	}
+	for _, property := range obj.Properties {
+		if property.Key.IsSoleLiteral() == false ||
+			property.Value.Size() != 1 ||
+			property.Value.IsRequired() == false ||
+			property.Value.Nullable {
+			return false
+		}
+		if len(property.Value.Atomics) == 1 {
+			continue
+		}
+		if lv < 1 && len(property.Value.Objects) == 1 && property.Value.Objects[0].Type.IsPlain(lv+1) {
+			continue
+		}
+		return false
+	}
+	return true
+}
+
+func (obj *MetadataObjectType) IsLiteral() bool {
+	if obj.literal_ != nil {
+		return *obj.literal_
+	}
+	value := false
+	if obj.Recursive == false {
+		name := strings.ToValidUTF8(obj.Name, "__")
+		name = strings.ReplaceAll(name, "\uFFFD", "__")
+		value = name == "__type" ||
+			name == "__object" ||
+			strings.HasPrefix(name, "__type.") ||
+			strings.HasPrefix(name, "__object.") ||
+			strings.Contains(name, "readonly [")
+	}
+	obj.literal_ = &value
+	return value
+}
+
+func (obj *MetadataObjectType) ToJSON() IMetadataSchema_IObjectType {
+	properties := make([]*IMetadataSchema_IProperty, 0, len(obj.Properties))
+	for _, property := range obj.Properties {
+		json := property.ToJSON()
+		properties = append(properties, &json)
+	}
+	return IMetadataSchema_IObjectType{
+		Name:        obj.Name,
+		Properties:  properties,
+		Description: obj.Description,
+		JsDocTags:   append([]IJsDocTagInfo{}, obj.JsDocTags...),
+		Index:       obj.Index,
+		Recursive:   obj.Recursive,
+		Nullables:   append([]bool{}, obj.Nullables...),
+	}
+}
+
+func MetadataObjectType_intersects(x *MetadataObjectType, y *MetadataObjectType) bool {
+	for _, prop := range x.Properties {
+		for _, oppo := range y.Properties {
+			if prop.Key.GetName() == oppo.Key.GetName() {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+func MetadataObjectType_covers(x *MetadataObjectType, y *MetadataObjectType) bool {
+	if len(x.Properties) < len(y.Properties) {
+		return false
+	}
+	for _, prop := range x.Properties {
+		found := false
+		for _, oppo := range y.Properties {
+			if prop.Key.GetName() == oppo.Key.GetName() {
+				found = true
+				break
+			}
+		}
+		if found == false {
+			return false
+		}
+	}
+	return true
+}

package/native/core/schemas/metadata/MetadataParameter.go

@@ -0,0 +1,46 @@
+package metadata
+
+import shimchecker "github.com/microsoft/typescript-go/shim/checker"
+
+type IMetadataSchema_IParameter struct {
+	Name        string
+	Type        *IMetadataSchema
+	Description *string
+	JsDocTags   []IJsDocTagInfo
+}
+
+type MetadataParameter struct {
+	Name        string
+	Type        *MetadataSchema
+	Description *string
+	JsDocTags   []IJsDocTagInfo
+	TsType      *shimchecker.Type
+}
+
+func MetadataParameter_create(props MetadataParameter) *MetadataParameter {
+	return &MetadataParameter{
+		Name:        props.Name,
+		Type:        props.Type,
+		Description: props.Description,
+		JsDocTags:   append([]IJsDocTagInfo{}, props.JsDocTags...),
+		TsType:      props.TsType,
+	}
+}
+
+func MetadataParameter_from(json IMetadataSchema_IParameter, dict IMetadataDictionary) *MetadataParameter {
+	return MetadataParameter_create(MetadataParameter{
+		Name:        json.Name,
+		Type:        MetadataSchema_from(json.Type, dict),
+		Description: json.Description,
+		JsDocTags:   json.JsDocTags,
+	})
+}
+
+func (obj *MetadataParameter) ToJSON() IMetadataSchema_IParameter {
+	return IMetadataSchema_IParameter{
+		Name:        obj.Name,
+		Type:        obj.Type.ToJSON(),
+		Description: obj.Description,
+		JsDocTags:   append([]IJsDocTagInfo{}, obj.JsDocTags...),
+	}
+}

package/native/core/schemas/metadata/MetadataProperty.go

@@ -0,0 +1,50 @@
+package metadata
+
+import nativeprotobuf "github.com/samchon/typia/packages/typia/native/core/schemas/protobuf"
+
+type IMetadataSchema_IProperty struct {
+	Key         *IMetadataSchema
+	Value       *IMetadataSchema
+	Description *string
+	JsDocTags   []IJsDocTagInfo
+	Mutability  *string
+}
+
+type MetadataProperty struct {
+	Key          *MetadataSchema
+	Value        *MetadataSchema
+	Description  *string
+	JsDocTags    []IJsDocTagInfo
+	Mutability   *string
+	Of_protobuf_ *nativeprotobuf.IProtobufProperty
+}
+
+func MetadataProperty_create(props MetadataProperty) *MetadataProperty {
+	return &MetadataProperty{
+		Key:         props.Key,
+		Value:       props.Value,
+		Description: props.Description,
+		JsDocTags:   append([]IJsDocTagInfo{}, props.JsDocTags...),
+		Mutability:  props.Mutability,
+	}
+}
+
+func MetadataProperty_from(property IMetadataSchema_IProperty, dict IMetadataDictionary) *MetadataProperty {
+	return MetadataProperty_create(MetadataProperty{
+		Key:         MetadataSchema_from(property.Key, dict),
+		Value:       MetadataSchema_from(property.Value, dict),
+		Description: property.Description,
+		JsDocTags:   append([]IJsDocTagInfo{}, property.JsDocTags...),
+		Mutability:  property.Mutability,
+	})
+}
+
+func (obj *MetadataProperty) ToJSON() IMetadataSchema_IProperty {
+	return IMetadataSchema_IProperty{
+		Key:         obj.Key.ToJSON(),
+		Value:       obj.Value.ToJSON(),
+		Description: obj.Description,
+		JsDocTags:   append([]IJsDocTagInfo{}, obj.JsDocTags...),
+		Mutability:  obj.Mutability,
+	}
+}