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

package/native/core/factories/StatementFactory.go

@@ -0,0 +1,105 @@
+package factories
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type statementFactoryNamespace struct{}
+
+var StatementFactory = statementFactoryNamespace{}
+
+type StatementFactory_MutProps struct {
+	Name        string
+	Type        *shimast.TypeNode
+	Initializer *shimast.Expression
+}
+
+type StatementFactory_ConstantProps struct {
+	Name  string
+	Type  *shimast.TypeNode
+	Value *shimast.Expression
+}
+
+type StatementFactory_EntryProps struct {
+	Key   string
+	Value string
+}
+
+var statementFactory_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
+
+func (statementFactoryNamespace) Mut(props StatementFactory_MutProps) *shimast.Node {
+	typeNode := props.Type
+	if typeNode == nil && props.Initializer == nil {
+		typeNode = TypeFactory.Keyword("any")
+	}
+	declaration := statementFactory_factory.NewVariableDeclaration(
+		statementFactory_factory.NewIdentifier(props.Name),
+		nil,
+		typeNode,
+		props.Initializer,
+	)
+	return statementFactory_factory.NewVariableStatement(
+		nil,
+		statementFactory_factory.NewVariableDeclarationList(
+			statementFactory_factory.NewNodeList([]*shimast.Node{declaration}),
+			shimast.NodeFlagsLet,
+		),
+	)
+}
+
+func (statementFactoryNamespace) Constant(props StatementFactory_ConstantProps) *shimast.Node {
+	typeNode := props.Type
+	if typeNode == nil && props.Value == nil {
+		typeNode = TypeFactory.Keyword("any")
+	}
+	declaration := statementFactory_factory.NewVariableDeclaration(
+		statementFactory_factory.NewIdentifier(props.Name),
+		nil,
+		typeNode,
+		props.Value,
+	)
+	return statementFactory_factory.NewVariableStatement(
+		nil,
+		statementFactory_factory.NewVariableDeclarationList(
+			statementFactory_factory.NewNodeList([]*shimast.Node{declaration}),
+			shimast.NodeFlagsConst,
+		),
+	)
+}
+
+func (statementFactoryNamespace) Entry(props StatementFactory_EntryProps) *shimast.Node {
+	key := statementFactory_factory.NewBindingElement(
+		nil,
+		nil,
+		statementFactory_factory.NewIdentifier(props.Key),
+		nil,
+	)
+	value := statementFactory_factory.NewBindingElement(
+		nil,
+		nil,
+		statementFactory_factory.NewIdentifier(props.Value),
+		nil,
+	)
+	pattern := statementFactory_factory.NewBindingPattern(
+		shimast.KindArrayBindingPattern,
+		statementFactory_factory.NewNodeList([]*shimast.Node{key, value}),
+	)
+	declaration := statementFactory_factory.NewVariableDeclaration(pattern, nil, nil, nil)
+	return statementFactory_factory.NewVariableDeclarationList(
+		statementFactory_factory.NewNodeList([]*shimast.Node{declaration}),
+		shimast.NodeFlagsConst,
+	)
+}
+
+func (statementFactoryNamespace) Transpile(script string) *shimast.Node {
+	return statementFactory_factory.NewExpressionStatement(
+		statementFactory_factory.NewIdentifier(script),
+	)
+}
+
+func (statementFactoryNamespace) Block(expression *shimast.Expression) *shimast.Node {
+	return statementFactory_factory.NewBlock(
+		statementFactory_factory.NewNodeList([]*shimast.Node{
+			statementFactory_factory.NewExpressionStatement(expression),
+		}),
+		true,
+	)
+}

package/native/core/factories/TemplateFactory.go

@@ -0,0 +1,77 @@
+package factories
+
+import strings "strings"
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type templateFactoryNamespace struct{}
+
+var TemplateFactory = templateFactoryNamespace{}
+
+type TemplateFactory_IIterator struct {
+	Value string
+	Index int
+}
+
+var templateFactory_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
+
+func (templateFactoryNamespace) Generate(expressions []*shimast.Expression) *shimast.Node {
+	allString := true
+	for _, exp := range expressions {
+		if !shimast.IsStringLiteral(exp) {
+			allString = false
+			break
+		}
+	}
+	if allString {
+		values := make([]string, 0, len(expressions))
+		for _, str := range expressions {
+			values = append(values, str.Text())
+		}
+		return templateFactory_factory.NewStringLiteral(strings.Join(values, ""), shimast.TokenFlagsNone)
+	}
+	iterator := &TemplateFactory_IIterator{Value: "", Index: 0}
+	templateFactory_gather(expressions, iterator)
+	head := templateFactory_factory.NewTemplateHead(iterator.Value, iterator.Value, shimast.TokenFlagsNone)
+	spans := []*shimast.Node{}
+	for {
+		elem := expressions[iterator.Index]
+		iterator.Index++
+		templateFactory_gather(expressions, iterator)
+		broken := iterator.Index == len(expressions)
+		var literal *shimast.TemplateMiddleOrTail
+		if broken {
+			literal = templateFactory_factory.NewTemplateTail(iterator.Value, iterator.Value, shimast.TokenFlagsNone)
+		} else {
+			literal = templateFactory_factory.NewTemplateMiddle(iterator.Value, iterator.Value, shimast.TokenFlagsNone)
+		}
+		spans = append(spans, templateFactory_factory.NewTemplateSpan(elem, literal))
+		if broken {
+			break
+		}
+	}
+	return templateFactory_factory.NewTemplateExpression(
+		head,
+		templateFactory_factory.NewNodeList(spans),
+	)
+}
+
+func templateFactory_gather(expressions []*shimast.Expression, iterator *TemplateFactory_IIterator) {
+	found := -1
+	for i := iterator.Index; i < len(expressions); i++ {
+		if !shimast.IsStringLiteral(expressions[i]) {
+			found = i
+			break
+		}
+	}
+	last := len(expressions)
+	if found != -1 {
+		last = found
+	}
+	values := make([]string, 0, last-iterator.Index)
+	for _, elem := range expressions[iterator.Index:last] {
+		values = append(values, elem.Text())
+	}
+	iterator.Value = strings.Join(values, "")
+	iterator.Index = last
+}

package/native/core/factories/TypeFactory.go

@@ -0,0 +1,163 @@
+package factories
+
+import (
+	"strings"
+
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+	shimchecker "github.com/microsoft/typescript-go/shim/checker"
+)
+
+type typeFactoryNamespace struct{}
+
+var TypeFactory = typeFactoryNamespace{}
+
+type TypeFactory_GetReturnTypeOfClassMethodProps struct {
+	Checker  *shimchecker.Checker
+	Class    *shimchecker.Type
+	Function string
+}
+
+type TypeFactory_GetFullNameProps struct {
+	Checker            *shimchecker.Checker
+	Type               *shimchecker.Type
+	Symbol             *shimast.Symbol
+	AliasTypeArguments *bool
+}
+
+var typeFactory_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
+
+func (typeFactoryNamespace) IsFunction(t *shimchecker.Type) bool {
+	return TypeFactory.GetFunction(t) != nil
+}
+
+func (typeFactoryNamespace) GetFunction(t *shimchecker.Type) *shimast.Node {
+	if t == nil {
+		return nil
+	}
+	symbol := t.Symbol()
+	if symbol == nil || len(symbol.Declarations) == 0 {
+		return nil
+	}
+	node := symbol.Declarations[0]
+	if shimast.IsFunctionLike(node) {
+		return node
+	}
+	if shimast.IsPropertyAssignment(node) {
+		initializer := node.AsPropertyAssignment().Initializer
+		if shimast.IsFunctionLike(initializer) {
+			return initializer
+		}
+		return nil
+	}
+	if shimast.IsPropertyDeclaration(node) {
+		initializer := node.AsPropertyDeclaration().Initializer
+		if shimast.IsFunctionLike(initializer) {
+			return initializer
+		}
+	}
+	return nil
+}
+
+func (typeFactoryNamespace) GetReturnTypeOfClassMethod(props TypeFactory_GetReturnTypeOfClassMethodProps) *shimchecker.Type {
+	if props.Checker == nil || props.Class == nil {
+		return nil
+	}
+	symbol := props.Checker.GetPropertyOfType(props.Class, props.Function)
+	if symbol == nil || symbol.ValueDeclaration == nil {
+		return nil
+	}
+	functor := props.Checker.GetTypeOfSymbolAtLocation(symbol, symbol.ValueDeclaration)
+	signatures := props.Checker.GetSignaturesOfType(functor, shimchecker.SignatureKindCall)
+	if len(signatures) == 0 {
+		return nil
+	}
+	return props.Checker.GetReturnTypeOfSignature(signatures[0])
+}
+
+func (typeFactoryNamespace) GetFullName(props TypeFactory_GetFullNameProps) string {
+	if props.Checker == nil || props.Type == nil {
+		return ""
+	}
+	symbol := props.Symbol
+	if symbol == nil {
+		symbol = props.Type.Symbol()
+	}
+	if symbol == nil {
+		if props.Type.IsUnion() || props.Type.IsIntersection() {
+			joiner := " | "
+			if props.Type.IsIntersection() {
+				joiner = " & "
+			}
+			children := props.Type.Types()
+			names := make([]string, 0, len(children))
+			for _, child := range children {
+				names = append(names, TypeFactory.GetFullName(TypeFactory_GetFullNameProps{
+					Checker: props.Checker,
+					Type:    child,
+				}))
+			}
+			return strings.Join(names, joiner)
+		}
+		return props.Checker.TypeToString(props.Type)
+	}
+	name := typeFactory_get_name(symbol)
+	generic := props.Checker.GetTypeArguments(props.Type)
+	if len(generic) == 0 {
+		return name
+	}
+	if name == "Promise" {
+		return TypeFactory.GetFullName(TypeFactory_GetFullNameProps{
+			Checker: props.Checker,
+			Type:    generic[0],
+		})
+	}
+	names := make([]string, 0, len(generic))
+	for _, child := range generic {
+		names = append(names, TypeFactory.GetFullName(TypeFactory_GetFullNameProps{
+			Checker: props.Checker,
+			Type:    child,
+		}))
+	}
+	return name + "<" + strings.Join(names, ", ") + ">"
+}
+
+func typeFactory_explore_name(node *shimast.Node, name string) string {
+	if node != nil && shimast.IsModuleBlock(node) && node.Parent != nil && node.Parent.Parent != nil {
+		parentName := ""
+		if node.Parent.Name() != nil {
+			parentName = strings.TrimSpace(node.Parent.Name().Text())
+		}
+		if parentName != "" {
+			return typeFactory_explore_name(node.Parent.Parent, parentName+"."+name)
+		}
+	}
+	return name
+}
+
+func typeFactory_get_name(symbol *shimast.Symbol) string {
+	if symbol == nil || len(symbol.Declarations) == 0 || symbol.Declarations[0].Parent == nil {
+		return "__type"
+	}
+	return typeFactory_explore_name(symbol.Declarations[0].Parent, symbol.Name)
+}
+
+func (typeFactoryNamespace) Keyword(t string) *shimast.Node {
+	var kind shimast.KeywordTypeSyntaxKind
+	switch t {
+	case "void":
+		kind = shimast.KindVoidKeyword
+	case "any":
+		kind = shimast.KindAnyKeyword
+	case "unknown":
+		kind = shimast.KindUnknownKeyword
+	case "boolean":
+		kind = shimast.KindBooleanKeyword
+	case "number":
+		kind = shimast.KindNumberKeyword
+	case "bigint":
+		kind = shimast.KindBigIntKeyword
+	default:
+		kind = shimast.KindStringKeyword
+	}
+	return typeFactory_factory.NewKeywordTypeNode(kind)
+}

package/native/core/factories/ValueFactory.go

@@ -0,0 +1,36 @@
+package factories
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type valueFactoryNamespace struct{}
+
+var ValueFactory = valueFactoryNamespace{}
+
+var valueFactory_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
+
+func (valueFactoryNamespace) NULL() *shimast.Node {
+	return valueFactory_factory.NewKeywordExpression(shimast.KindNullKeyword)
+}
+
+func (valueFactoryNamespace) UNDEFINED() *shimast.Node {
+	return valueFactory_factory.NewIdentifier("undefined")
+}
+
+func (valueFactoryNamespace) BOOLEAN(value bool) *shimast.Node {
+	if value {
+		return valueFactory_factory.NewKeywordExpression(shimast.KindTrueKeyword)
+	}
+	return valueFactory_factory.NewKeywordExpression(shimast.KindFalseKeyword)
+}
+
+func (valueFactoryNamespace) INPUT(str ...string) *shimast.Node {
+	name := "input"
+	if len(str) != 0 {
+		name = str[0]
+	}
+	return valueFactory_factory.NewIdentifier(name)
+}
+
+func (valueFactoryNamespace) TYPEOF(input *shimast.Expression) *shimast.Node {
+	return valueFactory_factory.NewTypeOfExpression(input)
+}

package/native/core/factories/index.go

@@ -0,0 +1 @@
+package factories

package/native/core/factories/internal/metadata/IMetadataIteratorProps.go

@@ -0,0 +1,56 @@
+package metadata
+
+import (
+	nativechecker "github.com/microsoft/typescript-go/shim/checker"
+	schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+)
+
+type MetadataFactory_IOptions struct {
+	Escape     bool
+	Absorb     bool
+	Constant   bool
+	Functional bool
+	Validate   func(props struct {
+		Metadata *schemametadata.MetadataSchema
+		Explore  MetadataFactory_IExplore
+		Top      *schemametadata.MetadataSchema
+	}) []string
+	OnError func(node any, message string)
+}
+
+type MetadataFactory_IError struct {
+	Name     string
+	Explore  MetadataFactory_IExplore
+	Messages []string
+}
+
+type MetadataFactory_IExplore struct {
+	Top       bool
+	Object    *schemametadata.MetadataObjectType
+	Property  any
+	Parameter any
+	Nested    any
+	Aliased   bool
+	Escaped   bool
+	Output    bool
+}
+
+type MetadataFactory_IExplore_Function func(MetadataFactory_IExplore) MetadataFactory_IExplore
+
+type IMetadataIteratorProps struct {
+	Options     MetadataFactory_IOptions
+	Checker     *nativechecker.Checker
+	Components  *schemametadata.MetadataCollection
+	Errors      *[]MetadataFactory_IError
+	Metadata    *schemametadata.MetadataSchema
+	Type        *nativechecker.Type
+	Explore     MetadataFactory_IExplore
+	Intersected bool
+}
+
+var MetadataTypeTagAnalyzer func(props struct {
+	Errors  *[]MetadataFactory_IError
+	Type    string
+	Objects []*schemametadata.MetadataObjectType
+	Explore MetadataFactory_IExplore
+}) []schemametadata.IMetadataTypeTag

package/native/core/factories/internal/metadata/MetadataHelper.go

@@ -0,0 +1,225 @@
+package metadata
+
+import (
+	"strings"
+
+	nativeast "github.com/microsoft/typescript-go/shim/ast"
+	nativechecker "github.com/microsoft/typescript-go/shim/checker"
+	schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+)
+
+type metadataHelperNamespace struct{}
+
+var MetadataHelper = metadataHelperNamespace{}
+
+func (metadataHelperNamespace) Literal_to_metadata(key string) *schemametadata.MetadataSchema {
+	metadata := schemametadata.MetadataSchema_initialize()
+	metadata.Constants = append(metadata.Constants, schemametadata.MetadataConstant_create(schemametadata.MetadataConstant{
+		Type: "string",
+		Values: []*schemametadata.MetadataConstantValue{
+			schemametadata.MetadataConstantValue_create(schemametadata.MetadataConstantValue{
+				Value: key,
+				Tags:  [][]schemametadata.IMetadataTypeTag{},
+			}),
+		},
+	}))
+	return metadata
+}
+
+func metadata_array_util_add_bool(array *[]bool, value bool) {
+	for _, elem := range *array {
+		if elem == value {
+			return
+		}
+	}
+	*array = append(*array, value)
+}
+
+func metadata_type_full_name(checker *nativechecker.Checker, typ *nativechecker.Type) string {
+	if checker == nil || typ == nil {
+		return ""
+	}
+	if typ.IsUnion() || typ.IsIntersection() {
+		joiner := " | "
+		if typ.IsIntersection() {
+			joiner = " & "
+		}
+		children := typ.Types()
+		names := make([]string, 0, len(children))
+		for _, child := range children {
+			names = append(names, metadata_type_full_name(checker, child))
+		}
+		return strings.Join(names, joiner)
+	}
+	return checker.TypeToString(typ)
+}
+
+func metadata_get_type_arguments(checker *nativechecker.Checker, typ *nativechecker.Type) (output []*nativechecker.Type) {
+	if checker == nil || typ == nil {
+		return nil
+	}
+	defer func() {
+		if recover() != nil {
+			output = nil
+		}
+	}()
+	return checker.GetTypeArguments(typ)
+}
+
+func metadata_get_function_node(typ *nativechecker.Type) *nativeast.Node {
+	if typ == nil {
+		return nil
+	}
+	symbol := typ.Symbol()
+	if symbol == nil || len(symbol.Declarations) == 0 {
+		return nil
+	}
+	node := symbol.Declarations[0]
+	if nativeast.IsFunctionLike(node) {
+		return node
+	}
+	if nativeast.IsPropertyAssignment(node) {
+		initializer := node.AsPropertyAssignment().Initializer
+		if nativeast.IsFunctionLike(initializer) {
+			return initializer
+		}
+		return nil
+	}
+	if nativeast.IsPropertyDeclaration(node) {
+		initializer := node.AsPropertyDeclaration().Initializer
+		if nativeast.IsFunctionLike(initializer) {
+			return initializer
+		}
+	}
+	return nil
+}
+
+func metadata_get_return_type_of_class_method(props struct {
+	Checker  *nativechecker.Checker
+	Class    *nativechecker.Type
+	Function string
+}) *nativechecker.Type {
+	if props.Checker == nil || props.Class == nil {
+		return nil
+	}
+	symbol := props.Checker.GetPropertyOfType(props.Class, props.Function)
+	if symbol == nil || symbol.ValueDeclaration == nil {
+		return nil
+	}
+	functor := props.Checker.GetTypeOfSymbolAtLocation(symbol, symbol.ValueDeclaration)
+	signatures := props.Checker.GetSignaturesOfType(functor, nativechecker.SignatureKindCall)
+	if len(signatures) == 0 {
+		return nil
+	}
+	return props.Checker.GetReturnTypeOfSignature(signatures[0])
+}
+
+func metadata_node_js_doc_tags(symbol *nativeast.Symbol) []schemametadata.IJsDocTagInfo {
+	output := []schemametadata.IJsDocTagInfo{}
+	for _, node := range metadata_node_declarations(symbol) {
+		for _, jsdoc := range node.JSDoc(nil) {
+			doc := jsdoc.AsJSDoc()
+			if doc == nil || doc.Tags == nil {
+				continue
+			}
+			for _, tag := range doc.Tags.Nodes {
+				if tag == nil || tag.TagName() == nil {
+					continue
+				}
+				texts := []schemametadata.IJsDocTagInfo_IText{}
+				if name := metadata_js_doc_parameter_name(tag); name != "" {
+					texts = append(texts, schemametadata.IJsDocTagInfo_IText{
+						Kind: "parameterName",
+						Text: name,
+					})
+				}
+				if text := metadata_js_doc_comment_text(tag.CommentList()); text != "" {
+					texts = append(texts, schemametadata.IJsDocTagInfo_IText{
+						Kind: "text",
+						Text: text,
+					})
+				}
+				output = append(output, schemametadata.IJsDocTagInfo{
+					Name: tag.TagName().Text(),
+					Text: texts,
+				})
+			}
+		}
+	}
+	return output
+}
+
+func metadata_node_description(symbol *nativeast.Symbol) *string {
+	for _, node := range metadata_node_declarations(symbol) {
+		for _, jsdoc := range node.JSDoc(nil) {
+			doc := jsdoc.AsJSDoc()
+			if doc == nil {
+				continue
+			}
+			if text := metadata_js_doc_comment_text(doc.Comment); text != "" {
+				return &text
+			}
+		}
+	}
+	return nil
+}
+
+func metadata_is_internal(symbol *nativeast.Symbol) bool {
+	return false
+}
+
+func metadata_node_declarations(symbol *nativeast.Symbol) []*nativeast.Node {
+	if symbol == nil {
+		return nil
+	}
+	output := []*nativeast.Node{}
+	visited := map[*nativeast.Node]bool{}
+	appendNode := func(node *nativeast.Node) {
+		if node != nil && visited[node] == false {
+			visited[node] = true
+			output = append(output, node)
+		}
+	}
+	appendNode(symbol.ValueDeclaration)
+	for _, node := range symbol.Declarations {
+		appendNode(node)
+	}
+	return output
+}
+
+func metadata_js_doc_parameter_name(tag *nativeast.Node) string {
+	if tag == nil {
+		return ""
+	}
+	if tag.Kind.String() != "KindJSDocParameterTag" && tag.Kind.String() != "KindJSDocPropertyTag" {
+		return ""
+	}
+	name := tag.AsJSDocParameterOrPropertyTag().Name()
+	if name == nil {
+		return ""
+	}
+	return name.Text()
+}
+
+func metadata_js_doc_comment_text(list *nativeast.NodeList) string {
+	if list == nil {
+		return ""
+	}
+	parts := []string{}
+	for _, node := range list.Nodes {
+		if node != nil {
+			parts = append(parts, node.Text())
+		}
+	}
+	return metadata_clean_js_doc_text(strings.Join(parts, ""))
+}
+
+func metadata_clean_js_doc_text(text string) string {
+	text = strings.ReplaceAll(text, "\r\n", "\n")
+	text = strings.ReplaceAll(text, "\r", "\n")
+	lines := strings.Split(text, "\n")
+	for i, line := range lines {
+		lines[i] = strings.TrimRight(line, " \t")
+	}
+	return strings.TrimSpace(strings.Join(lines, "\n"))
+}