de795ea233
TypeScript compiler will now build to ES2015 code and modules. Babili is used to minify ES2015 code, providing an initial optimization that we couldn't previously get just from Uglify. Uses Babel to convert ES2015 to UMD/ES5 code, and Uglify to minimize the output.
588 lines
20 KiB
TypeScript
588 lines
20 KiB
TypeScript
export declare class AttrAst implements TemplateAst {
|
|
name: string;
|
|
sourceSpan: ParseSourceSpan;
|
|
value: string;
|
|
constructor(name: string, value: string, sourceSpan: ParseSourceSpan);
|
|
visit(visitor: TemplateAstVisitor, context: any): any;
|
|
}
|
|
|
|
export declare class BoundDirectivePropertyAst implements TemplateAst {
|
|
directiveName: string;
|
|
sourceSpan: ParseSourceSpan;
|
|
templateName: string;
|
|
value: AST;
|
|
constructor(directiveName: string, templateName: string, value: AST, sourceSpan: ParseSourceSpan);
|
|
visit(visitor: TemplateAstVisitor, context: any): any;
|
|
}
|
|
|
|
export declare class BoundElementPropertyAst implements TemplateAst {
|
|
name: string;
|
|
securityContext: SecurityContext;
|
|
sourceSpan: ParseSourceSpan;
|
|
type: PropertyBindingType;
|
|
unit: string;
|
|
value: AST;
|
|
constructor(name: string, type: PropertyBindingType, securityContext: SecurityContext, value: AST, unit: string, sourceSpan: ParseSourceSpan);
|
|
visit(visitor: TemplateAstVisitor, context: any): any;
|
|
}
|
|
|
|
export declare class BoundEventAst implements TemplateAst {
|
|
fullName: string;
|
|
handler: AST;
|
|
name: string;
|
|
sourceSpan: ParseSourceSpan;
|
|
target: string;
|
|
constructor(name: string, target: string, handler: AST, sourceSpan: ParseSourceSpan);
|
|
visit(visitor: TemplateAstVisitor, context: any): any;
|
|
}
|
|
|
|
export declare class BoundTextAst implements TemplateAst {
|
|
ngContentIndex: number;
|
|
sourceSpan: ParseSourceSpan;
|
|
value: AST;
|
|
constructor(value: AST, ngContentIndex: number, sourceSpan: ParseSourceSpan);
|
|
visit(visitor: TemplateAstVisitor, context: any): any;
|
|
}
|
|
|
|
export declare class CompileDiDependencyMetadata {
|
|
isAttribute: boolean;
|
|
isHost: boolean;
|
|
isOptional: boolean;
|
|
isSelf: boolean;
|
|
isSkipSelf: boolean;
|
|
isValue: boolean;
|
|
query: CompileQueryMetadata;
|
|
token: CompileTokenMetadata;
|
|
value: any;
|
|
viewQuery: CompileQueryMetadata;
|
|
constructor({isAttribute, isSelf, isHost, isSkipSelf, isOptional, isValue, query, viewQuery, token, value}?: {
|
|
isAttribute?: boolean;
|
|
isSelf?: boolean;
|
|
isHost?: boolean;
|
|
isSkipSelf?: boolean;
|
|
isOptional?: boolean;
|
|
isValue?: boolean;
|
|
query?: CompileQueryMetadata;
|
|
viewQuery?: CompileQueryMetadata;
|
|
token?: CompileTokenMetadata;
|
|
value?: any;
|
|
});
|
|
toJson(): {
|
|
[key: string]: any;
|
|
};
|
|
static fromJson(data: {
|
|
[key: string]: any;
|
|
}): CompileDiDependencyMetadata;
|
|
}
|
|
|
|
export declare class CompileDirectiveMetadata implements CompileMetadataWithType {
|
|
changeDetection: ChangeDetectionStrategy;
|
|
exportAs: string;
|
|
hostAttributes: {
|
|
[key: string]: string;
|
|
};
|
|
hostListeners: {
|
|
[key: string]: string;
|
|
};
|
|
hostProperties: {
|
|
[key: string]: string;
|
|
};
|
|
identifier: CompileIdentifierMetadata;
|
|
inputs: {
|
|
[key: string]: string;
|
|
};
|
|
isComponent: boolean;
|
|
lifecycleHooks: LifecycleHooks[];
|
|
outputs: {
|
|
[key: string]: string;
|
|
};
|
|
precompile: CompileTypeMetadata[];
|
|
providers: CompileProviderMetadata[];
|
|
queries: CompileQueryMetadata[];
|
|
selector: string;
|
|
template: CompileTemplateMetadata;
|
|
type: CompileTypeMetadata;
|
|
viewProviders: CompileProviderMetadata[];
|
|
viewQueries: CompileQueryMetadata[];
|
|
constructor({type, isComponent, selector, exportAs, changeDetection, inputs, outputs, hostListeners, hostProperties, hostAttributes, lifecycleHooks, providers, viewProviders, queries, viewQueries, precompile, template}?: {
|
|
type?: CompileTypeMetadata;
|
|
isComponent?: boolean;
|
|
selector?: string;
|
|
exportAs?: string;
|
|
changeDetection?: ChangeDetectionStrategy;
|
|
inputs?: {
|
|
[key: string]: string;
|
|
};
|
|
outputs?: {
|
|
[key: string]: string;
|
|
};
|
|
hostListeners?: {
|
|
[key: string]: string;
|
|
};
|
|
hostProperties?: {
|
|
[key: string]: string;
|
|
};
|
|
hostAttributes?: {
|
|
[key: string]: string;
|
|
};
|
|
lifecycleHooks?: LifecycleHooks[];
|
|
providers?: Array<CompileProviderMetadata | CompileTypeMetadata | CompileIdentifierMetadata | any[]>;
|
|
viewProviders?: Array<CompileProviderMetadata | CompileTypeMetadata | CompileIdentifierMetadata | any[]>;
|
|
queries?: CompileQueryMetadata[];
|
|
viewQueries?: CompileQueryMetadata[];
|
|
precompile?: CompileTypeMetadata[];
|
|
template?: CompileTemplateMetadata;
|
|
});
|
|
toJson(): {
|
|
[key: string]: any;
|
|
};
|
|
static create({type, isComponent, selector, exportAs, changeDetection, inputs, outputs, host, lifecycleHooks, providers, viewProviders, queries, viewQueries, precompile, template}?: {
|
|
type?: CompileTypeMetadata;
|
|
isComponent?: boolean;
|
|
selector?: string;
|
|
exportAs?: string;
|
|
changeDetection?: ChangeDetectionStrategy;
|
|
inputs?: string[];
|
|
outputs?: string[];
|
|
host?: {
|
|
[key: string]: string;
|
|
};
|
|
lifecycleHooks?: LifecycleHooks[];
|
|
providers?: Array<CompileProviderMetadata | CompileTypeMetadata | CompileIdentifierMetadata | any[]>;
|
|
viewProviders?: Array<CompileProviderMetadata | CompileTypeMetadata | CompileIdentifierMetadata | any[]>;
|
|
queries?: CompileQueryMetadata[];
|
|
viewQueries?: CompileQueryMetadata[];
|
|
precompile?: CompileTypeMetadata[];
|
|
template?: CompileTemplateMetadata;
|
|
}): CompileDirectiveMetadata;
|
|
static fromJson(data: {
|
|
[key: string]: any;
|
|
}): CompileDirectiveMetadata;
|
|
}
|
|
|
|
export declare class CompileFactoryMetadata implements CompileIdentifierMetadata, CompileMetadataWithIdentifier {
|
|
diDeps: CompileDiDependencyMetadata[];
|
|
identifier: CompileIdentifierMetadata;
|
|
moduleUrl: string;
|
|
name: string;
|
|
prefix: string;
|
|
runtime: Function;
|
|
value: any;
|
|
constructor({runtime, name, moduleUrl, prefix, diDeps, value}: {
|
|
runtime?: Function;
|
|
name?: string;
|
|
prefix?: string;
|
|
moduleUrl?: string;
|
|
value?: boolean;
|
|
diDeps?: CompileDiDependencyMetadata[];
|
|
});
|
|
toJson(): {
|
|
[key: string]: any;
|
|
};
|
|
static fromJson(data: {
|
|
[key: string]: any;
|
|
}): CompileFactoryMetadata;
|
|
}
|
|
|
|
export declare class CompileIdentifierMetadata implements CompileMetadataWithIdentifier {
|
|
identifier: CompileIdentifierMetadata;
|
|
moduleUrl: string;
|
|
name: string;
|
|
prefix: string;
|
|
runtime: any;
|
|
value: any;
|
|
constructor({runtime, name, moduleUrl, prefix, value}?: {
|
|
runtime?: any;
|
|
name?: string;
|
|
moduleUrl?: string;
|
|
prefix?: string;
|
|
value?: any;
|
|
});
|
|
toJson(): {
|
|
[key: string]: any;
|
|
};
|
|
static fromJson(data: {
|
|
[key: string]: any;
|
|
}): CompileIdentifierMetadata;
|
|
}
|
|
|
|
export declare abstract class CompileMetadataWithIdentifier {
|
|
identifier: CompileIdentifierMetadata;
|
|
abstract toJson(): {
|
|
[key: string]: any;
|
|
};
|
|
}
|
|
|
|
export declare abstract class CompileMetadataWithType extends CompileMetadataWithIdentifier {
|
|
identifier: CompileIdentifierMetadata;
|
|
type: CompileTypeMetadata;
|
|
abstract toJson(): {
|
|
[key: string]: any;
|
|
};
|
|
}
|
|
|
|
export declare class CompilePipeMetadata implements CompileMetadataWithType {
|
|
identifier: CompileIdentifierMetadata;
|
|
lifecycleHooks: LifecycleHooks[];
|
|
name: string;
|
|
pure: boolean;
|
|
type: CompileTypeMetadata;
|
|
constructor({type, name, pure, lifecycleHooks}?: {
|
|
type?: CompileTypeMetadata;
|
|
name?: string;
|
|
pure?: boolean;
|
|
lifecycleHooks?: LifecycleHooks[];
|
|
});
|
|
toJson(): {
|
|
[key: string]: any;
|
|
};
|
|
static fromJson(data: {
|
|
[key: string]: any;
|
|
}): CompilePipeMetadata;
|
|
}
|
|
|
|
export declare class CompileProviderMetadata {
|
|
deps: CompileDiDependencyMetadata[];
|
|
multi: boolean;
|
|
token: CompileTokenMetadata;
|
|
useClass: CompileTypeMetadata;
|
|
useExisting: CompileTokenMetadata;
|
|
useFactory: CompileFactoryMetadata;
|
|
useValue: any;
|
|
constructor({token, useClass, useValue, useExisting, useFactory, deps, multi}: {
|
|
token?: CompileTokenMetadata;
|
|
useClass?: CompileTypeMetadata;
|
|
useValue?: any;
|
|
useExisting?: CompileTokenMetadata;
|
|
useFactory?: CompileFactoryMetadata;
|
|
deps?: CompileDiDependencyMetadata[];
|
|
multi?: boolean;
|
|
});
|
|
toJson(): {
|
|
[key: string]: any;
|
|
};
|
|
static fromJson(data: {
|
|
[key: string]: any;
|
|
}): CompileProviderMetadata;
|
|
}
|
|
|
|
export declare class CompileQueryMetadata {
|
|
descendants: boolean;
|
|
first: boolean;
|
|
propertyName: string;
|
|
read: CompileTokenMetadata;
|
|
selectors: Array<CompileTokenMetadata>;
|
|
constructor({selectors, descendants, first, propertyName, read}?: {
|
|
selectors?: Array<CompileTokenMetadata>;
|
|
descendants?: boolean;
|
|
first?: boolean;
|
|
propertyName?: string;
|
|
read?: CompileTokenMetadata;
|
|
});
|
|
toJson(): {
|
|
[key: string]: any;
|
|
};
|
|
static fromJson(data: {
|
|
[key: string]: any;
|
|
}): CompileQueryMetadata;
|
|
}
|
|
|
|
export declare const COMPILER_PROVIDERS: Array<any | Type | {
|
|
[k: string]: any;
|
|
} | any[]>;
|
|
|
|
export declare class CompilerConfig {
|
|
defaultEncapsulation: ViewEncapsulation;
|
|
genDebugInfo: boolean;
|
|
logBindingUpdate: boolean;
|
|
platformDirectives: any[];
|
|
platformPipes: any[];
|
|
renderTypes: RenderTypes;
|
|
useJit: boolean;
|
|
constructor({renderTypes, defaultEncapsulation, genDebugInfo, logBindingUpdate, useJit, platformDirectives, platformPipes}?: {
|
|
renderTypes?: RenderTypes;
|
|
defaultEncapsulation?: ViewEncapsulation;
|
|
genDebugInfo?: boolean;
|
|
logBindingUpdate?: boolean;
|
|
useJit?: boolean;
|
|
platformDirectives?: any[];
|
|
platformPipes?: any[];
|
|
});
|
|
}
|
|
|
|
export declare class CompileTemplateMetadata implements CompileStylesheetMetadata {
|
|
animations: CompileAnimationEntryMetadata[];
|
|
encapsulation: ViewEncapsulation;
|
|
externalStylesheets: CompileStylesheetMetadata[];
|
|
interpolation: [string, string];
|
|
moduleUrl: string;
|
|
ngContentSelectors: string[];
|
|
styleUrls: string[];
|
|
styles: string[];
|
|
template: string;
|
|
templateUrl: string;
|
|
constructor({encapsulation, template, templateUrl, styles, styleUrls, externalStylesheets, animations, ngContentSelectors, interpolation}?: {
|
|
encapsulation?: ViewEncapsulation;
|
|
template?: string;
|
|
templateUrl?: string;
|
|
styles?: string[];
|
|
styleUrls?: string[];
|
|
externalStylesheets?: CompileStylesheetMetadata[];
|
|
ngContentSelectors?: string[];
|
|
animations?: CompileAnimationEntryMetadata[];
|
|
interpolation?: [string, string];
|
|
});
|
|
toJson(): {
|
|
[key: string]: any;
|
|
};
|
|
static fromJson(data: {
|
|
[key: string]: any;
|
|
}): CompileTemplateMetadata;
|
|
}
|
|
|
|
export declare class CompileTokenMetadata implements CompileMetadataWithIdentifier {
|
|
assetCacheKey: any;
|
|
identifier: CompileIdentifierMetadata;
|
|
identifierIsInstance: boolean;
|
|
name: string;
|
|
runtimeCacheKey: any;
|
|
value: any;
|
|
constructor({value, identifier, identifierIsInstance}: {
|
|
value?: any;
|
|
identifier?: CompileIdentifierMetadata;
|
|
identifierIsInstance?: boolean;
|
|
});
|
|
equalsTo(token2: CompileTokenMetadata): boolean;
|
|
toJson(): {
|
|
[key: string]: any;
|
|
};
|
|
static fromJson(data: {
|
|
[key: string]: any;
|
|
}): CompileTokenMetadata;
|
|
}
|
|
|
|
export declare class CompileTypeMetadata implements CompileIdentifierMetadata, CompileMetadataWithType {
|
|
diDeps: CompileDiDependencyMetadata[];
|
|
identifier: CompileIdentifierMetadata;
|
|
isHost: boolean;
|
|
moduleUrl: string;
|
|
name: string;
|
|
prefix: string;
|
|
runtime: Type;
|
|
type: CompileTypeMetadata;
|
|
value: any;
|
|
constructor({runtime, name, moduleUrl, prefix, isHost, value, diDeps}?: {
|
|
runtime?: Type;
|
|
name?: string;
|
|
moduleUrl?: string;
|
|
prefix?: string;
|
|
isHost?: boolean;
|
|
value?: any;
|
|
diDeps?: CompileDiDependencyMetadata[];
|
|
});
|
|
toJson(): {
|
|
[key: string]: any;
|
|
};
|
|
static fromJson(data: {
|
|
[key: string]: any;
|
|
}): CompileTypeMetadata;
|
|
}
|
|
|
|
export declare function createOfflineCompileUrlResolver(): UrlResolver;
|
|
|
|
export declare var DEFAULT_PACKAGE_URL_PROVIDER: {
|
|
provide: any;
|
|
useValue: string;
|
|
};
|
|
|
|
export declare class DirectiveAst implements TemplateAst {
|
|
directive: CompileDirectiveMetadata;
|
|
hostEvents: BoundEventAst[];
|
|
hostProperties: BoundElementPropertyAst[];
|
|
inputs: BoundDirectivePropertyAst[];
|
|
sourceSpan: ParseSourceSpan;
|
|
constructor(directive: CompileDirectiveMetadata, inputs: BoundDirectivePropertyAst[], hostProperties: BoundElementPropertyAst[], hostEvents: BoundEventAst[], sourceSpan: ParseSourceSpan);
|
|
visit(visitor: TemplateAstVisitor, context: any): any;
|
|
}
|
|
|
|
export declare class DirectiveResolver {
|
|
constructor(_reflector?: ReflectorReader);
|
|
resolve(type: Type): DirectiveMetadata;
|
|
}
|
|
|
|
export declare class ElementAst implements TemplateAst {
|
|
attrs: AttrAst[];
|
|
children: TemplateAst[];
|
|
directives: DirectiveAst[];
|
|
hasViewContainer: boolean;
|
|
inputs: BoundElementPropertyAst[];
|
|
name: string;
|
|
ngContentIndex: number;
|
|
outputs: BoundEventAst[];
|
|
providers: ProviderAst[];
|
|
references: ReferenceAst[];
|
|
sourceSpan: ParseSourceSpan;
|
|
constructor(name: string, attrs: AttrAst[], inputs: BoundElementPropertyAst[], outputs: BoundEventAst[], references: ReferenceAst[], directives: DirectiveAst[], providers: ProviderAst[], hasViewContainer: boolean, children: TemplateAst[], ngContentIndex: number, sourceSpan: ParseSourceSpan);
|
|
visit(visitor: TemplateAstVisitor, context: any): any;
|
|
}
|
|
|
|
export declare abstract class ElementSchemaRegistry {
|
|
abstract getMappedPropName(propName: string): string;
|
|
abstract hasProperty(tagName: string, propName: string): boolean;
|
|
abstract securityContext(tagName: string, propName: string): any;
|
|
}
|
|
|
|
export declare class EmbeddedTemplateAst implements TemplateAst {
|
|
attrs: AttrAst[];
|
|
children: TemplateAst[];
|
|
directives: DirectiveAst[];
|
|
hasViewContainer: boolean;
|
|
ngContentIndex: number;
|
|
outputs: BoundEventAst[];
|
|
providers: ProviderAst[];
|
|
references: ReferenceAst[];
|
|
sourceSpan: ParseSourceSpan;
|
|
variables: VariableAst[];
|
|
constructor(attrs: AttrAst[], outputs: BoundEventAst[], references: ReferenceAst[], variables: VariableAst[], directives: DirectiveAst[], providers: ProviderAst[], hasViewContainer: boolean, children: TemplateAst[], ngContentIndex: number, sourceSpan: ParseSourceSpan);
|
|
visit(visitor: TemplateAstVisitor, context: any): any;
|
|
}
|
|
|
|
export declare class NgContentAst implements TemplateAst {
|
|
index: number;
|
|
ngContentIndex: number;
|
|
sourceSpan: ParseSourceSpan;
|
|
constructor(index: number, ngContentIndex: number, sourceSpan: ParseSourceSpan);
|
|
visit(visitor: TemplateAstVisitor, context: any): any;
|
|
}
|
|
|
|
export declare class NormalizedComponentWithViewDirectives {
|
|
component: CompileDirectiveMetadata;
|
|
directives: CompileDirectiveMetadata[];
|
|
pipes: CompilePipeMetadata[];
|
|
constructor(component: CompileDirectiveMetadata, directives: CompileDirectiveMetadata[], pipes: CompilePipeMetadata[]);
|
|
}
|
|
|
|
export declare class OfflineCompiler {
|
|
constructor(_directiveNormalizer: DirectiveNormalizer, _templateParser: TemplateParser, _styleCompiler: StyleCompiler, _viewCompiler: ViewCompiler, _outputEmitter: OutputEmitter);
|
|
compileTemplates(components: NormalizedComponentWithViewDirectives[]): SourceModule[];
|
|
normalizeDirectiveMetadata(directive: CompileDirectiveMetadata): Promise<CompileDirectiveMetadata>;
|
|
}
|
|
|
|
export declare class PipeResolver {
|
|
constructor(_reflector?: ReflectorReader);
|
|
resolve(type: Type): PipeMetadata;
|
|
}
|
|
|
|
export declare enum PropertyBindingType {
|
|
Property = 0,
|
|
Attribute = 1,
|
|
Class = 2,
|
|
Style = 3,
|
|
Animation = 4,
|
|
}
|
|
|
|
export declare class ProviderAst implements TemplateAst {
|
|
eager: boolean;
|
|
multiProvider: boolean;
|
|
providerType: ProviderAstType;
|
|
providers: CompileProviderMetadata[];
|
|
sourceSpan: ParseSourceSpan;
|
|
token: CompileTokenMetadata;
|
|
constructor(token: CompileTokenMetadata, multiProvider: boolean, eager: boolean, providers: CompileProviderMetadata[], providerType: ProviderAstType, sourceSpan: ParseSourceSpan);
|
|
visit(visitor: TemplateAstVisitor, context: any): any;
|
|
}
|
|
|
|
export declare enum ProviderAstType {
|
|
PublicService = 0,
|
|
PrivateService = 1,
|
|
Component = 2,
|
|
Directive = 3,
|
|
Builtin = 4,
|
|
}
|
|
|
|
export declare class ReferenceAst implements TemplateAst {
|
|
name: string;
|
|
sourceSpan: ParseSourceSpan;
|
|
value: CompileTokenMetadata;
|
|
constructor(name: string, value: CompileTokenMetadata, sourceSpan: ParseSourceSpan);
|
|
visit(visitor: TemplateAstVisitor, context: any): any;
|
|
}
|
|
|
|
export declare abstract class RenderTypes {
|
|
renderComment: CompileIdentifierMetadata;
|
|
renderElement: CompileIdentifierMetadata;
|
|
renderEvent: CompileIdentifierMetadata;
|
|
renderNode: CompileIdentifierMetadata;
|
|
renderText: CompileIdentifierMetadata;
|
|
renderer: CompileIdentifierMetadata;
|
|
}
|
|
|
|
export declare class RuntimeCompiler implements ComponentResolver, Compiler {
|
|
constructor(_metadataResolver: CompileMetadataResolver, _templateNormalizer: DirectiveNormalizer, _templateParser: TemplateParser, _styleCompiler: StyleCompiler, _viewCompiler: ViewCompiler, _genConfig: CompilerConfig);
|
|
clearCache(): void;
|
|
clearCacheFor(compType: Type): void;
|
|
compileComponentAsync<T>(compType: ConcreteType<T>): Promise<ComponentFactory<T>>;
|
|
compileComponentSync<T>(compType: ConcreteType<T>): ComponentFactory<T>;
|
|
resolveComponent(component: Type | string): Promise<ComponentFactory<any>>;
|
|
}
|
|
|
|
export declare class SourceModule {
|
|
moduleUrl: string;
|
|
source: string;
|
|
constructor(moduleUrl: string, source: string);
|
|
}
|
|
|
|
export declare const TEMPLATE_TRANSFORMS: any;
|
|
|
|
export interface TemplateAst {
|
|
sourceSpan: ParseSourceSpan;
|
|
visit(visitor: TemplateAstVisitor, context: any): any;
|
|
}
|
|
|
|
export interface TemplateAstVisitor {
|
|
visitAttr(ast: AttrAst, context: any): any;
|
|
visitBoundText(ast: BoundTextAst, context: any): any;
|
|
visitDirective(ast: DirectiveAst, context: any): any;
|
|
visitDirectiveProperty(ast: BoundDirectivePropertyAst, context: any): any;
|
|
visitElement(ast: ElementAst, context: any): any;
|
|
visitElementProperty(ast: BoundElementPropertyAst, context: any): any;
|
|
visitEmbeddedTemplate(ast: EmbeddedTemplateAst, context: any): any;
|
|
visitEvent(ast: BoundEventAst, context: any): any;
|
|
visitNgContent(ast: NgContentAst, context: any): any;
|
|
visitReference(ast: ReferenceAst, context: any): any;
|
|
visitText(ast: TextAst, context: any): any;
|
|
visitVariable(ast: VariableAst, context: any): any;
|
|
}
|
|
|
|
export declare function templateVisitAll(visitor: TemplateAstVisitor, asts: TemplateAst[], context?: any): any[];
|
|
|
|
export declare class TextAst implements TemplateAst {
|
|
ngContentIndex: number;
|
|
sourceSpan: ParseSourceSpan;
|
|
value: string;
|
|
constructor(value: string, ngContentIndex: number, sourceSpan: ParseSourceSpan);
|
|
visit(visitor: TemplateAstVisitor, context: any): any;
|
|
}
|
|
|
|
export declare class UrlResolver {
|
|
constructor(_packagePrefix?: string);
|
|
resolve(baseUrl: string, url: string): string;
|
|
}
|
|
|
|
export declare class VariableAst implements TemplateAst {
|
|
name: string;
|
|
sourceSpan: ParseSourceSpan;
|
|
value: string;
|
|
constructor(name: string, value: string, sourceSpan: ParseSourceSpan);
|
|
visit(visitor: TemplateAstVisitor, context: any): any;
|
|
}
|
|
|
|
export declare class ViewResolver {
|
|
constructor(_reflector?: ReflectorReader);
|
|
resolve(component: Type): ViewMetadata;
|
|
}
|
|
|
|
export declare class XHR {
|
|
get(url: string): Promise<string>;
|
|
}
|