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

package/native/core/factories/JsonMetadataFactory.go

@@ -0,0 +1,162 @@
+package factories
+
+import (
+	nativechecker "github.com/microsoft/typescript-go/shim/checker"
+	nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
+	schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+)
+
+type jsonMetadataFactoryNamespace struct{}
+
+var JsonMetadataFactory = jsonMetadataFactoryNamespace{}
+
+type JsonMetadataFactory_IProps struct {
+	Method      string
+	Checker     *nativechecker.Checker
+	Transformer any
+	Type        *nativechecker.Type
+	Validate    MetadataFactory_Validator
+}
+
+type JsonMetadataFactory_IOutput struct {
+	Collection *schemametadata.MetadataCollection
+	Metadata   *schemametadata.MetadataSchema
+}
+
+func (jsonMetadataFactoryNamespace) Analyze(props JsonMetadataFactory_IProps) JsonMetadataFactory_IOutput {
+	collection := schemametadata.NewMetadataCollection()
+	validate := func(next struct {
+		Metadata *schemametadata.MetadataSchema
+		Explore  MetadataFactory_IExplore
+		Top      *schemametadata.MetadataSchema
+	}) []string {
+		errors := JsonMetadataFactory.Validate(struct {
+			Metadata *schemametadata.MetadataSchema
+			Explore  MetadataFactory_IExplore
+		}{
+			Metadata: next.Metadata,
+			Explore:  next.Explore,
+		})
+		if props.Validate != nil {
+			errors = append(errors, props.Validate(next)...)
+		}
+		return errors
+	}
+	result := MetadataFactory.Analyze(MetadataFactory_IProps{
+		Checker:     props.Checker,
+		Transformer: props.Transformer,
+		Options: MetadataFactory_IOptions{
+			Absorb:   true,
+			Escape:   true,
+			Constant: true,
+			Validate: validate,
+		},
+		Components: collection,
+		Type:       props.Type,
+	})
+	if result.Success == false {
+		panic(nativecontext.TransformerError_from(struct {
+			Code   string
+			Errors []nativecontext.TransformerError_MetadataFactory_IError
+		}{
+			Code:   props.Method,
+			Errors: jsonMetadataFactory_errors(result.Errors),
+		}))
+	}
+	return JsonMetadataFactory_IOutput{
+		Collection: collection,
+		Metadata:   result.Data,
+	}
+}
+
+func (jsonMetadataFactoryNamespace) Validate(props struct {
+	Metadata *schemametadata.MetadataSchema
+	Explore  MetadataFactory_IExplore
+}) []string {
+	output := []string{}
+	for _, atomic := range props.Metadata.Atomics {
+		if atomic.Type == "bigint" {
+			output = append(output, "JSON does not support bigint type.")
+			break
+		}
+	}
+	for _, constant := range props.Metadata.Constants {
+		if constant.Type == "bigint" {
+			output = append(output, "JSON does not support bigint type.")
+			break
+		}
+	}
+	tupleInvalid := false
+	for _, tuple := range props.Metadata.Tuples {
+		for _, element := range tuple.Type.Elements {
+			if element.IsRequired() == false {
+				tupleInvalid = true
+				break
+			}
+		}
+		if tupleInvalid {
+			break
+		}
+	}
+	arrayInvalid := false
+	for _, array := range props.Metadata.Arrays {
+		if array.Type.Value.IsRequired() == false {
+			arrayInvalid = true
+			break
+		}
+	}
+	if tupleInvalid || arrayInvalid {
+		output = append(output, "JSON does not support undefined type in array.")
+	}
+	if len(props.Metadata.Maps) != 0 {
+		output = append(output, "JSON does not support Map type.")
+	}
+	if len(props.Metadata.Sets) != 0 {
+		output = append(output, "JSON does not support Set type.")
+	}
+	for _, native := range props.Metadata.Natives {
+		if jsonMetadataFactory_atomic_predicator_native(native.Name) == false && native.Name != "Date" {
+			output = append(output, "JSON does not support "+native.Name+" type.")
+		}
+	}
+	return output
+}
+
+func jsonMetadataFactory_atomic_predicator_native(name string) bool {
+	_, ok := jsonMetadataFactory_atomic_like[jsonMetadataFactory_lower(name)]
+	return ok
+}
+
+var jsonMetadataFactory_atomic_like = map[string]struct{}{
+	"boolean": {},
+	"bigint":  {},
+	"number":  {},
+	"string":  {},
+}
+
+func jsonMetadataFactory_lower(str string) string {
+	output := []byte(str)
+	for i, ch := range output {
+		if 'A' <= ch && ch <= 'Z' {
+			output[i] = ch + ('a' - 'A')
+		}
+	}
+	return string(output)
+}
+
+func jsonMetadataFactory_errors(errors []MetadataFactory_IError) []nativecontext.TransformerError_MetadataFactory_IError {
+	output := make([]nativecontext.TransformerError_MetadataFactory_IError, 0, len(errors))
+	for _, err := range errors {
+		output = append(output, nativecontext.TransformerError_MetadataFactory_IError{
+			Name: err.Name,
+			Explore: nativecontext.TransformerError_MetadataFactory_IExplore{
+				Object:    err.Explore.Object,
+				Property:  err.Explore.Property,
+				Parameter: err.Explore.Parameter,
+				Output:    err.Explore.Output,
+			},
+			Messages: err.Messages,
+		})
+	}
+	return output
+}

package/native/core/factories/LiteralFactory.go

@@ -0,0 +1,221 @@
+package factories
+
+import (
+	"math/big"
+	"reflect"
+	"sort"
+	"strings"
+)
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type literalFactoryNamespace struct{}
+
+var LiteralFactory = literalFactoryNamespace{}
+
+var literalFactory_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
+
+func (literalFactoryNamespace) Write(input any) *shimast.Node {
+	if input == nil {
+		return literalFactory_factory.NewKeywordExpression(shimast.KindNullKeyword)
+	}
+	if node, ok := input.(*shimast.Node); ok {
+		if node.Kind == shimast.KindArrowFunction || node.Kind == shimast.KindCallExpression || node.Kind == shimast.KindIdentifier {
+			return node
+		}
+	}
+	if array, ok := input.([]any); ok {
+		return literalFactory_writeArray(array)
+	}
+	if object, ok := input.(map[string]any); ok {
+		return literalFactory_writeObject(object)
+	}
+	switch value := input.(type) {
+	case bool:
+		return literalFactory_writeBoolean(value)
+	case *big.Int:
+		return literalFactory_writeBigint(value)
+	case int:
+		return literalFactory_writeNumber(value)
+	case int64:
+		return literalFactory_writeNumber(value)
+	case float64:
+		return literalFactory_writeNumber(value)
+	case string:
+		return literalFactory_writeString(value)
+	}
+	reflected := reflect.ValueOf(input)
+	switch reflected.Kind() {
+	case reflect.Bool:
+		return literalFactory_writeBoolean(reflected.Bool())
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		return literalFactory_writeNumber(reflected.Int())
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+		return literalFactory_writeNumber(reflected.Uint())
+	case reflect.Float32, reflect.Float64:
+		return literalFactory_writeNumber(reflected.Float())
+	case reflect.Pointer:
+		if reflected.IsNil() {
+			return literalFactory_factory.NewKeywordExpression(shimast.KindNullKeyword)
+		}
+		return LiteralFactory.Write(reflected.Elem().Interface())
+	case reflect.Struct:
+		object := map[string]any{}
+		typ := reflected.Type()
+		for i := 0; i < reflected.NumField(); i++ {
+			field := typ.Field(i)
+			if field.PkgPath != "" || reflected.Field(i).CanInterface() == false {
+				continue
+			}
+			object[literalFactory_fieldName(field.Name)] = reflected.Field(i).Interface()
+		}
+		return literalFactory_writeObject(object)
+	case reflect.Slice, reflect.Array:
+		array := make([]any, 0, reflected.Len())
+		for i := 0; i < reflected.Len(); i++ {
+			array = append(array, reflected.Index(i).Interface())
+		}
+		return literalFactory_writeArray(array)
+	case reflect.Map:
+		if reflected.Type().Key().Kind() == reflect.String {
+			object := map[string]any{}
+			for _, key := range reflected.MapKeys() {
+				object[key.String()] = reflected.MapIndex(key).Interface()
+			}
+			return literalFactory_writeObject(object)
+		}
+	case reflect.Func:
+		return literalFactory_factory.NewIdentifier("undefined")
+	}
+	panic("Error on LiteralFactory.generate(): unknown type.")
+}
+
+func literalFactory_fieldName(name string) string {
+	if name == "" {
+		return name
+	}
+	return strings.ToLower(name[:1]) + name[1:]
+}
+
+func literalFactory_writeObject(obj map[string]any) *shimast.Node {
+	keys := make([]string, 0, len(obj))
+	for key, value := range obj {
+		if value == nil {
+			continue
+		}
+		keys = append(keys, key)
+	}
+	sort.SliceStable(keys, func(i, j int) bool {
+		left, right := literalFactory_propertyRank(keys[i]), literalFactory_propertyRank(keys[j])
+		if left != right {
+			return left < right
+		}
+		return keys[i] < keys[j]
+	})
+	properties := make([]*shimast.Node, 0, len(keys))
+	for _, key := range keys {
+		properties = append(properties, literalFactory_factory.NewPropertyAssignment(
+			nil,
+			IdentifierFactory.Identifier(key),
+			nil,
+			nil,
+			LiteralFactory.Write(obj[key]),
+		))
+	}
+	return literalFactory_factory.NewObjectLiteralExpression(
+		literalFactory_factory.NewNodeList(properties),
+		true,
+	)
+}
+
+func literalFactory_propertyRank(key string) int {
+	switch key {
+	case "$ref":
+		return 0
+	case "type":
+		return 10
+	case "nullable":
+		return 11
+	case "const":
+		return 12
+	case "enum":
+		return 13
+	case "minimum":
+		return 20
+	case "exclusiveMinimum":
+		return 21
+	case "maximum":
+		return 22
+	case "exclusiveMaximum":
+		return 23
+	case "multipleOf":
+		return 24
+	case "minLength":
+		return 30
+	case "maxLength":
+		return 31
+	case "pattern":
+		return 32
+	case "format":
+		return 33
+	case "minItems":
+		return 40
+	case "maxItems":
+		return 41
+	case "uniqueItems":
+		return 42
+	case "items":
+		return 43
+	case "prefixItems":
+		return 44
+	case "properties":
+		return 50
+	case "required":
+		return 51
+	case "additionalProperties":
+		return 52
+	case "oneOf":
+		return 60
+	case "anyOf":
+		return 61
+	case "allOf":
+		return 62
+	case "title":
+		return 90
+	case "description":
+		return 91
+	case "default":
+		return 92
+	}
+	return 1_000
+}
+
+func literalFactory_writeArray(array []any) *shimast.Node {
+	elements := make([]*shimast.Node, 0, len(array))
+	for _, elem := range array {
+		elements = append(elements, LiteralFactory.Write(elem))
+	}
+	return literalFactory_factory.NewArrayLiteralExpression(
+		literalFactory_factory.NewNodeList(elements),
+		true,
+	)
+}
+
+func literalFactory_writeBoolean(value bool) *shimast.Node {
+	if value {
+		return literalFactory_factory.NewKeywordExpression(shimast.KindTrueKeyword)
+	}
+	return literalFactory_factory.NewKeywordExpression(shimast.KindFalseKeyword)
+}
+
+func literalFactory_writeNumber(value any) *shimast.Node {
+	return ExpressionFactory.Number(value)
+}
+
+func literalFactory_writeBigint(value any) *shimast.Node {
+	return ExpressionFactory.Bigint(value)
+}
+
+func literalFactory_writeString(value string) *shimast.Node {
+	return literalFactory_factory.NewStringLiteral(value, shimast.TokenFlagsNone)
+}