polymer-build

polymer-build

Version 3.1.4
Published 5 years ago
763 kB
65 dependencies
BSD-3-Clause license

Install

npm i polymer-build

yarn add polymer-build

pnpm add polymer-build

Overview

A library of Gulp build tasks

Index

Functions

addCustomElementsEs5Adapter()
addServiceWorker()
forkStream()
generateServiceWorker()
getOptimizeStreams()
htmlTransform()
jsTransform()
resolveBareSpecifiers()

Functions

function addCustomElementsEs5Adapter

addCustomElementsEs5Adapter: (html: string) => string;

Please avoid using this function because the API is likely to change. Prefer the interface provided by PolymerProject.addCustomElementsEs5Adapter.
When compiling ES6 classes down to ES5 we need to include a special shim so that compiled custom elements will still work on browsers that support native custom elements.
TODO(fks) 03-28-2017: Add tests.

function addServiceWorker

addServiceWorker: (options: AddServiceWorkerOptions) => Promise<void>;

Returns a promise that resolves when a service worker has been generated and written to the build directory. This uses generateServiceWorker() to generate a service worker, which it then writes to the file system based on the buildRoot & path (if provided) options.

function forkStream

forkStream: (stream: NodeJS.ReadableStream) => NodeJS.ReadableStream;

function generateServiceWorker

generateServiceWorker: (options: AddServiceWorkerOptions) => Promise<Buffer>;

Returns a promise that resolves with a generated service worker (the file contents), based off of the options provided.

function getOptimizeStreams

getOptimizeStreams: (options?: OptimizeOptions) => NodeJS.ReadWriteStream[];

Returns an array of optimization streams to use in your build, based on the OptimizeOptions given.

function htmlTransform

htmlTransform: (html: string, options: HtmlTransformOptions) => string;

Transform some HTML according to the given options.

function jsTransform

jsTransform: (js: string, options: JsTransformOptions) => string;

Transform some JavaScript according to the given options.

function resolveBareSpecifiers

resolveBareSpecifiers: (
    filePath: string,
    isComponentRequest: boolean,
    packageName?: string | undefined,
    componentDir?: string | undefined,
    rootDir?: string | undefined
) => {
    inherits: any;
    visitor: {
        Program(path: NodePath<Program>): void;
        'ImportDeclaration|ExportNamedDeclaration|ExportAllDeclaration'(
            path: NodePath<HasSpecifier>
        ): void;
    };
};

Rewrites so-called "bare module specifiers" to be web-compatible paths.

Classes

class BuildAnalyzer

class BuildAnalyzer {}

constructor

constructor(config: ProjectConfig, streamToWarnTo?: any);

property allFragmentsToAnalyze

allFragmentsToAnalyze: Set<LocalFsPath>;

property analyzeDependencies

analyzeDependencies: Promise<DepsIndex>;

property analyzer

analyzer: Analyzer;

property config

config: ProjectConfig;

property files

files: Map<PackageRelativeUrl, File>;

property loader

loader: StreamLoader;

property sourceFilesLoaded

sourceFilesLoaded: boolean;

property started

started: boolean;

property warnings

warnings: Set<Warning>;

method addFile

addFile: (file: File) => void;

A side-channel to add files to the loader that did not come through the stream transformation. This is for generated files, like shared-bundle.html. This should probably be refactored so that the files can be injected into the stream.

method analyzeFile

analyzeFile: (file: File) => Promise<void>;

Analyze a file to find additional dependencies to load. Currently we only get dependencies for application fragments. When all fragments are analyzed, we call _done() to signal that analysis is complete.

method dependencies

dependencies: () => NodeJS.ReadableStream;

Return _dependenciesOutputStream, which will contain fully loaded file objects for each dependency after analysis.

method dependencyPathAnalyzed

dependencyPathAnalyzed: (filePath: LocalFsPath) => void;

Push the given filepath into the dependencies stream for loading. Each dependency is only pushed through once to avoid duplicates.

method getFile

getFile: (filepath: LocalFsPath) => File | undefined;

method getFileByUrl

getFileByUrl: (url: PackageRelativeUrl) => File | undefined;

method printWarnings

printWarnings: () => void;

method resolveFile

resolveFile: (file: File) => void;

Resolve a file in our loader so that the analyzer can read it.

method sourcePathAnalyzed

sourcePathAnalyzed: (filePath: LocalFsPath) => void;

Check that the source stream has not already completed loading by the time this file was analyzed.

method sources

sources: () => NodeJS.ReadableStream;

Return _sourcesOutputStream, which will contain fully loaded file objects for each source after analysis.

method startAnalysis

startAnalysis: () => void;

Start analysis by setting up the sources and dependencies analysis pipelines and starting the source stream. Files will not be loaded from disk until this is called. Can be called multiple times but will only run set up once.

class BuildBundler

class BuildBundler extends AsyncTransformStream<File, File> {}

constructor

constructor(
    config: ProjectConfig,
    buildAnalyzer: BuildAnalyzer,
    options?: Options
);

property config

config: ProjectConfig;

property files

files: Map<ResolvedUrl, File>;

class HtmlSplitter

class HtmlSplitter {}

HTMLSplitter represents the shared state of files as they are passed through a splitting stream and then a rejoining stream. Creating a new instance of HTMLSplitter and adding its streams to the build pipeline is the supported user interface for splitting out and rejoining inlined CSS & JS in the build process.

method addSplitPath

addSplitPath: (parentPath: string, childPath: string) => void;

method getParentFile

getParentFile: (childPath: string) => SplitFile | undefined;

method getSplitFile

getSplitFile: (parentPath: string) => SplitFile;

method isSplitFile

isSplitFile: (parentPath: string) => boolean;

method rejoin

rejoin: () => Transform;

Returns a new Transform stream that rejoins inline scripts and styles that were originally split from this HTMLSplitter's split() back into their parent HTML files.

method split

split: () => Transform;

Returns a new Transform stream that splits inline script and styles into new, separate files that are passed out of the stream.

class PolymerProject

class PolymerProject {}

constructor

constructor(config: any);

property analyzer

analyzer: BuildAnalyzer;

A Transform stream that uses polymer-analyzer to analyze the files. It can be used to get information on dependencies and fragments for the project once the source & dependency streams have been piped into it.

property config

config: ProjectConfig;

method addBabelHelpersInEntrypoint

addBabelHelpersInEntrypoint: (entrypoint?: string) => NodeJS.ReadWriteStream;

method addCustomElementsEs5Adapter

addCustomElementsEs5Adapter: () => NodeJS.ReadWriteStream;

Returns a stream transformer that injects custom-elements-es5-adapter.js into the entry point HTML file. This adapter is needed when serving ES5 to browsers that support the native Custom Elements API.

method addPrefetchLinks

addPrefetchLinks: () => NodeJS.ReadWriteStream;

Returns a stream transformer that injects 'prefetch' link tags into HTML documents based on the transitive dependencies of the document. For entrypoint documents without <base> tag, absolute urls are used in prefetch link hrefs. In all other cases, link hrefs will be relative urls.

method addPushManifest

addPushManifest: (
    outPath?: LocalFsPath,
    basePath?: PackageRelativeUrl
) => NodeJS.ReadWriteStream;

Returns a stream transformer that adds a push manifest file to the set of all input files that pass through.

method bundler

bundler: (options?: BuildBundlerOptions) => BuildBundler;

Returns a Transform stream that modifies the files that pass through it based on the dependency analysis done by the analyzer transform. It "bundles" a project by injecting its dependencies into the application fragments themselves, so that a minimum number of requests need to be made to load.
(NOTE: The analyzer stream must be in the pipeline somewhere before this.)

method dependencies

dependencies: () => NodeJS.ReadableStream;

Returns the analyzer's stream of this project's dependency files - files loaded inside the analyzed project that are not considered source files.

method sources

sources: () => NodeJS.ReadableStream;

Returns the analyzer's stream of this project's source files - files matched by the project's config.sources value.

method updateBaseTag

updateBaseTag: (baseHref: string) => NodeJS.ReadWriteStream;

Return a stream transformer that updates the <base> tag of the project's entrypoint HTML file with the given new value. No change is made if a <base> tag does not already exist.

Interfaces

interface AddServiceWorkerOptions

interface AddServiceWorkerOptions {}

property basePath

basePath?: LocalFsPath;

property buildRoot

buildRoot: LocalFsPath;

property bundled

bundled?: boolean;

property path

path?: LocalFsPath;

property project

project: PolymerProject;

property swPrecacheConfig

swPrecacheConfig?: SWConfig | null;

interface DepsIndex

interface DepsIndex {}

property depsToFragments

depsToFragments: Map<PackageRelativeUrl, PackageRelativeUrl[]>;

property fragmentToDeps

fragmentToDeps: Map<PackageRelativeUrl, PackageRelativeUrl[]>;

property fragmentToFullDeps

fragmentToFullDeps: Map<PackageRelativeUrl, DocumentDeps>;

interface OptimizeOptions

interface OptimizeOptions {}

property css

css?: {
    minify?:
        | boolean
        | {
              exclude?: string[];
          };
};

property entrypointPath

entrypointPath?: string;

property html

html?: {
    minify?:
        | boolean
        | {
              exclude?: string[];
          };
};

property js

js?: JsOptimizeOptions;

property rootDir

rootDir?: string;

interface SWConfig

interface SWConfig {}

property cacheId

cacheId?: string;

property directoryIndex

directoryIndex?: string;

property dynamicUrlToDependencies

dynamicUrlToDependencies?: {
    [property: string]: string[];
};

property handleFetch

handleFetch?: boolean;

property ignoreUrlParametersMatching

ignoreUrlParametersMatching?: RegExp[];

property importScripts

importScripts?: string[];

property logger

logger?: Function;

property maximumFileSizeToCacheInBytes

maximumFileSizeToCacheInBytes?: number;

property navigateFallback

navigateFallback?: string;

property navigateFallbackWhitelist

navigateFallbackWhitelist?: RegExp[];

property replacePrefix

replacePrefix?: string;

property runtimeCaching

runtimeCaching?: {
    urlPattern: RegExp;
    handler: string;
    options?: {
        cache: {
            maxEntries: number;
            name: string;
        };
    };
}[];

property staticFileGlobs

staticFileGlobs?: string[];

property stripPrefix

stripPrefix?: string;

property templateFilePath

templateFilePath?: string;

property verbose

verbose?: boolean;

Namespaces

namespace @babel/core

module '@babel/core' {}

namespace @babel/helper-plugin-utils

module '@babel/helper-plugin-utils' {}

namespace @babel/plugin-syntax-dynamic-import

module '@babel/plugin-syntax-dynamic-import' {}

namespace @babel/plugin-syntax-import-meta

module '@babel/plugin-syntax-import-meta' {}

namespace @babel/template

module '@babel/template' {}

namespace @babel/traverse

module '@babel/traverse' {}

class Binding

class Binding {}

constructor

constructor(opts: {
    existing: Binding;
    identifier: t.Identifier;
    scope: Scope;
    path: NodePath;
    kind: 'var' | 'let' | 'const';
});

property constant

constant: boolean;

property constantViolations

constantViolations: NodePath<t.Node>[];

property identifier

identifier: t.Identifier;

property kind

kind: 'var' | 'let' | 'const' | 'module';

property path

path: NodePath<t.Node>;

property referenced

referenced: boolean;

property referencePaths

referencePaths: NodePath<t.Node>[];

property references

references: number;

property scope

scope: Scope;

class NodePath

class NodePath<T = Node> {}

property node

node: {};

property scope

scope: Scope;

method replaceExpressionWithStatements

replaceExpressionWithStatements: (nodes: Node[]) => t.Node;

This method takes an array of statements nodes and then explodes it into expressions. This method retains completion records which is extremely important to retain original semantics.

method replaceInline

replaceInline: (nodes: Node | Node[]) => void;

method replaceWith

replaceWith: (replacement: Node | NodePath) => void;

Replace the current node with another.

method replaceWithMultiple

replaceWithMultiple: (nodes: Node[]) => void;

Replace a node with an array of multiple. This method performs the following steps:
- Inherit the comments of first provided node with that of the current node. - Insert the provided nodes after the current node. - Remove the current node.

method replaceWithSourceString

replaceWithSourceString: (replacement: any) => void;

Parse a string as an expression and replace the current node with the result.
NOTE: This is typically not a good idea to use. Building source strings when transforming ASTs is an antipattern and SHOULD NOT be encouraged. Even if it's easier to use, your transforms will be extremely brittle.

method traverse

traverse: (visitor: Visitor, state?: any) => void;

class Scope

class Scope {}

constructor

constructor(path: NodePath<t.Node>, parentScope?: Scope);

property bindings

bindings: { [name: string]: Binding };

property block

block: t.Node;

property parent

parent: Scope;

property parentBlock

parentBlock: t.Node;

property path

path: NodePath<t.Node>;

method generateDeclaredUidIdentifier

generateDeclaredUidIdentifier: (name?: string) => t.Identifier;

Generate a unique identifier and add it to the current scope.

method generateUid

generateUid: (name?: string) => string;

Generate a unique _id1 binding.

method generateUidIdentifier

generateUidIdentifier: (name?: string) => t.Identifier;

Generate a unique identifier.

method getAllBindings

getAllBindings: (...kinds: string[]) => object;

Walks the scope tree and gathers **all** bindings.

interface VisitNodeObject

interface VisitNodeObject<T> {}

method enter

enter: (path: NodePath<T>, state: any) => void;

method exit

exit: (path: NodePath<T>, state: any) => void;

interface Visitor

interface Visitor<S = Node> extends VisitNodeObject<Node> {}

property AnyTypeAnnotation

AnyTypeAnnotation?: VisitNode<S, t.AnyTypeAnnotation>;

property ArrayExpression

ArrayExpression?: VisitNode<S, t.ArrayExpression>;

property ArrayPattern

ArrayPattern?: VisitNode<S, t.ArrayPattern>;

property ArrayTypeAnnotation

ArrayTypeAnnotation?: VisitNode<S, t.ArrayTypeAnnotation>;

property ArrowFunctionExpression

ArrowFunctionExpression?: VisitNode<S, t.ArrowFunctionExpression>;

property AssignmentExpression

AssignmentExpression?: VisitNode<S, t.AssignmentExpression>;

property AssignmentPattern

AssignmentPattern?: VisitNode<S, t.AssignmentPattern>;

property AwaitExpression

AwaitExpression?: VisitNode<S, t.AwaitExpression>;

property Binary

Binary?: VisitNode<S, t.Binary>;

property BinaryExpression

BinaryExpression?: VisitNode<S, t.BinaryExpression>;

property BindExpression

BindExpression?: VisitNode<S, t.BindExpression>;

property Block

Block?: VisitNode<S, t.Block>;

property BlockParent

BlockParent?: VisitNode<S, t.BlockParent>;

property BlockStatement

BlockStatement?: VisitNode<S, t.BlockStatement>;

property BooleanLiteral

BooleanLiteral?: VisitNode<S, t.BooleanLiteral>;

property BooleanLiteralTypeAnnotation

BooleanLiteralTypeAnnotation?: VisitNode<S, t.BooleanLiteralTypeAnnotation>;

property BooleanTypeAnnotation

BooleanTypeAnnotation?: VisitNode<S, t.BooleanTypeAnnotation>;

property BreakStatement

BreakStatement?: VisitNode<S, t.BreakStatement>;

property CallExpression

CallExpression?: VisitNode<S, t.CallExpression>;

property CatchClause

CatchClause?: VisitNode<S, t.CatchClause>;

property Class

Class?: VisitNode<S, t.Class>;

property ClassBody

ClassBody?: VisitNode<S, t.ClassBody>;

property ClassDeclaration

ClassDeclaration?: VisitNode<S, t.ClassDeclaration>;

property ClassExpression

ClassExpression?: VisitNode<S, t.ClassExpression>;

property ClassImplements

ClassImplements?: VisitNode<S, t.ClassImplements>;

property ClassMethod

ClassMethod?: VisitNode<S, t.ClassMethod>;

property ClassProperty

ClassProperty?: VisitNode<S, t.ClassProperty>;

property CompletionStatement

CompletionStatement?: VisitNode<S, t.CompletionStatement>;

property Conditional

Conditional?: VisitNode<S, t.Conditional>;

property ConditionalExpression

ConditionalExpression?: VisitNode<S, t.ConditionalExpression>;

property ContinueStatement

ContinueStatement?: VisitNode<S, t.ContinueStatement>;

property DebuggerStatement

DebuggerStatement?: VisitNode<S, t.DebuggerStatement>;

property Declaration

Declaration?: VisitNode<S, t.Declaration>;

property DeclareClass

DeclareClass?: VisitNode<S, t.DeclareClass>;

property DeclareFunction

DeclareFunction?: VisitNode<S, t.DeclareFunction>;

property DeclareInterface

DeclareInterface?: VisitNode<S, t.DeclareInterface>;

property DeclareModule

DeclareModule?: VisitNode<S, t.DeclareModule>;

property DeclareTypeAlias

DeclareTypeAlias?: VisitNode<S, t.DeclareTypeAlias>;

property DeclareVariable

DeclareVariable?: VisitNode<S, t.DeclareVariable>;

property Decorator

Decorator?: VisitNode<S, t.Decorator>;

property Directive

Directive?: VisitNode<S, t.Directive>;

property DirectiveLiteral

DirectiveLiteral?: VisitNode<S, t.DirectiveLiteral>;

property DoExpression

DoExpression?: VisitNode<S, t.DoExpression>;

property DoWhileStatement

DoWhileStatement?: VisitNode<S, t.DoWhileStatement>;

property EmptyStatement

EmptyStatement?: VisitNode<S, t.EmptyStatement>;

property ExistentialTypeParam

ExistentialTypeParam?: VisitNode<S, t.ExistentialTypeParam>;

property ExportAllDeclaration

ExportAllDeclaration?: VisitNode<S, t.ExportAllDeclaration>;

property ExportDeclaration

ExportDeclaration?: VisitNode<S, t.ExportDeclaration>;

property ExportDefaultDeclaration

ExportDefaultDeclaration?: VisitNode<S, t.ExportDefaultDeclaration>;

property ExportDefaultSpecifier

ExportDefaultSpecifier?: VisitNode<S, t.ExportDefaultSpecifier>;

property ExportNamedDeclaration

ExportNamedDeclaration?: VisitNode<S, t.ExportNamedDeclaration>;

property ExportNamespaceSpecifier

ExportNamespaceSpecifier?: VisitNode<S, t.ExportNamespaceSpecifier>;

property ExportSpecifier

ExportSpecifier?: VisitNode<S, t.ExportSpecifier>;

property Expression

Expression?: VisitNode<S, t.Expression>;

property ExpressionStatement

ExpressionStatement?: VisitNode<S, t.ExpressionStatement>;

property ExpressionWrapper

ExpressionWrapper?: VisitNode<S, t.ExpressionWrapper>;

property File

File?: VisitNode<S, t.File>;

property Flow

Flow?: VisitNode<S, t.Flow>;

property FlowBaseAnnotation

FlowBaseAnnotation?: VisitNode<S, t.FlowBaseAnnotation>;

property FlowDeclaration

FlowDeclaration?: VisitNode<S, t.FlowDeclaration>;

property For

For?: VisitNode<S, t.For>;

property ForInStatement

ForInStatement?: VisitNode<S, t.ForInStatement>;

property ForOfStatement

ForOfStatement?: VisitNode<S, t.ForOfStatement>;

property ForStatement

ForStatement?: VisitNode<S, t.ForStatement>;

property ForXStatement

ForXStatement?: VisitNode<S, t.ForXStatement>;

property Function

Function?: VisitNode<S, t.Function>;

property FunctionDeclaration

FunctionDeclaration?: VisitNode<S, t.FunctionDeclaration>;

property FunctionExpression

FunctionExpression?: VisitNode<S, t.FunctionExpression>;

property FunctionParent

FunctionParent?: VisitNode<S, t.FunctionParent>;

property FunctionTypeAnnotation

FunctionTypeAnnotation?: VisitNode<S, t.FunctionTypeAnnotation>;

property FunctionTypeParam

FunctionTypeParam?: VisitNode<S, t.FunctionTypeParam>;

property GenericTypeAnnotation

GenericTypeAnnotation?: VisitNode<S, t.GenericTypeAnnotation>;

property Identifier

Identifier?: VisitNode<S, t.Identifier>;

property IfStatement

IfStatement?: VisitNode<S, t.IfStatement>;

property Immutable

Immutable?: VisitNode<S, t.Immutable>;

property ImportDeclaration

ImportDeclaration?: VisitNode<S, t.ImportDeclaration>;

property ImportDefaultSpecifier

ImportDefaultSpecifier?: VisitNode<S, t.ImportDefaultSpecifier>;

property ImportNamespaceSpecifier

ImportNamespaceSpecifier?: VisitNode<S, t.ImportNamespaceSpecifier>;

property ImportSpecifier

ImportSpecifier?: VisitNode<S, t.ImportSpecifier>;

property InterfaceDeclaration

InterfaceDeclaration?: VisitNode<S, t.InterfaceDeclaration>;

property InterfaceExtends

InterfaceExtends?: VisitNode<S, t.InterfaceExtends>;

property IntersectionTypeAnnotation

IntersectionTypeAnnotation?: VisitNode<S, t.IntersectionTypeAnnotation>;

property JSX

JSX?: VisitNode<S, t.JSX>;

property JSXAttribute

JSXAttribute?: VisitNode<S, t.JSXAttribute>;

property JSXClosingElement

JSXClosingElement?: VisitNode<S, t.JSXClosingElement>;

property JSXElement

JSXElement?: VisitNode<S, t.JSXElement>;

property JSXEmptyExpression

JSXEmptyExpression?: VisitNode<S, t.JSXEmptyExpression>;

property JSXExpressionContainer

JSXExpressionContainer?: VisitNode<S, t.JSXExpressionContainer>;

property JSXIdentifier

JSXIdentifier?: VisitNode<S, t.JSXIdentifier>;

property JSXMemberExpression

JSXMemberExpression?: VisitNode<S, t.JSXMemberExpression>;

property JSXNamespacedName

JSXNamespacedName?: VisitNode<S, t.JSXNamespacedName>;

property JSXOpeningElement

JSXOpeningElement?: VisitNode<S, t.JSXOpeningElement>;

property JSXSpreadAttribute

JSXSpreadAttribute?: VisitNode<S, t.JSXSpreadAttribute>;

property JSXText

JSXText?: VisitNode<S, t.JSXText>;

property LabeledStatement

LabeledStatement?: VisitNode<S, t.LabeledStatement>;

property Literal

Literal?: VisitNode<S, t.Literal>;

property LogicalExpression

LogicalExpression?: VisitNode<S, t.LogicalExpression>;

property Loop

Loop?: VisitNode<S, t.Loop>;

property LVal

LVal?: VisitNode<S, t.LVal>;

property MemberExpression

MemberExpression?: VisitNode<S, t.MemberExpression>;

property MetaProperty

MetaProperty?: VisitNode<S, t.MetaProperty>;

property Method

Method?: VisitNode<S, t.Method>;

property MixedTypeAnnotation

MixedTypeAnnotation?: VisitNode<S, t.MixedTypeAnnotation>;

property ModuleDeclaration

ModuleDeclaration?: VisitNode<S, t.ModuleDeclaration>;

property ModuleSpecifier

ModuleSpecifier?: VisitNode<S, t.ModuleSpecifier>;

property NewExpression

NewExpression?: VisitNode<S, t.NewExpression>;

property Noop

Noop?: VisitNode<S, t.Noop>;

property NullableTypeAnnotation

NullableTypeAnnotation?: VisitNode<S, t.NullableTypeAnnotation>;

property NullLiteral

NullLiteral?: VisitNode<S, t.NullLiteral>;

property NullLiteralTypeAnnotation

NullLiteralTypeAnnotation?: VisitNode<S, t.NullLiteralTypeAnnotation>;

property NumberTypeAnnotation

NumberTypeAnnotation?: VisitNode<S, t.NumberTypeAnnotation>;

property NumericLiteral

NumericLiteral?: VisitNode<S, t.NumericLiteral>;

property NumericLiteralTypeAnnotation

NumericLiteralTypeAnnotation?: VisitNode<S, t.NumericLiteralTypeAnnotation>;

property ObjectExpression

ObjectExpression?: VisitNode<S, t.ObjectExpression>;

property ObjectMember

ObjectMember?: VisitNode<S, t.ObjectMember>;

property ObjectMethod

ObjectMethod?: VisitNode<S, t.ObjectMethod>;

property ObjectPattern

ObjectPattern?: VisitNode<S, t.ObjectPattern>;

property ObjectProperty

ObjectProperty?: VisitNode<S, t.ObjectProperty>;

property ObjectTypeAnnotation

ObjectTypeAnnotation?: VisitNode<S, t.ObjectTypeAnnotation>;

property ObjectTypeCallProperty

ObjectTypeCallProperty?: VisitNode<S, t.ObjectTypeCallProperty>;

property ObjectTypeIndexer

ObjectTypeIndexer?: VisitNode<S, t.ObjectTypeIndexer>;

property ObjectTypeProperty

ObjectTypeProperty?: VisitNode<S, t.ObjectTypeProperty>;

property ParenthesizedExpression

ParenthesizedExpression?: VisitNode<S, t.ParenthesizedExpression>;

property Pattern

Pattern?: VisitNode<S, t.Pattern>;

property Program

Program?: VisitNode<S, t.Program>;

property Property

Property?: VisitNode<S, t.Property>;

property Pureish

Pureish?: VisitNode<S, t.Pureish>;

property QualifiedTypeIdentifier

QualifiedTypeIdentifier?: VisitNode<S, t.QualifiedTypeIdentifier>;

property RegExpLiteral

RegExpLiteral?: VisitNode<S, t.RegExpLiteral>;

property RestElement

RestElement?: VisitNode<S, t.RestElement>;

property RestProperty

RestProperty?: VisitNode<S, t.RestProperty>;

property ReturnStatement

ReturnStatement?: VisitNode<S, t.ReturnStatement>;

property Scopable

Scopable?: VisitNode<S, t.Scopable>;

property Scope

Scope?: VisitNode<S, t.Scopable>;

property SequenceExpression

SequenceExpression?: VisitNode<S, t.SequenceExpression>;

property SpreadElement

SpreadElement?: VisitNode<S, t.SpreadElement>;

property SpreadProperty

SpreadProperty?: VisitNode<S, t.SpreadProperty>;

property Statement

Statement?: VisitNode<S, t.Statement>;

property StringLiteral

StringLiteral?: VisitNode<S, t.StringLiteral>;

property StringLiteralTypeAnnotation

StringLiteralTypeAnnotation?: VisitNode<S, t.StringLiteralTypeAnnotation>;

property StringTypeAnnotation

StringTypeAnnotation?: VisitNode<S, t.StringTypeAnnotation>;

property Super

Super?: VisitNode<S, t.Super>;

property SwitchCase

SwitchCase?: VisitNode<S, t.SwitchCase>;

property SwitchStatement

SwitchStatement?: VisitNode<S, t.SwitchStatement>;

property TaggedTemplateExpression

TaggedTemplateExpression?: VisitNode<S, t.TaggedTemplateExpression>;

property TemplateElement

TemplateElement?: VisitNode<S, t.TemplateElement>;

property TemplateLiteral

TemplateLiteral?: VisitNode<S, t.TemplateLiteral>;

property Terminatorless

Terminatorless?: VisitNode<S, t.Terminatorless>;

property ThisExpression

ThisExpression?: VisitNode<S, t.ThisExpression>;

property ThisTypeAnnotation

ThisTypeAnnotation?: VisitNode<S, t.ThisTypeAnnotation>;

property ThrowStatement

ThrowStatement?: VisitNode<S, t.ThrowStatement>;

property TryStatement

TryStatement?: VisitNode<S, t.TryStatement>;

property TupleTypeAnnotation

TupleTypeAnnotation?: VisitNode<S, t.TupleTypeAnnotation>;

property TypeAlias

TypeAlias?: VisitNode<S, t.TypeAlias>;

property TypeAnnotation

TypeAnnotation?: VisitNode<S, t.TypeAnnotation>;

property TypeCastExpression

TypeCastExpression?: VisitNode<S, t.TypeCastExpression>;

property TypeofTypeAnnotation

TypeofTypeAnnotation?: VisitNode<S, t.TypeofTypeAnnotation>;

property TypeParameterDeclaration

TypeParameterDeclaration?: VisitNode<S, t.TypeParameterDeclaration>;

property TypeParameterInstantiation

TypeParameterInstantiation?: VisitNode<S, t.TypeParameterInstantiation>;

property UnaryExpression

UnaryExpression?: VisitNode<S, t.UnaryExpression>;

property UnaryLike

UnaryLike?: VisitNode<S, t.UnaryLike>;

property UnionTypeAnnotation

UnionTypeAnnotation?: VisitNode<S, t.UnionTypeAnnotation>;

property UpdateExpression

UpdateExpression?: VisitNode<S, t.UpdateExpression>;

property UserWhitespacable

UserWhitespacable?: VisitNode<S, t.UserWhitespacable>;

property VariableDeclaration

VariableDeclaration?: VisitNode<S, t.VariableDeclaration>;

property VariableDeclarator

VariableDeclarator?: VisitNode<S, t.VariableDeclarator>;

property VoidTypeAnnotation

VoidTypeAnnotation?: VisitNode<S, t.VoidTypeAnnotation>;

property While

While?: VisitNode<S, t.While>;

property WhileStatement

WhileStatement?: VisitNode<S, t.WhileStatement>;

property WithStatement

WithStatement?: VisitNode<S, t.WithStatement>;

property YieldExpression

YieldExpression?: VisitNode<S, t.YieldExpression>;

type Node

type Node = t.Node;

type VisitNode

type VisitNode<T, P> = VisitNodeFunction<T, P> | VisitNodeObject<T>;

type VisitNodeFunction

type VisitNodeFunction<T, P> = (this: T, path: NodePath<P>, state: any) => void;

namespace matcher

module 'matcher' {}

function isMatch

isMatch: (
    input: string,
    pattern: string,
    options?: { caseSensitive: boolean }
) => boolean;

namespace sw-precache

module 'sw-precache' {}

function generate

generate: (
    options: SWConfig,
    callback: (err?: Error, fileContents?: string) => void
) => void;

function write

write: (
    filepath: string,
    options: SWConfig,
    callback: (err?: Error) => void
) => void;

interface SWConfig

interface SWConfig {}

property cacheId

cacheId?: string;

property directoryIndex

directoryIndex?: string;

property dynamicUrlToDependencies

dynamicUrlToDependencies?: {
    [property: string]: string[];
};

property handleFetch

handleFetch?: boolean;

property ignoreUrlParametersMatching

ignoreUrlParametersMatching?: RegExp[];

property importScripts

importScripts?: string[];

property logger

logger?: Function;

property maximumFileSizeToCacheInBytes

maximumFileSizeToCacheInBytes?: number;

property navigateFallback

navigateFallback?: string;

property navigateFallbackWhitelist

navigateFallbackWhitelist?: RegExp[];

property replacePrefix

replacePrefix?: string;

property runtimeCaching

runtimeCaching?: {
    urlPattern: RegExp;
    handler: string;
    options?: {
        cache: {
            maxEntries: number;
            name: string;
        };
    };
}[];

property staticFileGlobs

staticFileGlobs?: string[];

property stripPrefix

stripPrefix?: string;

property templateFilePath

templateFilePath?: string;

property verbose

verbose?: boolean;

namespace vinyl-fs-fake

module 'vinyl-fs-fake' {}

function src

src: (files: File[], options?: Options) => stream.Readable;

interface File

interface File {}

property contents

contents: string;

property path

path: string;

interface Options

interface Options {}

property cwdbase

cwdbase: boolean;

namespace whatwg-url

module 'whatwg-url' {}

function parseURL

parseURL: (
    input: string,
    options?: { baseURL?: URL; encodingOverride?: string }
) => URL | null;

interface URL

interface URL {}

property cannotBeABaseURL

cannotBeABaseURL: boolean;

property fragment

fragment: string | null;

property host

host: string;

property password

password: string;

property path

path: string[];

property port

port: number | null;

property query

query: string | null;

property scheme

scheme: string;

property username

username: string;

Package Files (17)

Dependencies (65)

Dev Dependencies (11)

Peer Dependencies (0)

No peer dependencies.

Badge

To add a badge like this oneto your package's README, use the codes available below.

You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/polymer-build.

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/polymer-build)

HTML

<a href="https://www.jsdocs.io/package/polymer-build"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>

Updated 1 year ago.
Package analyzed in 5598 ms.
Missing or incorrect documentation? Open an issue for this package.