vendor tsgo
This commit is contained in:
502
tools/tsgo/internal/modulespecifiers/util.go
Normal file
502
tools/tsgo/internal/modulespecifiers/util.go
Normal file
@@ -0,0 +1,502 @@
|
||||
package modulespecifiers
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"regexp"
|
||||
"slices"
|
||||
"strings"
|
||||
"sync"
|
||||
|
||||
"github.com/microsoft/typescript-go/internal/ast"
|
||||
"github.com/microsoft/typescript-go/internal/collections"
|
||||
"github.com/microsoft/typescript-go/internal/core"
|
||||
"github.com/microsoft/typescript-go/internal/module"
|
||||
"github.com/microsoft/typescript-go/internal/packagejson"
|
||||
"github.com/microsoft/typescript-go/internal/tsoptions"
|
||||
"github.com/microsoft/typescript-go/internal/tspath"
|
||||
)
|
||||
|
||||
type regexPatternCacheKey struct {
|
||||
pattern string
|
||||
caseInsensitive bool
|
||||
}
|
||||
|
||||
var (
|
||||
regexPatternCacheMu sync.RWMutex
|
||||
regexPatternCache = make(map[regexPatternCacheKey]*regexp.Regexp)
|
||||
)
|
||||
|
||||
func comparePathsByRedirect(a ModulePath, b ModulePath, useCaseSensitiveFileNames bool) int {
|
||||
// Redirects sort first, matching Strada's compareBooleans(b.isRedirect, a.isRedirect).
|
||||
if c := core.CompareBooleans(b.IsRedirect, a.IsRedirect); c != 0 {
|
||||
return c
|
||||
}
|
||||
if c := tspath.CompareNumberOfDirectorySeparators(a.FileName, b.FileName); c != 0 {
|
||||
return c
|
||||
}
|
||||
// Strada relies on Map insertion order to break remaining ties deterministically;
|
||||
// Go maps are unordered, so compare paths to keep the ordering stable.
|
||||
return tspath.ComparePaths(a.FileName, b.FileName, tspath.ComparePathsOptions{UseCaseSensitiveFileNames: useCaseSensitiveFileNames})
|
||||
}
|
||||
|
||||
func PathIsBareSpecifier(path string) bool {
|
||||
return !tspath.PathIsAbsolute(path) && !tspath.PathIsRelative(path)
|
||||
}
|
||||
|
||||
func IsExcludedByRegex(moduleSpecifier string, excludes []string) bool {
|
||||
for _, pattern := range excludes {
|
||||
re := stringToRegex(pattern)
|
||||
if re == nil {
|
||||
continue
|
||||
}
|
||||
if re.MatchString(moduleSpecifier) {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func stringToRegex(pattern string) *regexp.Regexp {
|
||||
caseInsensitive := false
|
||||
|
||||
if len(pattern) > 2 && pattern[0] == '/' {
|
||||
lastSlash := strings.LastIndex(pattern, "/")
|
||||
if lastSlash > 0 {
|
||||
hasUnescapedMiddleSlash := false
|
||||
for i := 1; i < lastSlash; i++ {
|
||||
if pattern[i] == '/' && (i == 0 || pattern[i-1] != '\\') {
|
||||
hasUnescapedMiddleSlash = true
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
if !hasUnescapedMiddleSlash {
|
||||
flags := pattern[lastSlash+1:]
|
||||
pattern = pattern[1:lastSlash]
|
||||
|
||||
for _, flag := range flags {
|
||||
switch flag {
|
||||
case 'i':
|
||||
caseInsensitive = true
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
key := regexPatternCacheKey{pattern, caseInsensitive}
|
||||
|
||||
regexPatternCacheMu.RLock()
|
||||
re, ok := regexPatternCache[key]
|
||||
regexPatternCacheMu.RUnlock()
|
||||
if ok {
|
||||
return re
|
||||
}
|
||||
|
||||
regexPatternCacheMu.Lock()
|
||||
defer regexPatternCacheMu.Unlock()
|
||||
|
||||
re, ok = regexPatternCache[key]
|
||||
if ok {
|
||||
return re
|
||||
}
|
||||
|
||||
if len(regexPatternCache) > 1000 {
|
||||
clear(regexPatternCache)
|
||||
}
|
||||
|
||||
pattern = strings.Clone(pattern)
|
||||
key.pattern = pattern
|
||||
|
||||
compilePattern := pattern
|
||||
if caseInsensitive {
|
||||
compilePattern = "(?i:" + pattern + ")"
|
||||
}
|
||||
|
||||
compiled, err := regexp.Compile(compilePattern)
|
||||
if err != nil {
|
||||
regexPatternCache[key] = nil
|
||||
return nil
|
||||
}
|
||||
regexPatternCache[key] = compiled
|
||||
return compiled
|
||||
}
|
||||
|
||||
/**
|
||||
* Ensures a path is either absolute (prefixed with `/` or `c:`) or dot-relative (prefixed
|
||||
* with `./` or `../`) so as not to be confused with an unprefixed module name.
|
||||
*
|
||||
* ```ts
|
||||
* ensurePathIsNonModuleName("/path/to/file.ext") === "/path/to/file.ext"
|
||||
* ensurePathIsNonModuleName("./path/to/file.ext") === "./path/to/file.ext"
|
||||
* ensurePathIsNonModuleName("../path/to/file.ext") === "../path/to/file.ext"
|
||||
* ensurePathIsNonModuleName("path/to/file.ext") === "./path/to/file.ext"
|
||||
* ```
|
||||
*
|
||||
*/
|
||||
func ensurePathIsNonModuleName(path string) string {
|
||||
if PathIsBareSpecifier(path) {
|
||||
return "./" + path
|
||||
}
|
||||
return path
|
||||
}
|
||||
|
||||
func GetJSExtensionForDeclarationFileExtension(ext string) string {
|
||||
switch ext {
|
||||
case tspath.ExtensionDts:
|
||||
return tspath.ExtensionJs
|
||||
case tspath.ExtensionDmts:
|
||||
return tspath.ExtensionMjs
|
||||
case tspath.ExtensionDcts:
|
||||
return tspath.ExtensionCjs
|
||||
default:
|
||||
// .d.json.ts and the like
|
||||
return ext[len(".d") : len(ext)-len(tspath.ExtensionTs)]
|
||||
}
|
||||
}
|
||||
|
||||
// TryGetRealFileNameForNonJSDeclarationFileName remaps files like `foo.d.json.ts` or
|
||||
// `foo.module.d.css.ts` back to their real non-JS names.
|
||||
func TryGetRealFileNameForNonJSDeclarationFileName(fileName string) string {
|
||||
baseName := tspath.GetBaseFileName(fileName)
|
||||
// Ends with .ts, contains ".d.", and is NOT a standard .d.ts file
|
||||
if !strings.HasSuffix(fileName, tspath.ExtensionTs) ||
|
||||
!strings.Contains(baseName, ".d.") ||
|
||||
strings.HasSuffix(baseName, tspath.ExtensionDts) {
|
||||
return ""
|
||||
}
|
||||
noExtension := tspath.RemoveExtension(fileName, tspath.ExtensionTs)
|
||||
lastDotIndex := strings.LastIndex(noExtension, ".")
|
||||
ext := noExtension[lastDotIndex:]
|
||||
before, _, _ := strings.Cut(noExtension, ".d.")
|
||||
return before + ext
|
||||
}
|
||||
|
||||
func getJSExtensionForFile(fileName string, options *core.CompilerOptions) string {
|
||||
result := module.TryGetJSExtensionForFile(fileName, options)
|
||||
if len(result) == 0 {
|
||||
panic(fmt.Sprintf("Extension %s is unsupported:: FileName:: %s", extensionFromPath(fileName), fileName))
|
||||
}
|
||||
return result
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the extension from a path.
|
||||
* Path must have a valid extension.
|
||||
*/
|
||||
func extensionFromPath(path string) string {
|
||||
ext := tspath.TryGetExtensionFromPath(path)
|
||||
if len(ext) == 0 {
|
||||
panic(fmt.Sprintf("File %s has unknown extension.", path))
|
||||
}
|
||||
return ext
|
||||
}
|
||||
|
||||
func tryGetAnyFileFromPath(host ModuleSpecifierGenerationHost, path string) bool {
|
||||
// !!! TODO: shouldn't this use readdir instead of fileexists for perf?
|
||||
// We check all js, `node` and `json` extensions in addition to TS, since node module resolution would also choose those over the directory
|
||||
extGroups := tsoptions.GetSupportedExtensions(
|
||||
&core.CompilerOptions{
|
||||
AllowJs: core.TSTrue,
|
||||
},
|
||||
[]tsoptions.FileExtensionInfo{
|
||||
{
|
||||
Extension: "node",
|
||||
IsMixedContent: false,
|
||||
ScriptKind: core.ScriptKindExternal,
|
||||
},
|
||||
{
|
||||
Extension: "json",
|
||||
IsMixedContent: false,
|
||||
ScriptKind: core.ScriptKindJSON,
|
||||
},
|
||||
},
|
||||
)
|
||||
for _, exts := range extGroups {
|
||||
for _, e := range exts {
|
||||
fullPath := path + e
|
||||
if host.FileExists(tspath.GetNormalizedAbsolutePath(fullPath, host.GetCurrentDirectory())) {
|
||||
return true
|
||||
}
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func getPathsRelativeToRootDirs(path string, rootDirs []string, useCaseSensitiveFileNames bool) []string {
|
||||
var results []string
|
||||
for _, rootDir := range rootDirs {
|
||||
relativePath := getRelativePathIfInSameVolume(path, rootDir, useCaseSensitiveFileNames)
|
||||
if !isPathRelativeToParent(relativePath) {
|
||||
results = append(results, relativePath)
|
||||
}
|
||||
}
|
||||
return results
|
||||
}
|
||||
|
||||
func isPathRelativeToParent(path string) bool {
|
||||
return strings.HasPrefix(path, "..")
|
||||
}
|
||||
|
||||
func getRelativePathIfInSameVolume(path string, directoryPath string, useCaseSensitiveFileNames bool) string {
|
||||
relativePath := tspath.GetRelativePathToDirectoryOrUrl(directoryPath, path, false, tspath.ComparePathsOptions{
|
||||
UseCaseSensitiveFileNames: useCaseSensitiveFileNames,
|
||||
CurrentDirectory: directoryPath,
|
||||
})
|
||||
if tspath.IsRootedDiskPath(relativePath) {
|
||||
return ""
|
||||
}
|
||||
return relativePath
|
||||
}
|
||||
|
||||
func packageJsonPathsAreEqual(a string, b string, options tspath.ComparePathsOptions) bool {
|
||||
if a == b {
|
||||
return true
|
||||
}
|
||||
if len(a) == 0 || len(b) == 0 {
|
||||
return false
|
||||
}
|
||||
return tspath.ComparePaths(a, b, options) == 0
|
||||
}
|
||||
|
||||
func prefersTsExtension(allowedEndings []ModuleSpecifierEnding) bool {
|
||||
jsPriority := slices.Index(allowedEndings, ModuleSpecifierEndingJsExtension)
|
||||
tsPriority := slices.Index(allowedEndings, ModuleSpecifierEndingTsExtension)
|
||||
if tsPriority > -1 {
|
||||
return tsPriority < jsPriority
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func replaceFirstStar(s string, replacement string) string {
|
||||
return strings.Replace(s, "*", replacement, 1)
|
||||
}
|
||||
|
||||
type NodeModulePathParts struct {
|
||||
TopLevelNodeModulesIndex int
|
||||
TopLevelPackageNameIndex int
|
||||
PackageRootIndex int
|
||||
FileNameIndex int
|
||||
}
|
||||
|
||||
type nodeModulesPathParseState uint8
|
||||
|
||||
const (
|
||||
nodeModulesPathParseStateBeforeNodeModules nodeModulesPathParseState = iota
|
||||
nodeModulesPathParseStateNodeModules
|
||||
nodeModulesPathParseStateScope
|
||||
nodeModulesPathParseStatePackageContent
|
||||
)
|
||||
|
||||
func GetNodeModulePathParts(fullPath string) *NodeModulePathParts {
|
||||
// If fullPath can't be valid module file within node_modules, returns undefined.
|
||||
// Example of expected pattern: /base/path/node_modules/[@scope/otherpackage/@otherscope/node_modules/]package/[subdirectory/]file.js
|
||||
// Returns indices: ^ ^ ^ ^
|
||||
|
||||
topLevelNodeModulesIndex := 0
|
||||
topLevelPackageNameIndex := 0
|
||||
packageRootIndex := 0
|
||||
fileNameIndex := 0
|
||||
|
||||
partStart := 0
|
||||
partEnd := 0
|
||||
state := nodeModulesPathParseStateBeforeNodeModules
|
||||
|
||||
for partEnd >= 0 {
|
||||
partStart = partEnd
|
||||
partEnd = core.IndexAfter(fullPath, "/", partStart+1)
|
||||
switch state {
|
||||
case nodeModulesPathParseStateBeforeNodeModules:
|
||||
if strings.Index(fullPath[partStart:], "/node_modules/") == 0 {
|
||||
topLevelNodeModulesIndex = partStart
|
||||
topLevelPackageNameIndex = partEnd
|
||||
state = nodeModulesPathParseStateNodeModules
|
||||
}
|
||||
case nodeModulesPathParseStateNodeModules, nodeModulesPathParseStateScope:
|
||||
if state == nodeModulesPathParseStateNodeModules && fullPath[partStart+1] == '@' {
|
||||
state = nodeModulesPathParseStateScope
|
||||
} else {
|
||||
packageRootIndex = partEnd
|
||||
state = nodeModulesPathParseStatePackageContent
|
||||
}
|
||||
case nodeModulesPathParseStatePackageContent:
|
||||
if strings.Index(fullPath[partStart:], "/node_modules/") == 0 {
|
||||
state = nodeModulesPathParseStateNodeModules
|
||||
} else {
|
||||
state = nodeModulesPathParseStatePackageContent
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fileNameIndex = partStart
|
||||
|
||||
if state > nodeModulesPathParseStateNodeModules {
|
||||
return &NodeModulePathParts{
|
||||
TopLevelNodeModulesIndex: topLevelNodeModulesIndex,
|
||||
TopLevelPackageNameIndex: topLevelPackageNameIndex,
|
||||
PackageRootIndex: packageRootIndex,
|
||||
FileNameIndex: fileNameIndex,
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func GetNodeModulesPackageName(
|
||||
compilerOptions *core.CompilerOptions,
|
||||
importingSourceFile *ast.SourceFile, // !!! | FutureSourceFile
|
||||
nodeModulesFileName string,
|
||||
host ModuleSpecifierGenerationHost,
|
||||
preferences UserPreferences,
|
||||
options ModuleSpecifierOptions,
|
||||
) string {
|
||||
info := getInfo(importingSourceFile.FileName(), host)
|
||||
modulePaths := getAllModulePaths(info, nodeModulesFileName, host, compilerOptions, preferences, options)
|
||||
for _, modulePath := range modulePaths {
|
||||
if result := tryGetModuleNameAsNodeModule(modulePath, info, importingSourceFile, host, compilerOptions, preferences, true /*packageNameOnly*/, options.OverrideImportMode); len(result) > 0 {
|
||||
return result
|
||||
}
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
func allKeysStartWithDot(obj *collections.OrderedMap[string, packagejson.ExportsOrImports]) bool {
|
||||
for k := range obj.Keys() {
|
||||
if !strings.HasPrefix(k, ".") {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
func GetPackageNameFromDirectory(fileOrDirectoryPath string) string {
|
||||
idx := strings.LastIndex(fileOrDirectoryPath, "/node_modules/")
|
||||
if idx == -1 {
|
||||
return ""
|
||||
}
|
||||
|
||||
basename := fileOrDirectoryPath[idx+len("/node_modules/"):]
|
||||
if basename[0] == '.' {
|
||||
return ""
|
||||
}
|
||||
|
||||
nextSlash := strings.Index(basename, "/")
|
||||
if nextSlash == -1 {
|
||||
return basename
|
||||
}
|
||||
|
||||
if basename[0] != '@' || nextSlash == len(basename)-1 {
|
||||
return basename[:nextSlash]
|
||||
}
|
||||
|
||||
secondSlash := strings.Index(basename[nextSlash+1:], "/")
|
||||
if secondSlash == -1 {
|
||||
return basename
|
||||
}
|
||||
|
||||
return basename[:nextSlash+1+secondSlash]
|
||||
}
|
||||
|
||||
// ProcessEntrypointEnding processes a pre-computed module specifier from a package.json exports
|
||||
// entrypoint according to the entrypoint's Ending type and the user's preferred endings.
|
||||
func ProcessEntrypointEnding(
|
||||
entrypoint *module.ResolvedEntrypoint,
|
||||
prefs UserPreferences,
|
||||
host ModuleSpecifierGenerationHost,
|
||||
options *core.CompilerOptions,
|
||||
importingSourceFile SourceFileForSpecifierGeneration,
|
||||
allowedEndings []ModuleSpecifierEnding,
|
||||
) string {
|
||||
specifier := entrypoint.ModuleSpecifier
|
||||
if entrypoint.Ending == module.EndingFixed {
|
||||
return specifier
|
||||
}
|
||||
|
||||
if len(allowedEndings) == 0 {
|
||||
allowedEndings = GetAllowedEndingsInPreferredOrder(
|
||||
prefs,
|
||||
host,
|
||||
options,
|
||||
importingSourceFile,
|
||||
"",
|
||||
host.GetDefaultResolutionModeForFile(importingSourceFile),
|
||||
)
|
||||
}
|
||||
|
||||
preferredEnding := allowedEndings[0]
|
||||
|
||||
// Handle declaration file extensions
|
||||
dtsExtension := tspath.GetDeclarationFileExtension(specifier)
|
||||
if dtsExtension != "" {
|
||||
switch preferredEnding {
|
||||
case ModuleSpecifierEndingTsExtension, ModuleSpecifierEndingJsExtension:
|
||||
// Map .d.ts -> .js, .d.mts -> .mjs, .d.cts -> .cjs
|
||||
jsExtension := GetJSExtensionForDeclarationFileExtension(dtsExtension)
|
||||
return tspath.ChangeAnyExtension(specifier, jsExtension, []string{dtsExtension}, false)
|
||||
case ModuleSpecifierEndingMinimal, ModuleSpecifierEndingIndex:
|
||||
if entrypoint.Ending == module.EndingChangeable {
|
||||
// .d.mts/.d.cts must keep an extension; rewrite to .mjs/.cjs instead of dropping
|
||||
if dtsExtension == tspath.ExtensionDts {
|
||||
specifier = tspath.RemoveExtension(specifier, dtsExtension)
|
||||
if preferredEnding == ModuleSpecifierEndingMinimal {
|
||||
specifier = strings.TrimSuffix(specifier, "/index")
|
||||
}
|
||||
return specifier
|
||||
}
|
||||
jsExtension := GetJSExtensionForDeclarationFileExtension(dtsExtension)
|
||||
return tspath.ChangeAnyExtension(specifier, jsExtension, []string{dtsExtension}, false)
|
||||
}
|
||||
// EndingExtensionChangeable - can only change extension, not remove it
|
||||
jsExtension := GetJSExtensionForDeclarationFileExtension(dtsExtension)
|
||||
return tspath.ChangeAnyExtension(specifier, jsExtension, []string{dtsExtension}, false)
|
||||
}
|
||||
return specifier
|
||||
}
|
||||
|
||||
// Handle .ts/.tsx/.mts/.cts extensions
|
||||
if tspath.FileExtensionIsOneOf(specifier, []string{tspath.ExtensionTs, tspath.ExtensionTsx, tspath.ExtensionMts, tspath.ExtensionCts}) {
|
||||
switch preferredEnding {
|
||||
case ModuleSpecifierEndingTsExtension:
|
||||
return specifier
|
||||
case ModuleSpecifierEndingJsExtension:
|
||||
if jsExtension := module.TryGetJSExtensionForFile(specifier, options); jsExtension != "" {
|
||||
return tspath.RemoveFileExtension(specifier) + jsExtension
|
||||
}
|
||||
return specifier
|
||||
case ModuleSpecifierEndingMinimal, ModuleSpecifierEndingIndex:
|
||||
if entrypoint.Ending == module.EndingChangeable {
|
||||
specifier = tspath.RemoveFileExtension(specifier)
|
||||
if preferredEnding == ModuleSpecifierEndingMinimal {
|
||||
specifier = strings.TrimSuffix(specifier, "/index")
|
||||
}
|
||||
return specifier
|
||||
}
|
||||
// EndingExtensionChangeable - can only change extension, not remove it
|
||||
if jsExtension := module.TryGetJSExtensionForFile(specifier, options); jsExtension != "" {
|
||||
return tspath.RemoveFileExtension(specifier) + jsExtension
|
||||
}
|
||||
return specifier
|
||||
}
|
||||
return specifier
|
||||
}
|
||||
|
||||
// Handle .js/.jsx/.mjs/.cjs extensions
|
||||
if tspath.FileExtensionIsOneOf(specifier, []string{tspath.ExtensionJs, tspath.ExtensionJsx, tspath.ExtensionMjs, tspath.ExtensionCjs}) {
|
||||
switch preferredEnding {
|
||||
case ModuleSpecifierEndingTsExtension, ModuleSpecifierEndingJsExtension:
|
||||
return specifier
|
||||
case ModuleSpecifierEndingMinimal, ModuleSpecifierEndingIndex:
|
||||
if entrypoint.Ending == module.EndingChangeable {
|
||||
specifier = tspath.RemoveFileExtension(specifier)
|
||||
if preferredEnding == ModuleSpecifierEndingMinimal {
|
||||
specifier = strings.TrimSuffix(specifier, "/index")
|
||||
}
|
||||
return specifier
|
||||
}
|
||||
// EndingExtensionChangeable - keep the extension
|
||||
return specifier
|
||||
}
|
||||
return specifier
|
||||
}
|
||||
|
||||
// For other extensions (like .json), return as-is
|
||||
return specifier
|
||||
}
|
||||
Reference in New Issue
Block a user