github.com/evanw/esbuild/internal/logger.Path.Text (field)

139 uses

	github.com/evanw/esbuild/internal/logger (current package)
		logger.go#L136: 	Text      string
		logger.go#L161: 		(a.Namespace == b.Namespace && (a.Text < b.Text ||
		logger.go#L162: 			(a.Text == b.Text && (a.Flags < b.Flags ||

	github.com/evanw/esbuild/internal/bundler
		bundler.go#L159: 		IdentifierName: js_ast.GenerateNonUniqueNameFromPath(args.keyPath.Text),
		bundler.go#L203: 	_, base, ext := logger.PlatformIndependentPathDirBaseExt(source.KeyPath.Text)
		bundler.go#L418: 				if resolveResult, ok := cache[record.Path.Text]; ok {
		bundler.go#L431: 					record.Path.Text,
		bundler.go#L436: 				cache[record.Path.Text] = resolveResult
		bundler.go#L443: 							fmt.Sprintf("%q should be marked as external for use with \"require.resolve\"", record.Path.Text))
		bundler.go#L455: 						if resolver.IsPackagePath(record.Path.Text) {
		bundler.go#L457: 							if pluginName == "" && !args.fs.IsAbs(record.Path.Text) {
		bundler.go#L458: 								if query := args.res.ProbeResolvePackageAsRelative(absResolveDir, record.Path.Text, record.Kind); query != nil {
		bundler.go#L459: 									hint = fmt.Sprintf(" (use %q to reference the file %q)", "./"+record.Path.Text, args.res.PrettyPath(query.PathPair.Primary))
		bundler.go#L464: 							if _, ok := resolver.BuiltInNodeModules[record.Path.Text]; ok {
		bundler.go#L472: 							fmt.Sprintf("Could not resolve %q%s", record.Path.Text, hint))
		bundler.go#L530: 			return logger.Path{Text: source.PrettyPath, IgnoredSuffix: "#sourceMappingURL"}, &contents
		bundler.go#L540: 		path := logger.Path{Text: absPath, Namespace: "file"}
		bundler.go#L564: 			loc.File = res.PrettyPath(logger.Path{Text: loc.File, Namespace: loc.Namespace})
		bundler.go#L643: 	applyPath := logger.Path{Text: path}
		bundler.go#L677: 			if result.Path.Text == "" {
		bundler.go#L679: 					result.Path = logger.Path{Text: path}
		bundler.go#L686: 			if result.Path.Namespace == "file" && !fs.IsAbs(result.Path.Text) {
		bundler.go#L689: 						fmt.Sprintf("Plugin %q returned a path in the \"file\" namespace that is not an absolute path: %s", pluginName, result.Path.Text))
		bundler.go#L692: 						fmt.Sprintf("Plugin %q returned a non-absolute path: %s (set a namespace if this is not a file path)", pluginName, result.Path.Text))
		bundler.go#L715: 			res.PrettyPath(logger.Path{Text: fs.Join(diffCase.Dir, diffCase.Actual), Namespace: "file"}),
		bundler.go#L716: 			res.PrettyPath(logger.Path{Text: fs.Join(diffCase.Dir, diffCase.Query), Namespace: "file"}),
		bundler.go#L764: 					fsCache.ReadFile(fs, source.KeyPath.Text) // Read the file for watch mode tracking
		bundler.go#L780: 				result.AbsResolveDir = fs.Dir(source.KeyPath.Text)
		bundler.go#L783: 				fsCache.ReadFile(fs, source.KeyPath.Text) // Read the file for watch mode tracking
		bundler.go#L801: 		if contents, err := fsCache.ReadFile(fs, source.KeyPath.Text); err == nil {
		bundler.go#L805: 				absResolveDir: fs.Dir(source.KeyPath.Text),
		bundler.go#L809: 				fmt.Sprintf("Could not read from file: %s", source.KeyPath.Text))
		bundler.go#L821: 		if parsed, ok := resolver.ParseDataURL(source.KeyPath.Text); ok {
		bundler.go#L946: 		visitedKey.Text = lowerCaseAbsPathForWindows(visitedKey.Text)
		bundler.go#L964: 	if resolver.IsInsideNodeModules(path.Text) {
		bundler.go#L995: 		if _, ok := resolver.ParseDataURL(path.Text); ok {
		bundler.go#L996: 			prettyPath = path.Text
		bundler.go#L1055: 		visitedKey := logger.Path{Text: fmt.Sprintf("", define.Name)}
		bundler.go#L1062: 			IdentifierName: js_ast.EnsureValidIdentifier(visitedKey.Text),
		bundler.go#L1069: 			Path:        visitedKey.Text,
		bundler.go#L1095: 		prettyPath := s.res.PrettyPath(logger.Path{Text: absPath, Namespace: "file"})
		bundler.go#L1136: 		stdinPath := logger.Path{Text: ""}
		bundler.go#L1139: 				stdinPath = logger.Path{Text: stdin.SourceFile}
		bundler.go#L1141: 				stdinPath = logger.Path{Text: stdin.SourceFile, Namespace: "file"}
		bundler.go#L1143: 				stdinPath = logger.Path{Text: s.fs.Join(stdin.AbsResolveDir, stdin.SourceFile), Namespace: "file"}
		bundler.go#L1267: 						if relPath, ok := s.fs.Rel(s.options.AbsOutputDir, path.Text); ok {
		bundler.go#L1273: 							record.Path.Text = relPath
		bundler.go#L1328: 						secondaryKey.Text = lowerCaseAbsPathForWindows(secondaryKey.Text)
		bundler.go#L1385: 								stubKey.Text = lowerCaseAbsPathForWindows(stubKey.Text)
		bundler.go#L1568: 				lowerAbsPath := lowerCaseAbsPathForWindows(keyPath.Text)
		bundler.go#L1707: 			absPaths = append(absPaths, keyPath.Text)
		bundler.go#L1782: 			path := b.res.PrettyPath(logger.Path{Text: result.AbsPath, Namespace: "file"})
		linker.go#L743: 					Path: logger.Path{Text: c.pathBetweenChunks(chunk.relDir, relPath)},
		linker.go#L834: 								record.Path.Text = c.pathBetweenChunks(chunk.relDir, c.files[record.SourceIndex.GetIndex()].entryPointRelPath)
		linker.go#L1122: 						record.Path.Text = otherRepr.ast.URLForCSS
		linker.go#L2738: 				baseName = baseFileNameForVirtualModulePath(source.KeyPath.Text)
		linker.go#L2739: 			} else if relPath, ok := c.fs.Rel(c.options.AbsOutputBase, source.KeyPath.Text); ok {
		linker.go#L2764: 				baseName = c.fs.Base(source.KeyPath.Text)
		linker.go#L3797: 					js_printer.QuoteForJSON(c.res.PrettyPath(logger.Path{Text: importAbsPath, Namespace: "file"}), c.options.ASCIIOnly),
		linker.go#L4234: 					js_printer.QuoteForJSON(c.res.PrettyPath(logger.Path{Text: importAbsPath, Namespace: "file"}), c.options.ASCIIOnly),
		linker.go#L4487: 				Text:      source,
		linker.go#L4493: 				path.Text = c.fs.Join(c.fs.Dir(file.source.KeyPath.Text), source)
		linker.go#L4519: 			if relPath, ok := c.fs.Rel(chunkAbsDir, item.path.Text); ok {
		linker.go#L4616: 			filePath = file.source.KeyPath.Text

	github.com/evanw/esbuild/internal/config
		config.go#L398: 	return (namespace == "" || path.Namespace == namespace) && filter.MatchString(path.Text)

	github.com/evanw/esbuild/internal/css_parser
		css_parser.go#L344: 				Path:  logger.Path{Text: path},
		css_parser.go#L604: 				Path:     logger.Path{Text: token.Text},
		css_parser.go#L629: 					Path:     logger.Path{Text: nested[0].Text},

	github.com/evanw/esbuild/internal/css_printer
		css_printer.go#L58: 		p.printQuoted(p.importRecords[r.ImportRecordIndex].Path.Text)
		css_printer.go#L638: 			text := p.importRecords[t.ImportRecordIndex].Path.Text

	github.com/evanw/esbuild/internal/js_parser
		js_parser.go#L6147: 		Path:  logger.Path{Text: text},

	github.com/evanw/esbuild/internal/js_printer
		js_printer.go#L1286: 		p.printQuotedUTF8(record.Path.Text, true /* allowBacktick */)
		js_printer.go#L1330: 		p.printQuotedUTF8(record.Path.Text, true /* allowBacktick */)
		js_printer.go#L1513: 		p.printQuotedUTF8(p.importRecords[e.ImportRecordIndex].Path.Text, true /* allowBacktick */)
		js_printer.go#L2601: 		p.printQuotedUTF8(p.importRecords[s.ImportRecordIndex].Path.Text, false /* allowBacktick */)
		js_printer.go#L2684: 		p.printQuotedUTF8(p.importRecords[s.ImportRecordIndex].Path.Text, false /* allowBacktick */)
		js_printer.go#L2958: 		p.printQuotedUTF8(p.importRecords[s.ImportRecordIndex].Path.Text, false /* allowBacktick */)

	github.com/evanw/esbuild/internal/resolver
		resolver.go#L77: 	return pp.Secondary.Text != ""
		resolver.go#L220: 			PathPair:   PathPair{Primary: logger.Path{Text: importPath}},
		resolver.go#L230: 				PathPair: PathPair{Primary: logger.Path{Text: importPath, Namespace: "dataurl"}},
		resolver.go#L236: 			PathPair:   PathPair{Primary: logger.Path{Text: importPath}},
		resolver.go#L288: 	result := &ResolveResult{PathPair: PathPair{Primary: logger.Path{Text: absPath, Namespace: "file"}}}
		resolver.go#L329: 			if dirInfo := r.dirInfoCached(r.fs.Dir(path.Text)); dirInfo != nil {
		resolver.go#L330: 				base := r.fs.Base(path.Text)
		resolver.go#L346: 								if info.packageJSON.sideEffectsMap[path.Text] {
		resolver.go#L352: 										if re.MatchString(path.Text) {
		resolver.go#L379: 							path.Text = symlink
		resolver.go#L382: 							path.Text = r.fs.Join(dirInfo.absRealPath, base)
		resolver.go#L418: 			return &ResolveResult{PathPair: PathPair{Primary: logger.Path{Text: importPath}}, IsExternal: true}
		resolver.go#L439: 			return &ResolveResult{PathPair: PathPair{Primary: logger.Path{Text: absPath, Namespace: "file"}}, IsExternal: true}
		resolver.go#L448: 						return &ResolveResult{PathPair: PathPair{Primary: logger.Path{Text: absPath, Namespace: "file", Flags: logger.PathDisabled}}}
		resolver.go#L474: 					return &ResolveResult{PathPair: PathPair{Primary: logger.Path{Text: importPath}}, IsExternal: true}
		resolver.go#L501: 							absolute.Primary = logger.Path{Text: absolute.Primary.Text, Namespace: "file", Flags: logger.PathDisabled}
		resolver.go#L503: 								absolute.Secondary = logger.Path{Text: absolute.Secondary.Text, Namespace: "file", Flags: logger.PathDisabled}
		resolver.go#L507: 							return &ResolveResult{PathPair: PathPair{Primary: logger.Path{Text: importPath, Flags: logger.PathDisabled}}, DifferentCase: diffCase}
		resolver.go#L529: 		resultDir := r.fs.Dir(path.Text)
		resolver.go#L536: 				if remapped, ok := packageJSON.browserNonPackageMap[path.Text]; ok {
		resolver.go#L562: 		if rel, ok := r.fs.Rel(r.fs.Cwd(), path.Text); ok {
		resolver.go#L563: 			path.Text = rel
		resolver.go#L571: 		path.Text = strings.ReplaceAll(path.Text, "\\", "/")
		resolver.go#L573: 		path.Text = fmt.Sprintf("%s:%s", path.Namespace, path.Text)
		resolver.go#L577: 		path.Text = "(disabled):" + path.Text
		resolver.go#L580: 	return path.Text + path.IgnoredSuffix
		resolver.go#L688: 	keyPath := logger.Path{Text: file, Namespace: "file"}
		resolver.go#L721: 									r.PrettyPath(logger.Path{Text: fileToCheck, Namespace: "file"}), err.Error()))
		resolver.go#L752: 							r.PrettyPath(logger.Path{Text: fileToCheck, Namespace: "file"}), err.Error()))
		resolver.go#L808: 					r.PrettyPath(logger.Path{Text: path, Namespace: "file"}), err.Error()))
		resolver.go#L871: 						r.PrettyPath(logger.Path{Text: tsConfigPath, Namespace: "file"})))
		resolver.go#L875: 							r.PrettyPath(logger.Path{Text: tsConfigPath, Namespace: "file"}), err.Error()))
		resolver.go#L900: 				r.PrettyPath(logger.Path{Text: packageJsonPath, Namespace: "file"}), err.Error()))
		resolver.go#L904: 	keyPath := logger.Path{Text: packageJsonPath, Namespace: "file"}
		resolver.go#L931: 					r.PrettyPath(logger.Path{Text: pathText, Namespace: "file"}), err.Error()))
		resolver.go#L1097: 					r.PrettyPath(logger.Path{Text: dirPath, Namespace: "file"}), err.Error()))
		resolver.go#L1196: 		return PathPair{Primary: logger.Path{Text: absolute, Namespace: "file"}}, true, diffCase
		resolver.go#L1246: 								Primary:   logger.Path{Text: absolute, Namespace: "file"},
		resolver.go#L1247: 								Secondary: logger.Path{Text: absoluteMain, Namespace: "file"},
		resolver.go#L1250: 							return PathPair{Primary: logger.Path{Text: absoluteMain, Namespace: "file"}}, true, nil
		resolver.go#L1255: 				return PathPair{Primary: logger.Path{Text: absolute, Namespace: "file"}}, true, nil
		resolver.go#L1262: 		return PathPair{Primary: logger.Path{Text: *dirInfo.absPathIndex, Namespace: "file"}}, true, nil
		resolver.go#L1391: 							return PathPair{Primary: logger.Path{Text: absPath, Namespace: "file", Flags: logger.PathDisabled}}, true, nil

	github.com/evanw/esbuild/internal/runtime
		runtime.go#L217: 	KeyPath:        logger.Path{Text: ""},
		runtime.go#L225: 	KeyPath:        logger.Path{Text: ""},

	github.com/evanw/esbuild/pkg/api
		api_impl.go#L298: 			KeyPath:    logger.Path{Text: "(global path)"},
		api_impl.go#L946: 						prettyPath := w.resolver.PrettyPath(logger.Path{Text: absPath, Namespace: "file"})
		api_impl.go#L1050: 			KeyPath:    logger.Path{Text: "tsconfig.json"},
		api_impl.go#L1206: 				Importer:   args.Importer.Text,
		api_impl.go#L1219: 			result.Path = logger.Path{Text: response.Path, Namespace: response.Namespace}
		api_impl.go#L1248: 				Path:       args.Path.Text,