bundler

Documentation

Index

• func DefaultExtensionToLoaderMap() map[string]Loader
• type Bundle
  • func ScanBundle(log logging.Log, fs fs.FS, res resolver.Resolver, entryPaths []string, ...) Bundle
  • func (b *Bundle) Compile(log logging.Log, options BundleOptions) []BundleResult
• type BundleOptions
• type BundleResult
• type Format
• type Loader
• type SourceMap

Functions

func DefaultExtensionToLoaderMap

func DefaultExtensionToLoaderMap() map[string]Loader

Types

type Bundle

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

func ScanBundle

func ScanBundle(
	log logging.Log, fs fs.FS, res resolver.Resolver, entryPaths []string,
	parseOptions parser.ParseOptions, bundleOptions BundleOptions,
) Bundle

func (*Bundle) Compile

func (b *Bundle) Compile(log logging.Log, options BundleOptions) []BundleResult

type BundleOptions

type BundleOptions struct {
	// true: imports are scanned and bundled along with the file
	// false: imports are left alone and the file is passed through as-is
	IsBundling bool

	AbsOutputFile     string
	AbsOutputDir      string
	RemoveWhitespace  bool
	MinifyIdentifiers bool
	MangleSyntax      bool
	ModuleName        string
	ExtensionToLoader map[string]Loader
	OutputFormat      Format

	SourceMap  SourceMap
	SourceFile string // The "original file path" for the source map

	// If this isn't LoaderNone, all entry point contents are assumed to come
	// from stdin and must be loaded with this loader
	LoaderForStdin Loader

	// If true, make sure to generate a single file that can be written to stdout
	WriteToStdout bool
	// contains filtered or unexported fields
}

type BundleResult

type BundleResult struct {
	JsAbsPath         string
	JsContents        []byte
	SourceMapAbsPath  string
	SourceMapContents []byte
}

type Format

type Format uint8

const (
	FormatNone Format = iota

	// IIFE stands for immediately-invoked function expression. That looks like
	// this:
	//
	//   (() => {
	//     ... bundled code ...
	//     require(entryPoint);
	//   })();
	//
	// If the optional ModuleName is configured, then we'll write out this:
	//
	//   let moduleName = (() => {
	//     ... bundled code ...
	//     return require(entryPoint);
	//   })();
	//
	FormatIIFE

	// The CommonJS format looks like this:
	//
	//   ... bundled code ...
	//   module.exports = require(entryPoint);
	//
	FormatCommonJS
)

type Loader

type Loader int

const (
	LoaderNone Loader = iota
	LoaderJS
	LoaderJSX
	LoaderTS
	LoaderTSX
	LoaderJSON
	LoaderText
	LoaderBase64
)

type SourceMap

type SourceMap uint8

const (
	SourceMapNone SourceMap = iota
	SourceMapInline
	SourceMapLinkedWithComment
	SourceMapExternalWithoutComment
)