js

Documentation

Index

• Variables
• func MakeJsLanguage(cfg *Config) (language.Language, error)
• type CompilerOptions
• type Config
• type ExportsCacheKey
• type Language
  • func (l *Language) ParseExports(file *language.FileInfo) (*language.ExportsResult, error)
  • func (l *Language) ParseFile(id string) (*language.FileInfo, error)
  • func (l *Language) ParseImports(file *language.FileInfo) (*language.ImportsResult, error)
  • func (l *Language) ResolvePath(unresolved string, dir string) (string, error)
• type TsConfig
  • func ParseTsConfig(filePath string) (TsConfig, error)
  • func (t *TsConfig) ResolveFromBaseUrl(unresolved string) string
  • func (t *TsConfig) ResolveFromPaths(unresolved string) (string, error)
• type Workspaces
  • func (w *Workspaces) ResolveFromWorkspaces(unresolved string) (string, error)

Variables

var Extensions = []string{
	"js", "ts", "tsx", "jsx", "d.ts", "mjs", "cjs",
}

var NewWorkspaces = utils.Cached1In1OutErr(func(searchPath string) (*Workspaces, error) {
	searchPath, err := filepath.Abs(searchPath)
	if err != nil {
		return nil, err
	}
	rootPackageJson, err := searchFirstPackageJsonWithWorkspaces(searchPath)
	if err != nil {
		return nil, err
	}
	if rootPackageJson == nil {
		return nil, nil
	}
	dirsWithAPackageJson, err := allDirsWithAPackageJson(rootPackageJson.absPath)
	workspacesMap := map[string]*packageJson{}

	for _, dir := range dirsWithAPackageJson {
		for _, ws := range rootPackageJson.workspaces() {
			rel, _ := filepath.Rel(rootPackageJson.absPath, dir)
			match, err := utils.GlobstarMatch(ws, rel)
			if err != nil {
				return nil, err
			}
			if match {
				pkgJson, err := readPackageJson(dir)
				if err != nil {
					return nil, err
				}
				workspacesMap[pkgJson.Name] = pkgJson
			}
		}
	}
	return &Workspaces{ws: workspacesMap}, nil
})

Functions

func MakeJsLanguage

func MakeJsLanguage(cfg *Config) (language.Language, error)

Types

type CompilerOptions

type CompilerOptions struct {
	BaseUrl string              `json:"baseUrl,omitempty"`
	Paths   map[string][]string `json:"paths,omitempty"`
}

type Config

type Config struct {
	TsConfigPaths bool `yaml:"tsConfigPaths"`
	Workspaces    bool `yaml:"workspaces"`
}

type ExportsCacheKey

type ExportsCacheKey string

type Language

type Language struct {
	Cfg *Config
}

func (*Language) ParseExports

func (l *Language) ParseExports(file *language.FileInfo) (*language.ExportsResult, error)

func (*Language) ParseFile

func (l *Language) ParseFile(id string) (*language.FileInfo, error)

func (*Language) ParseImports

func (l *Language) ParseImports(file *language.FileInfo) (*language.ImportsResult, error)

func (*Language) ResolvePath

func (l *Language) ResolvePath(unresolved string, dir string) (string, error)

ResolvePath resolves an unresolved import based on the dir where the import was executed.

type TsConfig

type TsConfig struct {
	CompilerOptions CompilerOptions `json:"compilerOptions,omitempty"`
	// contains filtered or unexported fields
}

func ParseTsConfig

func ParseTsConfig(filePath string) (TsConfig, error)

func (*TsConfig) ResolveFromBaseUrl

func (t *TsConfig) ResolveFromBaseUrl(unresolved string) string

func (*TsConfig) ResolveFromPaths

func (t *TsConfig) ResolveFromPaths(unresolved string) (string, error)

type Workspaces

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

func (*Workspaces) ResolveFromWorkspaces

func (w *Workspaces) ResolveFromWorkspaces(unresolved string) (string, error)