vendor tsgo

tools/tsgo/internal/module/util.go

@@ -0,0 +1,197 @@
+package module
+
+import (
+	"strings"
+
+	"github.com/microsoft/typescript-go/internal/ast"
+	"github.com/microsoft/typescript-go/internal/core"
+	"github.com/microsoft/typescript-go/internal/diagnostics"
+	"github.com/microsoft/typescript-go/internal/semver"
+	"github.com/microsoft/typescript-go/internal/tspath"
+)
+
+var typeScriptVersion = semver.MustParse(core.Version())
+
+const InferredTypesContainingFile = "__inferred type names__.ts"
+
+func IsApplicableVersionedTypesKey(key string) bool {
+	if !strings.HasPrefix(key, "types@") {
+		return false
+	}
+	range_, ok := semver.TryParseVersionRange(key[len("types@"):])
+	if !ok {
+		return false
+	}
+	return range_.Test(&typeScriptVersion)
+}
+
+func ParseNodeModuleFromPath(resolved string, isFolder bool) string {
+	path := tspath.NormalizePath(resolved)
+	idx := strings.LastIndex(path, "/node_modules/")
+	if idx == -1 {
+		return ""
+	}
+
+	indexAfterNodeModules := idx + len("/node_modules/")
+	indexAfterPackageName := moveToNextDirectorySeparatorIfAvailable(path, indexAfterNodeModules, isFolder)
+	if path[indexAfterNodeModules] == '@' {
+		indexAfterPackageName = moveToNextDirectorySeparatorIfAvailable(path, indexAfterPackageName, isFolder)
+	}
+	return path[:indexAfterPackageName]
+}
+
+func ParsePackageName(moduleName string) (packageName, rest string) {
+	idx := strings.Index(moduleName, "/")
+	if len(moduleName) > 0 && moduleName[0] == '@' {
+		offset := idx + 1
+		idx = strings.Index(moduleName[offset:], "/")
+		if idx != -1 {
+			idx += offset
+		}
+	}
+	if idx == -1 {
+		return moduleName, ""
+	}
+	return moduleName[:idx], moduleName[idx+1:]
+}
+
+func MangleScopedPackageName(packageName string) string {
+	if len(packageName) > 0 && packageName[0] == '@' {
+		idx := strings.Index(packageName, "/")
+		if idx == -1 {
+			return packageName
+		}
+		return packageName[1:idx] + "__" + packageName[idx+1:]
+	}
+	return packageName
+}
+
+func UnmangleScopedPackageName(packageName string) string {
+	before, after, ok := strings.Cut(packageName, "__")
+	if ok {
+		return "@" + before + "/" + after
+	}
+	return packageName
+}
+
+func GetTypesPackageName(packageName string) string {
+	return "@types/" + MangleScopedPackageName(packageName)
+}
+
+func GetPackageNameFromTypesPackageName(mangledName string) string {
+	withoutAtTypePrefix := strings.TrimPrefix(mangledName, "@types/")
+	if withoutAtTypePrefix != mangledName {
+		return UnmangleScopedPackageName(withoutAtTypePrefix)
+	}
+	return mangledName
+}
+
+func ComparePatternKeys(a, b string) int {
+	aPatternIndex := strings.Index(a, "*")
+	bPatternIndex := strings.Index(b, "*")
+	baseLenA := len(a)
+	if aPatternIndex != -1 {
+		baseLenA = aPatternIndex + 1
+	}
+	baseLenB := len(b)
+	if bPatternIndex != -1 {
+		baseLenB = bPatternIndex + 1
+	}
+
+	if baseLenA > baseLenB {
+		return -1
+	}
+	if baseLenB > baseLenA {
+		return 1
+	}
+	if aPatternIndex == -1 {
+		return 1
+	}
+	if bPatternIndex == -1 {
+		return -1
+	}
+	if len(a) > len(b) {
+		return -1
+	}
+	if len(b) > len(a) {
+		return 1
+	}
+	return 0
+}
+
+// Returns a DiagnosticMessage if we won't include a resolved module due to its extension.
+// The DiagnosticMessage's parameters are the imported module name, and the filename it resolved to.
+// This returns a diagnostic even if the module will be an untyped module.
+func GetResolutionDiagnostic(options *core.CompilerOptions, resolvedModule *ResolvedModule, file *ast.SourceFile) *diagnostics.Message {
+	needJsx := func() *diagnostics.Message {
+		if options.Jsx != core.JsxEmitNone {
+			return nil
+		}
+		return diagnostics.Module_0_was_resolved_to_1_but_jsx_is_not_set
+	}
+
+	needAllowJs := func() *diagnostics.Message {
+		if options.GetAllowJS() || !options.NoImplicitAny.DefaultIfUnknown(options.Strict).IsTrue() {
+			return nil
+		}
+		return diagnostics.Could_not_find_a_declaration_file_for_module_0_1_implicitly_has_an_any_type
+	}
+
+	needResolveJsonModule := func() *diagnostics.Message {
+		if options.GetResolveJsonModule() {
+			return nil
+		}
+		return diagnostics.Module_0_was_resolved_to_1_but_resolveJsonModule_is_not_used
+	}
+
+	needAllowArbitraryExtensions := func() *diagnostics.Message {
+		if file.IsDeclarationFile || options.AllowArbitraryExtensions.IsTrue() {
+			return nil
+		}
+		return diagnostics.Module_0_was_resolved_to_1_but_allowArbitraryExtensions_is_not_set
+	}
+
+	switch resolvedModule.Extension {
+	case tspath.ExtensionTs, tspath.ExtensionDts,
+		tspath.ExtensionMts, tspath.ExtensionDmts,
+		tspath.ExtensionCts, tspath.ExtensionDcts:
+		// These are always allowed.
+		return nil
+	case tspath.ExtensionTsx:
+		return needJsx()
+	case tspath.ExtensionJsx:
+		if message := needJsx(); message != nil {
+			return message
+		}
+		return needAllowJs()
+	case tspath.ExtensionJs, tspath.ExtensionMjs, tspath.ExtensionCjs:
+		return needAllowJs()
+	case tspath.ExtensionJson:
+		return needResolveJsonModule()
+	default:
+		return needAllowArbitraryExtensions()
+	}
+}
+
+// TryGetJSExtensionForFile maps TS/JS/DTS extensions to the output JS-side extension.
+// Returns an empty string if the extension is unsupported.
+func TryGetJSExtensionForFile(fileName string, options *core.CompilerOptions) string {
+	ext := tspath.TryGetExtensionFromPath(fileName)
+	switch ext {
+	case tspath.ExtensionTs, tspath.ExtensionDts:
+		return tspath.ExtensionJs
+	case tspath.ExtensionTsx:
+		if options.Jsx == core.JsxEmitPreserve {
+			return tspath.ExtensionJsx
+		}
+		return tspath.ExtensionJs
+	case tspath.ExtensionJs, tspath.ExtensionJsx, tspath.ExtensionJson:
+		return ext
+	case tspath.ExtensionDmts, tspath.ExtensionMts, tspath.ExtensionMjs:
+		return tspath.ExtensionMjs
+	case tspath.ExtensionDcts, tspath.ExtensionCts, tspath.ExtensionCjs:
+		return tspath.ExtensionCjs
+	default:
+		return ""
+	}
+}