polymer-bundler

Variables

• bundleTypeExtnames

Functions

• composeStrategies()
• generateBundles()
• generateCountingSharedBundleUrlMapper()
• generateEagerMergeStrategy()
• generateMatchMergeStrategy()
• generateNoBackLinkStrategy()
• generateSharedBundleUrlMapper()
• generateSharedDepsMergeStrategy()
• generateShellMergeStrategy()
• mergeBundles()
• mergeMatchingBundles()
• mergeSingleEntrypointSubBundles()

Classes

• AssignedBundle

  • bundle
  • url
• Bundle

  • bundledExports
  • entrypoints
  • extname
  • files
  • inlinedHtmlImports
  • inlinedScripts
  • inlinedStyles
  • missingImports
  • stripImports
  • type
• BundleManifest

  • bundles
  • fork()
  • getBundleForFile()
  • toJson()
• Bundler

  • analyzeContents()
  • analyzer
  • bundle()
  • enableCssInlining
  • enableScriptInlining
  • excludes
  • generateManifest()
  • rewriteUrlsInTemplates
  • sourcemaps
  • strategy
  • stripComments
  • treeshake
  • urlMapper

Interfaces

• BundleManifestJson
• BundleResult

  • documents
  • manifest
• Options

  • analyzer
  • excludes
  • inlineCss
  • inlineScripts
  • rewriteUrlsInTemplates
  • sourcemaps
  • strategy
  • stripComments
  • treeshake
  • urlMapper

Type Aliases

• BundleStrategy
• BundleType
• BundleUrlMapper
• TransitiveDependenciesMap

Namespaces

• command-line-args

  • ArgDescriptor
  • commandLineArgs()
  • UsageOpts
• command-line-usage

  • commandLineUsage()
• espree

  • ParseOpts2
  • Token
  • tokenize()
• mkdirp

  • mkdirp()
  • sync()

variable bundleTypeExtnames

const bundleTypeExtnames: Map<BundleType, string>;

function composeStrategies

composeStrategies: (strategies: BundleStrategy[]) => BundleStrategy;

• Chains multiple bundle strategy functions together so the output of one becomes the input of the next and so-on.

function generateBundles

generateBundles: (depsIndex: TransitiveDependenciesMap) => Bundle[];

• Given an index of files and their dependencies, produce an array of bundles, where a bundle is defined for each set of dependencies.

  For example, a dependency index representing the graph: a->b, b->c, b->d, e->c, e->f

  Would produce an array of three bundles: [a]->[a,b,d], [e]->[e,f], [a,e]->[c]

function generateCountingSharedBundleUrlMapper

generateCountingSharedBundleUrlMapper: (
    urlPrefix: ResolvedUrl
) => BundleUrlMapper;

• Creates a bundle URL mapper function which takes a prefix and appends an incrementing value, starting with 1 to the filename.

function generateEagerMergeStrategy

generateEagerMergeStrategy: (entrypoint: ResolvedUrl) => BundleStrategy;

• Generates a strategy function which finds all non-entrypoint bundles which are dependencies of the given entrypoint and merges them into that entrypoint's bundle.

function generateMatchMergeStrategy

generateMatchMergeStrategy: (
    predicate: (b: Bundle) => boolean
) => BundleStrategy;

• Generates a strategy function which finds all bundles matching the predicate function and merges them into the bundle containing the target file.

function generateNoBackLinkStrategy

generateNoBackLinkStrategy: (urls: ResolvedUrl[]) => BundleStrategy;

• Generates a strategy function that ensures bundles do not link to given URLs. Bundles which contain matching files will still have them inlined.

function generateSharedBundleUrlMapper

generateSharedBundleUrlMapper: (
    mapper: (sharedBundles: Bundle[]) => ResolvedUrl[]
) => BundleUrlMapper;

• Creates a bundle URL mapper function which maps non-shared bundles to the URLs of their single entrypoint and yields responsibility for naming remaining shared bundle URLs to the mapper function argument. The mapper function takes a collection of shared bundles and a URL map, calling .set(url, bundle) for each.

function generateSharedDepsMergeStrategy

generateSharedDepsMergeStrategy: (
    maybeMinEntrypoints?: number
) => BundleStrategy;

• Generates a strategy function to merge all bundles where the dependencies for a bundle are shared by at least 2 entrypoints (default; set minEntrypoints to change threshold).

  This function will convert an array of 4 bundles: [a]->[a,b], [a,c]->[d], [c]->[c,e], [f,g]->[f,g,h]

  Into the following 3 bundles, including a single bundle for all of the dependencies which are shared by at least 2 entrypoints: [a]->[a,b], [c]->[c,e], [a,c,f,g]->[d,f,g,h]

function generateShellMergeStrategy

generateShellMergeStrategy: (
    shell: ResolvedUrl,
    maybeMinEntrypoints?: number
) => BundleStrategy;

• A bundle strategy function which merges all shared dependencies into a bundle for an application shell.

function mergeBundles

mergeBundles: (bundles: Bundle[], ignoreTypeCheck?: boolean) => Bundle;

• Given an Array of bundles, produce a single bundle with the entrypoints and files of all bundles represented. By default, bundles of different types can not be merged, but this constraint can be skipped by providing ignoreTypeCheck argument with value true, which is necessary to merge a bundle containining an inline document's unique transitive dependencies, as inline documents typically are of different type (<script type="module"> within HTML document contains JavaScript document).

function mergeMatchingBundles

mergeMatchingBundles: (
    bundles: Bundle[],
    predicate: (bundle: Bundle) => boolean
) => Bundle[];

• Return a new bundle array where bundles within it matching the predicate are merged together. Note that merge operations are segregated by type so that no attempt to merge bundles of different types will occur.

function mergeSingleEntrypointSubBundles

mergeSingleEntrypointSubBundles: (bundles: Bundle[]) => void;

• Instances of <script type="module"> generate synthetic entrypoints in the depsIndex and are treated as entrypoints during the initial phase of generateBundles. Any bundle which provides dependencies to a single synthetic entrypoint of this type (aka a single entrypoint sub-bundle) are merged back into the bundle for the HTML containing the script tag.

  For example, the following bundles: [a]->[a], [a>1]->[x], [a>1,a>2]->[y], [a>2]->[z]

  Would be merged into the following set of bundles: [a]->[a,x,z], [a>1,a>2]->[y]

  a>1 and a>2 represent script tag entrypoints. Only x and z are bundled with a because they each serve only a single script tag entrypoint. y has to be in a separate bundle so that it is not inlined into bundle a in both script tags.

type BundleStrategy

type BundleStrategy = (bundles: Bundle[]) => Bundle[];

• A bundle strategy function is used to transform an array of bundles.

type BundleType

type BundleType = 'html-fragment' | 'es6-module';

• The output format of the bundle.

type BundleUrlMapper

type BundleUrlMapper = (bundles: Bundle[]) => Map<ResolvedUrl, Bundle>;

• A bundle URL mapper function produces a map of URLs to bundles.

type TransitiveDependenciesMap

type TransitiveDependenciesMap = Map<ResolvedUrl, Set<ResolvedUrl>>;

• A mapping of entrypoints to their full set of transitive dependencies, such that a dependency graph a->c, c->d, d->e, b->d, b->f would be represented {a:[a,c,d,e], b:[b,d,e,f]}. Please note that there is an explicit identity dependency (a depends on a, b depends on b).