Documentation
¶
Index ¶
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
This section is empty.
Types ¶
type DefineData ¶ added in v0.5.22
type DefineData struct { DefineFunc DefineFunc // True if a call to this value is known to not have any side effects. For // example, a bare call to "Object()" can be removed because it does not // have any observable side effects. CallCanBeUnwrappedIfUnused bool }
type DefineFunc ¶
type DefineFunc func(logger.Loc, FindSymbol) js_ast.E
type DotDefine ¶
type DotDefine struct { Parts []string Data DefineData }
type ExternalModules ¶ added in v0.5.20
type Format ¶
type Format uint8
const ( // This is used when not bundling. It means to preserve whatever form the // import or export was originally in. ES6 syntax stays ES6 syntax and // CommonJS syntax stays CommonJS syntax. FormatPreserve Format = iota // IIFE stands for immediately-invoked function expression. That looks like // this: // // (() => { // ... bundled code ... // })(); // // If the optional ModuleName is configured, then we'll write out this: // // let moduleName = (() => { // ... bundled code ... // return exports; // })(); // FormatIIFE // The CommonJS format looks like this: // // ... bundled code ... // module.exports = exports; // FormatCommonJS // The ES module format looks like this: // // ... bundled code ... // export {...}; // FormatESModule )
func (Format) KeepES6ImportExportSyntax ¶
type JSXOptions ¶
type LanguageTarget ¶
type LanguageTarget int8
type Loader ¶
type Loader int
func (Loader) CanHaveSourceMap ¶ added in v0.6.13
func (Loader) IsTypeScript ¶ added in v0.6.13
type Options ¶
type Options struct { Mode Mode RemoveWhitespace bool MinifyIdentifiers bool MangleSyntax bool CodeSplitting bool // Setting this to true disables warnings about code that is very likely to // be a bug. This is used to ignore issues inside "node_modules" directories. // This has caught real issues in the past. However, it's not esbuild's job // to find bugs in other libraries, and these warnings are problematic for // people using these libraries with esbuild. The only fix is to either // disable all esbuild warnings and not get warnings about your own code, or // to try to get the warning fixed in the affected library. This is // especially annoying if the warning is a false positive as was the case in // https://github.com/firebase/firebase-js-sdk/issues/3814. So these warnings // are now disabled for code inside "node_modules" directories. SuppressWarningsAboutWeirdCode bool // If true, make sure to generate a single file that can be written to stdout WriteToStdout bool OmitRuntimeForTests bool PreserveUnusedImportsTS bool Strict StrictOptions Defines *ProcessedDefines TS TSOptions JSX JSXOptions Platform Platform UnsupportedJSFeatures compat.JSFeature UnsupportedCSSFeatures compat.CSSFeature ExtensionOrder []string MainFields []string ExternalModules ExternalModules AbsOutputFile string AbsOutputDir string OutputExtensions map[string]string ModuleName string TsConfigOverride string ExtensionToLoader map[string]Loader OutputFormat Format // If present, metadata about the bundle is written as JSON here AbsMetadataFile string SourceMap SourceMap Stdin *StdinInfo }
func (*Options) OutputExtensionFor ¶ added in v0.6.6
type ProcessedDefines ¶
type ProcessedDefines struct { IdentifierDefines map[string]DefineData DotDefines map[string][]DotDefine }
func ProcessDefines ¶
func ProcessDefines(userDefines map[string]DefineData) ProcessedDefines
This transformation is expensive, so we only want to do it once. Make sure to only call processDefines() once per compilation. Unfortunately Golang doesn't have an efficient way to copy a map and the overhead of copying all of the properties into a new map once for every new parser noticeably slows down our benchmarks.
type StrictOptions ¶
type StrictOptions struct { // Loose: "a ?? b" => "a != null ? a : b" // Strict: "a ?? b" => "a !== null && a !== void 0 ? a : b" // // The disadvantage of strictness here is code bloat. The only observable // difference between the two is when the left operand is the bizarre legacy // value "document.all". This value is special-cased in the standard for // legacy reasons such that "document.all != null" is false even though it's // not "null" or "undefined". NullishCoalescing bool // Loose: "a?.b" => "a == null ? void 0 : a.b" // Strict: "a?.b" => "a === null || a === void 0 ? void 0 : a.b" // // The disadvantage of strictness here is code bloat. The only observable // difference between the two is when the left operand is the bizarre legacy // value "document.all". This value is special-cased in the standard for // legacy reasons such that "document.all == null" is true even though it's // not "null" or "undefined". OptionalChaining bool // Loose: "class Foo { foo = 1 }" => "class Foo { constructor() { this.foo = 1; } }" // Strict: "class Foo { foo = 1 }" => "class Foo { constructor() { __publicField(this, 'foo', 1); } }" // // The disadvantage of strictness here is code bloat and performance. The // advantage is following the class field specification accurately. For // example, loose mode will incorrectly trigger setter methods while strict // mode won't. ClassFields bool }
Click to show internal directories.
Click to hide internal directories.