resolver

Documentation

Index

• Variables
• func IsPackagePath(path string) bool
• type DataURL
  • func ParseDataURL(url string) (parsed DataURL, ok bool)
  • func (parsed DataURL) DecodeData() (string, error)
  • func (parsed DataURL) DecodeMIMEType() MIMEType
• type DebugMeta
  • func (dm DebugMeta) LogErrorMsg(log logger.Log, source *logger.Source, r logger.Range, text string, ...)
• type MIMEType
• type PathPair
  • func (pp *PathPair) HasSecondary() bool
• type ResolveResult
• type Resolver
  • func NewResolver(fs fs.FS, log logger.Log, caches *cache.CacheSet, options config.Options) *Resolver
  • func (res *Resolver) PrettyPath(path logger.Path) string
  • func (res *Resolver) ProbeResolvePackageAsRelative(sourceDir string, importPath string, kind ast.ImportKind) *ResolveResult
  • func (res *Resolver) Resolve(sourceDir string, importPath string, kind ast.ImportKind) (*ResolveResult, DebugMeta)
  • func (res *Resolver) ResolveAbs(absPath string) *ResolveResult
• type SideEffectsData
• type TSConfigJSON
  • func ParseTSConfigJSON(log logger.Log, source logger.Source, jsonCache *cache.JSONCache, ...) *TSConfigJSON
  • func (config *TSConfigJSON) TSAlwaysStrictOrStrict() *config.TSAlwaysStrict
• type TSConfigPath
• type TSConfigPaths

Variables

var BuiltInNodeModules = map[string]bool{
	"_http_agent":         true,
	"_http_client":        true,
	"_http_common":        true,
	"_http_incoming":      true,
	"_http_outgoing":      true,
	"_http_server":        true,
	"_stream_duplex":      true,
	"_stream_passthrough": true,
	"_stream_readable":    true,
	"_stream_transform":   true,
	"_stream_wrap":        true,
	"_stream_writable":    true,
	"_tls_common":         true,
	"_tls_wrap":           true,
	"assert":              true,
	"assert/strict":       true,
	"async_hooks":         true,
	"buffer":              true,
	"child_process":       true,
	"cluster":             true,
	"console":             true,
	"constants":           true,
	"crypto":              true,
	"dgram":               true,
	"diagnostics_channel": true,
	"dns":                 true,
	"dns/promises":        true,
	"domain":              true,
	"events":              true,
	"fs":                  true,
	"fs/promises":         true,
	"http":                true,
	"http2":               true,
	"https":               true,
	"inspector":           true,
	"module":              true,
	"net":                 true,
	"os":                  true,
	"path":                true,
	"path/posix":          true,
	"path/win32":          true,
	"perf_hooks":          true,
	"process":             true,
	"punycode":            true,
	"querystring":         true,
	"readline":            true,
	"repl":                true,
	"stream":              true,
	"stream/consumers":    true,
	"stream/promises":     true,
	"stream/web":          true,
	"string_decoder":      true,
	"sys":                 true,
	"timers":              true,
	"timers/promises":     true,
	"tls":                 true,
	"trace_events":        true,
	"tty":                 true,
	"url":                 true,
	"util":                true,
	"util/types":          true,
	"v8":                  true,
	"vm":                  true,
	"wasi":                true,
	"worker_threads":      true,
	"zlib":                true,
}

This list can be obtained with the following command:

node --experimental-wasi-unstable-preview1 -p "[...require('module').builtinModules].join('\n')"

Be sure to use the *LATEST* version of node when updating this list!

Functions

func IsPackagePath

func IsPackagePath(path string) bool

Package paths are loaded from a "node_modules" directory. Non-package paths are relative or absolute paths.

Types

type DataURL

type DataURL struct {
	// contains filtered or unexported fields
}

func ParseDataURL

func ParseDataURL(url string) (parsed DataURL, ok bool)

func (DataURL) DecodeData

func (parsed DataURL) DecodeData() (string, error)

func (DataURL) DecodeMIMEType

func (parsed DataURL) DecodeMIMEType() MIMEType

type DebugMeta

type DebugMeta struct {
	ModifiedImportPath string
	// contains filtered or unexported fields
}

func (DebugMeta) LogErrorMsg

func (dm DebugMeta) LogErrorMsg(log logger.Log, source *logger.Source, r logger.Range, text string, suggestion string, notes []logger.MsgData)

type MIMEType

type MIMEType uint8

const (
	MIMETypeUnsupported MIMEType = iota
	MIMETypeTextCSS
	MIMETypeTextJavaScript
	MIMETypeApplicationJSON
)

type PathPair

type PathPair struct {
	// Either secondary will be empty, or primary will be "module" and secondary
	// will be "main"
	Primary   logger.Path
	Secondary logger.Path
}

Path resolution is a mess. One tricky issue is the "module" override for the "main" field in "package.json" files. Bundlers generally prefer "module" over "main" but that breaks packages that export a function in "main" for use with "require()", since resolving to "module" means an object will be returned. We attempt to handle this automatically by having import statements resolve to "module" but switch that out later for "main" if "require()" is used too.

func (*PathPair) HasSecondary

func (pp *PathPair) HasSecondary() bool

type ResolveResult

type ResolveResult struct {
	PathPair PathPair

	// If this was resolved by a plugin, the plugin gets to store its data here
	PluginData interface{}

	// If not empty, these should override the default values
	JSXFactory      []string // Default if empty: "React.createElement"
	JSXFragment     []string // Default if empty: "React.Fragment"
	JSXImportSource string   // Default if empty: "react"
	JSX             config.TSJSX

	DifferentCase *fs.DifferentCase

	// If present, any ES6 imports to this file can be considered to have no side
	// effects. This means they should be removed if unused.
	PrimarySideEffectsData *SideEffectsData

	// These are from "tsconfig.json"
	TSTarget       *config.TSTarget
	TSAlwaysStrict *config.TSAlwaysStrict

	// This is the "type" field from "package.json"
	ModuleTypeData js_ast.ModuleTypeData

	IsExternal bool

	// If true, the class field transform should use Object.defineProperty().
	UseDefineForClassFieldsTS config.MaybeBool

	// This is the "importsNotUsedAsValues" and "preserveValueImports" fields from "package.json"
	UnusedImportFlagsTS config.UnusedImportFlagsTS
}

type Resolver

type Resolver struct {
	// contains filtered or unexported fields
}

func NewResolver

func NewResolver(fs fs.FS, log logger.Log, caches *cache.CacheSet, options config.Options) *Resolver

func (*Resolver) PrettyPath

func (res *Resolver) PrettyPath(path logger.Path) string

func (*Resolver) ProbeResolvePackageAsRelative

func (res *Resolver) ProbeResolvePackageAsRelative(sourceDir string, importPath string, kind ast.ImportKind) *ResolveResult

This tries to run "Resolve" on a package path as a relative path. If successful, the user just forgot a leading "./" in front of the path.

func (*Resolver) Resolve

func (res *Resolver) Resolve(sourceDir string, importPath string, kind ast.ImportKind) (*ResolveResult, DebugMeta)

func (*Resolver) ResolveAbs

func (res *Resolver) ResolveAbs(absPath string) *ResolveResult

type SideEffectsData

type SideEffectsData struct {
	Source *logger.Source

	// If non-empty, this false value came from a plugin
	PluginName string

	Range logger.Range

	// If true, "sideEffects" was an array. If false, "sideEffects" was false.
	IsSideEffectsArrayInJSON bool
}

type TSConfigJSON

type TSConfigJSON struct {
	AbsPath string

	// The absolute path of "compilerOptions.baseUrl"
	BaseURL *string

	// This is used if "Paths" is non-nil. It's equal to "BaseURL" except if
	// "BaseURL" is missing, in which case it is as if "BaseURL" was ".". This
	// is to implement the "paths without baseUrl" feature from TypeScript 4.1.
	// More info: https://github.com/microsoft/TypeScript/issues/31869
	BaseURLForPaths string

	// The verbatim values of "compilerOptions.paths". The keys are patterns to
	// match and the values are arrays of fallback paths to search. Each key and
	// each fallback path can optionally have a single "*" wildcard character.
	// If both the key and the value have a wildcard, the substring matched by
	// the wildcard is substituted into the fallback path. The keys represent
	// module-style path names and the fallback paths are relative to the
	// "baseUrl" value in the "tsconfig.json" file.
	Paths *TSConfigPaths

	TSTarget                       *config.TSTarget
	TSStrict                       *config.TSAlwaysStrict
	TSAlwaysStrict                 *config.TSAlwaysStrict
	JSX                            config.TSJSX
	JSXFactory                     []string
	JSXFragmentFactory             []string
	JSXImportSource                string
	ModuleSuffixes                 []string
	UseDefineForClassFields        config.MaybeBool
	PreserveImportsNotUsedAsValues bool
	PreserveValueImports           bool
}

func ParseTSConfigJSON

func ParseTSConfigJSON(
	log logger.Log,
	source logger.Source,
	jsonCache *cache.JSONCache,
	extends func(string, logger.Range) *TSConfigJSON,
) *TSConfigJSON

func (*TSConfigJSON) TSAlwaysStrictOrStrict

func (config *TSConfigJSON) TSAlwaysStrictOrStrict() *config.TSAlwaysStrict

type TSConfigPath

type TSConfigPath struct {
	Text string
	Loc  logger.Loc
}

type TSConfigPaths

type TSConfigPaths struct {
	Map map[string][]TSConfigPath

	// This may be different from the original "tsconfig.json" source if the
	// "paths" value is from another file via an "extends" clause.
	Source logger.Source
}