ngast/lib/directive-symbol.d.ts

import { Program } from 'typescript';
import { SchemaMetadata } from '@angular/core';
import { StaticSymbol, DirectiveResolver, CompileMetadataResolver, StaticReflector, DirectiveNormalizer, CompilePipeSummary, CompileNgModuleMetadata, CompileTemplateMetadata, CompileDirectiveMetadata, TemplateAst, ParseError, CompileDirectiveSummary } from '@angular/compiler';
import { ProjectSymbols } from './project-symbols';
import { Symbol } from './symbol';
import { ResourceResolver } from './resource-resolver';
import { CssAst } from './css-parser/css-ast';
import { ProviderSymbol } from './provider-symbol';
/**
 * The context into which the template of given
 * directive will be compiled.
 *
 * @export
 * @interface DirectiveContext
 */
export interface DirectiveContext {
    /**
     * The directives that are available for the compilation
     * of the compilation of given template.
     *
     * @type {CompileDirectiveSummary[]}
     * @memberOf DirectiveContext
     */
    directives: CompileDirectiveSummary[];
    /**
     * The pipes which are available for the compilation
     * of the template of given target component.
     *
     * @type {CompilePipeSummary[]}
     * @memberOf DirectiveContext
     */
    pipes: CompilePipeSummary[];
    /**
     * The schemas that are used for the compilation of the template
     * of given component.
     *
     * @type {SchemaMetadata[]}
     * @memberOf DirectiveContext
     */
    schemas: SchemaMetadata[];
}
/**
 * The result of the compilation of the template of given component.
 *
 * @export
 * @interface TemplateAstResult
 */
export interface TemplateAstResult {
    /**
     * The root template nodes.
     *
     * @type {TemplateAst[]}
     * @memberOf TemplateAstResult
     */
    templateAst?: TemplateAst[];
    /**
     * All the parse errors.
     *
     * @type {ParseError[]}
     * @memberOf TemplateAstResult
     */
    parseErrors?: ParseError[];
    /**
     * Non-parse errors occured during compilation.
     *
     * @type {{message: string}[]}
     * @memberOf TemplateAstResult
     */
    errors?: {
        message: string;
    }[];
}
/**
 * This class represents the individual directives and wrapps
 * their `StaticSymbol`s produced by the `@angular/compiler`.
 *
 * @export
 * @class DirectiveSymbol
 * @extends {Symbol}
 */
export declare class DirectiveSymbol extends Symbol {
    private metadataResolver;
    private directiveNormalizer;
    private resolver;
    private reflector;
    private resourceResolver;
    private projectSymbols;
    private urlResolver;
    /**
     * Creates an instance of DirectiveSymbol.
     *
     * @param {Program} program
     * @param {StaticSymbol} symbol
     * @param {CompileMetadataResolver} metadataResolver
     * @param {DirectiveNormalizer} directiveNormalizer
     * @param {DirectiveResolver} resolver
     * @param {StaticReflector} reflector
     * @param {ResourceResolver} resourceResolver
     * @param {ContextSymbols} projectSymbols
     *
     * @memberOf DirectiveSymbol
     */
    constructor(program: Program, symbol: StaticSymbol, metadataResolver: CompileMetadataResolver, directiveNormalizer: DirectiveNormalizer, resolver: DirectiveResolver, reflector: StaticReflector, resourceResolver: ResourceResolver, projectSymbols: ProjectSymbols);
    /**
     * Returns the non-resolved metadata for given directive.
     * If it is a component, this means that the external templates
     * and styles won't be read from the drive. Also, the paths to
     * external metadata won't be resolved.
     *
     * @returns {CompileDirectiveMetadata}
     *
     * @memberOf DirectiveSymbol
     */
    getNonResolvedMetadata(): CompileDirectiveMetadata | null;
    /**
     * Returns the normalized and resolved metadata for given directive or component.
     * For components, all the external templates and styles will be read and
     * set as values of the returned `CompileTemplateMetadata` properties.
     *
     * @returns {CompileTemplateMetadata}
     *
     * @memberOf DirectiveSymbol
     */
    getResolvedMetadata(): CompileTemplateMetadata | null;
    /**
     * Returns the module where the given directive has been declared.
     *
     * @returns {(CompileNgModuleMetadata | undefined)}
     *
     * @memberOf DirectiveSymbol
     */
    getModule(): CompileNgModuleMetadata | undefined;
    /**
     * Returns the ASTs of all styles of the target directive.
     *
     * @returns {CssAst[]}
     *
     * @memberOf DirectiveSymbol
     */
    getStyleAsts(): CssAst[] | null;
    /**
     * Returns the context into which the template of given
     * component is going to be compiled.
     *
     * @returns {DirectiveContext}
     *
     * @memberOf DirectiveSymbol
     */
    getDirectiveContext(): DirectiveContext;
    /**
     * Returns the compiled template of the target component.
     *
     * @returns {TemplateAstResult}
     *
     * @memberOf DirectiveSymbol
     */
    getTemplateAst(): TemplateAstResult;
    getDependencies(): ProviderSymbol[];
    getProviders(): ProviderSymbol[];
    getViewProviders(): ProviderSymbol[];
    /**
     * Returns if the target directive is a component.
     *
     * @returns {boolean}
     *
     * @memberOf DirectiveSymbol
     */
    isComponent(): boolean;
}