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

package/native/core/programmers/iterate/check_union_array_like.go

@@ -0,0 +1,416 @@
+package iterate
+
+import (
+	"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"
+)
+
+type Check_union_array_likeProps struct {
+	Config      Check_union_array_like_IConfig
+	Accessor    Check_union_array_like_IAccessor
+	Parameters  []*shimast.Node
+	Input       *shimast.Expression
+	Definitions []any
+	Explore     any
+}
+
+type Check_union_array_like_IConfig struct {
+	Checker func(props Check_union_array_like_CheckerProps) *shimast.Node
+	Decoder func(props Check_union_array_like_DecoderProps) *shimast.Node
+	Empty   *shimast.Node
+	Success *shimast.Expression
+	Failure func(props Check_union_array_like_FailureProps) *shimast.Node
+}
+
+type Check_union_array_like_CheckerProps struct {
+	Input      *shimast.Expression
+	Definition any
+	Explore    any
+	Container  *shimast.Expression
+}
+
+type Check_union_array_like_DecoderProps struct {
+	Input      *shimast.Expression
+	Definition any
+	Explore    any
+}
+
+type Check_union_array_like_FailureProps struct {
+	Input    *shimast.Expression
+	Expected string
+	Explore  any
+}
+
+type Check_union_array_like_IAccessor struct {
+	Transform func(origin any) any
+	Element   func(meta any) any
+	Name      func(meta any, elem any) string
+	Front     func(input *shimast.Expression) *shimast.Node
+	Array     func(input *shimast.Expression) *shimast.Node
+	Size      func(input *shimast.Expression) *shimast.Node
+}
+
+func Check_union_array_like(props Check_union_array_likeProps) *shimast.Node {
+	targets := make([]any, 0, len(props.Definitions))
+	for _, definition := range props.Definitions {
+		targets = append(targets, props.Accessor.Transform(definition))
+	}
+	if len(targets) == 1 {
+		return check_union_array_like_factory.NewArrowFunction(
+			nil,
+			nil,
+			check_union_array_like_factory.NewNodeList(props.Parameters),
+			nil,
+			nil,
+			check_union_array_like_factory.NewToken(shimast.KindEqualsGreaterThanToken),
+			props.Config.Decoder(Check_union_array_like_DecoderProps{
+				Input:      props.Accessor.Array(props.Input),
+				Definition: targets[0],
+				Explore:    props.Explore,
+			}),
+		)
+	}
+
+	array := check_union_array_like_factory.NewIdentifier("array")
+	top := check_union_array_like_factory.NewIdentifier("top")
+	statements := []*shimast.Node{}
+	tupleList := []*nativemetadata.MetadataTuple{}
+	arrayList := []*nativemetadata.MetadataArray{}
+	for _, target := range targets {
+		switch v := target.(type) {
+		case *nativemetadata.MetadataTuple:
+			tupleList = append(tupleList, v)
+		case *nativemetadata.MetadataArray:
+			arrayList = append(arrayList, v)
+		}
+	}
+
+	predicate := func(meta any) *shimast.Node {
+		inputType := check_union_array_like_factory.NewTypeReferenceNode(check_union_array_like_factory.NewIdentifier("any[]"), nil)
+		postfix := ""
+		if _, ok := meta.(*nativemetadata.MetadataArrayType); ok {
+			inputType = nativefactories.TypeFactory.Keyword("any")
+			postfix = "\"[0]\""
+		}
+		return check_union_array_like_factory.NewAsExpression(
+			check_union_array_like_factory.NewArrayLiteralExpression(
+				check_union_array_like_factory.NewNodeList([]*shimast.Node{
+					check_union_array_like_factory.NewArrowFunction(
+						nil,
+						nil,
+						check_union_array_like_factory.NewNodeList([]*shimast.Node{
+							nativefactories.IdentifierFactory.Parameter("top", inputType, nil),
+						}),
+						nativefactories.TypeFactory.Keyword("any"),
+						nil,
+						check_union_array_like_factory.NewToken(shimast.KindEqualsGreaterThanToken),
+						props.Config.Checker(Check_union_array_like_CheckerProps{
+							Input:      check_union_array_like_factory.NewIdentifier("top"),
+							Definition: props.Accessor.Element(meta),
+							Explore:    check_union_array_like_explore(props.Explore, false, postfix),
+							Container:  array,
+						}),
+					),
+					check_union_array_like_factory.NewArrowFunction(
+						nil,
+						nil,
+						check_union_array_like_factory.NewNodeList([]*shimast.Node{
+							nativefactories.IdentifierFactory.Parameter(
+								"entire",
+								check_union_array_like_factory.NewTypeReferenceNode(check_union_array_like_factory.NewIdentifier("any[]"), nil),
+								nil,
+							),
+						}),
+						nativefactories.TypeFactory.Keyword("any"),
+						nil,
+						check_union_array_like_factory.NewToken(shimast.KindEqualsGreaterThanToken),
+						props.Config.Decoder(Check_union_array_like_DecoderProps{
+							Input:      check_union_array_like_factory.NewIdentifier("entire"),
+							Definition: meta,
+							Explore:    check_union_array_like_explore_trace(props.Explore, true),
+						}),
+					),
+				}),
+				true,
+			),
+			check_union_array_like_factory.NewTypeReferenceNode(check_union_array_like_factory.NewIdentifier("const"), nil),
+		)
+	}
+
+	iterate := func(init string, from *shimast.Expression, ifStatement *shimast.Node) *shimast.Node {
+		return check_union_array_like_factory.NewForInOrOfStatement(
+			shimast.KindForOfStatement,
+			nil,
+			check_union_array_like_factory.NewVariableDeclarationList(
+				check_union_array_like_factory.NewNodeList([]*shimast.Node{
+					check_union_array_like_factory.NewVariableDeclaration(
+						check_union_array_like_factory.NewIdentifier(init),
+						nil,
+						nil,
+						nil,
+					),
+				}),
+				shimast.NodeFlagsConst,
+			),
+			from,
+			ifStatement,
+		)
+	}
+
+	if len(tupleList) != 0 {
+		tuplePredicates := make([]*shimast.Node, 0, len(tupleList))
+		for _, x := range tupleList {
+			tuplePredicates = append(tuplePredicates, predicate(x))
+		}
+		statements = append(statements,
+			nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
+				Name:  "array",
+				Value: props.Accessor.Array(props.Input),
+			}),
+			nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
+				Name: "tuplePredicators",
+				Value: check_union_array_like_factory.NewArrayLiteralExpression(
+					check_union_array_like_factory.NewNodeList(tuplePredicates),
+					true,
+				),
+			}),
+			iterate(
+				"pred",
+				check_union_array_like_factory.NewIdentifier("tuplePredicators"),
+				check_union_array_like_factory.NewIfStatement(
+					check_union_array_like_factory.NewCallExpression(
+						check_union_array_like_factory.NewIdentifier("pred[0]"),
+						nil,
+						nil,
+						check_union_array_like_factory.NewNodeList([]*shimast.Node{array}),
+						shimast.NodeFlagsNone,
+					),
+					check_union_array_like_factory.NewReturnStatement(
+						check_union_array_like_factory.NewCallExpression(
+							check_union_array_like_factory.NewIdentifier("pred[1]"),
+							nil,
+							nil,
+							check_union_array_like_factory.NewNodeList([]*shimast.Node{array}),
+							shimast.NodeFlagsNone,
+						),
+					),
+					nil,
+				),
+			),
+		)
+	}
+	if len(arrayList) != 0 {
+		if len(tupleList) == 0 {
+			statements = append(statements, nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
+				Name:  "array",
+				Value: props.Accessor.Array(props.Input),
+			}))
+		}
+		arrayPredicates := make([]*shimast.Node, 0, len(arrayList))
+		for _, x := range arrayList {
+			arrayPredicates = append(arrayPredicates, predicate(x))
+		}
+		statements = append(statements,
+			nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
+				Name:  "top",
+				Value: props.Accessor.Front(props.Input),
+			}),
+			check_union_array_like_factory.NewIfStatement(
+				check_union_array_like_factory.NewBinaryExpression(
+					nil,
+					nativefactories.ExpressionFactory.Number(0),
+					nil,
+					check_union_array_like_factory.NewToken(shimast.KindEqualsEqualsEqualsToken),
+					props.Accessor.Size(props.Input),
+				),
+				check_union_array_like_return_or_statement(props.Config.Empty),
+				nil,
+			),
+			nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
+				Name: "arrayPredicators",
+				Value: check_union_array_like_factory.NewArrayLiteralExpression(
+					check_union_array_like_factory.NewNodeList(arrayPredicates),
+					true,
+				),
+			}),
+			nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
+				Name: "passed",
+				Value: check_union_array_like_factory.NewCallExpression(
+					nativefactories.IdentifierFactory.Access(check_union_array_like_factory.NewIdentifier("arrayPredicators"), "filter"),
+					nil,
+					nil,
+					check_union_array_like_factory.NewNodeList([]*shimast.Node{
+						check_union_array_like_factory.NewArrowFunction(
+							nil,
+							nil,
+							check_union_array_like_factory.NewNodeList([]*shimast.Node{
+								nativefactories.IdentifierFactory.Parameter("pred", nil, nil),
+							}),
+							nil,
+							nil,
+							check_union_array_like_factory.NewToken(shimast.KindEqualsGreaterThanToken),
+							check_union_array_like_factory.NewCallExpression(
+								check_union_array_like_factory.NewIdentifier("pred[0]"),
+								nil,
+								nil,
+								check_union_array_like_factory.NewNodeList([]*shimast.Node{top}),
+								shimast.NodeFlagsNone,
+							),
+						),
+					}),
+					shimast.NodeFlagsNone,
+				),
+			}),
+			check_union_array_like_array_if(iterate, array, top, props.Config.Success),
+		)
+	}
+	names := make([]string, 0, len(targets))
+	for _, target := range targets {
+		elem := props.Accessor.Element(target)
+		names = append(names, props.Accessor.Name(target, elem))
+	}
+	statements = append(statements, props.Config.Failure(Check_union_array_like_FailureProps{
+		Input:    props.Input,
+		Expected: "(" + strings.Join(names, " | ") + ")",
+		Explore:  props.Explore,
+	}))
+	return check_union_array_like_factory.NewArrowFunction(
+		nil,
+		nil,
+		check_union_array_like_factory.NewNodeList(props.Parameters),
+		nil,
+		nil,
+		check_union_array_like_factory.NewToken(shimast.KindEqualsGreaterThanToken),
+		check_union_array_like_factory.NewBlock(
+			check_union_array_like_factory.NewNodeList(statements),
+			true,
+		),
+	)
+}
+
+func check_union_array_like_array_if(iterate func(init string, from *shimast.Expression, ifStatement *shimast.Node) *shimast.Node, array *shimast.Node, top *shimast.Node, success *shimast.Expression) *shimast.Node {
+	return check_union_array_like_factory.NewIfStatement(
+		check_union_array_like_factory.NewBinaryExpression(
+			nil,
+			nativefactories.ExpressionFactory.Number(1),
+			nil,
+			check_union_array_like_factory.NewToken(shimast.KindEqualsEqualsEqualsToken),
+			check_union_array_like_factory.NewIdentifier("passed.length"),
+		),
+		check_union_array_like_factory.NewReturnStatement(
+			check_union_array_like_factory.NewCallExpression(
+				check_union_array_like_factory.NewElementAccessExpression(
+					check_union_array_like_factory.NewNonNullExpression(
+						check_union_array_like_factory.NewIdentifier("passed[0]"),
+						shimast.NodeFlagsNone,
+					),
+					nil,
+					nativefactories.ExpressionFactory.Number(1),
+					shimast.NodeFlagsNone,
+				),
+				nil,
+				nil,
+				check_union_array_like_factory.NewNodeList([]*shimast.Node{array}),
+				shimast.NodeFlagsNone,
+			),
+		),
+		check_union_array_like_factory.NewIfStatement(
+			check_union_array_like_factory.NewBinaryExpression(
+				nil,
+				nativefactories.ExpressionFactory.Number(1),
+				nil,
+				check_union_array_like_factory.NewToken(shimast.KindLessThanToken),
+				check_union_array_like_factory.NewIdentifier("passed.length"),
+			),
+			iterate(
+				"pred",
+				check_union_array_like_factory.NewIdentifier("passed"),
+				check_union_array_like_factory.NewIfStatement(
+					check_union_array_like_factory.NewCallExpression(
+						nativefactories.IdentifierFactory.Access(array, "every"),
+						nil,
+						nil,
+						check_union_array_like_factory.NewNodeList([]*shimast.Node{
+							check_union_array_like_factory.NewArrowFunction(
+								nil,
+								nil,
+								check_union_array_like_factory.NewNodeList([]*shimast.Node{
+									nativefactories.IdentifierFactory.Parameter("value", nativefactories.TypeFactory.Keyword("any"), nil),
+								}),
+								nil,
+								nil,
+								check_union_array_like_factory.NewToken(shimast.KindEqualsGreaterThanToken),
+								check_union_array_like_factory.NewBinaryExpression(
+									nil,
+									success,
+									nil,
+									check_union_array_like_factory.NewToken(shimast.KindEqualsEqualsEqualsToken),
+									check_union_array_like_factory.NewCallExpression(
+										check_union_array_like_factory.NewIdentifier("pred[0]"),
+										nil,
+										nil,
+										check_union_array_like_factory.NewNodeList([]*shimast.Node{
+											check_union_array_like_factory.NewIdentifier("value"),
+										}),
+										shimast.NodeFlagsNone,
+									),
+								),
+							),
+						}),
+						shimast.NodeFlagsNone,
+					),
+					check_union_array_like_factory.NewReturnStatement(
+						check_union_array_like_factory.NewCallExpression(
+							check_union_array_like_factory.NewIdentifier("pred[1]"),
+							nil,
+							nil,
+							check_union_array_like_factory.NewNodeList([]*shimast.Node{
+								check_union_array_like_factory.NewIdentifier("array"),
+							}),
+							shimast.NodeFlagsNone,
+						),
+					),
+					nil,
+				),
+			),
+			nil,
+		),
+	)
+}
+
+func check_union_array_like_return_or_statement(node *shimast.Node) *shimast.Node {
+	if node == nil || node.Kind == shimast.KindReturnStatement {
+		return node
+	}
+	return check_union_array_like_factory.NewReturnStatement(node)
+}
+
+func check_union_array_like_explore(base any, tracable bool, postfix string) any {
+	if value, ok := base.(map[string]any); ok {
+		next := map[string]any{}
+		for k, v := range value {
+			next[k] = v
+		}
+		next["tracable"] = tracable
+		next["postfix"] = postfix
+		return next
+	}
+	return base
+}
+
+func check_union_array_like_explore_trace(base any, tracable bool) any {
+	if value, ok := base.(map[string]any); ok {
+		next := map[string]any{}
+		for k, v := range value {
+			next[k] = v
+		}
+		next["tracable"] = tracable
+		return next
+	}
+	return base
+}
+
+var check_union_array_like_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})

package/native/core/programmers/iterate/decode_union_object.go

@@ -0,0 +1,150 @@
+package iterate
+
+import (
+	"strings"
+
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+	nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+)
+
+type Decode_union_objectProps struct {
+	Checker func(next Decode_union_object_next) *shimast.Node
+	Decoder func(next Decode_union_object_next) *shimast.Node
+	Success func(exp *shimast.Expression) *shimast.Node
+	Escaper func(next Decode_union_object_escape) *shimast.Node
+	Objects []*nativemetadata.MetadataObjectType
+	Input   *shimast.Expression
+	Explore any
+}
+
+type Decode_union_object_next struct {
+	Input   *shimast.Expression
+	Object  *nativemetadata.MetadataObjectType
+	Explore any
+}
+
+type Decode_union_object_escape struct {
+	Input    *shimast.Expression
+	Expected string
+}
+
+func Decode_union_object(props Decode_union_objectProps) *shimast.Node {
+	unions := make([]decode_union_object_IUnion, 0, len(props.Objects))
+	names := make([]string, 0, len(props.Objects))
+	for _, object := range props.Objects {
+		obj := object
+		names = append(names, obj.Name)
+		unions = append(unions, decode_union_object_IUnion{
+			Type: "object",
+			Is: func() *shimast.Node {
+				return props.Success(props.Checker(Decode_union_object_next{
+					Input:   props.Input,
+					Explore: props.Explore,
+					Object:  obj,
+				}))
+			},
+			Value: func() *shimast.Node {
+				return props.Decoder(Decode_union_object_next{
+					Input:   props.Input,
+					Explore: props.Explore,
+					Object:  obj,
+				})
+			},
+		})
+	}
+	return decode_union_object_factory.NewCallExpression(
+		decode_union_object_factory.NewArrowFunction(
+			nil,
+			nil,
+			decode_union_object_factory.NewNodeList(nil),
+			nil,
+			nil,
+			decode_union_object_factory.NewToken(shimast.KindEqualsGreaterThanToken),
+			decode_union_object_iterate(decode_union_object_iterateProps{
+				Escaper:  props.Escaper,
+				Input:    props.Input,
+				Unions:   unions,
+				Expected: "(" + strings.Join(names, " | ") + ")",
+			}),
+		),
+		nil,
+		nil,
+		nil,
+		shimast.NodeFlagsNone,
+	)
+}
+
+type decode_union_object_iterateProps struct {
+	Escaper  func(next Decode_union_object_escape) *shimast.Node
+	Unions   []decode_union_object_IUnion
+	Expected string
+	Input    *shimast.Expression
+}
+
+type decode_union_object_IBranch struct {
+	Condition *shimast.Node
+	Value     *shimast.Node
+}
+
+func decode_union_object_iterate(props decode_union_object_iterateProps) *shimast.Node {
+	branches := []decode_union_object_IBranch{}
+	for _, u := range props.Unions {
+		condition := u.Is()
+		if condition.Kind == shimast.KindTrueKeyword {
+			branches = append(branches, decode_union_object_IBranch{
+				Condition: nil,
+				Value:     u.Value(),
+			})
+			break
+		}
+		branches = append(branches, decode_union_object_IBranch{
+			Condition: condition,
+			Value:     u.Value(),
+		})
+	}
+	if len(branches) == 0 {
+		return decode_union_object_factory.NewBlock(
+			decode_union_object_factory.NewNodeList([]*shimast.Node{
+				props.Escaper(Decode_union_object_escape{
+					Input:    props.Input,
+					Expected: props.Expected,
+				}),
+			}),
+			true,
+		)
+	}
+	if len(branches) == 1 && branches[0].Condition == nil {
+		return branches[0].Value
+	}
+
+	statements := make([]*shimast.Node, 0, len(branches)+1)
+	for _, b := range branches {
+		if b.Condition != nil {
+			statements = append(statements, decode_union_object_factory.NewIfStatement(
+				b.Condition,
+				decode_union_object_factory.NewReturnStatement(b.Value),
+				nil,
+			))
+		} else {
+			statements = append(statements, decode_union_object_factory.NewReturnStatement(b.Value))
+		}
+	}
+	if branches[len(branches)-1].Condition != nil {
+		statements = append(statements, props.Escaper(Decode_union_object_escape{
+			Input:    props.Input,
+			Expected: props.Expected,
+		}))
+	}
+	return decode_union_object_factory.NewBlock(
+		decode_union_object_factory.NewNodeList(statements),
+		true,
+	)
+}
+
+type decode_union_object_IUnion struct {
+	Type  string
+	Is    func() *shimast.Node
+	Value func() *shimast.Node
+}
+
+var decode_union_object_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})