@nestia/core 12.0.0-dev.20260601.1 → 12.0.0-dev.20260612.2

package/native/transform/path_rewrite.go

@@ -1,285 +1,285 @@
-package transform
-
-import (
-	"path/filepath"
-	"sort"
-	"strings"
-
-	shimast "github.com/microsoft/typescript-go/shim/ast"
-	shimcore "github.com/microsoft/typescript-go/shim/core"
-	"github.com/samchon/ttsc/packages/ttsc/driver"
-)
-
-type pathsRewriter struct {
-	basePath    string
-	outDir      string
-	patterns    []pathsPattern
-	rootDir     string
-	sourceFiles map[string]string
-}
-
-type pathsPattern struct {
-	pattern string
-	targets []string
-}
-
-func newPathsRewriter(prog *driver.Program) *pathsRewriter {
-	out := &pathsRewriter{sourceFiles: map[string]string{}}
-	if prog == nil || prog.ParsedConfig == nil || prog.ParsedConfig.ParsedConfig == nil || prog.ParsedConfig.ParsedConfig.CompilerOptions == nil {
-		return out
-	}
-	options := prog.ParsedConfig.ParsedConfig.CompilerOptions
-	out.basePath = filepath.Clean(options.GetPathsBasePath(prog.Host.GetCurrentDirectory()))
-	out.outDir = optionalPath(options.OutDir, prog.Host.GetCurrentDirectory())
-	out.rootDir = optionalPath(options.RootDir, prog.Host.GetCurrentDirectory())
-	files := prog.SourceFiles()
-	if out.rootDir == "" {
-		out.rootDir = commonSourceDir(files)
-	}
-	for _, file := range files {
-		name := normalizePath(file.FileName())
-		out.sourceFiles[name] = name
-		out.sourceFiles[stripKnownSourceExtension(name)] = name
-	}
-	if options.Paths != nil {
-		for pattern, targets := range options.Paths.Entries() {
-			out.patterns = append(out.patterns, pathsPattern{
-				pattern: pattern,
-				targets: append([]string(nil), targets...),
-			})
-		}
-	}
-	sort.SliceStable(out.patterns, func(i, j int) bool {
-		return patternRank(out.patterns[i].pattern) > patternRank(out.patterns[j].pattern)
-	})
-	return out
-}
-
-func (r *pathsRewriter) applyAll(files []*shimast.SourceFile) {
-	if r == nil || len(r.patterns) == 0 {
-		return
-	}
-	for _, file := range files {
-		r.apply(file)
-	}
-}
-
-func (r *pathsRewriter) apply(file *shimast.SourceFile) {
-	if r == nil || file == nil || len(r.patterns) == 0 {
-		return
-	}
-	visitModuleSpecifiers(file.AsNode(), func(lit *shimast.Node) {
-		if lit == nil || lit.Kind != shimast.KindStringLiteral {
-			return
-		}
-		spec := lit.Text()
-		rewritten, ok := r.rewrite(file.FileName(), spec)
-		if ok && rewritten != spec {
-			lit.AsStringLiteral().Text = rewritten
-			lit.Flags |= shimast.NodeFlagsSynthesized
-			lit.Loc = shimcore.UndefinedTextRange()
-		}
-	})
-}
-
-func visitModuleSpecifiers(node *shimast.Node, visit func(*shimast.Node)) {
-	if node == nil {
-		return
-	}
-	switch node.Kind {
-	case shimast.KindImportDeclaration:
-		visit(node.AsImportDeclaration().ModuleSpecifier)
-	case shimast.KindExportDeclaration:
-		visit(node.AsExportDeclaration().ModuleSpecifier)
-	case shimast.KindImportEqualsDeclaration:
-		ref := node.AsImportEqualsDeclaration().ModuleReference
-		if ref != nil && ref.Kind == shimast.KindExternalModuleReference {
-			visit(ref.AsExternalModuleReference().Expression)
-		}
-	case shimast.KindImportType:
-		arg := node.AsImportTypeNode().Argument
-		if arg != nil && arg.Kind == shimast.KindLiteralType {
-			visit(arg.AsLiteralTypeNode().Literal)
-		}
-	case shimast.KindModuleDeclaration:
-		decl := node.AsModuleDeclaration()
-		if decl != nil {
-			visit(decl.Name())
-		}
-	case shimast.KindCallExpression:
-		call := node.AsCallExpression()
-		if isModuleSpecifierCall(call) && call.Arguments != nil && len(call.Arguments.Nodes) > 0 {
-			visit(call.Arguments.Nodes[0])
-		}
-	}
-	node.ForEachChild(func(child *shimast.Node) bool {
-		visitModuleSpecifiers(child, visit)
-		return false
-	})
-}
-
-func isModuleSpecifierCall(call *shimast.CallExpression) bool {
-	if call == nil || call.Expression == nil {
-		return false
-	}
-	switch call.Expression.Kind {
-	case shimast.KindImportKeyword:
-		return true
-	case shimast.KindIdentifier:
-		return call.Expression.Text() == "require"
-	default:
-		return false
-	}
-}
-
-func (r *pathsRewriter) rewrite(fromSource string, specifier string) (string, bool) {
-	if specifier == "" || strings.HasPrefix(specifier, ".") || strings.HasPrefix(specifier, "/") {
-		return specifier, false
-	}
-	targetSource, ok := r.resolveSource(specifier)
-	if !ok {
-		return specifier, false
-	}
-	fromOut := r.outputPathForSource(fromSource)
-	targetOut := r.outputPathForSource(targetSource)
-	if fromOut == "" || targetOut == "" {
-		return specifier, false
-	}
-	rel, err := filepath.Rel(filepath.Dir(fromOut), targetOut)
-	if err != nil {
-		return specifier, false
-	}
-	rel = filepath.ToSlash(rel)
-	if !strings.HasPrefix(rel, ".") {
-		rel = "./" + rel
-	}
-	return rel, true
-}
-
-func (r *pathsRewriter) resolveSource(specifier string) (string, bool) {
-	for _, pattern := range r.patterns {
-		star, ok := matchPattern(pattern.pattern, specifier)
-		if !ok {
-			continue
-		}
-		for _, target := range pattern.targets {
-			candidate := strings.Replace(target, "*", star, 1)
-			resolved := normalizePath(filepath.Join(r.basePath, candidate))
-			if source, ok := r.lookupSource(resolved); ok {
-				return source, true
-			}
-		}
-	}
-	return "", false
-}
-
-func (r *pathsRewriter) lookupSource(candidate string) (string, bool) {
-	if source, ok := r.sourceFiles[normalizePath(candidate)]; ok {
-		return source, true
-	}
-	stem := stripKnownSourceExtension(normalizePath(candidate))
-	if source, ok := r.sourceFiles[stem]; ok {
-		return source, true
-	}
-	for _, ext := range []string{".ts", ".tsx", ".mts", ".cts"} {
-		if source, ok := r.sourceFiles[stem+ext]; ok {
-			return source, true
-		}
-	}
-	for _, ext := range []string{".ts", ".tsx", ".mts", ".cts"} {
-		if source, ok := r.sourceFiles[normalizePath(filepath.Join(stem, "index"+ext))]; ok {
-			return source, true
-		}
-	}
-	return "", false
-}
-
-func (r *pathsRewriter) outputPathForSource(source string) string {
-	if r.outDir == "" || r.rootDir == "" {
-		return ""
-	}
-	rel, err := filepath.Rel(r.rootDir, source)
-	if err != nil || isOutsideRelativePath(rel) {
-		return ""
-	}
-	return normalizePath(filepath.Join(r.outDir, replaceSourceExtension(rel, emittedJavaScriptExtension(rel))))
-}
-
-func emittedJavaScriptExtension(source string) string {
-	switch strings.ToLower(filepath.Ext(source)) {
-	case ".mts":
-		return ".mjs"
-	case ".cts":
-		return ".cjs"
-	default:
-		return ".js"
-	}
-}
-
-func matchPattern(pattern string, specifier string) (string, bool) {
-	if !strings.Contains(pattern, "*") {
-		return "", pattern == specifier
-	}
-	parts := strings.SplitN(pattern, "*", 2)
-	if !strings.HasPrefix(specifier, parts[0]) || !strings.HasSuffix(specifier, parts[1]) {
-		return "", false
-	}
-	return specifier[len(parts[0]) : len(specifier)-len(parts[1])], true
-}
-
-func patternRank(pattern string) int {
-	return len(strings.ReplaceAll(pattern, "*", ""))
-}
-
-func optionalPath(value string, cwd string) string {
-	if value == "" {
-		return ""
-	}
-	if filepath.IsAbs(value) {
-		return normalizePath(value)
-	}
-	return normalizePath(filepath.Join(cwd, value))
-}
-
-func commonSourceDir(files []*shimast.SourceFile) string {
-	if len(files) == 0 {
-		return ""
-	}
-	common := normalizePath(filepath.Dir(files[0].FileName()))
-	for _, file := range files[1:] {
-		dir := normalizePath(filepath.Dir(file.FileName()))
-		for common != "" && !strings.HasPrefix(dir+"/", common+"/") {
-			next := filepath.Dir(common)
-			if next == common {
-				return common
-			}
-			common = normalizePath(next)
-		}
-	}
-	return common
-}
-
-func normalizePath(value string) string {
-	if value == "" {
-		return ""
-	}
-	return filepath.ToSlash(filepath.Clean(value))
-}
-
-func isOutsideRelativePath(rel string) bool {
-	return rel == ".." || strings.HasPrefix(filepath.ToSlash(rel), "../")
-}
-
-func stripKnownSourceExtension(value string) string {
-	lower := strings.ToLower(value)
-	for _, ext := range []string{".d.ts", ".d.mts", ".d.cts", ".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"} {
-		if strings.HasSuffix(lower, ext) {
-			return value[:len(value)-len(ext)]
-		}
-	}
-	return strings.TrimSuffix(value, filepath.Ext(value))
-}
-
-func replaceSourceExtension(value string, ext string) string {
-	return stripKnownSourceExtension(filepath.ToSlash(value)) + ext
-}
+package transform
+
+import (
+	"path/filepath"
+	"sort"
+	"strings"
+
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+	shimcore "github.com/microsoft/typescript-go/shim/core"
+	"github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+type pathsRewriter struct {
+	basePath    string
+	outDir      string
+	patterns    []pathsPattern
+	rootDir     string
+	sourceFiles map[string]string
+}
+
+type pathsPattern struct {
+	pattern string
+	targets []string
+}
+
+func newPathsRewriter(prog *driver.Program) *pathsRewriter {
+	out := &pathsRewriter{sourceFiles: map[string]string{}}
+	if prog == nil || prog.ParsedConfig == nil || prog.ParsedConfig.ParsedConfig == nil || prog.ParsedConfig.ParsedConfig.CompilerOptions == nil {
+		return out
+	}
+	options := prog.ParsedConfig.ParsedConfig.CompilerOptions
+	out.basePath = filepath.Clean(options.GetPathsBasePath(prog.Host.GetCurrentDirectory()))
+	out.outDir = optionalPath(options.OutDir, prog.Host.GetCurrentDirectory())
+	out.rootDir = optionalPath(options.RootDir, prog.Host.GetCurrentDirectory())
+	files := prog.SourceFiles()
+	if out.rootDir == "" {
+		out.rootDir = commonSourceDir(files)
+	}
+	for _, file := range files {
+		name := normalizePath(file.FileName())
+		out.sourceFiles[name] = name
+		out.sourceFiles[stripKnownSourceExtension(name)] = name
+	}
+	if options.Paths != nil {
+		for pattern, targets := range options.Paths.Entries() {
+			out.patterns = append(out.patterns, pathsPattern{
+				pattern: pattern,
+				targets: append([]string(nil), targets...),
+			})
+		}
+	}
+	sort.SliceStable(out.patterns, func(i, j int) bool {
+		return patternRank(out.patterns[i].pattern) > patternRank(out.patterns[j].pattern)
+	})
+	return out
+}
+
+func (r *pathsRewriter) applyAll(files []*shimast.SourceFile) {
+	if r == nil || len(r.patterns) == 0 {
+		return
+	}
+	for _, file := range files {
+		r.apply(file)
+	}
+}
+
+func (r *pathsRewriter) apply(file *shimast.SourceFile) {
+	if r == nil || file == nil || len(r.patterns) == 0 {
+		return
+	}
+	visitModuleSpecifiers(file.AsNode(), func(lit *shimast.Node) {
+		if lit == nil || lit.Kind != shimast.KindStringLiteral {
+			return
+		}
+		spec := lit.Text()
+		rewritten, ok := r.rewrite(file.FileName(), spec)
+		if ok && rewritten != spec {
+			lit.AsStringLiteral().Text = rewritten
+			lit.Flags |= shimast.NodeFlagsSynthesized
+			lit.Loc = shimcore.UndefinedTextRange()
+		}
+	})
+}
+
+func visitModuleSpecifiers(node *shimast.Node, visit func(*shimast.Node)) {
+	if node == nil {
+		return
+	}
+	switch node.Kind {
+	case shimast.KindImportDeclaration:
+		visit(node.AsImportDeclaration().ModuleSpecifier)
+	case shimast.KindExportDeclaration:
+		visit(node.AsExportDeclaration().ModuleSpecifier)
+	case shimast.KindImportEqualsDeclaration:
+		ref := node.AsImportEqualsDeclaration().ModuleReference
+		if ref != nil && ref.Kind == shimast.KindExternalModuleReference {
+			visit(ref.AsExternalModuleReference().Expression)
+		}
+	case shimast.KindImportType:
+		arg := node.AsImportTypeNode().Argument
+		if arg != nil && arg.Kind == shimast.KindLiteralType {
+			visit(arg.AsLiteralTypeNode().Literal)
+		}
+	case shimast.KindModuleDeclaration:
+		decl := node.AsModuleDeclaration()
+		if decl != nil {
+			visit(decl.Name())
+		}
+	case shimast.KindCallExpression:
+		call := node.AsCallExpression()
+		if isModuleSpecifierCall(call) && call.Arguments != nil && len(call.Arguments.Nodes) > 0 {
+			visit(call.Arguments.Nodes[0])
+		}
+	}
+	node.ForEachChild(func(child *shimast.Node) bool {
+		visitModuleSpecifiers(child, visit)
+		return false
+	})
+}
+
+func isModuleSpecifierCall(call *shimast.CallExpression) bool {
+	if call == nil || call.Expression == nil {
+		return false
+	}
+	switch call.Expression.Kind {
+	case shimast.KindImportKeyword:
+		return true
+	case shimast.KindIdentifier:
+		return call.Expression.Text() == "require"
+	default:
+		return false
+	}
+}
+
+func (r *pathsRewriter) rewrite(fromSource string, specifier string) (string, bool) {
+	if specifier == "" || strings.HasPrefix(specifier, ".") || strings.HasPrefix(specifier, "/") {
+		return specifier, false
+	}
+	targetSource, ok := r.resolveSource(specifier)
+	if !ok {
+		return specifier, false
+	}
+	fromOut := r.outputPathForSource(fromSource)
+	targetOut := r.outputPathForSource(targetSource)
+	if fromOut == "" || targetOut == "" {
+		return specifier, false
+	}
+	rel, err := filepath.Rel(filepath.Dir(fromOut), targetOut)
+	if err != nil {
+		return specifier, false
+	}
+	rel = filepath.ToSlash(rel)
+	if !strings.HasPrefix(rel, ".") {
+		rel = "./" + rel
+	}
+	return rel, true
+}
+
+func (r *pathsRewriter) resolveSource(specifier string) (string, bool) {
+	for _, pattern := range r.patterns {
+		star, ok := matchPattern(pattern.pattern, specifier)
+		if !ok {
+			continue
+		}
+		for _, target := range pattern.targets {
+			candidate := strings.Replace(target, "*", star, 1)
+			resolved := normalizePath(filepath.Join(r.basePath, candidate))
+			if source, ok := r.lookupSource(resolved); ok {
+				return source, true
+			}
+		}
+	}
+	return "", false
+}
+
+func (r *pathsRewriter) lookupSource(candidate string) (string, bool) {
+	if source, ok := r.sourceFiles[normalizePath(candidate)]; ok {
+		return source, true
+	}
+	stem := stripKnownSourceExtension(normalizePath(candidate))
+	if source, ok := r.sourceFiles[stem]; ok {
+		return source, true
+	}
+	for _, ext := range []string{".ts", ".tsx", ".mts", ".cts"} {
+		if source, ok := r.sourceFiles[stem+ext]; ok {
+			return source, true
+		}
+	}
+	for _, ext := range []string{".ts", ".tsx", ".mts", ".cts"} {
+		if source, ok := r.sourceFiles[normalizePath(filepath.Join(stem, "index"+ext))]; ok {
+			return source, true
+		}
+	}
+	return "", false
+}
+
+func (r *pathsRewriter) outputPathForSource(source string) string {
+	if r.outDir == "" || r.rootDir == "" {
+		return ""
+	}
+	rel, err := filepath.Rel(r.rootDir, source)
+	if err != nil || isOutsideRelativePath(rel) {
+		return ""
+	}
+	return normalizePath(filepath.Join(r.outDir, replaceSourceExtension(rel, emittedJavaScriptExtension(rel))))
+}
+
+func emittedJavaScriptExtension(source string) string {
+	switch strings.ToLower(filepath.Ext(source)) {
+	case ".mts":
+		return ".mjs"
+	case ".cts":
+		return ".cjs"
+	default:
+		return ".js"
+	}
+}
+
+func matchPattern(pattern string, specifier string) (string, bool) {
+	if !strings.Contains(pattern, "*") {
+		return "", pattern == specifier
+	}
+	parts := strings.SplitN(pattern, "*", 2)
+	if !strings.HasPrefix(specifier, parts[0]) || !strings.HasSuffix(specifier, parts[1]) {
+		return "", false
+	}
+	return specifier[len(parts[0]) : len(specifier)-len(parts[1])], true
+}
+
+func patternRank(pattern string) int {
+	return len(strings.ReplaceAll(pattern, "*", ""))
+}
+
+func optionalPath(value string, cwd string) string {
+	if value == "" {
+		return ""
+	}
+	if filepath.IsAbs(value) {
+		return normalizePath(value)
+	}
+	return normalizePath(filepath.Join(cwd, value))
+}
+
+func commonSourceDir(files []*shimast.SourceFile) string {
+	if len(files) == 0 {
+		return ""
+	}
+	common := normalizePath(filepath.Dir(files[0].FileName()))
+	for _, file := range files[1:] {
+		dir := normalizePath(filepath.Dir(file.FileName()))
+		for common != "" && !strings.HasPrefix(dir+"/", common+"/") {
+			next := filepath.Dir(common)
+			if next == common {
+				return common
+			}
+			common = normalizePath(next)
+		}
+	}
+	return common
+}
+
+func normalizePath(value string) string {
+	if value == "" {
+		return ""
+	}
+	return filepath.ToSlash(filepath.Clean(value))
+}
+
+func isOutsideRelativePath(rel string) bool {
+	return rel == ".." || strings.HasPrefix(filepath.ToSlash(rel), "../")
+}
+
+func stripKnownSourceExtension(value string) string {
+	lower := strings.ToLower(value)
+	for _, ext := range []string{".d.ts", ".d.mts", ".d.cts", ".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"} {
+		if strings.HasSuffix(lower, ext) {
+			return value[:len(value)-len(ext)]
+		}
+	}
+	return strings.TrimSuffix(value, filepath.Ext(value))
+}
+
+func replaceSourceExtension(value string, ext string) string {
+	return stripKnownSourceExtension(filepath.ToSlash(value)) + ext
+}