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

package/native/core/programmers/helpers/ProtobufUtil.go

@@ -0,0 +1,297 @@
+package helpers
+
+import (
+	"fmt"
+	"math"
+	"strconv"
+	"strings"
+
+	nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+)
+
+type protobufUtilNamespace struct{}
+
+var ProtobufUtil = protobufUtilNamespace{}
+
+func (protobufUtilNamespace) IsStaticObject(obj *nativemetadata.MetadataObjectType) bool {
+	if len(obj.Properties) == 0 {
+		return false
+	}
+	for _, property := range obj.Properties {
+		if property.Key.IsSoleLiteral() == false {
+			return false
+		}
+	}
+	return true
+}
+
+func (protobufUtilNamespace) Size(meta *nativemetadata.MetadataSchema) int {
+	return len(ProtobufUtil.GetAtomics(meta)) +
+		len(meta.Arrays) +
+		len(meta.Tuples) +
+		len(meta.Natives) +
+		len(meta.Objects) +
+		len(meta.Maps)
+}
+
+func (protobufUtilNamespace) GetSequence(tags []nativemetadata.IMetadataTypeTag) *int {
+	for _, tag := range tags {
+		if tag.Kind != "sequence" {
+			continue
+		}
+		schema, ok := tag.Schema.(map[string]any)
+		if ok == false {
+			continue
+		}
+		value, ok := schema["x-protobuf-sequence"]
+		if ok == false {
+			continue
+		}
+		if parsed, ok := protobufUtil_toInt(value); ok {
+			return &parsed
+		}
+	}
+	return nil
+}
+
+func (protobufUtilNamespace) IsUnion(meta *nativemetadata.MetadataSchema) bool {
+	return ProtobufUtil.Size(meta) > 1
+}
+
+func (protobufUtilNamespace) GetAtomics(meta *nativemetadata.MetadataSchema, union ...map[string]*int) map[string]*int {
+	output := protobufUtil_map(union...)
+	for _, constant := range meta.Constants {
+		if constant.Type == "boolean" {
+			output["bool"] = ProtobufUtil.GetSequence(protobufUtil_firstTags(constant.Values))
+		} else if constant.Type == "bigint" {
+			init := protobufUtil_deduce_bigint_type(protobufUtil_values(constant.Values))
+			for _, value := range constant.Values {
+				protobufUtil_decode_bigint(output, value.Tags, init)
+			}
+		} else if constant.Type == "number" {
+			init := protobufUtil_deduce_numeric_type(protobufUtil_values(constant.Values))
+			for _, value := range constant.Values {
+				protobufUtil_decode_number(output, value.Tags, init)
+			}
+		} else if constant.Type == "string" {
+			output["string"] = ProtobufUtil.GetSequence(protobufUtil_firstTags(constant.Values))
+		}
+	}
+	if len(meta.Templates) != 0 {
+		output["string"] = ProtobufUtil.GetSequence(protobufUtil_firstTagRow(meta.Templates[0].Tags))
+	}
+	for _, atomic := range meta.Atomics {
+		if atomic.Type == "boolean" {
+			output["bool"] = ProtobufUtil.GetSequence(protobufUtil_firstTagRow(atomic.Tags))
+		} else if atomic.Type == "bigint" {
+			protobufUtil_decode_bigint(output, atomic.Tags, "int64")
+		} else if atomic.Type == "number" {
+			protobufUtil_decode_number(output, atomic.Tags, "double")
+		} else if atomic.Type == "string" {
+			output["string"] = ProtobufUtil.GetSequence(protobufUtil_firstTagRow(atomic.Tags))
+		}
+	}
+	return output
+}
+
+func (protobufUtilNamespace) GetNumbers(meta *nativemetadata.MetadataSchema, union ...map[string]*int) map[string]*int {
+	output := protobufUtil_map(union...)
+	for _, constant := range meta.Constants {
+		if constant.Type == "number" {
+			init := protobufUtil_deduce_numeric_type(protobufUtil_values(constant.Values))
+			for _, value := range constant.Values {
+				protobufUtil_decode_number(output, value.Tags, init)
+			}
+		}
+	}
+	for _, atomic := range meta.Atomics {
+		if atomic.Type == "number" {
+			protobufUtil_decode_number(output, atomic.Tags, "double")
+		}
+	}
+	return output
+}
+
+func (protobufUtilNamespace) GetBigints(meta *nativemetadata.MetadataSchema, union ...map[string]*int) map[string]*int {
+	output := protobufUtil_map(union...)
+	for _, constant := range meta.Constants {
+		if constant.Type == "bigint" {
+			init := protobufUtil_deduce_bigint_type(protobufUtil_values(constant.Values))
+			for _, value := range constant.Values {
+				protobufUtil_decode_bigint(output, value.Tags, init)
+			}
+		}
+	}
+	for _, atomic := range meta.Atomics {
+		if atomic.Type == "bigint" {
+			protobufUtil_decode_bigint(output, atomic.Tags, "int64")
+		}
+	}
+	return output
+}
+
+func (protobufUtilNamespace) Compare(x string, y string) int {
+	return protobufUtil_atomicOrder[x] - protobufUtil_atomicOrder[y]
+}
+
+var protobufUtil_atomicOrder = map[string]int{
+	"bool":   0,
+	"int32":  1,
+	"uint32": 2,
+	"int64":  3,
+	"uint64": 4,
+	"float":  5,
+	"double": 6,
+	"string": 7,
+}
+
+func protobufUtil_map(union ...map[string]*int) map[string]*int {
+	if len(union) != 0 && union[0] != nil {
+		return union[0]
+	}
+	return map[string]*int{}
+}
+
+func protobufUtil_firstTags(values []*nativemetadata.MetadataConstantValue) []nativemetadata.IMetadataTypeTag {
+	if len(values) == 0 || len(values[0].Tags) == 0 {
+		return []nativemetadata.IMetadataTypeTag{}
+	}
+	return values[0].Tags[0]
+}
+
+func protobufUtil_firstTagRow(tags [][]nativemetadata.IMetadataTypeTag) []nativemetadata.IMetadataTypeTag {
+	if len(tags) == 0 {
+		return []nativemetadata.IMetadataTypeTag{}
+	}
+	return tags[0]
+}
+
+func protobufUtil_values(values []*nativemetadata.MetadataConstantValue) []any {
+	output := make([]any, 0, len(values))
+	for _, value := range values {
+		output = append(output, value.Value)
+	}
+	return output
+}
+
+func protobufUtil_deduce_bigint_type(values []any) string {
+	for _, value := range values {
+		if strings.HasPrefix(fmt.Sprint(value), "-") {
+			return "int64"
+		}
+	}
+	return "uint64"
+}
+
+func protobufUtil_deduce_numeric_type(values []any) string {
+	integers := true
+	int32s := true
+	for _, value := range values {
+		number := protobufUtil_toFloat(value)
+		if math.Floor(number) != number {
+			integers = false
+			break
+		}
+		if -2147483648 <= number && number <= 2147483647 {
+			continue
+		}
+		int32s = false
+	}
+	if integers == false {
+		return "double"
+	}
+	if int32s {
+		return "int32"
+	}
+	return "int64"
+}
+
+func protobufUtil_decode_bigint(output map[string]*int, tags [][]nativemetadata.IMetadataTypeTag, defaultType string) {
+	if len(tags) == 0 {
+		output[defaultType] = nil
+		return
+	}
+	for _, row := range tags {
+		value := "int64"
+		for _, tag := range row {
+			if tag.Kind == "type" && (tag.Value == "int64" || tag.Value == "uint64") {
+				value = fmt.Sprint(tag.Value)
+				break
+			}
+		}
+		output[value] = ProtobufUtil.GetSequence(row)
+	}
+}
+
+func protobufUtil_decode_number(output map[string]*int, tags [][]nativemetadata.IMetadataTypeTag, defaultType string) {
+	if len(tags) == 0 {
+		output[defaultType] = nil
+		return
+	}
+	for _, row := range tags {
+		value := "double"
+		for _, tag := range row {
+			if tag.Kind == "type" {
+				str := fmt.Sprint(tag.Value)
+				if str == "int32" || str == "uint32" || str == "int64" || str == "uint64" || str == "float" || str == "double" {
+					value = str
+					break
+				}
+			}
+		}
+		output[value] = ProtobufUtil.GetSequence(row)
+	}
+}
+
+func protobufUtil_toInt(value any) (int, bool) {
+	switch v := value.(type) {
+	case int:
+		return v, true
+	case int32:
+		return int(v), true
+	case int64:
+		return int(v), true
+	case uint:
+		return int(v), true
+	case uint32:
+		return int(v), true
+	case uint64:
+		return int(v), true
+	case float64:
+		return int(v), true
+	case float32:
+		return int(v), true
+	case string:
+		parsed, err := strconv.Atoi(v)
+		return parsed, err == nil
+	default:
+		return 0, false
+	}
+}
+
+func protobufUtil_toFloat(value any) float64 {
+	switch v := value.(type) {
+	case float64:
+		return v
+	case float32:
+		return float64(v)
+	case int:
+		return float64(v)
+	case int32:
+		return float64(v)
+	case int64:
+		return float64(v)
+	case uint:
+		return float64(v)
+	case uint32:
+		return float64(v)
+	case uint64:
+		return float64(v)
+	case string:
+		parsed, _ := strconv.ParseFloat(v, 64)
+		return parsed
+	default:
+		parsed, _ := strconv.ParseFloat(fmt.Sprint(value), 64)
+		return parsed
+	}
+}

package/native/core/programmers/helpers/ProtobufWire.go

@@ -0,0 +1,14 @@
+package helpers
+
+type ProtobufWire int
+
+const (
+	VARIANT ProtobufWire = 0
+	I64     ProtobufWire = 1
+	LEN     ProtobufWire = 2
+
+	START_GROUP ProtobufWire = 3
+	END_GROUP   ProtobufWire = 4
+
+	I32 ProtobufWire = 5
+)

package/native/core/programmers/helpers/PruneJoiner.go

@@ -0,0 +1,274 @@
+package helpers
+
+import (
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+	nativefactories "github.com/samchon/typia/packages/typia/native/core/factories"
+	nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+)
+
+type pruneJoinerNamespace struct{}
+
+var PruneJoiner = pruneJoinerNamespace{}
+
+type PruneJoiner_ObjectProps struct {
+	Input   *shimast.Expression
+	Entries []IExpressionEntry
+	Object  *nativemetadata.MetadataObjectType
+}
+
+type PruneJoiner_ArrayProps struct {
+	Input *shimast.Expression
+	Arrow *shimast.Expression
+}
+
+type PruneJoiner_TupleProps struct {
+	Elements []*shimast.ConciseBody
+	Rest     *shimast.ConciseBody
+}
+
+var pruneJoiner_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
+
+func (pruneJoinerNamespace) Object(props PruneJoiner_ObjectProps) *shimast.Node {
+	regular := []IExpressionEntry{}
+	dynamic := []IExpressionEntry{}
+	for _, entry := range props.Entries {
+		if entry.Key.IsSoleLiteral() {
+			regular = append(regular, entry)
+		} else {
+			dynamic = append(dynamic, entry)
+		}
+	}
+
+	statements := []*shimast.Node{}
+	for _, entry := range regular {
+		statements = append(statements, pruneJoiner_statements(entry.Expression)...)
+	}
+	if len(dynamic) != 0 {
+		statements = append(statements, pruneJoiner_factory.NewExpressionStatement(
+			pruneJoiner_iterate_dynamic_properties(pruneJoiner_iterate_dynamic_propertiesProps{
+				Regular: regular,
+				Dynamic: dynamic,
+				Input:   props.Input,
+			}),
+		))
+	}
+	statements = append(statements, pruneJoiner_prune_object_properties(props.Object))
+	return pruneJoiner_factory.NewBlock(
+		pruneJoiner_factory.NewNodeList(statements),
+		true,
+	)
+}
+
+func (pruneJoinerNamespace) Array(props PruneJoiner_ArrayProps) *shimast.Node {
+	return pruneJoiner_factory.NewCallExpression(
+		nativefactories.IdentifierFactory.Access(props.Input, "forEach"),
+		nil,
+		nil,
+		pruneJoiner_factory.NewNodeList([]*shimast.Node{props.Arrow}),
+		shimast.NodeFlagsNone,
+	)
+}
+
+func (pruneJoinerNamespace) Tuple(props PruneJoiner_TupleProps) *shimast.Node {
+	entire := make([]*shimast.Node, 0, len(props.Elements)+1)
+	for _, elem := range props.Elements {
+		entire = append(entire, elem)
+	}
+	if props.Rest != nil {
+		entire = append(entire, props.Rest)
+	}
+	statements := []*shimast.Node{}
+	for _, elem := range entire {
+		statements = append(statements, pruneJoiner_statements(elem)...)
+	}
+	return pruneJoiner_factory.NewBlock(
+		pruneJoiner_factory.NewNodeList(statements),
+		true,
+	)
+}
+
+func pruneJoiner_statements(node *shimast.Node) []*shimast.Node {
+	if node != nil && node.Kind == shimast.KindBlock {
+		return append([]*shimast.Node{}, node.Statements()...)
+	}
+	return []*shimast.Node{pruneJoiner_factory.NewExpressionStatement(node)}
+}
+
+type pruneJoiner_iterate_dynamic_propertiesProps struct {
+	Regular []IExpressionEntry
+	Dynamic []IExpressionEntry
+	Input   *shimast.Expression
+}
+
+func pruneJoiner_iterate_dynamic_properties(props pruneJoiner_iterate_dynamic_propertiesProps) *shimast.Node {
+	statements := []*shimast.Node{
+		pruneJoiner_factory.NewIfStatement(
+			pruneJoiner_factory.NewBinaryExpression(
+				nil,
+				pruneJoiner_factory.NewIdentifier("undefined"),
+				nil,
+				pruneJoiner_factory.NewToken(shimast.KindEqualsEqualsEqualsToken),
+				pruneJoiner_factory.NewIdentifier("value"),
+			),
+			pruneJoiner_factory.NewReturnStatement(nil),
+			nil,
+		),
+	}
+	for _, entry := range props.Regular {
+		key := entry.Key.GetSoleLiteral()
+		statements = append(statements, pruneJoiner_factory.NewIfStatement(
+			pruneJoiner_factory.NewBinaryExpression(
+				nil,
+				pruneJoiner_factory.NewStringLiteral(*key, shimast.TokenFlagsNone),
+				nil,
+				pruneJoiner_factory.NewToken(shimast.KindEqualsEqualsEqualsToken),
+				pruneJoiner_factory.NewIdentifier("key"),
+			),
+			pruneJoiner_factory.NewReturnStatement(nil),
+			nil,
+		))
+	}
+	for _, dynamic := range props.Dynamic {
+		body := dynamic.Expression
+		if body.Kind != shimast.KindBlock {
+			body = pruneJoiner_factory.NewBlock(
+				pruneJoiner_factory.NewNodeList([]*shimast.Node{
+					pruneJoiner_factory.NewExpressionStatement(body),
+				}),
+				false,
+			)
+		}
+		statements = append(statements, pruneJoiner_factory.NewIfStatement(
+			pruneJoiner_factory.NewCallExpression(
+				pruneJoiner_factory.NewIdentifier("RegExp(/"+cloneJoiner_metadata_to_pattern(struct {
+					top      bool
+					metadata *nativemetadata.MetadataSchema
+				}{top: true, metadata: dynamic.Key})+"/).test"),
+				nil,
+				nil,
+				pruneJoiner_factory.NewNodeList([]*shimast.Node{
+					pruneJoiner_factory.NewIdentifier("key"),
+				}),
+				shimast.NodeFlagsNone,
+			),
+			body,
+			nil,
+		))
+	}
+	return pruneJoiner_factory.NewCallExpression(
+		nativefactories.IdentifierFactory.Access(
+			pruneJoiner_factory.NewCallExpression(
+				pruneJoiner_factory.NewIdentifier("Object.entries"),
+				nil,
+				nil,
+				pruneJoiner_factory.NewNodeList([]*shimast.Node{props.Input}),
+				shimast.NodeFlagsNone,
+			),
+			"forEach",
+		),
+		nil,
+		nil,
+		pruneJoiner_factory.NewNodeList([]*shimast.Node{
+			pruneJoiner_factory.NewArrowFunction(
+				nil,
+				nil,
+				pruneJoiner_factory.NewNodeList([]*shimast.Node{
+					nativefactories.IdentifierFactory.Parameter(pruneJoiner_binding_pattern(), nil, nil),
+				}),
+				nil,
+				nil,
+				pruneJoiner_factory.NewToken(shimast.KindEqualsGreaterThanToken),
+				pruneJoiner_factory.NewBlock(pruneJoiner_factory.NewNodeList(statements), true),
+			),
+		}),
+		shimast.NodeFlagsNone,
+	)
+}
+
+func pruneJoiner_binding_pattern() *shimast.Node {
+	return pruneJoiner_factory.NewBindingPattern(
+		shimast.KindArrayBindingPattern,
+		pruneJoiner_factory.NewNodeList([]*shimast.Node{
+			pruneJoiner_factory.NewBindingElement(nil, nil, pruneJoiner_factory.NewIdentifier("key"), nil),
+			pruneJoiner_factory.NewBindingElement(nil, nil, pruneJoiner_factory.NewIdentifier("value"), nil),
+		}),
+	)
+}
+
+func pruneJoiner_prune_object_properties(object *nativemetadata.MetadataObjectType) *shimast.Node {
+	input := pruneJoiner_factory.NewIdentifier("input")
+	key := pruneJoiner_factory.NewIdentifier("key")
+	conditions := []*shimast.Node{}
+	for _, prop := range object.Properties {
+		name := prop.Key.GetSoleLiteral()
+		if name != nil {
+			conditions = append(conditions, pruneJoiner_factory.NewBinaryExpression(
+				nil,
+				pruneJoiner_factory.NewStringLiteral(*name, shimast.TokenFlagsNone),
+				nil,
+				pruneJoiner_factory.NewToken(shimast.KindEqualsEqualsEqualsToken),
+				key,
+			))
+		} else {
+			conditions = append(conditions, pruneJoiner_factory.NewCallExpression(
+				pruneJoiner_factory.NewIdentifier("RegExp(/"+cloneJoiner_metadata_to_pattern(struct {
+					top      bool
+					metadata *nativemetadata.MetadataSchema
+				}{top: true, metadata: prop.Key})+"/).test"),
+				nil,
+				nil,
+				pruneJoiner_factory.NewNodeList([]*shimast.Node{key}),
+				shimast.NodeFlagsNone,
+			))
+		}
+	}
+	statements := []*shimast.Node{}
+	if len(conditions) != 0 {
+		statements = append(statements, pruneJoiner_factory.NewIfStatement(
+			pruneJoiner_reduce(conditions, shimast.KindBarBarToken),
+			pruneJoiner_factory.NewContinueStatement(nil),
+			nil,
+		))
+	}
+	statements = append(statements, pruneJoiner_factory.NewExpressionStatement(
+		pruneJoiner_factory.NewDeleteExpression(
+			pruneJoiner_factory.NewElementAccessExpression(input, nil, key, shimast.NodeFlagsNone),
+		),
+	))
+	statement := statements[0]
+	if len(statements) != 1 {
+		statement = pruneJoiner_factory.NewBlock(pruneJoiner_factory.NewNodeList(statements), true)
+	}
+	return pruneJoiner_factory.NewForInOrOfStatement(
+		shimast.KindForOfStatement,
+		nil,
+		pruneJoiner_factory.NewVariableDeclarationList(
+			pruneJoiner_factory.NewNodeList([]*shimast.Node{
+				pruneJoiner_factory.NewVariableDeclaration(key, nil, nil, nil),
+			}),
+			shimast.NodeFlagsConst,
+		),
+		pruneJoiner_factory.NewCallExpression(
+			pruneJoiner_factory.NewIdentifier("Object.keys"),
+			nil,
+			nil,
+			pruneJoiner_factory.NewNodeList([]*shimast.Node{input}),
+			shimast.NodeFlagsNone,
+		),
+		statement,
+	)
+}
+
+func pruneJoiner_reduce(expressions []*shimast.Node, operator shimast.Kind) *shimast.Node {
+	output := expressions[0]
+	for _, next := range expressions[1:] {
+		output = pruneJoiner_factory.NewBinaryExpression(
+			nil,
+			output,
+			nil,
+			pruneJoiner_factory.NewToken(operator),
+			next,
+		)
+	}
+	return output
+}