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

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

@@ -0,0 +1,261 @@
+package helpers
+
+import (
+	"fmt"
+	"strings"
+
+	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"
+	nativeutils "github.com/samchon/typia/packages/typia/native/core/utils"
+)
+
+type cloneJoinerNamespace struct{}
+
+var CloneJoiner = cloneJoinerNamespace{}
+
+type CloneJoiner_ObjectProps struct {
+	Input   *shimast.Expression
+	Entries []IExpressionEntry
+}
+
+type CloneJoiner_TupleProps struct {
+	Elements []*shimast.Expression
+	Rest     *shimast.Expression
+}
+
+type CloneJoiner_ArrayProps struct {
+	Input *shimast.Expression
+	Arrow *shimast.Expression
+}
+
+var cloneJoiner_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
+
+func (cloneJoinerNamespace) Object(props CloneJoiner_ObjectProps) *shimast.Node {
+	if len(props.Entries) == 0 {
+		return cloneJoiner_factory.NewIdentifier("{}")
+	}
+
+	regular := []IExpressionEntry{}
+	dynamic := []IExpressionEntry{}
+	for _, entry := range props.Entries {
+		if entry.Key.IsSoleLiteral() {
+			regular = append(regular, entry)
+		} else {
+			dynamic = append(dynamic, entry)
+		}
+	}
+
+	properties := make([]*shimast.Node, 0, len(regular))
+	for _, entry := range regular {
+		str := entry.Key.GetSoleLiteral()
+		properties = append(properties, cloneJoiner_factory.NewPropertyAssignment(
+			nil,
+			nativefactories.IdentifierFactory.Identifier(*str),
+			nil,
+			nil,
+			entry.Expression,
+		))
+	}
+	literal := cloneJoiner_factory.NewObjectLiteralExpression(
+		cloneJoiner_factory.NewNodeList(properties),
+		true,
+	)
+	if len(dynamic) == 0 {
+		return literal
+	}
+
+	key := cloneJoiner_factory.NewIdentifier("key")
+	output := cloneJoiner_factory.NewIdentifier("output")
+	statements := []*shimast.Node{}
+	if len(regular) != 0 {
+		statements = append(statements, cloneJoiner_regular_skip(regular))
+	}
+	for _, entry := range dynamic {
+		statements = append(statements, cloneJoiner_factory.NewIfStatement(
+			cloneJoiner_factory.NewCallExpression(
+				cloneJoiner_factory.NewIdentifier("RegExp(/"+cloneJoiner_metadata_to_pattern(struct {
+					top      bool
+					metadata *nativemetadata.MetadataSchema
+				}{top: true, metadata: entry.Key})+"/).test"),
+				nil,
+				nil,
+				cloneJoiner_factory.NewNodeList([]*shimast.Node{key}),
+				shimast.NodeFlagsNone,
+			),
+			cloneJoiner_factory.NewBlock(
+				cloneJoiner_factory.NewNodeList([]*shimast.Node{
+					cloneJoiner_factory.NewExpressionStatement(
+						cloneJoiner_factory.NewBinaryExpression(
+							nil,
+							cloneJoiner_factory.NewElementAccessExpression(output, nil, key, shimast.NodeFlagsNone),
+							nil,
+							cloneJoiner_factory.NewToken(shimast.KindEqualsToken),
+							entry.Expression,
+						),
+					),
+					cloneJoiner_factory.NewContinueStatement(nil),
+				}),
+				false,
+			),
+			nil,
+		))
+	}
+
+	return cloneJoiner_factory.NewBlock(
+		cloneJoiner_factory.NewNodeList([]*shimast.Node{
+			nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
+				Name: "output",
+				Value: cloneJoiner_factory.NewAsExpression(
+					literal,
+					nativefactories.TypeFactory.Keyword("any"),
+				),
+			}),
+			cloneJoiner_factory.NewForInOrOfStatement(
+				shimast.KindForOfStatement,
+				nil,
+				nativefactories.StatementFactory.Entry(nativefactories.StatementFactory_EntryProps{Key: "key", Value: "value"}),
+				cloneJoiner_factory.NewCallExpression(
+					cloneJoiner_factory.NewIdentifier("Object.entries"),
+					nil,
+					nil,
+					cloneJoiner_factory.NewNodeList([]*shimast.Node{props.Input}),
+					shimast.NodeFlagsNone,
+				),
+				cloneJoiner_factory.NewBlock(cloneJoiner_factory.NewNodeList(statements), false),
+			),
+			cloneJoiner_factory.NewReturnStatement(output),
+		}),
+		false,
+	)
+}
+
+func (cloneJoinerNamespace) Tuple(props CloneJoiner_TupleProps) *shimast.Node {
+	elements := make([]*shimast.Node, 0, len(props.Elements)+1)
+	for _, elem := range props.Elements {
+		elements = append(elements, elem)
+	}
+	if props.Rest != nil {
+		elements = append(elements, cloneJoiner_factory.NewSpreadElement(props.Rest))
+	}
+	return cloneJoiner_factory.NewAsExpression(
+		cloneJoiner_factory.NewArrayLiteralExpression(
+			cloneJoiner_factory.NewNodeList(elements),
+			true,
+		),
+		nativefactories.TypeFactory.Keyword("any"),
+	)
+}
+
+func (cloneJoinerNamespace) Array(props CloneJoiner_ArrayProps) *shimast.Node {
+	return cloneJoiner_factory.NewCallExpression(
+		nativefactories.IdentifierFactory.Access(props.Input, "map"),
+		nil,
+		nil,
+		cloneJoiner_factory.NewNodeList([]*shimast.Node{props.Arrow}),
+		shimast.NodeFlagsNone,
+	)
+}
+
+func cloneJoiner_regular_skip(regular []IExpressionEntry) *shimast.Node {
+	elements := make([]*shimast.Node, 0, len(regular))
+	for _, entry := range regular {
+		elements = append(elements, cloneJoiner_factory.NewStringLiteral(*entry.Key.GetSoleLiteral(), shimast.TokenFlagsNone))
+	}
+	return cloneJoiner_factory.NewIfStatement(
+		cloneJoiner_factory.NewCallExpression(
+			nativefactories.IdentifierFactory.Access(
+				cloneJoiner_factory.NewArrayLiteralExpression(cloneJoiner_factory.NewNodeList(elements), false),
+				"some",
+			),
+			nil,
+			nil,
+			cloneJoiner_factory.NewNodeList([]*shimast.Node{
+				cloneJoiner_factory.NewArrowFunction(
+					nil,
+					nil,
+					cloneJoiner_factory.NewNodeList([]*shimast.Node{
+						nativefactories.IdentifierFactory.Parameter("regular", nil, nil),
+					}),
+					nil,
+					nil,
+					cloneJoiner_factory.NewToken(shimast.KindEqualsGreaterThanToken),
+					cloneJoiner_factory.NewBinaryExpression(
+						nil,
+						cloneJoiner_factory.NewIdentifier("regular"),
+						nil,
+						cloneJoiner_factory.NewToken(shimast.KindEqualsEqualsEqualsToken),
+						cloneJoiner_factory.NewIdentifier("key"),
+					),
+				),
+			}),
+			shimast.NodeFlagsNone,
+		),
+		cloneJoiner_factory.NewContinueStatement(nil),
+		nil,
+	)
+}
+
+func cloneJoiner_metadata_to_pattern(props struct {
+	top      bool
+	metadata *nativemetadata.MetadataSchema
+}) string {
+	for _, atomic := range props.metadata.Atomics {
+		if atomic.Type == "string" {
+			return "(.*)"
+		}
+	}
+	values := []string{}
+	for _, constant := range props.metadata.Constants {
+		if constant.Type != "string" {
+			for _, value := range constant.Values {
+				values = append(values, fmt.Sprint(value.Value))
+			}
+			continue
+		}
+		for _, value := range constant.Values {
+			values = append(values, nativeutils.PatternUtil.Escape(fmt.Sprint(value.Value)))
+		}
+	}
+	for _, atomic := range props.metadata.Atomics {
+		if atomic.Type == "number" || atomic.Type == "bigint" {
+			values = append(values, nativeutils.PatternUtil.NUMBER)
+		} else if atomic.Type == "boolean" {
+			values = append(values, nativeutils.PatternUtil.BOOLEAN)
+		}
+	}
+	for _, template := range props.metadata.Templates {
+		values = append(values, "("+cloneJoiner_template_to_pattern(struct {
+			top      bool
+			template []*nativemetadata.MetadataSchema
+		}{top: false, template: template.Row})+")")
+	}
+	pattern := ""
+	if len(values) == 1 {
+		pattern = values[0]
+	} else {
+		pattern = "(" + strings.Join(values, "|") + ")"
+	}
+	if props.top {
+		return nativeutils.PatternUtil.Fix(pattern)
+	}
+	return pattern
+}
+
+func cloneJoiner_template_to_pattern(props struct {
+	top      bool
+	template []*nativemetadata.MetadataSchema
+}) string {
+	patterns := make([]string, 0, len(props.template))
+	for _, meta := range props.template {
+		patterns = append(patterns, cloneJoiner_metadata_to_pattern(struct {
+			top      bool
+			metadata *nativemetadata.MetadataSchema
+		}{top: false, metadata: meta}))
+	}
+	pattern := strings.Join(patterns, "")
+	if props.top {
+		return nativeutils.PatternUtil.Fix(pattern)
+	}
+	return pattern
+}

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

@@ -0,0 +1,116 @@
+package helpers
+
+import (
+	"fmt"
+
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+	nativefactories "github.com/samchon/typia/packages/typia/native/core/factories"
+)
+
+type FunctionProgrammer struct {
+	Method         string
+	local_         map[string]bool
+	unions_        map[string]*functionProgrammer_union
+	unionOrder_    []string
+	variables_     map[string]*shimast.Node
+	variableOrder_ []string
+	sequence_      int
+	disableDeclare bool
+}
+
+type functionProgrammer_union struct {
+	name  string
+	value *shimast.Node
+}
+
+var functionProgrammer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
+
+func NewFunctionProgrammer(method string) *FunctionProgrammer {
+	return &FunctionProgrammer{
+		Method:         method,
+		local_:         map[string]bool{},
+		unions_:        map[string]*functionProgrammer_union{},
+		unionOrder_:    []string{},
+		variables_:     map[string]*shimast.Node{},
+		variableOrder_: []string{},
+	}
+}
+
+func (p *FunctionProgrammer) UseLocal(name string) string {
+	p.local_[name] = true
+	return name
+}
+
+func (p *FunctionProgrammer) HasLocal(name string) bool {
+	return p.local_[name]
+}
+
+func (p *FunctionProgrammer) Declare(includeUnions ...bool) []*shimast.Node {
+	if p.disableDeclare {
+		return []*shimast.Node{}
+	}
+	output := []*shimast.Node{}
+	for _, name := range p.variableOrder_ {
+		value := p.variables_[name]
+		output = append(output, nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
+			Name:  name,
+			Value: value,
+		}))
+	}
+	enabled := true
+	if len(includeUnions) != 0 {
+		enabled = includeUnions[0]
+	}
+	if enabled {
+		for _, key := range p.unionOrder_ {
+			tuple := p.unions_[key]
+			output = append(output, nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
+				Name:  tuple.name,
+				Value: tuple.value,
+			}))
+		}
+	}
+	return output
+}
+
+func (p *FunctionProgrammer) DeclareUnions() []*shimast.Node {
+	if p.disableDeclare {
+		return []*shimast.Node{}
+	}
+	output := []*shimast.Node{}
+	for _, key := range p.unionOrder_ {
+		tuple := p.unions_[key]
+		output = append(output, nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
+			Name:  tuple.name,
+			Value: tuple.value,
+		}))
+	}
+	return output
+}
+
+func (p *FunctionProgrammer) Increment() int {
+	p.sequence_++
+	return p.sequence_
+}
+
+func (p *FunctionProgrammer) EmplaceUnion(prefix string, name string, factory func() *shimast.Node) string {
+	key := prefix + "::" + name
+	if oldbie, ok := p.unions_[key]; ok {
+		return oldbie.name
+	}
+	index := len(p.unions_)
+	accessor := fmt.Sprintf("%sp%d", prefix, index)
+	tuple := &functionProgrammer_union{name: accessor}
+	p.unions_[key] = tuple
+	p.unionOrder_ = append(p.unionOrder_, key)
+	tuple.value = factory()
+	return accessor
+}
+
+func (p *FunctionProgrammer) EmplaceVariable(name string, value *shimast.Expression) *shimast.Node {
+	if _, ok := p.variables_[name]; !ok {
+		p.variableOrder_ = append(p.variableOrder_, name)
+	}
+	p.variables_[name] = value
+	return functionProgrammer_factory.NewIdentifier(name)
+}

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

@@ -0,0 +1,30 @@
+package helpers
+
+import nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+
+type httpMetadataUtilNamespace struct{}
+
+var HttpMetadataUtil = httpMetadataUtilNamespace{}
+
+func (httpMetadataUtilNamespace) Atomics(metadata *nativemetadata.MetadataSchema) map[string]struct{} {
+	output := map[string]struct{}{}
+	for _, atomic := range metadata.Atomics {
+		output[atomic.Type] = struct{}{}
+	}
+	for _, constant := range metadata.Constants {
+		output[constant.Type] = struct{}{}
+	}
+	if len(metadata.Templates) != 0 {
+		output["string"] = struct{}{}
+	}
+	return output
+}
+
+func (httpMetadataUtilNamespace) IsUnion(metadata *nativemetadata.MetadataSchema) bool {
+	return len(HttpMetadataUtil.Atomics(metadata))+
+		len(metadata.Arrays)+
+		len(metadata.Tuples)+
+		len(metadata.Natives)+
+		len(metadata.Maps)+
+		len(metadata.Objects) > 1
+}

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

@@ -0,0 +1,14 @@
+package helpers
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type ICheckEntry struct {
+	Expected   string
+	Expression *shimast.Node
+	Conditions [][]ICheckEntry_ICondition
+}
+
+type ICheckEntry_ICondition struct {
+	Expected   string
+	Expression *shimast.Node
+}

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

@@ -0,0 +1,13 @@
+package helpers
+
+import (
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+	nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+)
+
+type IExpressionEntry struct {
+	Input      *shimast.Node
+	Key        *nativemetadata.MetadataSchema
+	Meta       *nativemetadata.MetadataSchema
+	Expression *shimast.Node
+}

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

@@ -0,0 +1,194 @@
+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 notationJoinerNamespace struct{}
+
+var NotationJoiner = notationJoinerNamespace{}
+
+type NotationJoiner_ObjectProps struct {
+	Rename  func(str string) string
+	Input   *shimast.Expression
+	Entries []IExpressionEntry
+}
+
+type NotationJoiner_TupleProps struct {
+	Elements []*shimast.Expression
+	Rest     *shimast.Expression
+}
+
+type NotationJoiner_ArrayProps struct {
+	Input *shimast.Expression
+	Arrow *shimast.Expression
+}
+
+var notationJoiner_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
+
+func (notationJoinerNamespace) Object(props NotationJoiner_ObjectProps) *shimast.Node {
+	if len(props.Entries) == 0 {
+		return notationJoiner_factory.NewIdentifier("{}")
+	}
+
+	regular := []IExpressionEntry{}
+	dynamic := []IExpressionEntry{}
+	for _, entry := range props.Entries {
+		if entry.Key.IsSoleLiteral() {
+			regular = append(regular, entry)
+		} else {
+			dynamic = append(dynamic, entry)
+		}
+	}
+
+	properties := make([]*shimast.Node, 0, len(regular))
+	for _, entry := range regular {
+		str := props.Rename(*entry.Key.GetSoleLiteral())
+		properties = append(properties, notationJoiner_factory.NewPropertyAssignment(
+			nil,
+			nativefactories.IdentifierFactory.Identifier(str),
+			nil,
+			nil,
+			entry.Expression,
+		))
+	}
+	literal := notationJoiner_factory.NewObjectLiteralExpression(
+		notationJoiner_factory.NewNodeList(properties),
+		true,
+	)
+	if len(dynamic) == 0 {
+		return literal
+	}
+
+	key := notationJoiner_factory.NewIdentifier("key")
+	output := notationJoiner_factory.NewIdentifier("output")
+	statements := []*shimast.Node{}
+	if len(regular) != 0 {
+		statements = append(statements, notationJoiner_regular_skip(regular))
+	}
+	for _, entry := range dynamic {
+		statements = append(statements, notationJoiner_factory.NewIfStatement(
+			notationJoiner_factory.NewCallExpression(
+				notationJoiner_factory.NewIdentifier("RegExp(/"+cloneJoiner_metadata_to_pattern(struct {
+					top      bool
+					metadata *nativemetadata.MetadataSchema
+				}{top: true, metadata: entry.Key})+"/).test"),
+				nil,
+				nil,
+				notationJoiner_factory.NewNodeList([]*shimast.Node{key}),
+				shimast.NodeFlagsNone,
+			),
+			notationJoiner_factory.NewBlock(
+				notationJoiner_factory.NewNodeList([]*shimast.Node{
+					notationJoiner_factory.NewExpressionStatement(
+						notationJoiner_factory.NewBinaryExpression(
+							nil,
+							notationJoiner_factory.NewElementAccessExpression(output, nil, key, shimast.NodeFlagsNone),
+							nil,
+							notationJoiner_factory.NewToken(shimast.KindEqualsToken),
+							entry.Expression,
+						),
+					),
+					notationJoiner_factory.NewContinueStatement(nil),
+				}),
+				false,
+			),
+			nil,
+		))
+	}
+
+	return notationJoiner_factory.NewBlock(
+		notationJoiner_factory.NewNodeList([]*shimast.Node{
+			nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
+				Name: "output",
+				Value: notationJoiner_factory.NewAsExpression(
+					literal,
+					nativefactories.TypeFactory.Keyword("any"),
+				),
+			}),
+			notationJoiner_factory.NewForInOrOfStatement(
+				shimast.KindForOfStatement,
+				nil,
+				nativefactories.StatementFactory.Entry(nativefactories.StatementFactory_EntryProps{Key: "key", Value: "value"}),
+				notationJoiner_factory.NewCallExpression(
+					notationJoiner_factory.NewIdentifier("Object.entries"),
+					nil,
+					nil,
+					notationJoiner_factory.NewNodeList([]*shimast.Node{props.Input}),
+					shimast.NodeFlagsNone,
+				),
+				notationJoiner_factory.NewBlock(notationJoiner_factory.NewNodeList(statements), false),
+			),
+			notationJoiner_factory.NewReturnStatement(output),
+		}),
+		false,
+	)
+}
+
+func (notationJoinerNamespace) Tuple(props NotationJoiner_TupleProps) *shimast.Node {
+	elements := make([]*shimast.Node, 0, len(props.Elements)+1)
+	for _, elem := range props.Elements {
+		elements = append(elements, elem)
+	}
+	if props.Rest != nil {
+		elements = append(elements, notationJoiner_factory.NewSpreadElement(props.Rest))
+	}
+	return notationJoiner_factory.NewAsExpression(
+		notationJoiner_factory.NewArrayLiteralExpression(
+			notationJoiner_factory.NewNodeList(elements),
+			true,
+		),
+		nativefactories.TypeFactory.Keyword("any"),
+	)
+}
+
+func (notationJoinerNamespace) Array(props NotationJoiner_ArrayProps) *shimast.Node {
+	return notationJoiner_factory.NewCallExpression(
+		nativefactories.IdentifierFactory.Access(props.Input, "map"),
+		nil,
+		nil,
+		notationJoiner_factory.NewNodeList([]*shimast.Node{props.Arrow}),
+		shimast.NodeFlagsNone,
+	)
+}
+
+func notationJoiner_regular_skip(regular []IExpressionEntry) *shimast.Node {
+	elements := make([]*shimast.Node, 0, len(regular))
+	for _, entry := range regular {
+		elements = append(elements, notationJoiner_factory.NewStringLiteral(*entry.Key.GetSoleLiteral(), shimast.TokenFlagsNone))
+	}
+	return notationJoiner_factory.NewIfStatement(
+		notationJoiner_factory.NewCallExpression(
+			nativefactories.IdentifierFactory.Access(
+				notationJoiner_factory.NewArrayLiteralExpression(notationJoiner_factory.NewNodeList(elements), false),
+				"some",
+			),
+			nil,
+			nil,
+			notationJoiner_factory.NewNodeList([]*shimast.Node{
+				notationJoiner_factory.NewArrowFunction(
+					nil,
+					nil,
+					notationJoiner_factory.NewNodeList([]*shimast.Node{
+						nativefactories.IdentifierFactory.Parameter("regular", nil, nil),
+					}),
+					nil,
+					nil,
+					notationJoiner_factory.NewToken(shimast.KindEqualsGreaterThanToken),
+					notationJoiner_factory.NewBinaryExpression(
+						nil,
+						notationJoiner_factory.NewIdentifier("regular"),
+						nil,
+						notationJoiner_factory.NewToken(shimast.KindEqualsEqualsEqualsToken),
+						notationJoiner_factory.NewIdentifier("key"),
+					),
+				),
+			}),
+			shimast.NodeFlagsNone,
+		),
+		notationJoiner_factory.NewContinueStatement(nil),
+		nil,
+	)
+}

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

@@ -0,0 +1,23 @@
+package helpers
+
+import nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
+
+type optionPredicatorNamespace struct{}
+
+var OptionPredicator optionPredicatorNamespace
+
+func (optionPredicatorNamespace) Numeric(options nativecontext.ITransformOptions) bool {
+	return OptionPredicator.Finite(options) || options.Numeric != nil && *options.Numeric
+}
+
+func (optionPredicatorNamespace) Functional(options nativecontext.ITransformOptions) bool {
+	return options.Functional != nil && *options.Functional
+}
+
+func (optionPredicatorNamespace) Finite(options nativecontext.ITransformOptions) bool {
+	return options.Finite != nil && *options.Finite
+}
+
+func (optionPredicatorNamespace) Undefined(options nativecontext.ITransformOptions) bool {
+	return options.Undefined == nil || *options.Undefined
+}