polymer-analyzer

polymer-analyzer

Version 3.2.4
Published 4 years ago
1.2 MB
37 dependencies
BSD-3-Clause license

Install

npm i polymer-analyzer

yarn add polymer-analyzer

pnpm add polymer-analyzer

Overview

Static analysis for Web Components

Index

Functions

function applyEdits

applyEdits: (
    edits: Edit[],
    loader: (url: ResolvedUrl) => Promise<ParsedDocument>
) => Promise<EditResult>;

Takes the given edits and, provided there are no overlaps, applies them to the contents loadable from the given loader.
If there are overlapping edits, then edits earlier in the array get priority over later ones.

function comparePosition

comparePosition: (a: SourcePosition, b: SourcePosition) => number;

Returns -1 if source position a comes before source position b, returns 0 if they are the same, returns 1 if a comes after b.

function comparePositionAndRange

comparePositionAndRange: (
    position: SourcePosition,
    range: SourceRange,
    includeEdges?: boolean
) => 1 | -1 | 0;

If the position is inside the range, returns 0. If it comes before the range, it returns -1. If it comes after the range, it returns 1.
TODO(rictic): test this method directly (currently most of its tests are indirectly, through ast-from-source-position).

function correctPosition

correctPosition: (
    position: SourcePosition,
    locationOffset: LocationOffset
) => SourcePosition;

function correctSourceRange

correctSourceRange: {
    (sourceRange: SourceRange, locationOffset?: LocationOffset | null): SourceRange;
    (sourceRange: undefined, locationOffset?: LocationOffset): undefined;
    (sourceRange?: SourceRange, locationOffset?: LocationOffset): SourceRange;
};

Corrects source ranges based on an offset.
Source ranges for inline documents need to be corrected relative to their positions in their containing documents.
For example, if a tag appears in the fifth line of its containing document, we need to move all the source ranges inside that script tag down by 5 lines. We also need to correct the column offsets, but only for the first line of the contents.

function generateAnalysis

generateAnalysis: (
    input: AnalysisResult,
    urlResolver: UrlResolver,
    filter?: Filter
) => Analysis;

function getAttachedCommentText

getAttachedCommentText: (node: ASTNode) => string | undefined;

function getLocationOffsetOfStartOfTextContent

getLocationOffsetOfStartOfTextContent: (
    node: ASTNode,
    parsedDocument: ParsedHtmlDocument
) => LocationOffset;

function isPositionInsideRange

isPositionInsideRange: (
    position: SourcePosition,
    range: SourceRange | undefined,
    includeEdges?: boolean
) => boolean;

function isResolvable

isResolvable: (x: ScannedFeature & { resolve?: Function }) => x is Resolvable;

function makeParseLoader

makeParseLoader: (
    analyzer: Analyzer,
    analysis?: Analysis
) => (url: ResolvedUrl) => Promise<ParsedDocument<{} | null | undefined, {}>>;

function uncorrectPosition

uncorrectPosition: (
    position: SourcePosition,
    locationOffset: LocationOffset
) => SourcePosition;

function uncorrectSourceRange

uncorrectSourceRange: (
    sourceRange?: SourceRange,
    locationOffset?: LocationOffset | null
) => SourceRange | undefined;

function validateAnalysis

validateAnalysis: (analyzedPackage: Analysis | null | undefined) => void;

Throws if the given object isn't a valid AnalyzedPackage according to the JSON schema.

Classes

class Analysis

class Analysis implements Queryable {}

Represents a queryable interface over all documents in a package/project.
Results of queries will include results from all documents in the package, as well as from external dependencies that are transitively imported by documents in the package.

constructor

constructor(
    results: Map<ResolvedUrl, Warning | Document<ParsedDocument<{}, {}>>>,
    context: AnalysisContext
);

method getDocument

getDocument: (
    packageRelativeUrl: string
) => Result<Document, Warning | undefined>;

method getDocumentContaining

getDocumentContaining: (
    sourceRange: SourceRange | undefined
) => Document | undefined;

Potentially narrow down the document that contains the sourceRange. For example, if a source range is inside a inlineDocument, this function will narrow down the document to the most specific inline document.
Parameter sourceRange
Source range to search for in a document

method getFeatures

getFeatures: {
    <K extends keyof FeatureKindMap>(query: QueryWithKind<K>): Set<
        FeatureKindMap[K]
    >;
    (query?: Query): Set<Feature>;
};

Get features in the package.
Be default this includes features in all documents inside the package, but you can specify whether to also include features that are outside the package reachable by documents inside. See the documentation for Query for more details.
You can also narrow by feature kind and identifier.

method getWarnings

getWarnings: (options?: Query) => Warning[];

Get all warnings in the project.

method isExternal

static isExternal: (path: string) => boolean;

class Analyzer

class Analyzer {}

A static analyzer for web projects.
An Analyzer can load and parse documents of various types, and extract arbitrary information from the documents, and transitively load dependencies. An Analyzer instance is configured with parsers, and scanners which do the actual work of understanding different file types.

constructor

constructor(options: Options);

property urlResolver

readonly urlResolver: UrlResolver;

method analyze

analyze: (urls: string[], options?: AnalyzeOptions) => Promise<Analysis>;

Loads, parses and analyzes the root document of a dependency graph and its transitive dependencies.

method analyzePackage

analyzePackage: (options?: AnalyzeOptions) => Promise<Analysis>;

method canLoad

canLoad: (resolvedUrl: ResolvedUrl) => boolean;

Returns true if the provided resolved URL can be loaded. Obeys the semantics defined by UrlLoader and should only be used to check resolved URLs.

method clearCaches

clearCaches: () => Promise<void>;

Clear all cached information from this analyzer instance.
Note: if at all possible, instead tell the analyzer about the specific files that changed rather than clearing caches like this. Caching provides large performance gains.

method filesChanged

filesChanged: (urls: string[]) => Promise<void>;

Clears all information about the given files from our caches, such that future calls to analyze() will reload these files if they're needed.
The analyzer assumes that if this method isn't called with a file's url, then that file has not changed and does not need to be reloaded.
Parameter urls
The urls of files which may have changed.

method load

load: (resolvedUrl: ResolvedUrl) => Promise<string>;

Loads the content at the provided resolved URL. Obeys the semantics defined by UrlLoader and should only be used to attempt to load resolved URLs.

method resolveUrl

resolveUrl: (url: string) => ResolvedUrl | undefined;

Resoves url to a new location.

class AttributeDatabindingExpression

class AttributeDatabindingExpression extends DatabindingExpression {}

constructor

constructor(
    astNode: parse5.ASTNode,
    isCompleteBinding: boolean,
    direction: '{' | '[',
    eventName: string,
    attribute: parse5.ASTAttribute,
    sourceRange: SourceRange,
    expressionText: string,
    ast: babel.Program,
    document: ParsedHtmlDocument
);

property astNode

readonly astNode: parse5.ASTNode;

The element whose attribute/property is assigned to.

property attribute

readonly attribute: parse5.ASTAttribute;

The attribute we're databinding into.

property databindingInto

readonly databindingInto: string;

property direction

readonly direction: '{' | '[';

The databinding syntax used.

property eventName

readonly eventName: string;

If this is a two-way data binding, and an event name was specified (using ::eventName syntax), this is that event name.

property isCompleteBinding

readonly isCompleteBinding: boolean;

If true, this is databinding into the complete attribute. Polymer treats such databindings specially, e.g. they're setting the property by default, not the attribute.
e.g. foo="{{bar}}" is complete, foo="hello {{bar}} world" is not complete.
An attribute may have multiple incomplete bindings. They will be separate AttributeDatabindingExpressions.

class Class

class Class implements Feature, DeclaredWithStatement {}

constructor

constructor(init: ClassInit, document: Document<ParsedDocument<{}, {}>>);

property abstract

readonly abstract: boolean;

property astNode

readonly astNode: AstNodeWithLanguage;

property className

readonly className: string;

Deprecated
use the name field instead.

property constructorMethod

constructorMethod?: Method;

property demos

demos: Demo[];

property description

description: string;

property identifiers

readonly identifiers: Set<string>;

property jsdoc

readonly jsdoc: any;

property kinds

readonly kinds: Set<string>;

property methods

readonly methods: Map<string, Method>;

property mixins

readonly mixins: readonly ScannedReference<'element-mixin'>[];

Mixins that this class declares with @mixes.
Mixins are applied linearly after the superclass, in order from first to last. Mixins that compose other mixins will be flattened into a single list. A mixin can be applied more than once, each time its members override those before it in the prototype chain.

property name

readonly name: string;

property privacy

readonly privacy: Privacy;

property properties

readonly properties: Map<string, Property>;

property sourceRange

readonly sourceRange: SourceRange;

property statementAst

readonly statementAst: any;

property staticMethods

readonly staticMethods: Map<string, Method>;

property summary

readonly summary: string;

property superClass

readonly superClass: ScannedReference<'class'>;

property warnings

readonly warnings: Warning[];

method emitMetadata

emitMetadata: () => object;

method emitMethodMetadata

emitMethodMetadata: (_method: Method) => object;

method emitPropertyMetadata

emitPropertyMetadata: (_property: Property) => object;

method inheritFrom

protected inheritFrom: (superClass: Class) => void;

class Document

class Document<ParsedType extends ParsedDocument = ParsedDocument>
    implements Feature, Queryable {}

constructor

constructor(
    base: ScannedDocument,
    analyzer: AnalysisContext,
    languageAnalysis?: {}
);

property astNode

readonly astNode: AstNodeWithLanguage;

property identifiers

readonly identifiers: ImmutableSet<string>;

property isInline

readonly isInline: boolean;

property kinds

readonly kinds: ImmutableSet<string>;

property languageAnalysis

languageAnalysis?: {};

property parsedDocument

readonly parsedDocument: ParsedDocument<{}, {}>;

property resolved

readonly resolved: boolean;

property sourceRange

readonly sourceRange: SourceRange;

property type

readonly type: string;

property url

readonly url: String & ResolvedUrlBrand;

property warnings

warnings: Warning[];

method getFeatures

getFeatures: {
    <K extends keyof FeatureKindMap>(query: QueryWithKind<K>): Set<
        FeatureKindMap[K]
    >;
    (query?: Query): Set<Feature>;
};

Get features on the document.
Be default it includes only features on the document, but you can specify whether to include features that are reachable by imports, features from outside the current package, etc. See the documentation for Query for more details.
You can also narrow by feature kind and identifier.

method getWarnings

getWarnings: (query?: Query) => Warning[];

Get warnings for the document and all matched features.

method resolve

resolve: () => void;

Resolves all features of this document, so that they have references to all their dependencies.
This method can only be called once

method stringify

stringify: () => string;

method toString

toString: () => string;

class DocumentBackreference

class DocumentBackreference extends ScannedFeature {}

The DocumentBackreference is added to the set of features for an inline/imported document to provide a link to its containing/importer document.

constructor

constructor(document: Document<ParsedDocument<{}, {}>>);

property document

readonly document: Document<ParsedDocument<{}, {}>>;

property identifiers

identifiers: Set<string>;

property kinds

kinds: Set<string>;

class DomModule

class DomModule implements Feature {}

constructor

constructor(
    node: ASTNode,
    id: string,
    comment: string,
    sourceRange: SourceRange,
    ast: HtmlAstNode,
    warnings: Warning[],
    slots: Slot[],
    localIds: LocalId[],
    template: Template,
    databindings: HtmlDatabindingExpression[]
);

property 'slots'

'slots': Slot[];

property astNode

astNode: HtmlAstNode;

property comment

comment?: string;

property databindings

databindings: HtmlDatabindingExpression[];

property id

id: string;

property identifiers

identifiers: Set<string>;

property kinds

kinds: Set<string>;

property localIds

localIds: LocalId[];

property node

node: ASTNode;

property sourceRange

sourceRange: SourceRange;

property template

template: Template;

property warnings

warnings: Warning[];

class Element

class Element extends ElementBase implements Feature {}

constructor

constructor(init: ElementInit, document: Document<ParsedDocument<{}, {}>>);

property extends

extends?: string;

For customized built-in elements, the tagname of the builtin element that this element extends.

property tagName

readonly tagName: string;

class ElementBase

abstract class ElementBase extends Class implements Feature {}

Base class for Element and ElementMixin.

constructor

constructor(init: ElementBaseInit, document: Document<ParsedDocument<{}, {}>>);

property 'slots'

'slots': ImmutableArray<Slot>;

property attributes

attributes: Map<string, Attribute>;

property events

events: Map<string, Event>;

property template

template: ElementTemplate;

method emitAttributeMetadata

emitAttributeMetadata: (_attribute: Attribute) => Object;

method emitEventMetadata

emitEventMetadata: (_event: Event) => Object;

method inheritFrom

protected inheritFrom: (superClass: Class) => void;

class ElementMixin

class ElementMixin extends ElementBase implements Feature {}

constructor

constructor(init: ElementMixinInit, document: Document<ParsedDocument<{}, {}>>);

property name

readonly name: string;

class ElementReference

class ElementReference implements Feature {}

constructor

constructor(
    scannedRef: ScannedElementReference,
    _document: Document<ParsedDocument<{}, {}>>
);

property astNode

readonly astNode: HtmlAstNode;

property attributes

readonly attributes: ImmutableMap<string, Attribute>;

property identifiers

readonly identifiers: ImmutableSet<string>;

property kinds

readonly kinds: ImmutableSet<string>;

property sourceRange

readonly sourceRange: SourceRange;

property tagName

readonly tagName: string;

property warnings

readonly warnings: ImmutableArray<Warning>;

class Export

class Export implements Resolvable, Feature {}

constructor

constructor(
    astNode: JsAstNode<any>,
    statementAst: babel.Statement,
    sourceRange: SourceRange,
    nodePath: NodePath<babel.Node>,
    exportingAllFrom?: Iterable<Export>
);

property astNode

readonly astNode: JsAstNode<any>;

property astNodePath

readonly astNodePath: NodePath<babel.Node>;

property description

readonly description: undefined;

property identifiers

readonly identifiers: Set<string>;

property jsdoc

readonly jsdoc: undefined;

property kinds

readonly kinds: ReadonlySet<string>;

property sourceRange

readonly sourceRange: SourceRange;

property statementAst

readonly statementAst: babel.Statement;

property warnings

readonly warnings: readonly Warning[];

method resolve

resolve: (document: Document) => Feature | undefined;

class Feature

abstract class Feature {}

constructor

constructor(
    sourceRange?: SourceRange,
    astNode?: AstNodeWithLanguage,
    warnings?: Warning[] | ImmutableArray<Warning>
);

property astNode

readonly astNode?: AstNodeWithLanguage;

The AST Node, if any, that corresponds to this feature in its containing document.

property identifiers

readonly identifiers: Set<string> | ImmutableSet<string>;

property kinds

readonly kinds: Set<string> | ImmutableSet<string>;

property sourceRange

readonly sourceRange?: SourceRange;

Tracks the source that this feature came from.

property warnings

readonly warnings: Warning[] | ImmutableArray<Warning>;

Warnings that were encountered while processing this feature.

class FetchUrlLoader

class FetchUrlLoader implements UrlLoader {}

Resolves requests via the the DOM fetch API.

constructor

constructor(baseUrl: string);

property baseUrl

baseUrl: string;

method canLoad

canLoad: (_: string) => boolean;

method load

load: (url: string) => Promise<string>;

class FileRelativeUrlBrand

class FileRelativeUrlBrand {}

class FsUrlLoader

class FsUrlLoader implements UrlLoader {}

Resolves requests via the file system.

constructor

constructor(root?: string);

property root

root: string;

method canLoad

canLoad: (url: ResolvedUrl) => boolean;

method getFilePath

getFilePath: (url: ResolvedUrl) => Result<string, string>;

If successful, result.value will be the filesystem path that we would load the given url from.
If unsuccessful, result.value will be an error message as a string.

method load

load: (url: ResolvedUrl) => Promise<string>;

method readDirectory

readDirectory: (
    pathFromRoot: string,
    deep?: boolean
) => Promise<PackageRelativeUrl[]>;

class FsUrlResolver

class FsUrlResolver extends UrlResolver {}

Resolves package-relative urls to a configured root directory.
For file-relative URLs it does the normal URL resolution algorithm relative to the base url.
It does no remapping of urls in source to urls on the filesystem, but a subclass can override modifyFsPath for this purpose.

constructor

constructor(packageDir: string, host?: string, protocol?: string);

property packageDir

protected readonly packageDir: string;

property packageUrl

protected readonly packageUrl: String & ResolvedUrlBrand;

property protocol

protected readonly protocol: string;

method filesystemPathForPathname

protected filesystemPathForPathname: (decodedPathname: string) => string;

method modifyFsPath

protected modifyFsPath: (fsPath: string) => string;

Overridable method, for subclasses that want to redirect some filesystem paths.
Parameter fsPath
An absolute path on the file system. Note that it will be OS-specific. An absolute path on the file system that we should resolve to.

method relative

relative: {
    (to: ResolvedUrl): PackageRelativeUrl;
    (from: ResolvedUrl, to: ResolvedUrl, _kind?: string): FileRelativeUrl;
};

method resolve

resolve: (
    firstHref: ResolvedUrl | PackageRelativeUrl,
    secondHref?: FileRelativeUrl,
    _import?: ScannedImport
) => ResolvedUrl | undefined;

method shouldHandleAsFileUrl

protected shouldHandleAsFileUrl: (url: Url) => boolean;

class Function

class Function implements Feature {}

constructor

constructor(scannedFunction: ScannedFunction);

property astNode

astNode: JsAstNode<babel.Node>;

property description

description?: string;

property identifiers

identifiers: Set<string>;

property kinds

kinds: Set<string>;

property name

name: string;

property params

params?: { name: string; type?: string }[];

property privacy

privacy: Privacy;

property return

return?: { type?: string; desc?: string };

property sourceRange

sourceRange: SourceRange;

property summary

summary?: string;

property templateTypes

templateTypes?: string[];

property warnings

warnings: Warning[];

method toString

toString: () => string;

class Import

class Import implements Feature {}

constructor

constructor(
    url: String & ResolvedUrlBrand,
    originalUrl: String & FileRelativeUrlBrand,
    type: string,
    document: Document<ParsedDocument<{}, {}>>,
    sourceRange: SourceRange,
    urlSourceRange: SourceRange,
    ast: AstNodeWithLanguage,
    warnings: Warning[],
    lazy: boolean
);

property astNode

readonly astNode: AstNodeWithLanguage;

property document

readonly document: Document<ParsedDocument<{}, {}>>;

property identifiers

readonly identifiers: Set<any>;

property kinds

readonly kinds: Set<string>;

property lazy

readonly lazy: boolean;

property originalUrl

readonly originalUrl: String & FileRelativeUrlBrand;

property sourceRange

readonly sourceRange: SourceRange;

property type

readonly type: string;

property url

readonly url: String & ResolvedUrlBrand;

property urlSourceRange

readonly urlSourceRange: SourceRange;

property warnings

readonly warnings: Warning[];

method toString

toString: () => string;

class InlineDocument

class InlineDocument extends Document {}

constructor

constructor(
    base: ScannedDocument,
    containerDocument: Document<ParsedDocument<{}, {}>>
);

class InMemoryOverlayUrlLoader

class InMemoryOverlayUrlLoader implements UrlLoader {}

Resolves requests first from an in-memory map of file contents, and if a file isn't found there, defers to another url loader.
Useful for the editor use case. An editor will have a number of files in open buffers at any time. For these files, the editor's in-memory buffer is canonical, so that their contents are read even when they have unsaved changes. For all other files, we can load the files using another loader, e.g. from disk.
TODO(rictic): make this a mixin that mixes another loader.

constructor

constructor(fallbackLoader?: UrlLoader);

property readDirectory

readDirectory?: (
    pathFromRoot: string,
    deep?: boolean
) => Promise<PackageRelativeUrl[]>;

property urlContentsMap

urlContentsMap: Map<ResolvedUrl, string>;

method canLoad

canLoad: (url: ResolvedUrl) => boolean;

method load

load: (url: ResolvedUrl) => Promise<string>;

class JavascriptDatabindingExpression

class JavascriptDatabindingExpression extends DatabindingExpression {}

constructor

constructor(
    astNode: babel.Node,
    sourceRange: SourceRange,
    expressionText: string,
    ast: babel.Program,
    kind: ExpressionLimitation,
    document: JavaScriptDocument
);

property astNode

readonly astNode: babel.Node;

property databindingInto

readonly databindingInto: string;

class JavascriptImport

class JavascriptImport extends Import implements DeclaredWithStatement {}

constructor

constructor(
    url: String & ResolvedUrlBrand,
    originalUrl: String & FileRelativeUrlBrand,
    type: string,
    document: Document<ParsedDocument<{}, {}>>,
    sourceRange: SourceRange,
    urlSourceRange: SourceRange,
    ast: JsAstNode<any>,
    astNodePath: NodePath<babel.Node>,
    warnings: Warning[],
    lazy: boolean,
    specifier: string,
    statementAst: any
);

property astNode

readonly astNode: JsAstNode<any>;

property astNodePath

readonly astNodePath: NodePath<babel.Node>;

property specifier

readonly specifier: string;

The original text of the specifier. Unlike this.url, this may not be a URL, but may be a bare module specifier, like 'jquery'.

property statementAst

readonly statementAst: any;

class MapWithDefault

class MapWithDefault<K, V> extends Map<K, V> {}

This is a special map which automatically creates a default value if the key is not found.

constructor

constructor(makeDefault: (key: K) => V);

method get

get: (key: K) => V;

class MultiUrlLoader

class MultiUrlLoader implements UrlLoader {}

Resolves requests via one of a sequence of loaders.

constructor

constructor(_loaders: UrlLoader[]);

method canLoad

canLoad: (url: ResolvedUrl) => boolean;

method load

load: (url: ResolvedUrl) => Promise<string>;

method readDirectory

readDirectory: (
    path: ResolvedUrl,
    deep?: boolean
) => Promise<PackageRelativeUrl[]>;

class MultiUrlResolver

class MultiUrlResolver extends UrlResolver {}

Resolves a URL using multiple resolvers.

constructor

constructor(_resolvers: readonly UrlResolver[]);

method relative

relative: {
    (to: ResolvedUrl): PackageRelativeUrl;
    (from: ResolvedUrl, to: ResolvedUrl, kind?: string): FileRelativeUrl;
};

Delegates to relative method on the first resolver which can resolve the destination URL.

method resolve

resolve: (
    firstUrl: ResolvedUrl | PackageRelativeUrl,
    secondUrl?: FileRelativeUrl,
    import_?: ScannedImport
) => ResolvedUrl | undefined;

Returns the first resolved URL (which is not undefined.)

class Namespace

class Namespace implements Feature {}

constructor

constructor(scannedNamespace: ScannedNamespace);

property astNode

astNode: JsAstNode<babel.Node>;

property description

description?: string;

property identifiers

identifiers: Set<string>;

property kinds

kinds: Set<string>;

property name

name: string;

property properties

readonly properties: Map<string, Property>;

property sourceRange

sourceRange: SourceRange;

property summary

summary?: string;

property warnings

warnings: Warning[];

method toString

toString: () => string;

class PackageRelativeUrlBrand

class PackageRelativeUrlBrand {}

class PackageUrlResolver

class PackageUrlResolver extends FsUrlResolver {}

Resolves a URL to a canonical URL within a package.

constructor

constructor(options?: PackageUrlResolverOptions);

property componentDir

readonly componentDir: string;

method modifyFsPath

protected modifyFsPath: (path: string) => string;

method relative

relative: {
    (to: ResolvedUrl): PackageRelativeUrl;
    (from: ResolvedUrl, to: ResolvedUrl, _kind?: string): FileRelativeUrl;
};

class ParsedCssDocument

class ParsedCssDocument extends ParsedDocument<shady.Node, Visitor> {}

property type

readonly type: string;

method [Symbol.iterator]

[Symbol.iterator]: () => Iterator<shady.Node>;

method sourceRangeForNode

sourceRangeForNode: (node: shady.Node) => SourceRange;

method sourceRangeForShadyRange

sourceRangeForShadyRange: (range: shady.Range) => SourceRange;

Takes a range from a shadycss node directly, rather than a shadycss node. Useful when there are multiple ranges for a given node.

method stringify

stringify: (options?: StringifyOptions) => string;

method visit

visit: (visitors: Visitor[]) => void;

class ParsedDocument

abstract class ParsedDocument<AstNode = {} | null | undefined, Visitor = {}> {}

A parsed Document.
AstNode The AST type of the document. Visitor The type of the visitors that can walk the document.

constructor

constructor(from: Options<AstNode>);

property ast

ast: {};

property astNode

readonly astNode: AstNodeWithLanguage;

If not null, this is an inline document, and astNode is the AST Node of this document inside of the parent. (e.g. the or tag)

property baseUrl

baseUrl: String & ResolvedUrlBrand;

property contents

contents: string;

property isInline

isInline: boolean;

property newlineIndexes

readonly newlineIndexes: number[];

The 0-based offsets into contents of all newline characters.
Useful for converting between string offsets and SourcePositions.

property sourceRange

sourceRange: SourceRange;

property type

abstract type: string;

property url

url: String & ResolvedUrlBrand;

method absoluteToRelativeSourceRange

absoluteToRelativeSourceRange: {
    (sourceRange: SourceRange): SourceRange;
    (sourceRange: undefined): undefined;
    (sourceRange: SourceRange): SourceRange;
};

method offsetsToSourceRange

offsetsToSourceRange: (start: number, end: number) => SourceRange;

method offsetToSourcePosition

offsetToSourcePosition: (offset: number) => SourcePosition;

method relativeToAbsoluteSourceRange

relativeToAbsoluteSourceRange: {
    (sourceRange: SourceRange): SourceRange;
    (sourceRange: undefined): undefined;
    (sourceRange: SourceRange): SourceRange;
};

method sourcePositionToOffset

sourcePositionToOffset: (position: SourcePosition) => number;

method sourceRangeForNode

sourceRangeForNode: (node: AstNode) => SourceRange | undefined;

method sourceRangeToOffsets

sourceRangeToOffsets: (range: SourceRange) => [number, number];

method stringify

abstract stringify: (options: StringifyOptions) => string;

Convert this.ast back into a string document.

method toString

toString: () => string;

method visit

abstract visit: (visitors: Visitor[]) => void;

Runs a set of document-type specific visitors against the document.

class ParsedHtmlDocument

class ParsedHtmlDocument extends ParsedDocument<ASTNode, HtmlVisitor> {}

property type

type: string;

method sourceRangeForAttribute

sourceRangeForAttribute: (
    node: ASTNode,
    attrName: string
) => SourceRange | undefined;

method sourceRangeForAttributeName

sourceRangeForAttributeName: (
    node: ASTNode,
    attrName: string
) => SourceRange | undefined;

method sourceRangeForAttributeValue

sourceRangeForAttributeValue: (
    node: ASTNode,
    attrName: string,
    excludeQuotes?: boolean
) => SourceRange | undefined;

method sourceRangeForEndTag

sourceRangeForEndTag: (node: ASTNode) => SourceRange | undefined;

method sourceRangeForStartTag

sourceRangeForStartTag: (node: ASTNode) => SourceRange | undefined;

method stringify

stringify: (options?: StringifyOptions) => string;

method visit

visit: (visitors: HtmlVisitor[]) => void;

class ParsedJavaScriptDocument

class JavaScriptDocument extends ParsedDocument<Node, Visitor> {}

constructor

constructor(from: Options);

property ast

ast: babel.File;

property parsedAsSourceType

parsedAsSourceType: 'script' | 'module';

How the js document was parsed. If 'module' then the source code is definitely an ES6 module, as it has imports or exports. If 'script' then it may be an ES6 module with no imports or exports, or it may be a script.

property type

readonly type: string;

method stringify

stringify: (options?: StringifyOptions) => string;

method visit

visit: (visitors: Visitor[]) => void;

class ParsedJsonDocument

class ParsedJsonDocument extends ParsedDocument<Json, Visitor> {}

property type

readonly type: string;

method stringify

stringify: (options?: StringifyOptions) => string;

method visit

visit: (visitors: Visitor[]) => void;

class PolymerBehavior

class Behavior extends PolymerElement {}

constructor

constructor(
    scannedBehavior: ScannedBehavior,
    document: Document<ParsedDocument<{}, {}>>
);

property tagName

readonly tagName: undefined;

method toString

toString: () => string;

class PolymerDatabindingExpression

abstract class DatabindingExpression {}

constructor

constructor(
    sourceRange: SourceRange,
    expressionText: string,
    ast: babel.Program,
    limitation: ExpressionLimitation,
    document: ParsedDocument<{}, {}>
);

property expressionText

readonly expressionText: string;

property properties

properties: { name: string; sourceRange: SourceRange }[];

Toplevel properties on the model that are referenced in this expression.
e.g. in {{foo(bar, baz.zod)}} the properties are foo, bar, and baz (but not zod).

property sourceRange

readonly sourceRange: SourceRange;

property warnings

readonly warnings: Warning[];

method sourceRangeForNode

sourceRangeForNode: (node: babel.Node) => SourceRange | undefined;

Given an estree node in this databinding expression, give its source range.

class PolymerElement

class PolymerElement extends Element implements PolymerExtension {}

constructor

constructor(
    scannedElement: ScannedPolymerElement,
    document: Document<ParsedDocument<{}, {}>>
);

property behaviorAssignments

readonly behaviorAssignments: ImmutableArray<ScannedReference<'behavior'>>;

property domModule

readonly domModule?: dom5.Node;

property isLegacyFactoryCall

readonly isLegacyFactoryCall: boolean;

true iff element was defined using the legacy Polymer() function.

property listeners

readonly listeners: ImmutableArray<{ event: string; handler: string }>;

property localIds

readonly localIds: ImmutableArray<LocalId>;

property observers

readonly observers: ImmutableArray<Observer>;

property properties

readonly properties: Map<string, PolymerProperty>;

method emitPropertyMetadata

emitPropertyMetadata: (property: PolymerProperty) => {
    polymer: {
        notify: boolean | undefined;
        observer: string | undefined;
        readOnly: boolean | undefined;
        attributeType: string | undefined;
    };
};

class PolymerElementMixin

class PolymerElementMixin extends ElementMixin implements PolymerExtension {}

constructor

constructor(
    scannedMixin: ScannedPolymerElementMixin,
    document: Document<ParsedDocument<{}, {}>>
);

property behaviorAssignments

readonly behaviorAssignments: ScannedReference<'behavior'>[];

property listeners

readonly listeners: { event: string; handler: string }[];

property localIds

readonly localIds: LocalId[];

property observers

readonly observers: Observer[];

property properties

readonly properties: Map<string, PolymerProperty>;

property pseudo

readonly pseudo: boolean;

method emitPropertyMetadata

emitPropertyMetadata: (property: PolymerProperty) => {
    polymer: {
        notify: boolean | undefined;
        observer: string | undefined;
        readOnly: boolean | undefined;
        attributeType: string | undefined;
    };
};

class PrefixedUrlLoader

class PrefixedUrlLoader implements UrlLoader {}

Resolves requests via a given delegate loader for URLs matching a given prefix. URLs are provided to their delegate without the prefix.

constructor

constructor(prefix: string, delegate: UrlLoader);

property delegate

delegate: UrlLoader;

property prefix

prefix: string;

method canLoad

canLoad: (url: ResolvedUrl) => boolean;

method load

load: (url: ResolvedUrl) => Promise<string>;

class RedirectResolver

class RedirectResolver extends UrlResolver {}

Resolves a URL having one prefix to another URL with a different prefix.

constructor

constructor(
    packageUrl: String & ResolvedUrlBrand,
    _redirectFrom: string,
    _redirectTo: string
);

method relative

relative: {
    (to: ResolvedUrl): PackageRelativeUrl;
    (from: ResolvedUrl, to: ResolvedUrl, kind?: string): FileRelativeUrl;
};

method resolve

resolve: (
    firstUrl: ResolvedUrl | PackageRelativeUrl,
    secondUrl?: FileRelativeUrl,
    _import?: ScannedImport
) => ResolvedUrl | undefined;

class Reference

class Reference<F extends Feature> implements Feature {}

A reference to another feature by identifier.

constructor

constructor(
    identifier: string,
    sourceRange: SourceRange,
    astNode: AstNodeWithLanguage,
    feature: Feature,
    warnings: readonly Warning[]
);

property astNode

readonly astNode: AstNodeWithLanguage;

property feature

readonly feature: Feature;

property identifier

readonly identifier: string;

property identifiers

readonly identifiers: ReadonlySet<string>;

property kinds

readonly kinds: ReadonlySet<'reference'>;

property sourceRange

readonly sourceRange: SourceRange;

property warnings

readonly warnings: readonly Warning[];

class ResolvedUrlBrand

class ResolvedUrlBrand {}

class ScannedClass

class ScannedClass implements ScannedFeature, Resolvable {}

Represents a JS class as encountered in source code.
We only emit a ScannedClass when there's not a more specific kind of feature. Like, we don't emit a ScannedClass when we encounter an element or a mixin (though in the future those features will likely extend from ScannedClass/Class).
TODO(rictic): currently there's a ton of duplicated code across the Class, Element, Mixin, PolymerElement, and PolymerMixin classes. We should really unify this stuff to a single representation and set of algorithms.

constructor

constructor(
    className: string,
    localClassName: string,
    astNode: AstNodeWithLanguage,
    statementAst: any,
    jsdoc: jsdocLib.Annotation,
    description: string,
    sourceRange: SourceRange,
    properties: Map<string, ScannedProperty>,
    methods: Map<string, ScannedMethod>,
    constructorMethod: ScannedMethod,
    staticMethods: Map<string, ScannedMethod>,
    superClass: ScannedReference<'class'>,
    mixins: ScannedReference<'element-mixin'>[],
    privacy: Privacy,
    warnings: Warning[],
    abstract: boolean,
    demos: Demo[]
);

property abstract

readonly abstract: boolean;

property astNode

readonly astNode: AstNodeWithLanguage;

property constructorMethod

readonly constructorMethod?: ScannedMethod;

property demos

readonly demos: Demo[];

property description

readonly description: string;

property jsdoc

readonly jsdoc: jsdocLib.Annotation;

property localName

readonly localName: string;

The name of the class in the local scope where it is defined.

property methods

readonly methods: ImmutableMap<string, ScannedMethod>;

property mixins

readonly mixins: ScannedReference<'element-mixin'>[];

property name

readonly name: string;

property privacy

readonly privacy: Privacy;

property properties

readonly properties: Map<string, ScannedProperty>;

property sourceRange

readonly sourceRange: SourceRange;

property statementAst

readonly statementAst: any;

property staticMethods

readonly staticMethods: ImmutableMap<string, ScannedMethod>;

property summary

readonly summary: string;

property superClass

readonly superClass: ScannedReference<'class'>;

property warnings

readonly warnings: Warning[];

method finishInitialization

finishInitialization: (
    methods: Map<string, ScannedMethod>,
    properties: Map<string, ScannedProperty>
) => void;

Allows additional properties and methods to be added to the class after initialization. For example, members found attached to the prototype at a later place in the document

method resolve

resolve: (document: Document) => Feature | undefined;

class ScannedDocument

class ScannedDocument {}

The metadata for all features and elements defined in one document

constructor

constructor(
    document: ParsedDocument<{}, {}>,
    features: ScannedFeature[],
    warnings?: Warning[]
);

property astNode

readonly astNode: AstNodeWithLanguage;

property document

document: ParsedDocument<{}, {}>;

property features

features: ScannedFeature[];

property isInline

isInline: boolean;

property sourceRange

readonly sourceRange: SourceRange;

property url

readonly url: String & ResolvedUrlBrand;

property warnings

warnings: Warning[];

method getNestedFeatures

getNestedFeatures: () => ScannedFeature[];

Gets all features in this scanned document and all inline documents it contains.

class ScannedElement

class ScannedElement extends ScannedElementBase {}

property className

className?: string;

property extends

extends?: string;

For customized built-in elements, the tagname of the superClass.

property name

readonly name: string;

property superClass

superClass?: ScannedReference<'class'>;

property tagName

tagName?: string;

method resolve

resolve: (document: Document) => Element;

class ScannedElementBase

abstract class ScannedElementBase implements Resolvable {}

Base class for ScannedElement and ScannedElementMixin.

property 'slots'

'slots': Slot[];

property abstract

abstract: boolean;

property astNode

astNode: AstNodeWithLanguage;

property attributes

attributes: Map<string, ScannedAttribute>;

property demos

demos: Demo[];

property description

description: string;

property events

events: Map<string, ScannedEvent>;

property jsdoc

jsdoc?: jsdoc.Annotation;

property methods

methods: Map<string, ScannedMethod>;

property mixins

mixins: ScannedReference<'element-mixin'>[];

property privacy

privacy: Privacy;

property properties

properties: Map<string, ScannedProperty>;

property sourceRange

sourceRange: SourceRange;

property statementAst

statementAst: any;

property staticMethods

staticMethods: Map<string, ScannedMethod>;

property summary

summary: string;

property superClass

superClass?: ScannedReference<'class'>;

property warnings

warnings: Warning[];

method applyHtmlComment

applyHtmlComment: (
    commentText: string | undefined,
    containingDocument: ParsedDocument | undefined
) => void;

method resolve

abstract resolve: (_document: Document) => Feature;

class ScannedElementMixin

class ScannedElementMixin extends ScannedElementBase {}

constructor

constructor({ name }: { name: string });

property abstract

readonly abstract: boolean;

property name

readonly name: string;

method resolve

resolve: (document: Document) => ElementMixin;

class ScannedElementReference

class ScannedElementReference implements Resolvable {}

constructor

constructor(tagName: string, sourceRange: SourceRange, ast: HtmlAstNode);

property astNode

readonly astNode: HtmlAstNode;

property attributes

readonly attributes: Map<string, Attribute>;

property sourceRange

readonly sourceRange: SourceRange;

property tagName

readonly tagName: string;

property warnings

readonly warnings: ImmutableArray<Warning>;

method resolve

resolve: (document: Document) => ElementReference;

class ScannedFeature

abstract class ScannedFeature {}

constructor

constructor(
    sourceRange?: SourceRange,
    astNode?: AstNodeWithLanguage,
    description?: string,
    jsdoc?: jsdoc.Annotation,
    warnings?: Warning[]
);

property astNode

readonly astNode?: AstNodeWithLanguage;

The AST Node, if any, that corresponds to this feature in its containing document.

property description

readonly description?: string;

property jsdoc

readonly jsdoc?: jsdoc.Annotation;

property sourceRange

readonly sourceRange: SourceRange;

Tracks the source that this feature came from.

property warnings

readonly warnings: Warning[] | ImmutableArray<Warning>;

Warnings that were encountered while processing this feature.

class ScannedImport

class ScannedImport implements Resolvable {}

Represents an import, such as an HTML import, an external script or style tag, or an JavaScript import.
N The AST node type

constructor

constructor(
    type: string,
    url: String & FileRelativeUrlBrand,
    sourceRange: SourceRange,
    urlSourceRange: SourceRange,
    ast: AstNodeWithLanguage,
    lazy: boolean
);

property astNode

astNode: AstNodeWithLanguage;

property error

error: { message?: string };

property lazy

lazy: boolean;

If true, the imported document may not be loaded until well after the containing document has been evaluated, and indeed may never load.

property sourceRange

sourceRange: SourceRange;

property type

readonly type: string;

property url

url: String & FileRelativeUrlBrand;

URL of the import, relative to the base directory.

property urlSourceRange

urlSourceRange: SourceRange;

The source range specifically for the URL or reference to the imported resource.

property warnings

warnings: Warning[];

method addCouldNotLoadWarning

protected addCouldNotLoadWarning: (
    document: Document,
    warning?: Warning
) => void;

method constructImport

protected constructImport: (
    resolvedUrl: ResolvedUrl,
    relativeUrl: FileRelativeUrl,
    importedDocument: Document | undefined,
    _containingDocument: Document
) => Import;

method getLoadableUrlOrWarn

protected getLoadableUrlOrWarn: (document: Document) => ResolvedUrl | undefined;

Resolve the URL for this import and return it if the analyzer

method resolve

resolve: (document: Document) => Import | undefined;

class ScannedInlineDocument

class ScannedInlineDocument implements ScannedFeature, Resolvable {}

Represents an inline document, usually a or tag in an HTML document.
N The AST node type

constructor

constructor(
    type: string,
    contents: string,
    locationOffset: LocationOffset,
    attachedComment: string,
    sourceRange: SourceRange,
    astNode: AstNodeWithLanguage
);

property astNode

readonly astNode: AstNodeWithLanguage;

property attachedComment

readonly attachedComment?: string;

property contents

readonly contents: string;

property locationOffset

readonly locationOffset: LocationOffset;

The location offset of this document within the containing document.

property scannedDocument

scannedDocument?: ScannedDocument;

property sourceRange

readonly sourceRange: SourceRange;

property type

readonly type: string;

property warnings

readonly warnings: Warning[];

method resolve

resolve: (document: Document) => Document | undefined;

class ScannedReference

class ScannedReference<K extends keyof FeatureKindMap>
    extends ScannedFeature
    implements Resolvable {}

A reference to another feature by identifier.

constructor

constructor(
    kind: keyof FeatureKindMap,
    identifier: string,
    sourceRange: SourceRange,
    astNode: AstNodeWithLanguage,
    astPath: NodePath,
    description?: string,
    jsdoc?: Annotation,
    warnings?: Warning[]
);

property astNode

readonly astNode: AstNodeWithLanguage;

property astPath

readonly astPath: NodePath;

property identifier

readonly identifier: string;

property kind

readonly kind: keyof FeatureKindMap;

property sourceRange

readonly sourceRange: SourceRange;

method resolve

resolve: (document: Document) => Reference<FeatureKindMap[K]>;

method resolveWithKind

resolveWithKind: <DK extends keyof FeatureKindMap>(
    document: Document,
    kind: DK
) => Reference<FeatureKindMap[DK]>;

class Slot

class Slot {}

constructor

constructor(name: string, range: SourceRange, astNode: AstNodeWithLanguage);

property astNode

astNode?: AstNodeWithLanguage;

property name

name: string;

property range

range: SourceRange;

class UrlResolver

abstract class UrlResolver {}

Resolves the given URL to the concrete URL that a resource can be loaded from.
This can be useful to resolve name to paths, such as resolving 'polymer' to '../polymer/polymer.html', or component paths, like '../polymer/polymer.html' to '/bower_components/polymer/polymer.html'.

method brandAsFileRelative

protected brandAsFileRelative: (url: string) => FileRelativeUrl;

method brandAsPackageRelative

protected brandAsPackageRelative: (url: string) => PackageRelativeUrl;

method brandAsResolved

protected brandAsResolved: (url: string) => ResolvedUrl;

method getBaseAndUnresolved

protected getBaseAndUnresolved: (
    url1: PackageRelativeUrl | ResolvedUrl,
    url2?: FileRelativeUrl
) => [ResolvedUrl | undefined, FileRelativeUrl | PackageRelativeUrl];

method relative

abstract relative: {
    (to: ResolvedUrl): PackageRelativeUrl;
    (from: ResolvedUrl, to: ResolvedUrl, kind?: string): FileRelativeUrl;
};

method resolve

abstract resolve: {
    (url: PackageRelativeUrl): ResolvedUrl | undefined;
    (
        baseUrl: ResolvedUrl,
        url: FileRelativeUrl,
        scannedImport?: ScannedImport
    ): ResolvedUrl;
};

Resoves url to a new location.
Returns undefined if the given url cannot be resolved.

method simpleUrlRelative

protected simpleUrlRelative: (
    from: ResolvedUrl,
    to: ResolvedUrl
) => FileRelativeUrl;

method simpleUrlResolve

protected simpleUrlResolve: (
    baseUrl: ResolvedUrl,
    url: FileRelativeUrl | PackageRelativeUrl,
    defaultProtocol: string
) => ResolvedUrl;

class Warning

class Warning {}

constructor

constructor(init: WarningInit);

property actions

readonly actions: readonly Action[];

Other actions that could be taken in response to this warning.
Each action is separate and they may be mutually exclusive. In the case of edit actions they often are.

property code

readonly code: string;

property fix

readonly fix: Edit;

If the problem has a single automatic fix, this is it.
Whether and how much something is 'automatic' can be a bit tricky to delineate. Roughly speaking, if 99% of the time the change solves the issue completely then it should go in fix.

property message

readonly message: string;

property severity

readonly severity: Severity;

property sourceRange

readonly sourceRange: SourceRange;

method toJSON

toJSON: () => {
    code: string;
    message: string;
    severity: Severity;
    sourceRange: SourceRange;
};

method toString

toString: (options?: Partial<WarningStringifyOptions>) => string;

class WarningCarryingException

class WarningCarryingException extends Error {}

constructor

constructor(warning: Warning);

property warning

readonly warning: Warning;

class WarningFilter

class WarningFilter {}

constructor

constructor(options: Options);

property fileGlobsToFilterOut

fileGlobsToFilterOut: readonly IMinimatch[];

property minimumSeverity

minimumSeverity: Severity;

property warningCodesToIgnore

warningCodesToIgnore: ReadonlySet<string>;

method shouldIgnore

shouldIgnore: (warning: Warning) => boolean;

class WarningPrinter

class WarningPrinter {}

constructor

constructor(
    _outStream: NodeJS.WritableStream,
    options?: Partial<WarningStringifyOptions>
);

method printWarnings

printWarnings: (warnings: Iterable<Warning>) => Promise<void>;

Convenience method around printWarning.

Interfaces

interface AnalysisFormat

interface Analysis {}

The global namespace of features contained in an analysis.
Top-level members are unnamespaced, everything else is contained in a namespace. Often an analysis will contain only one namespace at the root.

property classes

classes?: Class[];

All toplevel classes found that were not covered by one of the other types.
e.g. classes that are elements are only found in elements

property elements

elements?: Element[];

All elements found.

property functions

functions?: Function[];

All toplevel functions found.

property metadata

metadata?: any;

An extension point for framework-specific metadata, as well as any metadata not yet standardized here such as what polyfills are needed, behaviors and mixins used, the framework that the package was written in, tags/categories, framework config files, etc.
Framework-specific metadata should be put into a sub-object with the name of that framework.

property mixins

mixins?: ElementMixin[];

All element mixins found.

property namespaces

namespaces?: Namespace[];

All toplevel namespaces found.

property schema_version

schema_version: string;

interface AnalyzerOptions

interface Options {}

property lazyEdges

lazyEdges?: LazyEdgeMap;

Map from url of an HTML Document to another HTML document it lazily depends on.

property moduleResolution

moduleResolution?: 'node';

Algorithm to use for resolving module specifiers in import and export statements when rewriting them to be web-compatible. A value of 'node' uses Node.js resolution to find modules.

property parsers

parsers?: Map<string, Parser<ParsedDocument>>;

property scanners

scanners?: ScannerTable;

property urlLoader

urlLoader: UrlLoader;

property urlResolver

urlResolver?: UrlResolver;

interface Attribute

interface Attribute extends ScannedAttribute {}

property inheritedFrom

readonly inheritedFrom?: string;

interface ClassInit

interface ClassInit {}

property abstract

readonly abstract: boolean;

property astNode

readonly astNode: AstNodeWithLanguage | undefined;

property className

readonly className?: string;

property constructorMethod

readonly constructorMethod?: Method;

property demos

readonly demos?: Demo[];

property description

readonly description: string;

property jsdoc

readonly jsdoc?: jsdocLib.Annotation;

property methods

readonly methods?: ImmutableMap<string, Method>;

property mixins

readonly mixins?: Array<ScannedReference<'element-mixin'>>;

property name

readonly name?: string;

property privacy

readonly privacy: Privacy;

property properties

readonly properties?: ImmutableMap<string, Property>;

property sourceRange

readonly sourceRange: SourceRange | undefined;

property statementAst

readonly statementAst: babel.Statement | undefined;

property staticMethods

readonly staticMethods: ImmutableMap<string, Method>;

property summary

readonly summary: string;

property superClass

readonly superClass?: ScannedReference<'class'> | undefined;

property warnings

readonly warnings?: Warning[];

interface CssAstNode

interface CssAstNode {}

property containingDocument

containingDocument: ParsedCssDocument;

property language

language: 'css';

property node

node: shady.Node;

interface CssVisitor

interface Visitor {}

method visit

visit: (node: shady.Node) => void;

interface Demo

interface Demo {}

property desc

desc?: string;

property path

path: FileRelativeUrl;

interface EditAction

interface EditAction {}

An EditAction is like a fix, only it's not applied automatically when the user runs polymer lint --fix. Often this is because it's less safe to apply automatically, and there may be caveats, or multiple ways to resolve the warning.
For example, a change to an element that updates it to no longer use a deprecated feature, but that involves a change in the element's API should not be a fix, but should instead be an EditAction.

property code

code: string;

A unique string code for the edit action. Useful so that the user can request that all actions with a given code should be applied.

property description

description: string;

A short description of the change, noting caveats and important information for the user.

property edit

edit: Edit;

property kind

kind: 'edit';

interface EditResult

interface EditResult {}

property appliedEdits

appliedEdits: Edit[];

The edits that had no conflicts, and are reflected in editedFiles.

property editedFiles

editedFiles: Map<ResolvedUrl, string>;

A map from urls to their new contents.

property incompatibleEdits

incompatibleEdits: Edit[];

Edits that could not be applied due to overlapping ranges.

interface ElementBaseInit

interface ElementBaseInit extends ClassInit {}

property attributes

readonly attributes?: Map<string, Attribute>;

property events

readonly events?: Map<string, Event>;

property slots

readonly slots?: Slot[];

interface ElementInit

interface ElementInit extends ElementBaseInit {}

property className

className?: string;

property extends

extends?: string;

property superClass

superClass?: ScannedReference<'class'>;

property tagName

tagName?: string;

interface ElementMixinInit

interface ElementMixinInit extends ElementBaseInit {}

property name

name: string;

interface Event

interface Event {}

property astNode

readonly astNode: JsAstNode | undefined;

property description

readonly description?: string;

property inheritedFrom

readonly inheritedFrom?: string;

property name

readonly name: string;

property type

readonly type?: string;

interface FeatureKindMap

interface FeatureKindMap {}

interface FeatureKindMap

interface FeatureKindMap {}

property 'css-document'

'css-document': Document<ParsedCssDocument>;

property 'document'

document: Document;

property 'html-document'

'html-document': Document<ParsedHtmlDocument>;

property 'js-document'

'js-document': Document<JavaScriptDocument>;

property 'json-document'

'json-document': Document<ParsedJsonDocument>;

property 'typescript-document'

'typescript-document': Document<ParsedTypeScriptDocument>;

interface FeatureKindMap

interface FeatureKindMap {}

property 'inline-document'

'inline-document': InlineDocument;

interface FeatureKindMap

interface FeatureKindMap {}

property 'class'

class: Class;

interface FeatureKindMap

interface FeatureKindMap {}

property 'reference'

reference: Reference<Feature>;

interface FeatureKindMap

interface FeatureKindMap {}

property 'element'

element: Element;

interface FeatureKindMap

interface FeatureKindMap {}

property 'element-mixin'

'element-mixin': ElementMixin;

interface FeatureKindMap

interface FeatureKindMap {}

property 'element-reference'

'element-reference': ElementReference;

interface FeatureKindMap

interface FeatureKindMap {}

property 'css-import'

'css-import': Import;

property 'html-import'

'html-import': Import;

property 'html-script'

'html-script': Import;

property 'html-style'

'html-style': Import;

property 'import'

import: Import;

property 'lazy-import'

'lazy-import': Import;

interface FeatureKindMap

interface FeatureKindMap {}

property 'namespace'

namespace: Namespace;

interface FeatureKindMap

interface FeatureKindMap {}

property 'js-import'

'js-import': JavascriptImport;

interface FeatureKindMap

interface FeatureKindMap {}

property 'export'

export: Export;

interface FeatureKindMap

interface FeatureKindMap {}

property 'function'

function: Function;

interface FeatureKindMap

interface FeatureKindMap {}

property 'behavior'

behavior: Behavior;

interface FeatureKindMap

interface FeatureKindMap {}

property 'polymer-element'

'polymer-element': PolymerElement;

property 'pseudo-element'

'pseudo-element': Element;

interface FeatureKindMap

interface FeatureKindMap {}

property 'polymer-element-mixin'

'polymer-element-mixin': PolymerElementMixin;

interface FeatureKindMap

interface FeatureKindMap {}

property 'dom-module'

'dom-module': DomModule;

interface FeatureKindMap

interface FeatureKindMap {}

property 'polymer-core-feature'

'polymer-core-feature': PolymerCoreFeature;

interface FeatureKindMap

interface FeatureKindMap {}

property 'css-custom-property-assignment'

'css-custom-property-assignment': CssCustomPropertyAssignment;

interface FeatureKindMap

interface FeatureKindMap {}

property 'css-custom-property-use'

'css-custom-property-use': CssCustomPropertyUse;

interface HtmlAstNode

interface HtmlAstNode {}

property containingDocument

containingDocument: ParsedHtmlDocument;

property language

language: 'html';

property node

node: dom5.Node;

interface HtmlVisitor

interface HtmlVisitor {}

The ASTs of the HTML elements needed to represent Polymer elements.

call signature

(node: ASTNode): void;

interface InlineDocInfo

interface InlineDocInfo {}

property astNode

astNode?: AstNodeWithLanguage;

property baseUrl

baseUrl?: ResolvedUrl;

property locationOffset

locationOffset?: LocationOffset;

interface JavascriptVisitor

interface Visitor {}

property enter

readonly enter?: VisitorCallback<babel.Node>;

property enterArrayExpression

readonly enterArrayExpression?: VisitorCallback<babel.ArrayExpression>;

property enterArrayPattern

readonly enterArrayPattern?: VisitorCallback<babel.ArrayPattern>;

property enterArrowFunctionExpression

readonly enterArrowFunctionExpression?: VisitorCallback<babel.ArrowFunctionExpression>;

property enterAssignmentExpression

readonly enterAssignmentExpression?: VisitorCallback<babel.AssignmentExpression>;

property enterAssignmentPattern

readonly enterAssignmentPattern?: VisitorCallback<babel.AssignmentPattern>;

property enterAssignmentProperty

readonly enterAssignmentProperty?: VisitorCallback<babel.AssignmentProperty>;

property enterBinaryExpression

readonly enterBinaryExpression?: VisitorCallback<babel.BinaryExpression>;

property enterBlockStatement

readonly enterBlockStatement?: VisitorCallback<babel.BlockStatement>;

property enterBreakStatement

readonly enterBreakStatement?: VisitorCallback<babel.BreakStatement>;

property enterCallExpression

readonly enterCallExpression?: VisitorCallback<babel.CallExpression>;

property enterCatchClause

readonly enterCatchClause?: VisitorCallback<babel.CatchClause>;

property enterClassDeclaration

readonly enterClassDeclaration?: VisitorCallback<babel.ClassDeclaration>;

property enterClassExpression

readonly enterClassExpression?: VisitorCallback<babel.ClassExpression>;

property enterClassMethod

readonly enterClassMethod?: VisitorCallback<babel.ClassMethod>;

property enterConditionalExpression

readonly enterConditionalExpression?: VisitorCallback<babel.ConditionalExpression>;

property enterContinueStatement

readonly enterContinueStatement?: VisitorCallback<babel.ContinueStatement>;

property enterDebuggerStatement

readonly enterDebuggerStatement?: VisitorCallback<babel.DebuggerStatement>;

property enterDoWhileStatement

readonly enterDoWhileStatement?: VisitorCallback<babel.DoWhileStatement>;

property enterEmptyStatement

readonly enterEmptyStatement?: VisitorCallback<babel.EmptyStatement>;

property enterExportAllDeclaration

readonly enterExportAllDeclaration?: VisitorCallback<babel.ExportAllDeclaration>;

property enterExportDefaultDeclaration

readonly enterExportDefaultDeclaration?: VisitorCallback<babel.ExportDefaultDeclaration>;

property enterExportNamedDeclaration

readonly enterExportNamedDeclaration?: VisitorCallback<babel.ExportNamedDeclaration>;

property enterExportSpecifier

readonly enterExportSpecifier?: VisitorCallback<babel.ExportSpecifier>;

property enterExpressionStatement

readonly enterExpressionStatement?: VisitorCallback<babel.ExpressionStatement>;

property enterForInStatement

readonly enterForInStatement?: VisitorCallback<babel.ForInStatement>;

property enterForOfStatement

readonly enterForOfStatement?: VisitorCallback<babel.ForOfStatement>;

property enterForStatement

readonly enterForStatement?: VisitorCallback<babel.ForStatement>;

property enterFunctionDeclaration

readonly enterFunctionDeclaration?: VisitorCallback<babel.FunctionDeclaration>;

property enterFunctionExpression

readonly enterFunctionExpression?: VisitorCallback<babel.FunctionExpression>;

property enterIdentifier

readonly enterIdentifier?: VisitorCallback<babel.Identifier>;

property enterIfStatement

readonly enterIfStatement?: VisitorCallback<babel.IfStatement>;

property enterImportDeclaration

readonly enterImportDeclaration?: VisitorCallback<babel.ImportDeclaration>;

property enterImportDefaultSpecifier

readonly enterImportDefaultSpecifier?: VisitorCallback<babel.ImportDefaultSpecifier>;

property enterImportNamespaceSpecifier

readonly enterImportNamespaceSpecifier?: VisitorCallback<babel.ImportNamespaceSpecifier>;

property enterImportSpecifier

readonly enterImportSpecifier?: VisitorCallback<babel.ImportSpecifier>;

property enterLabeledStatement

readonly enterLabeledStatement?: VisitorCallback<babel.LabeledStatement>;

property enterLiteral

readonly enterLiteral?: VisitorCallback<babel.Literal>;

property enterLogicalExpression

readonly enterLogicalExpression?: VisitorCallback<babel.LogicalExpression>;

property enterMemberExpression

readonly enterMemberExpression?: VisitorCallback<babel.MemberExpression>;

property enterMetaProperty

readonly enterMetaProperty?: VisitorCallback<babel.MetaProperty>;

property enterMethod

readonly enterMethod?: VisitorCallback<babel.Method>;

property enterModuleDeclaration

readonly enterModuleDeclaration?: VisitorCallback<babel.ModuleDeclaration>;

property enterModuleSpecifier

readonly enterModuleSpecifier?: VisitorCallback<babel.ModuleSpecifier>;

property enterNewExpression

readonly enterNewExpression?: VisitorCallback<babel.NewExpression>;

property enterObjectExpression

readonly enterObjectExpression?: VisitorCallback<babel.ObjectExpression>;

property enterObjectMethod

readonly enterObjectMethod?: VisitorCallback<babel.ObjectMethod>;

property enterObjectPattern

readonly enterObjectPattern?: VisitorCallback<babel.ObjectPattern>;

property enterObjectProperty

readonly enterObjectProperty?: VisitorCallback<babel.ObjectProperty>;

property enterPattern

readonly enterPattern?: VisitorCallback<babel.Pattern>;

property enterProgram

readonly enterProgram?: VisitorCallback<babel.Program>;

property enterProperty

readonly enterProperty?: VisitorCallback<babel.Property>;

property enterRestElement

readonly enterRestElement?: VisitorCallback<babel.RestElement>;

property enterReturnStatement

readonly enterReturnStatement?: VisitorCallback<babel.ReturnStatement>;

property enterSequenceExpression

readonly enterSequenceExpression?: VisitorCallback<babel.SequenceExpression>;

property enterSpreadElement

readonly enterSpreadElement?: VisitorCallback<babel.SpreadElement>;

property enterSuper

readonly enterSuper?: VisitorCallback<babel.Super>;

property enterSwitchCase

readonly enterSwitchCase?: VisitorCallback<babel.SwitchCase>;

property enterSwitchStatement

readonly enterSwitchStatement?: VisitorCallback<babel.SwitchStatement>;

property enterTaggedTemplateExpression

readonly enterTaggedTemplateExpression?: VisitorCallback<babel.TaggedTemplateExpression>;

property enterTemplateElement

readonly enterTemplateElement?: VisitorCallback<babel.TemplateElement>;

property enterTemplateLiteral

readonly enterTemplateLiteral?: VisitorCallback<babel.TemplateLiteral>;

property enterThisExpression

readonly enterThisExpression?: VisitorCallback<babel.ThisExpression>;

property enterThrowStatement

readonly enterThrowStatement?: VisitorCallback<babel.ThrowStatement>;

property enterTryStatement

readonly enterTryStatement?: VisitorCallback<babel.TryStatement>;

property enterUnaryExpression

readonly enterUnaryExpression?: VisitorCallback<babel.UnaryExpression>;

property enterUpdateExpression

readonly enterUpdateExpression?: VisitorCallback<babel.UpdateExpression>;

property enterVariableDeclaration

readonly enterVariableDeclaration?: VisitorCallback<babel.VariableDeclaration>;

property enterVariableDeclarator

readonly enterVariableDeclarator?: VisitorCallback<babel.VariableDeclarator>;

property enterWhileStatement

readonly enterWhileStatement?: VisitorCallback<babel.WhileStatement>;

property enterWithStatement

readonly enterWithStatement?: VisitorCallback<babel.WithStatement>;

property enterYieldExpression

readonly enterYieldExpression?: VisitorCallback<babel.YieldExpression>;

property leave

readonly leave?: VisitorCallback<babel.Node>;

property leaveArrayExpression

readonly leaveArrayExpression?: VisitorCallback<babel.ArrayExpression>;

property leaveArrayPattern

readonly leaveArrayPattern?: VisitorCallback<babel.ArrayPattern>;

property leaveArrowFunctionExpression

readonly leaveArrowFunctionExpression?: VisitorCallback<babel.ArrowFunctionExpression>;

property leaveAssignmentExpression

readonly leaveAssignmentExpression?: VisitorCallback<babel.AssignmentExpression>;

property leaveAssignmentPattern

readonly leaveAssignmentPattern?: VisitorCallback<babel.AssignmentPattern>;

property leaveAssignmentProperty

readonly leaveAssignmentProperty?: VisitorCallback<babel.AssignmentProperty>;

property leaveBinaryExpression

readonly leaveBinaryExpression?: VisitorCallback<babel.BinaryExpression>;

property leaveBlockStatement

readonly leaveBlockStatement?: VisitorCallback<babel.BlockStatement>;

property leaveBreakStatement

readonly leaveBreakStatement?: VisitorCallback<babel.BreakStatement>;

property leaveCallExpression

readonly leaveCallExpression?: VisitorCallback<babel.CallExpression>;

property leaveCatchClause

readonly leaveCatchClause?: VisitorCallback<babel.CatchClause>;

property leaveClassDeclaration

readonly leaveClassDeclaration?: VisitorCallback<babel.ClassDeclaration>;

property leaveClassExpression

readonly leaveClassExpression?: VisitorCallback<babel.ClassExpression>;

property leaveClassMethod

readonly leaveClassMethod?: VisitorCallback<babel.ClassMethod>;

property leaveConditionalExpression

readonly leaveConditionalExpression?: VisitorCallback<babel.ConditionalExpression>;

property leaveContinueStatement

readonly leaveContinueStatement?: VisitorCallback<babel.ContinueStatement>;

property leaveDebuggerStatement

readonly leaveDebuggerStatement?: VisitorCallback<babel.DebuggerStatement>;

property leaveDoWhileStatement

readonly leaveDoWhileStatement?: VisitorCallback<babel.DoWhileStatement>;

property leaveEmptyStatement

readonly leaveEmptyStatement?: VisitorCallback<babel.EmptyStatement>;

property leaveExportAllDeclaration

readonly leaveExportAllDeclaration?: VisitorCallback<babel.ExportAllDeclaration>;

property leaveExportDefaultDeclaration

readonly leaveExportDefaultDeclaration?: VisitorCallback<babel.ExportDefaultDeclaration>;

property leaveExportNamedDeclaration

readonly leaveExportNamedDeclaration?: VisitorCallback<babel.ExportNamedDeclaration>;

property leaveExportSpecifier

readonly leaveExportSpecifier?: VisitorCallback<babel.ExportSpecifier>;

property leaveExpressionStatement

readonly leaveExpressionStatement?: VisitorCallback<babel.ExpressionStatement>;

property leaveForInStatement

readonly leaveForInStatement?: VisitorCallback<babel.ForInStatement>;

property leaveForOfStatement

readonly leaveForOfStatement?: VisitorCallback<babel.ForOfStatement>;

property leaveForStatement

readonly leaveForStatement?: VisitorCallback<babel.ForStatement>;

property leaveFunctionDeclaration

readonly leaveFunctionDeclaration?: VisitorCallback<babel.FunctionDeclaration>;

property leaveFunctionExpression

readonly leaveFunctionExpression?: VisitorCallback<babel.FunctionExpression>;

property leaveIdentifier

readonly leaveIdentifier?: VisitorCallback<babel.Identifier>;

property leaveIfStatement

readonly leaveIfStatement?: VisitorCallback<babel.IfStatement>;

property leaveImportDeclaration

readonly leaveImportDeclaration?: VisitorCallback<babel.ImportDeclaration>;

property leaveImportDefaultSpecifier

readonly leaveImportDefaultSpecifier?: VisitorCallback<babel.ImportDefaultSpecifier>;

property leaveImportNamespaceSpecifier

readonly leaveImportNamespaceSpecifier?: VisitorCallback<babel.ImportNamespaceSpecifier>;

property leaveImportSpecifier

readonly leaveImportSpecifier?: VisitorCallback<babel.ImportSpecifier>;

property leaveLabeledStatement

readonly leaveLabeledStatement?: VisitorCallback<babel.LabeledStatement>;

property leaveLiteral

readonly leaveLiteral?: VisitorCallback<babel.Literal>;

property leaveLogicalExpression

readonly leaveLogicalExpression?: VisitorCallback<babel.LogicalExpression>;

property leaveMemberExpression

readonly leaveMemberExpression?: VisitorCallback<babel.MemberExpression>;

property leaveMetaProperty

readonly leaveMetaProperty?: VisitorCallback<babel.MetaProperty>;

property leaveMethod

readonly leaveMethod?: VisitorCallback<babel.Method>;

property leaveModuleDeclaration

readonly leaveModuleDeclaration?: VisitorCallback<babel.ModuleDeclaration>;

property leaveModuleSpecifier

readonly leaveModuleSpecifier?: VisitorCallback<babel.ModuleSpecifier>;

property leaveNewExpression

readonly leaveNewExpression?: VisitorCallback<babel.NewExpression>;

property leaveObjectExpression

readonly leaveObjectExpression?: VisitorCallback<babel.ObjectExpression>;

property leaveObjectMethod

readonly leaveObjectMethod?: VisitorCallback<babel.ObjectMethod>;

property leaveObjectPattern

readonly leaveObjectPattern?: VisitorCallback<babel.ObjectPattern>;

property leaveObjectProperty

readonly leaveObjectProperty?: VisitorCallback<babel.ObjectProperty>;

property leavePattern

readonly leavePattern?: VisitorCallback<babel.Pattern>;

property leaveProgram

readonly leaveProgram?: VisitorCallback<babel.Program>;

property leaveProperty

readonly leaveProperty?: VisitorCallback<babel.Property>;

property leaveRestElement

readonly leaveRestElement?: VisitorCallback<babel.RestElement>;

property leaveReturnStatement

readonly leaveReturnStatement?: VisitorCallback<babel.ReturnStatement>;

property leaveSequenceExpression

readonly leaveSequenceExpression?: VisitorCallback<babel.SequenceExpression>;

property leaveSpreadElement

readonly leaveSpreadElement?: VisitorCallback<babel.SpreadElement>;

property leaveSuper

readonly leaveSuper?: VisitorCallback<babel.Super>;

property leaveSwitchCase

readonly leaveSwitchCase?: VisitorCallback<babel.SwitchCase>;

property leaveSwitchStatement

readonly leaveSwitchStatement?: VisitorCallback<babel.SwitchStatement>;

property leaveTaggedTemplateExpression

readonly leaveTaggedTemplateExpression?: VisitorCallback<babel.TaggedTemplateExpression>;

property leaveTemplateElement

readonly leaveTemplateElement?: VisitorCallback<babel.TemplateElement>;

property leaveTemplateLiteral

readonly leaveTemplateLiteral?: VisitorCallback<babel.TemplateLiteral>;

property leaveThisExpression

readonly leaveThisExpression?: VisitorCallback<babel.ThisExpression>;

property leaveThrowStatement

readonly leaveThrowStatement?: VisitorCallback<babel.ThrowStatement>;

property leaveTryStatement

readonly leaveTryStatement?: VisitorCallback<babel.TryStatement>;

property leaveUnaryExpression

readonly leaveUnaryExpression?: VisitorCallback<babel.UnaryExpression>;

property leaveUpdateExpression

readonly leaveUpdateExpression?: VisitorCallback<babel.UpdateExpression>;

property leaveVariableDeclaration

readonly leaveVariableDeclaration?: VisitorCallback<babel.VariableDeclaration>;

property leaveVariableDeclarator

readonly leaveVariableDeclarator?: VisitorCallback<babel.VariableDeclarator>;

property leaveWhileStatement

readonly leaveWhileStatement?: VisitorCallback<babel.WhileStatement>;

property leaveWithStatement

readonly leaveWithStatement?: VisitorCallback<babel.WithStatement>;

property leaveYieldExpression

readonly leaveYieldExpression?: VisitorCallback<babel.YieldExpression>;

interface JsAstNode

interface JsAstNode<N extends babel.Node = babel.Node> {}

property containingDocument

containingDocument: JavaScriptDocument;

property language

language: 'js';

property node

node: N;

interface JsonVisitor

interface Visitor {}

method visit

visit: (node: Json) => void;

interface LiteralArray

interface LiteralArray extends Array<LiteralValue> {}

interface LiteralObj

interface LiteralObj {}

index signature

[key: string]: LiteralValue;

interface LocationOffset

interface LocationOffset {}

property col

readonly col: number;

Zero based column index.

property filename

readonly filename?: ResolvedUrl;

The url of the source file.

property line

readonly line: number;

Zero based line index.

interface Method

interface Method extends Property {}

property params

readonly params?: MethodParam[];

property return

readonly return?: {
    type?: string;
    desc?: string;
};

interface MethodParam

interface MethodParam {}

property defaultValue

readonly defaultValue?: string;

property description

readonly description?: string;

property name

readonly name: string;

property rest

readonly rest?: boolean;

property type

readonly type?: string;

interface Property

interface Property {}

property 'default'

readonly default?: string;

property astNode

readonly astNode: JsAstNode | undefined;

property changeEvent

readonly changeEvent?: string;

property description

readonly description?: string;

property inheritedFrom

readonly inheritedFrom?: string;

property jsdoc

readonly jsdoc?: jsdoc.Annotation;

property name

readonly name: string;

property privacy

privacy: Privacy;

property readOnly

readonly readOnly?: boolean;

property sourceRange

readonly sourceRange?: SourceRange;

property type

readonly type?: string;

interface PropertyLike

interface PropertyLike {}

property inheritedFrom

inheritedFrom?: string;

property name

name: string;

property privacy

privacy?: Privacy;

property sourceRange

sourceRange?: SourceRange;

interface Queryable

interface Queryable {}

Represents something like a Document or an Analysis. A container of features and warnings that's queryable in a few different ways.

method getFeatures

getFeatures: {
    <K extends keyof FeatureKindMap>(query: BaseQueryWithKind<K>): Set<
        FeatureKindMap[K]
    >;
    (query?: BaseQuery): Set<Feature>;
};

method getWarnings

getWarnings: (options?: BaseQuery) => Warning[];

interface Replacement

interface Replacement {}

Represents an action for replacing a range in a document with some text.
This is sufficient to represent all operations on text files, including inserting and deleting text (using empty ranges or empty replacement text, respectively).

property range

readonly range: SourceRange;

property replacementText

readonly replacementText: string;

interface Resolvable

interface Resolvable extends ScannedFeature {}

A ScannedFeature that needs to resolve other Features to build its final representation.

method resolve

resolve: (document: Document) => Feature | undefined;

interface ScannedAttribute

interface ScannedAttribute {}

property changeEvent

readonly changeEvent?: string;

property description

readonly description?: string;

property name

readonly name: string;

property sourceRange

readonly sourceRange: SourceRange | undefined;

property type

readonly type?: string;

interface ScannedEvent

interface ScannedEvent extends ScannedFeature {}

property astNode

readonly astNode: JsAstNode | undefined;

property description

readonly description?: string;

property name

readonly name: string;

property params

readonly params: {
    type: string;
    desc: string;
    name: string;
}[];

property type

readonly type?: string;

interface ScannedMethod

interface ScannedMethod extends ScannedProperty {}

property params

params?: MethodParam[];

property return

return?: {
    type?: string;
    desc?: string;
};

interface ScannedProperty

interface ScannedProperty extends ScannedFeature {}

property 'default'

default?: string;

property astNode

astNode: JsAstNode | undefined;

property changeEvent

changeEvent?: string;

property name

name: string;

property privacy

privacy: Privacy;

property readOnly

readOnly?: boolean;

property type

type?: string;

property warnings

warnings: Warning[];

interface SourcePosition

interface SourcePosition {}

property column

readonly column: number;

The column offset within the line, starting from zero.

property line

readonly line: number;

The line number, starting from zero.

interface SourceRange

interface SourceRange {}

Describes a range of text within a source file.
NOTE: line and column Position properties are indexed from zero. Consider displaying them to users as one-indexed numbers to match text editor conventions.

property end

readonly end: SourcePosition;

property file

readonly file: ResolvedUrl;

property start

readonly start: SourcePosition;

interface UrlLoader

interface UrlLoader {}

An object that reads files.

method canLoad

canLoad: (url: ResolvedUrl) => boolean;

Returns true if this loader can load the given url.

method load

load: (url: ResolvedUrl) => Promise<string>;

Reads a file from url.
This should only be called if canLoad returns true for url.

method readDirectory

readDirectory: (
    path: ResolvedUrl,
    deep?: boolean
) => Promise<PackageRelativeUrl[]>;

Lists files in a directory in the current project.
Parameter path
A relative path to a directory to read.
Parameter deep
If true, lists files recursively. Returned paths are relative to url.

interface Visitor

interface Visitor {}

property enter

readonly enter?: VisitorCallback<babel.Node>;

property enterArrayExpression

readonly enterArrayExpression?: VisitorCallback<babel.ArrayExpression>;

property enterArrayPattern

readonly enterArrayPattern?: VisitorCallback<babel.ArrayPattern>;

property enterArrowFunctionExpression

readonly enterArrowFunctionExpression?: VisitorCallback<babel.ArrowFunctionExpression>;

property enterAssignmentExpression

readonly enterAssignmentExpression?: VisitorCallback<babel.AssignmentExpression>;

property enterAssignmentPattern

readonly enterAssignmentPattern?: VisitorCallback<babel.AssignmentPattern>;

property enterAssignmentProperty

readonly enterAssignmentProperty?: VisitorCallback<babel.AssignmentProperty>;

property enterBinaryExpression

readonly enterBinaryExpression?: VisitorCallback<babel.BinaryExpression>;

property enterBlockStatement

readonly enterBlockStatement?: VisitorCallback<babel.BlockStatement>;

property enterBreakStatement

readonly enterBreakStatement?: VisitorCallback<babel.BreakStatement>;

property enterCallExpression

readonly enterCallExpression?: VisitorCallback<babel.CallExpression>;

property enterCatchClause

readonly enterCatchClause?: VisitorCallback<babel.CatchClause>;

property enterClassDeclaration

readonly enterClassDeclaration?: VisitorCallback<babel.ClassDeclaration>;

property enterClassExpression

readonly enterClassExpression?: VisitorCallback<babel.ClassExpression>;

property enterClassMethod

readonly enterClassMethod?: VisitorCallback<babel.ClassMethod>;

property enterConditionalExpression

readonly enterConditionalExpression?: VisitorCallback<babel.ConditionalExpression>;

property enterContinueStatement

readonly enterContinueStatement?: VisitorCallback<babel.ContinueStatement>;

property enterDebuggerStatement

readonly enterDebuggerStatement?: VisitorCallback<babel.DebuggerStatement>;

property enterDoWhileStatement

readonly enterDoWhileStatement?: VisitorCallback<babel.DoWhileStatement>;

property enterEmptyStatement

readonly enterEmptyStatement?: VisitorCallback<babel.EmptyStatement>;

property enterExportAllDeclaration

readonly enterExportAllDeclaration?: VisitorCallback<babel.ExportAllDeclaration>;

property enterExportDefaultDeclaration

readonly enterExportDefaultDeclaration?: VisitorCallback<babel.ExportDefaultDeclaration>;

property enterExportNamedDeclaration

readonly enterExportNamedDeclaration?: VisitorCallback<babel.ExportNamedDeclaration>;

property enterExportSpecifier

readonly enterExportSpecifier?: VisitorCallback<babel.ExportSpecifier>;

property enterExpressionStatement

readonly enterExpressionStatement?: VisitorCallback<babel.ExpressionStatement>;

property enterForInStatement

readonly enterForInStatement?: VisitorCallback<babel.ForInStatement>;

property enterForOfStatement

readonly enterForOfStatement?: VisitorCallback<babel.ForOfStatement>;

property enterForStatement

readonly enterForStatement?: VisitorCallback<babel.ForStatement>;

property enterFunctionDeclaration

readonly enterFunctionDeclaration?: VisitorCallback<babel.FunctionDeclaration>;

property enterFunctionExpression

readonly enterFunctionExpression?: VisitorCallback<babel.FunctionExpression>;

property enterIdentifier

readonly enterIdentifier?: VisitorCallback<babel.Identifier>;

property enterIfStatement

readonly enterIfStatement?: VisitorCallback<babel.IfStatement>;

property enterImportDeclaration

readonly enterImportDeclaration?: VisitorCallback<babel.ImportDeclaration>;

property enterImportDefaultSpecifier

readonly enterImportDefaultSpecifier?: VisitorCallback<babel.ImportDefaultSpecifier>;

property enterImportNamespaceSpecifier

readonly enterImportNamespaceSpecifier?: VisitorCallback<babel.ImportNamespaceSpecifier>;

property enterImportSpecifier

readonly enterImportSpecifier?: VisitorCallback<babel.ImportSpecifier>;

property enterLabeledStatement

readonly enterLabeledStatement?: VisitorCallback<babel.LabeledStatement>;

property enterLiteral

readonly enterLiteral?: VisitorCallback<babel.Literal>;

property enterLogicalExpression

readonly enterLogicalExpression?: VisitorCallback<babel.LogicalExpression>;

property enterMemberExpression

readonly enterMemberExpression?: VisitorCallback<babel.MemberExpression>;

property enterMetaProperty

readonly enterMetaProperty?: VisitorCallback<babel.MetaProperty>;

property enterMethod

readonly enterMethod?: VisitorCallback<babel.Method>;

property enterModuleDeclaration

readonly enterModuleDeclaration?: VisitorCallback<babel.ModuleDeclaration>;

property enterModuleSpecifier

readonly enterModuleSpecifier?: VisitorCallback<babel.ModuleSpecifier>;

property enterNewExpression

readonly enterNewExpression?: VisitorCallback<babel.NewExpression>;

property enterObjectExpression

readonly enterObjectExpression?: VisitorCallback<babel.ObjectExpression>;

property enterObjectMethod

readonly enterObjectMethod?: VisitorCallback<babel.ObjectMethod>;

property enterObjectPattern

readonly enterObjectPattern?: VisitorCallback<babel.ObjectPattern>;

property enterObjectProperty

readonly enterObjectProperty?: VisitorCallback<babel.ObjectProperty>;

property enterPattern

readonly enterPattern?: VisitorCallback<babel.Pattern>;

property enterProgram

readonly enterProgram?: VisitorCallback<babel.Program>;

property enterProperty

readonly enterProperty?: VisitorCallback<babel.Property>;

property enterRestElement

readonly enterRestElement?: VisitorCallback<babel.RestElement>;

property enterReturnStatement

readonly enterReturnStatement?: VisitorCallback<babel.ReturnStatement>;

property enterSequenceExpression

readonly enterSequenceExpression?: VisitorCallback<babel.SequenceExpression>;

property enterSpreadElement

readonly enterSpreadElement?: VisitorCallback<babel.SpreadElement>;

property enterSuper

readonly enterSuper?: VisitorCallback<babel.Super>;

property enterSwitchCase

readonly enterSwitchCase?: VisitorCallback<babel.SwitchCase>;

property enterSwitchStatement

readonly enterSwitchStatement?: VisitorCallback<babel.SwitchStatement>;

property enterTaggedTemplateExpression

readonly enterTaggedTemplateExpression?: VisitorCallback<babel.TaggedTemplateExpression>;

property enterTemplateElement

readonly enterTemplateElement?: VisitorCallback<babel.TemplateElement>;

property enterTemplateLiteral

readonly enterTemplateLiteral?: VisitorCallback<babel.TemplateLiteral>;

property enterThisExpression

readonly enterThisExpression?: VisitorCallback<babel.ThisExpression>;

property enterThrowStatement

readonly enterThrowStatement?: VisitorCallback<babel.ThrowStatement>;

property enterTryStatement

readonly enterTryStatement?: VisitorCallback<babel.TryStatement>;

property enterUnaryExpression

readonly enterUnaryExpression?: VisitorCallback<babel.UnaryExpression>;

property enterUpdateExpression

readonly enterUpdateExpression?: VisitorCallback<babel.UpdateExpression>;

property enterVariableDeclaration

readonly enterVariableDeclaration?: VisitorCallback<babel.VariableDeclaration>;

property enterVariableDeclarator

readonly enterVariableDeclarator?: VisitorCallback<babel.VariableDeclarator>;

property enterWhileStatement

readonly enterWhileStatement?: VisitorCallback<babel.WhileStatement>;

property enterWithStatement

readonly enterWithStatement?: VisitorCallback<babel.WithStatement>;

property enterYieldExpression

readonly enterYieldExpression?: VisitorCallback<babel.YieldExpression>;

property leave

readonly leave?: VisitorCallback<babel.Node>;

property leaveArrayExpression

readonly leaveArrayExpression?: VisitorCallback<babel.ArrayExpression>;

property leaveArrayPattern

readonly leaveArrayPattern?: VisitorCallback<babel.ArrayPattern>;

property leaveArrowFunctionExpression

readonly leaveArrowFunctionExpression?: VisitorCallback<babel.ArrowFunctionExpression>;

property leaveAssignmentExpression

readonly leaveAssignmentExpression?: VisitorCallback<babel.AssignmentExpression>;

property leaveAssignmentPattern

readonly leaveAssignmentPattern?: VisitorCallback<babel.AssignmentPattern>;

property leaveAssignmentProperty

readonly leaveAssignmentProperty?: VisitorCallback<babel.AssignmentProperty>;

property leaveBinaryExpression

readonly leaveBinaryExpression?: VisitorCallback<babel.BinaryExpression>;

property leaveBlockStatement

readonly leaveBlockStatement?: VisitorCallback<babel.BlockStatement>;

property leaveBreakStatement

readonly leaveBreakStatement?: VisitorCallback<babel.BreakStatement>;

property leaveCallExpression

readonly leaveCallExpression?: VisitorCallback<babel.CallExpression>;

property leaveCatchClause

readonly leaveCatchClause?: VisitorCallback<babel.CatchClause>;

property leaveClassDeclaration

readonly leaveClassDeclaration?: VisitorCallback<babel.ClassDeclaration>;

property leaveClassExpression

readonly leaveClassExpression?: VisitorCallback<babel.ClassExpression>;

property leaveClassMethod

readonly leaveClassMethod?: VisitorCallback<babel.ClassMethod>;

property leaveConditionalExpression

readonly leaveConditionalExpression?: VisitorCallback<babel.ConditionalExpression>;

property leaveContinueStatement

readonly leaveContinueStatement?: VisitorCallback<babel.ContinueStatement>;

property leaveDebuggerStatement

readonly leaveDebuggerStatement?: VisitorCallback<babel.DebuggerStatement>;

property leaveDoWhileStatement

readonly leaveDoWhileStatement?: VisitorCallback<babel.DoWhileStatement>;

property leaveEmptyStatement

readonly leaveEmptyStatement?: VisitorCallback<babel.EmptyStatement>;

property leaveExportAllDeclaration

readonly leaveExportAllDeclaration?: VisitorCallback<babel.ExportAllDeclaration>;

property leaveExportDefaultDeclaration

readonly leaveExportDefaultDeclaration?: VisitorCallback<babel.ExportDefaultDeclaration>;

property leaveExportNamedDeclaration

readonly leaveExportNamedDeclaration?: VisitorCallback<babel.ExportNamedDeclaration>;

property leaveExportSpecifier

readonly leaveExportSpecifier?: VisitorCallback<babel.ExportSpecifier>;

property leaveExpressionStatement

readonly leaveExpressionStatement?: VisitorCallback<babel.ExpressionStatement>;

property leaveForInStatement

readonly leaveForInStatement?: VisitorCallback<babel.ForInStatement>;

property leaveForOfStatement

readonly leaveForOfStatement?: VisitorCallback<babel.ForOfStatement>;

property leaveForStatement

readonly leaveForStatement?: VisitorCallback<babel.ForStatement>;

property leaveFunctionDeclaration

readonly leaveFunctionDeclaration?: VisitorCallback<babel.FunctionDeclaration>;

property leaveFunctionExpression

readonly leaveFunctionExpression?: VisitorCallback<babel.FunctionExpression>;

property leaveIdentifier

readonly leaveIdentifier?: VisitorCallback<babel.Identifier>;

property leaveIfStatement

readonly leaveIfStatement?: VisitorCallback<babel.IfStatement>;

property leaveImportDeclaration

readonly leaveImportDeclaration?: VisitorCallback<babel.ImportDeclaration>;

property leaveImportDefaultSpecifier

readonly leaveImportDefaultSpecifier?: VisitorCallback<babel.ImportDefaultSpecifier>;

property leaveImportNamespaceSpecifier

readonly leaveImportNamespaceSpecifier?: VisitorCallback<babel.ImportNamespaceSpecifier>;

property leaveImportSpecifier

readonly leaveImportSpecifier?: VisitorCallback<babel.ImportSpecifier>;

property leaveLabeledStatement

readonly leaveLabeledStatement?: VisitorCallback<babel.LabeledStatement>;

property leaveLiteral

readonly leaveLiteral?: VisitorCallback<babel.Literal>;

property leaveLogicalExpression

readonly leaveLogicalExpression?: VisitorCallback<babel.LogicalExpression>;

property leaveMemberExpression

readonly leaveMemberExpression?: VisitorCallback<babel.MemberExpression>;

property leaveMetaProperty

readonly leaveMetaProperty?: VisitorCallback<babel.MetaProperty>;

property leaveMethod

readonly leaveMethod?: VisitorCallback<babel.Method>;

property leaveModuleDeclaration

readonly leaveModuleDeclaration?: VisitorCallback<babel.ModuleDeclaration>;

property leaveModuleSpecifier

readonly leaveModuleSpecifier?: VisitorCallback<babel.ModuleSpecifier>;

property leaveNewExpression

readonly leaveNewExpression?: VisitorCallback<babel.NewExpression>;

property leaveObjectExpression

readonly leaveObjectExpression?: VisitorCallback<babel.ObjectExpression>;

property leaveObjectMethod

readonly leaveObjectMethod?: VisitorCallback<babel.ObjectMethod>;

property leaveObjectPattern

readonly leaveObjectPattern?: VisitorCallback<babel.ObjectPattern>;

property leaveObjectProperty

readonly leaveObjectProperty?: VisitorCallback<babel.ObjectProperty>;

property leavePattern

readonly leavePattern?: VisitorCallback<babel.Pattern>;

property leaveProgram

readonly leaveProgram?: VisitorCallback<babel.Program>;

property leaveProperty

readonly leaveProperty?: VisitorCallback<babel.Property>;

property leaveRestElement

readonly leaveRestElement?: VisitorCallback<babel.RestElement>;

property leaveReturnStatement

readonly leaveReturnStatement?: VisitorCallback<babel.ReturnStatement>;

property leaveSequenceExpression

readonly leaveSequenceExpression?: VisitorCallback<babel.SequenceExpression>;

property leaveSpreadElement

readonly leaveSpreadElement?: VisitorCallback<babel.SpreadElement>;

property leaveSuper

readonly leaveSuper?: VisitorCallback<babel.Super>;

property leaveSwitchCase

readonly leaveSwitchCase?: VisitorCallback<babel.SwitchCase>;

property leaveSwitchStatement

readonly leaveSwitchStatement?: VisitorCallback<babel.SwitchStatement>;

property leaveTaggedTemplateExpression

readonly leaveTaggedTemplateExpression?: VisitorCallback<babel.TaggedTemplateExpression>;

property leaveTemplateElement

readonly leaveTemplateElement?: VisitorCallback<babel.TemplateElement>;

property leaveTemplateLiteral

readonly leaveTemplateLiteral?: VisitorCallback<babel.TemplateLiteral>;

property leaveThisExpression

readonly leaveThisExpression?: VisitorCallback<babel.ThisExpression>;

property leaveThrowStatement

readonly leaveThrowStatement?: VisitorCallback<babel.ThrowStatement>;

property leaveTryStatement

readonly leaveTryStatement?: VisitorCallback<babel.TryStatement>;

property leaveUnaryExpression

readonly leaveUnaryExpression?: VisitorCallback<babel.UnaryExpression>;

property leaveUpdateExpression

readonly leaveUpdateExpression?: VisitorCallback<babel.UpdateExpression>;

property leaveVariableDeclaration

readonly leaveVariableDeclaration?: VisitorCallback<babel.VariableDeclaration>;

property leaveVariableDeclarator

readonly leaveVariableDeclarator?: VisitorCallback<babel.VariableDeclarator>;

property leaveWhileStatement

readonly leaveWhileStatement?: VisitorCallback<babel.WhileStatement>;

property leaveWithStatement

readonly leaveWithStatement?: VisitorCallback<babel.WithStatement>;

property leaveYieldExpression

readonly leaveYieldExpression?: VisitorCallback<babel.YieldExpression>;

interface WarningInit

interface WarningInit {}

property actions

readonly actions?: ReadonlyArray<Action>;

property code

readonly code: string;

property fix

readonly fix?: Edit;

property message

readonly message: string;

property parsedDocument

readonly parsedDocument: ParsedDocument;

property severity

readonly severity: Severity;

property sourceRange

readonly sourceRange: SourceRange;

interface WarningStringifyOptions

interface WarningStringifyOptions {}

property color

readonly color: boolean;

property maxCodeLines

readonly maxCodeLines?: number;

If given, we will only print this many lines of code. Otherwise print all lines in the source range.

property resolver

readonly resolver?: UrlResolver;

If given, we will use resolver.relative to get a relative path to the reported file.

property verbosity

readonly verbosity: Verbosity;

Enums

enum Severity

enum Severity {
    ERROR = 0,
    WARNING = 1,
    INFO = 2,
}

member ERROR

ERROR = 0

member INFO

INFO = 2

member WARNING

WARNING = 1

Type Aliases

type Action

type Action =
    | EditAction
    | {
          /** To ensure that type safe code actually checks for the action kind. */
          kind: 'never';
      };

type AnalysisQuery

type AnalysisQuery = BaseAnalysisQuery & {
    kind?: string;
};

type AstNodeWithLanguage

type AstNodeWithLanguage = HtmlAstNode | JsAstNode | CssAstNode;

type DocumentQuery

type DocumentQuery = BaseDocumentQuery & {
    kind?: string;
};

type Edit

type Edit = ReadonlyArray<Replacement>;

A set of replacements that must all be applied as a single atomic unit.

type ElementTemplate

type ElementTemplate =
    | {
          /**
           * HTML that is stamped out without data binding or other
           * interpretation beyond normal HTML semantics.
           */
          kind: 'html';
          contents: ASTNode;
      }
    | {
          /**
           * HTML that's interpreted with the polymer databinding
           * system.
           */
          kind: 'polymer-databinding';
          contents: ASTNode;
      };

The element's runtime contents.

type FileRelativeUrl

type FileRelativeUrl = string & FileRelativeUrlBrand;

A URL that must be resolved relative to a specific base url.
Note that it might still be an absolute URL, or even a url with a full protocol and host.
This is mostly used to type urls extracted from import statements taken directly out of documents. For example, in import * as foo from "./foo.js" ./foo.js is relative to the containing document.
Use UrlResolver#resolve to transform it to a ResolvedUrl. Use UrlResolver#relative to transform ResolvedUrls to FileRelativeUrls.

type HtmlDatabindingExpression

type HtmlDatabindingExpression =
    | TextNodeDatabindingExpression
    | AttributeDatabindingExpression;

type Json

type Json = JsonObject | JsonArray | number | string | boolean | null;

type LiteralValue

type LiteralValue =
    | string
    | number
    | boolean
    | RegExp
    | undefined
    | LiteralArray
    | LiteralObj
    | null;

Copyright (c) 2016 The Polymer Project Authors. All rights reserved. This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as part of the polymer project is also subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt

type PackageRelativeUrl

type PackageRelativeUrl = string & PackageRelativeUrlBrand;

A URL that must be resolved relative to the package itself.
Note it might still be an absolute URL, or even a url with a full protocol and host.
This is the assumed format of user input to Analyzer methods.
Use UrlResolver#resolve to transform it to a ResolvedUrl.

type Privacy

type Privacy = 'public' | 'private' | 'protected';

type ResolvedUrl

type ResolvedUrl = string & ResolvedUrlBrand;

A URL that has been resolved to its canonical and loadable form, by passing through the project's URL Resolver.
Use AnalysisContext#resolve to get a ResolvedUrl.

type Verbosity

type Verbosity = 'one-line' | 'full' | 'code-only';

type WarningPrinterVerbosity

type Verbosity = 'one-line' | 'full';

Namespaces

namespace @babel/generator

module '@babel/generator' {}

There aren't existing types for @babel/ packages, but we can create them given the babel-* typings.

namespace @babel/traverse

module '@babel/traverse' {}

namespace @babel/types

module '@babel/types' {}

namespace indent

module 'indent' {}

function indent

indent: (text: string, margin?: number | string) => string;

namespace knuth-shuffle

module 'knuth-shuffle' {}

function knuthShuffle

knuthShuffle: (arr: Array<any>) => void;

Does an in-place shuffle of the given array.

namespace strip-indent

module 'strip-indent' {}

function stripIndent

stripIndent: (text: string) => string;

Package Files (61)

Dev Dependencies (12)

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-analyzer.

Markdown

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

HTML

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

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

polymer-analyzer

Install

Overview

Index

Functions

Classes

Interfaces

Enums

Type Aliases

Namespaces

Functions

function applyEdits

function comparePosition

function comparePositionAndRange

function correctPosition

function correctSourceRange

function generateAnalysis

function getAttachedCommentText

function getLocationOffsetOfStartOfTextContent

function isPositionInsideRange

function isResolvable

function makeParseLoader

function uncorrectPosition

function uncorrectSourceRange

function validateAnalysis

Classes

class Analysis

method getDocument

method getDocumentContaining

Parameter sourceRange

method getFeatures

method getWarnings

method isExternal

class Analyzer

property urlResolver

method analyze

method analyzePackage

method canLoad

method clearCaches

method filesChanged

Parameter urls

method load

method resolveUrl

class AttributeDatabindingExpression

property astNode

property attribute

property databindingInto

property direction

property eventName

property isCompleteBinding

class Class

property abstract

property astNode

property className

Deprecated

property constructorMethod

property demos

property description

property identifiers

property jsdoc

property kinds

property methods

property mixins

property name

property privacy

property properties

property sourceRange

property statementAst

property staticMethods

property summary

property superClass

property warnings

method emitMetadata

method emitMethodMetadata

method emitPropertyMetadata

method inheritFrom

class Document

property astNode

property identifiers

property isInline