polymer-analyzer
- Version 3.2.4
- Published
- 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
Classes
Interfaces
JavascriptVisitor
- enter
- enterArrayExpression
- enterArrayPattern
- enterArrowFunctionExpression
- enterAssignmentExpression
- enterAssignmentPattern
- enterAssignmentProperty
- enterBinaryExpression
- enterBlockStatement
- enterBreakStatement
- enterCallExpression
- enterCatchClause
- enterClassDeclaration
- enterClassExpression
- enterClassMethod
- enterConditionalExpression
- enterContinueStatement
- enterDebuggerStatement
- enterDoWhileStatement
- enterEmptyStatement
- enterExportAllDeclaration
- enterExportDefaultDeclaration
- enterExportNamedDeclaration
- enterExportSpecifier
- enterExpressionStatement
- enterForInStatement
- enterForOfStatement
- enterForStatement
- enterFunctionDeclaration
- enterFunctionExpression
- enterIdentifier
- enterIfStatement
- enterImportDeclaration
- enterImportDefaultSpecifier
- enterImportNamespaceSpecifier
- enterImportSpecifier
- enterLabeledStatement
- enterLiteral
- enterLogicalExpression
- enterMemberExpression
- enterMetaProperty
- enterMethod
- enterModuleDeclaration
- enterModuleSpecifier
- enterNewExpression
- enterObjectExpression
- enterObjectMethod
- enterObjectPattern
- enterObjectProperty
- enterPattern
- enterProgram
- enterProperty
- enterRestElement
- enterReturnStatement
- enterSequenceExpression
- enterSpreadElement
- enterSuper
- enterSwitchCase
- enterSwitchStatement
- enterTaggedTemplateExpression
- enterTemplateElement
- enterTemplateLiteral
- enterThisExpression
- enterThrowStatement
- enterTryStatement
- enterUnaryExpression
- enterUpdateExpression
- enterVariableDeclaration
- enterVariableDeclarator
- enterWhileStatement
- enterWithStatement
- enterYieldExpression
- leave
- leaveArrayExpression
- leaveArrayPattern
- leaveArrowFunctionExpression
- leaveAssignmentExpression
- leaveAssignmentPattern
- leaveAssignmentProperty
- leaveBinaryExpression
- leaveBlockStatement
- leaveBreakStatement
- leaveCallExpression
- leaveCatchClause
- leaveClassDeclaration
- leaveClassExpression
- leaveClassMethod
- leaveConditionalExpression
- leaveContinueStatement
- leaveDebuggerStatement
- leaveDoWhileStatement
- leaveEmptyStatement
- leaveExportAllDeclaration
- leaveExportDefaultDeclaration
- leaveExportNamedDeclaration
- leaveExportSpecifier
- leaveExpressionStatement
- leaveForInStatement
- leaveForOfStatement
- leaveForStatement
- leaveFunctionDeclaration
- leaveFunctionExpression
- leaveIdentifier
- leaveIfStatement
- leaveImportDeclaration
- leaveImportDefaultSpecifier
- leaveImportNamespaceSpecifier
- leaveImportSpecifier
- leaveLabeledStatement
- leaveLiteral
- leaveLogicalExpression
- leaveMemberExpression
- leaveMetaProperty
- leaveMethod
- leaveModuleDeclaration
- leaveModuleSpecifier
- leaveNewExpression
- leaveObjectExpression
- leaveObjectMethod
- leaveObjectPattern
- leaveObjectProperty
- leavePattern
- leaveProgram
- leaveProperty
- leaveRestElement
- leaveReturnStatement
- leaveSequenceExpression
- leaveSpreadElement
- leaveSuper
- leaveSwitchCase
- leaveSwitchStatement
- leaveTaggedTemplateExpression
- leaveTemplateElement
- leaveTemplateLiteral
- leaveThisExpression
- leaveThrowStatement
- leaveTryStatement
- leaveUnaryExpression
- leaveUpdateExpression
- leaveVariableDeclaration
- leaveVariableDeclarator
- leaveWhileStatement
- leaveWithStatement
- leaveYieldExpression
Visitor
- enter
- enterArrayExpression
- enterArrayPattern
- enterArrowFunctionExpression
- enterAssignmentExpression
- enterAssignmentPattern
- enterAssignmentProperty
- enterBinaryExpression
- enterBlockStatement
- enterBreakStatement
- enterCallExpression
- enterCatchClause
- enterClassDeclaration
- enterClassExpression
- enterClassMethod
- enterConditionalExpression
- enterContinueStatement
- enterDebuggerStatement
- enterDoWhileStatement
- enterEmptyStatement
- enterExportAllDeclaration
- enterExportDefaultDeclaration
- enterExportNamedDeclaration
- enterExportSpecifier
- enterExpressionStatement
- enterForInStatement
- enterForOfStatement
- enterForStatement
- enterFunctionDeclaration
- enterFunctionExpression
- enterIdentifier
- enterIfStatement
- enterImportDeclaration
- enterImportDefaultSpecifier
- enterImportNamespaceSpecifier
- enterImportSpecifier
- enterLabeledStatement
- enterLiteral
- enterLogicalExpression
- enterMemberExpression
- enterMetaProperty
- enterMethod
- enterModuleDeclaration
- enterModuleSpecifier
- enterNewExpression
- enterObjectExpression
- enterObjectMethod
- enterObjectPattern
- enterObjectProperty
- enterPattern
- enterProgram
- enterProperty
- enterRestElement
- enterReturnStatement
- enterSequenceExpression
- enterSpreadElement
- enterSuper
- enterSwitchCase
- enterSwitchStatement
- enterTaggedTemplateExpression
- enterTemplateElement
- enterTemplateLiteral
- enterThisExpression
- enterThrowStatement
- enterTryStatement
- enterUnaryExpression
- enterUpdateExpression
- enterVariableDeclaration
- enterVariableDeclarator
- enterWhileStatement
- enterWithStatement
- enterYieldExpression
- leave
- leaveArrayExpression
- leaveArrayPattern
- leaveArrowFunctionExpression
- leaveAssignmentExpression
- leaveAssignmentPattern
- leaveAssignmentProperty
- leaveBinaryExpression
- leaveBlockStatement
- leaveBreakStatement
- leaveCallExpression
- leaveCatchClause
- leaveClassDeclaration
- leaveClassExpression
- leaveClassMethod
- leaveConditionalExpression
- leaveContinueStatement
- leaveDebuggerStatement
- leaveDoWhileStatement
- leaveEmptyStatement
- leaveExportAllDeclaration
- leaveExportDefaultDeclaration
- leaveExportNamedDeclaration
- leaveExportSpecifier
- leaveExpressionStatement
- leaveForInStatement
- leaveForOfStatement
- leaveForStatement
- leaveFunctionDeclaration
- leaveFunctionExpression
- leaveIdentifier
- leaveIfStatement
- leaveImportDeclaration
- leaveImportDefaultSpecifier
- leaveImportNamespaceSpecifier
- leaveImportSpecifier
- leaveLabeledStatement
- leaveLiteral
- leaveLogicalExpression
- leaveMemberExpression
- leaveMetaProperty
- leaveMethod
- leaveModuleDeclaration
- leaveModuleSpecifier
- leaveNewExpression
- leaveObjectExpression
- leaveObjectMethod
- leaveObjectPattern
- leaveObjectProperty
- leavePattern
- leaveProgram
- leaveProperty
- leaveRestElement
- leaveReturnStatement
- leaveSequenceExpression
- leaveSpreadElement
- leaveSuper
- leaveSwitchCase
- leaveSwitchStatement
- leaveTaggedTemplateExpression
- leaveTemplateElement
- leaveTemplateLiteral
- leaveThisExpression
- leaveThrowStatement
- leaveTryStatement
- leaveUnaryExpression
- leaveUpdateExpression
- leaveVariableDeclaration
- leaveVariableDeclarator
- leaveWhileStatement
- leaveWithStatement
- leaveYieldExpression
Enums
Type Aliases
Namespaces
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 positionb
, returns 0 if they are the same, returns 1 ifa
comes afterb
.
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 byUrlLoader
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> {}
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 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 {}
interface Method
interface Method extends Property {}
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 {}
interface ScannedProperty
interface ScannedProperty extends ScannedFeature {}
interface SourcePosition
interface SourcePosition {}
interface SourceRange
interface SourceRange {}
Describes a range of text within a source file.
NOTE:
line
andcolumn
Position properties are indexed from zero. Consider displaying them to users as one-indexed numbers to match text editor conventions.
interface UrlLoader
interface UrlLoader {}
An object that reads files.
method canLoad
canLoad: (url: ResolvedUrl) => boolean;
Returns
true
if this loader can load the givenurl
.
method load
load: (url: ResolvedUrl) => Promise<string>;
Reads a file from
url
.This should only be called if
canLoad
returnstrue
forurl
.
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
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)
- custom_typings/babel.d.ts
- custom_typings/indent.d.ts
- custom_typings/knuth-shuffle.d.ts
- custom_typings/strip-indent.d.ts
- lib/analysis-format/analysis-format.d.ts
- lib/analysis-format/generate-analysis.d.ts
- lib/core/analyzer.d.ts
- lib/css/css-custom-property-scanner.d.ts
- lib/css/css-document.d.ts
- lib/html/html-document.d.ts
- lib/index.d.ts
- lib/javascript/estree-visitor.d.ts
- lib/javascript/function.d.ts
- lib/javascript/javascript-document.d.ts
- lib/javascript/javascript-export-scanner.d.ts
- lib/javascript/javascript-import-scanner.d.ts
- lib/javascript/namespace.d.ts
- lib/json/json-document.d.ts
- lib/model/analysis.d.ts
- lib/model/attribute.d.ts
- lib/model/class.d.ts
- lib/model/document-backreference.d.ts
- lib/model/document.d.ts
- lib/model/element-base.d.ts
- lib/model/element-mixin.d.ts
- lib/model/element-reference.d.ts
- lib/model/element.d.ts
- lib/model/event.d.ts
- lib/model/feature.d.ts
- lib/model/import.d.ts
- lib/model/inline-document.d.ts
- lib/model/literal.d.ts
- lib/model/map.d.ts
- lib/model/method.d.ts
- lib/model/property.d.ts
- lib/model/queryable.d.ts
- lib/model/reference.d.ts
- lib/model/resolvable.d.ts
- lib/model/source-range.d.ts
- lib/model/url.d.ts
- lib/model/warning.d.ts
- lib/parser/document.d.ts
- lib/polymer/behavior.d.ts
- lib/polymer/dom-module-scanner.d.ts
- lib/polymer/expression-scanner.d.ts
- lib/polymer/polymer-core-feature.d.ts
- lib/polymer/polymer-element-mixin.d.ts
- lib/polymer/polymer-element.d.ts
- lib/url-loader/fetch-url-loader.d.ts
- lib/url-loader/fs-url-loader.d.ts
- lib/url-loader/fs-url-resolver.d.ts
- lib/url-loader/multi-url-loader.d.ts
- lib/url-loader/multi-url-resolver.d.ts
- lib/url-loader/overlay-loader.d.ts
- lib/url-loader/package-url-resolver.d.ts
- lib/url-loader/prefixed-url-loader.d.ts
- lib/url-loader/redirect-resolver.d.ts
- lib/url-loader/url-loader.d.ts
- lib/url-loader/url-resolver.d.ts
- lib/warning/warning-filter.d.ts
- lib/warning/warning-printer.d.ts
Dependencies (37)
- @babel/generator
- @babel/traverse
- @babel/types
- @types/babel-generator
- @types/babel-traverse
- @types/babel-types
- @types/babylon
- @types/chai-subset
- @types/chalk
- @types/clone
- @types/cssbeautify
- @types/doctrine
- @types/is-windows
- @types/minimatch
- @types/parse5
- @types/path-is-inside
- @types/resolve
- @types/whatwg-url
- babylon
- cancel-token
- chalk
- clone
- cssbeautify
- doctrine
- dom5
- indent
- is-windows
- jsonschema
- minimatch
- parse5
- path-is-inside
- resolve
- shady-css-parser
- stable
- strip-indent
- vscode-uri
- whatwg-url
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[](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 .
Package analyzed in 10242 ms. - Missing or incorrect documentation? Open an issue for this package.