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

package/native/adapter/cleanup.go

@@ -0,0 +1,218 @@
+package adapter
+
+import (
+	"fmt"
+	"regexp"
+	"sort"
+	"strings"
+)
+
+func CleanupTransformedText(text string) string {
+	for _, pattern := range unusedImportPatterns {
+		loc := pattern.regex.FindStringIndex(text)
+		for loc != nil {
+			alias := pattern.alias(text[loc[0]:loc[1]])
+			if alias != "" && !aliasStillReferenced(text, alias, loc[0], loc[1]) {
+				end := loc[1]
+				if end < len(text) && text[end] == '\n' {
+					end++
+				}
+				text = text[:loc[0]] + text[end:]
+				loc = pattern.regex.FindStringIndex(text)
+				continue
+			}
+			next := pattern.regex.FindStringIndex(text[loc[1]:])
+			if next == nil {
+				break
+			}
+			loc = []int{loc[1] + next[0], loc[1] + next[1]}
+		}
+	}
+	return injectRuntimeImports(text)
+}
+
+type unusedImportPattern struct {
+	regex *regexp.Regexp
+	alias func(string) string
+}
+
+var unusedImportPatterns = []unusedImportPattern{
+	{
+		regex: regexp.MustCompile(`(?m)^const (typia(?:_\d+)?) = __importDefault\(require\("typia"\)\);$`),
+		alias: func(s string) string {
+			return firstSubmatch(`^const (\w+) =`, s)
+		},
+	},
+	{
+		regex: regexp.MustCompile(`(?m)^const (typia(?:_\d+)?) = require\("typia"\);$`),
+		alias: func(s string) string {
+			return firstSubmatch(`^const (\w+) =`, s)
+		},
+	},
+	{
+		regex: regexp.MustCompile(`(?m)^import (\w+) from "typia";$`),
+		alias: func(s string) string {
+			return firstSubmatch(`^import (\w+) from`, s)
+		},
+	},
+}
+
+func firstSubmatch(pattern string, text string) string {
+	match := regexp.MustCompile(pattern).FindStringSubmatch(text)
+	if len(match) < 2 {
+		return ""
+	}
+	return match[1]
+}
+
+func aliasStillReferenced(text, alias string, lineStart, lineEnd int) bool {
+	head := text[:lineStart]
+	tail := text[lineEnd:]
+	pattern := regexp.MustCompile(`\b` + regexp.QuoteMeta(alias) + `\b`)
+	return pattern.MatchString(head) || pattern.MatchString(tail)
+}
+
+func injectRuntimeImports(text string) string {
+	aliases := collectRuntimeAliases(text)
+	if len(aliases) == 0 {
+		return text
+	}
+	esModule := isESModuleOutput(text)
+	imports := make([]string, 0, len(aliases))
+	for _, alias := range aliases {
+		module := runtimeModuleOf(alias)
+		if runtimeImportAlreadyExists(text, alias, module) {
+			continue
+		}
+		name := runtimeNameOf(alias)
+		if esModule {
+			if alias == "__typia_utils" {
+				imports = append(imports, fmt.Sprintf(`import * as %s from %q;`, alias, module))
+			} else {
+				imports = append(imports, fmt.Sprintf(`import { %s as %s } from %q;`, name, alias, module))
+			}
+		} else {
+			if alias == "__typia_utils" {
+				imports = append(imports, fmt.Sprintf(`const %s = require(%q);`, alias, module))
+			} else {
+				imports = append(imports, fmt.Sprintf(`const { %s: %s } = require(%q);`, name, alias, module))
+			}
+		}
+	}
+	if len(imports) == 0 {
+		return text
+	}
+	index := runtimeImportInsertionIndex(text, esModule)
+	return text[:index] + strings.Join(imports, "\n") + "\n" + text[index:]
+}
+
+func collectRuntimeAliases(text string) []string {
+	re := regexp.MustCompile(`\b__typia_transform_([A-Za-z0-9_]+)\b`)
+	seen := map[string]bool{}
+	for _, match := range re.FindAllStringSubmatch(text, -1) {
+		seen[match[0]] = true
+	}
+	if regexp.MustCompile(`\b__typia_utils\b`).MatchString(text) {
+		seen["__typia_utils"] = true
+	}
+	aliases := make([]string, 0, len(seen))
+	for alias := range seen {
+		aliases = append(aliases, alias)
+	}
+	sort.SliceStable(aliases, func(i, j int) bool {
+		left, right := runtimeAliasRank(aliases[i]), runtimeAliasRank(aliases[j])
+		if left != right {
+			return left < right
+		}
+		return aliases[i] < aliases[j]
+	})
+	return aliases
+}
+
+func runtimeAliasRank(alias string) int {
+	if alias == "__typia_utils" {
+		return 50
+	}
+	name := strings.TrimPrefix(alias, "__typia_transform_")
+	switch {
+	case strings.HasPrefix(name, "_is"):
+		return 100
+	case strings.HasPrefix(name, "_assert"):
+		return 150
+	case strings.HasPrefix(name, "_randomFormat"):
+		return 200
+	case name == "_randomString":
+		return 210
+	case name == "_randomInteger":
+		return 220
+	case name == "_randomNumber":
+		return 221
+	case strings.HasPrefix(name, "_random"):
+		return 230
+	case name == "_validateReport":
+		return 800
+	case name == "_createStandardSchema":
+		return 900
+	}
+	return 500
+}
+
+func runtimeModuleOf(alias string) string {
+	if alias == "__typia_utils" {
+		return "@typia/utils"
+	}
+	return "typia/lib/internal/" + runtimeNameOf(alias)
+}
+
+func runtimeNameOf(alias string) string {
+	name := strings.TrimPrefix(alias, "__typia_transform_")
+	if !strings.HasPrefix(name, "_") {
+		name = "_" + name
+	}
+	return name
+}
+
+func runtimeImportAlreadyExists(text string, alias string, module string) bool {
+	return regexp.MustCompile(`(?m)^import \* as `+regexp.QuoteMeta(alias)+` from ["']`+regexp.QuoteMeta(module)+`["'];$`).MatchString(text) ||
+		regexp.MustCompile(`(?m)^import \{[^}\n]*\bas\s+`+regexp.QuoteMeta(alias)+`\b[^}\n]*\} from ["']`+regexp.QuoteMeta(module)+`["'];$`).MatchString(text) ||
+		regexp.MustCompile(`(?m)^const `+regexp.QuoteMeta(alias)+` = require\(["']`+regexp.QuoteMeta(module)+`["']\);$`).MatchString(text) ||
+		regexp.MustCompile(`(?m)^const \{[^}\n]*:\s*`+regexp.QuoteMeta(alias)+`\b[^}\n]*\} = require\(["']`+regexp.QuoteMeta(module)+`["']\);$`).MatchString(text)
+}
+
+func isESModuleOutput(text string) bool {
+	return regexp.MustCompile(`(?m)^(import\s|import\{|import\*|export\s)`).MatchString(text)
+}
+
+func runtimeImportInsertionIndex(text string, esModule bool) int {
+	index := 0
+	if strings.HasPrefix(text, "#!") {
+		if next := strings.IndexByte(text, '\n'); next >= 0 {
+			index = next + 1
+		} else {
+			return len(text)
+		}
+	}
+	if esModule {
+		return index
+	}
+	for {
+		next := consumeRuntimeImportPrefix(text[index:])
+		if next == 0 {
+			return index
+		}
+		index += next
+	}
+}
+
+func consumeRuntimeImportPrefix(text string) int {
+	for _, prefix := range []string{
+		"\"use strict\";\n",
+		"'use strict';\n",
+		"/* @ttsc-rewritten */\n",
+	} {
+		if strings.HasPrefix(text, prefix) {
+			return len(prefix)
+		}
+	}
+	return 0
+}

package/native/adapter/imports.go

@@ -0,0 +1,91 @@
+package adapter
+
+import (
+	"path/filepath"
+	"strconv"
+	"strings"
+	"unicode"
+
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+func commonJSImportIdentifierSubstitutions(file *shimast.SourceFile) map[string]string {
+	if file == nil || file.Statements == nil {
+		return nil
+	}
+	output := map[string]string{}
+	counts := map[string]int{}
+	for _, stmt := range file.Statements.Nodes {
+		if stmt == nil || stmt.Kind != shimast.KindImportDeclaration {
+			continue
+		}
+		decl := stmt.AsImportDeclaration()
+		if decl == nil || decl.ImportClause == nil || decl.ModuleSpecifier == nil || decl.ModuleSpecifier.Kind != shimast.KindStringLiteral {
+			continue
+		}
+		clause := decl.ImportClause.AsImportClause()
+		if clause == nil || clause.PhaseModifier == shimast.KindTypeKeyword {
+			continue
+		}
+		base := commonJSImportAliasBase(decl.ModuleSpecifier.Text())
+		counts[base]++
+		moduleAlias := base + "_" + strconv.Itoa(counts[base])
+		if name := clause.Name(); name != nil {
+			output[name.Text()] = moduleAlias + ".default"
+		}
+		if clause.NamedBindings == nil || clause.NamedBindings.Kind != shimast.KindNamedImports {
+			continue
+		}
+		named := clause.NamedBindings.AsNamedImports()
+		if named == nil || named.Elements == nil {
+			continue
+		}
+		for _, elem := range named.Elements.Nodes {
+			if elem == nil {
+				continue
+			}
+			spec := elem.AsImportSpecifier()
+			if spec == nil || spec.IsTypeOnly {
+				continue
+			}
+			name := spec.Name()
+			if name == nil {
+				continue
+			}
+			local := name.Text()
+			imported := local
+			if spec.PropertyName != nil {
+				imported = spec.PropertyName.Text()
+			}
+			output[local] = moduleAlias + "." + imported
+		}
+	}
+	if len(output) == 0 {
+		return nil
+	}
+	return output
+}
+
+func commonJSImportAliasBase(module string) string {
+	base := strings.TrimSuffix(filepath.Base(module), filepath.Ext(module))
+	if base == "" || base == "." || base == string(filepath.Separator) {
+		base = "mod"
+	}
+	var builder strings.Builder
+	for _, r := range base {
+		if r == '_' || r == '$' || unicode.IsLetter(r) || unicode.IsDigit(r) {
+			builder.WriteRune(r)
+		} else {
+			builder.WriteByte('_')
+		}
+	}
+	text := builder.String()
+	if text == "" {
+		text = "mod"
+	}
+	first := []rune(text)[0]
+	if first != '_' && first != '$' && !unicode.IsLetter(first) {
+		text = "_" + text
+	}
+	return text
+}

package/native/adapter/visit.go

@@ -0,0 +1,168 @@
+package adapter
+
+import (
+	"path/filepath"
+	"strings"
+
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+	shimchecker "github.com/microsoft/typescript-go/shim/checker"
+)
+
+type CallSite struct {
+	File       *shimast.SourceFile
+	FilePath   string
+	Module     string
+	Method     string
+	Call       *shimast.CallExpression
+	RootName   string
+	Namespaces []string
+}
+
+func CollectCallSites(files []*shimast.SourceFile, checker *shimchecker.Checker) []CallSite {
+	sites := []CallSite{}
+	for _, file := range files {
+		if file == nil || file.IsDeclarationFile {
+			continue
+		}
+		file.ForEachChild(func(node *shimast.Node) bool {
+			visitCallSite(file, checker, node, &sites)
+			return false
+		})
+	}
+	return sites
+}
+
+func visitCallSite(file *shimast.SourceFile, checker *shimchecker.Checker, node *shimast.Node, sites *[]CallSite) {
+	if node == nil {
+		return
+	}
+	if node.Kind == shimast.KindCallExpression {
+		if site, ok := tryCallSite(file, checker, node); ok {
+			*sites = append(*sites, site)
+		}
+	}
+	node.ForEachChild(func(child *shimast.Node) bool {
+		visitCallSite(file, checker, child, sites)
+		return false
+	})
+}
+
+func tryCallSite(file *shimast.SourceFile, checker *shimchecker.Checker, node *shimast.Node) (CallSite, bool) {
+	if checker == nil {
+		return CallSite{}, false
+	}
+	call := node.AsCallExpression()
+	if call == nil {
+		return CallSite{}, false
+	}
+	signature := checker.GetResolvedSignature(node)
+	if signature == nil {
+		return CallSite{}, false
+	}
+	declaration := signature.Declaration()
+	if declaration == nil {
+		return CallSite{}, false
+	}
+	sourceFile := shimast.GetSourceFileOfNode(declaration)
+	if sourceFile == nil {
+		return CallSite{}, false
+	}
+	module, ok := matchTypiaModule(sourceFile.FileName())
+	if !ok {
+		return CallSite{}, false
+	}
+	method := callSiteMethodName(checker, declaration, call)
+	if method == "" {
+		return CallSite{}, false
+	}
+	root, namespaces, ok := extractRootAndNamespaces(call, method)
+	if !ok {
+		return CallSite{}, false
+	}
+	return CallSite{
+		File:       file,
+		FilePath:   file.FileName(),
+		Module:     module,
+		Method:     method,
+		Call:       call,
+		RootName:   root,
+		Namespaces: namespaces,
+	}, true
+}
+
+func matchTypiaModule(location string) (string, bool) {
+	location = filepath.ToSlash(location)
+	for _, suffix := range []string{".d.ts", ".ts"} {
+		for _, middle := range []string{"typia/lib/", "typia/src/", "packages/typia/src/"} {
+			index := strings.LastIndex(location, middle)
+			if index < 0 {
+				continue
+			}
+			name := location[index+len(middle):]
+			if !strings.HasSuffix(name, suffix) {
+				continue
+			}
+			name = strings.TrimSuffix(name, suffix)
+			if strings.Contains(name, "/") {
+				continue
+			}
+			return name, true
+		}
+	}
+	return "", false
+}
+
+func callSiteMethodName(checker *shimchecker.Checker, declaration *shimast.Node, call *shimast.CallExpression) string {
+	if name := declaration.Name(); name != nil {
+		if symbol := checker.GetSymbolAtLocation(name); symbol != nil && symbol.Name != "" {
+			return symbol.Name
+		}
+		if name.Kind == shimast.KindIdentifier {
+			if id := name.AsIdentifier(); id != nil {
+				return id.Text
+			}
+		}
+	}
+	if call.Expression != nil && call.Expression.Kind == shimast.KindPropertyAccessExpression {
+		if property := call.Expression.AsPropertyAccessExpression(); property != nil {
+			if name := property.Name(); name != nil && name.Kind == shimast.KindIdentifier {
+				if id := name.AsIdentifier(); id != nil {
+					return id.Text
+				}
+			}
+		}
+	}
+	return ""
+}
+
+func extractRootAndNamespaces(call *shimast.CallExpression, method string) (string, []string, bool) {
+	expression := call.Expression
+	segments := []string{}
+	for expression != nil && expression.Kind == shimast.KindPropertyAccessExpression {
+		property := expression.AsPropertyAccessExpression()
+		if property == nil {
+			break
+		}
+		name := property.Name()
+		if name == nil || name.Kind != shimast.KindIdentifier {
+			return "", nil, false
+		}
+		id := name.AsIdentifier()
+		if id == nil || id.Text == "" {
+			return "", nil, false
+		}
+		segments = append([]string{id.Text}, segments...)
+		expression = property.Expression
+	}
+	if expression == nil || expression.Kind != shimast.KindIdentifier {
+		return "", nil, false
+	}
+	root := expression.AsIdentifier()
+	if root == nil || root.Text == "" || len(segments) == 0 {
+		return "", nil, false
+	}
+	if segments[len(segments)-1] != method {
+		return "", nil, false
+	}
+	return root.Text, segments[:len(segments)-1], true
+}