PROPERTY,

ATTRIBUTE,

CLASS,

STYLE

index: number;

parentIndex: number;

distanceToParent: number;

directives: List<DirectiveBinder>;

nestedProtoView: ProtoViewDto;

propertyBindings: List<ElementPropertyBinding>;

variableBindings: Map<string, string>;

// Note: this contains a preprocessed AST

// that replaced the values that should be extracted from the element

// with a local name

eventBindings: List<EventBinding>;

readAttributes: Map<string, string>;

constructor({index, parentIndex, distanceToParent, directives, nestedProtoView, propertyBindings,

variableBindings, eventBindings, readAttributes}: {

index?: number,

parentIndex?: number,

distanceToParent?: number,

directives?: List<DirectiveBinder>,

nestedProtoView?: ProtoViewDto,

propertyBindings?: List<ElementPropertyBinding>,

variableBindings?: Map<string, string>,

eventBindings?: List<EventBinding>,

readAttributes?: Map<string, string>

} = {}) {

this.index = index;

this.parentIndex = parentIndex;

this.distanceToParent = distanceToParent;

this.directives = directives;

this.nestedProtoView = nestedProtoView;

this.propertyBindings = propertyBindings;

this.variableBindings = variableBindings;

this.eventBindings = eventBindings;

this.readAttributes = readAttributes;

}

// Index into the array of directives in the View instance

directiveIndex: number;

propertyBindings: Map<string, ASTWithSource>;

// Note: this contains a preprocessed AST

// that replaced the values that should be extracted from the element

// with a local name

eventBindings: List<EventBinding>;

hostPropertyBindings: List<ElementPropertyBinding>;

constructor({directiveIndex, propertyBindings, eventBindings, hostPropertyBindings}: {

directiveIndex?: number,

propertyBindings?: Map<string, ASTWithSource>,

eventBindings?: List<EventBinding>,

hostPropertyBindings?: List<ElementPropertyBinding>

}) {

this.directiveIndex = directiveIndex;

this.propertyBindings = propertyBindings;

this.eventBindings = eventBindings;

this.hostPropertyBindings = hostPropertyBindings;

}

// A view that contains the host element with bound component directive.

// Contains a COMPONENT view

HOST,

// The view of the component

// Can contain 0 to n EMBEDDED views

COMPONENT,

// A view that is embedded into another View via a <template> element

// inside of a COMPONENT view

EMBEDDED

render: RenderProtoViewRef;

elementBinders: List<RenderElementBinder>;

variableBindings: Map<string, string>;

type: ViewType;

textBindings: List<ASTWithSource>;

transitiveNgContentCount: number;

constructor({render, elementBinders, variableBindings, type, textBindings,

transitiveNgContentCount}: {

render?: RenderProtoViewRef,

elementBinders?: List<RenderElementBinder>,

variableBindings?: Map<string, string>,

type?: ViewType,

textBindings?: List<ASTWithSource>,

transitiveNgContentCount?: number

}) {

this.render = render;

this.elementBinders = elementBinders;

this.variableBindings = variableBindings;

this.type = type;

this.textBindings = textBindings;

this.transitiveNgContentCount = transitiveNgContentCount;

}

static get DIRECTIVE_TYPE() { return 0; }

static get COMPONENT_TYPE() { return 1; }

id: any;

selector: string;

compileChildren: boolean;

events: List<string>;

properties: List<string>;

readAttributes: List<string>;

type: number;

callOnDestroy: boolean;

callOnChange: boolean;

callOnCheck: boolean;

callOnInit: boolean;

callOnAllChangesDone: boolean;

changeDetection: string;

exportAs: string;

hostListeners: Map<string, string>;

hostProperties: Map<string, string>;

hostAttributes: Map<string, string>;

hostActions: Map<string, string>;

// group 1: "property" from "[property]"

// group 2: "event" from "(event)"

// group 3: "action" from "@action"

private static _hostRegExp = /^(?:(?:\[([^\]]+)\])|(?:\(([^\)]+)\))|(?:@(.+)))$/g;

constructor({id, selector, compileChildren, events, hostListeners, hostProperties, hostAttributes,

hostActions, properties, readAttributes, type, callOnDestroy, callOnChange,

callOnCheck, callOnInit, callOnAllChangesDone, changeDetection, exportAs}: {

id?: string,

selector?: string,

compileChildren?: boolean,

events?: List<string>,

hostListeners?: Map<string, string>,

hostProperties?: Map<string, string>,

hostAttributes?: Map<string, string>,

hostActions?: Map<string, string>,

properties?: List<string>,

readAttributes?: List<string>,

type?: number,

callOnDestroy?: boolean,

callOnChange?: boolean,

callOnCheck?: boolean,

callOnInit?: boolean,

callOnAllChangesDone?: boolean,

changeDetection?: string,

exportAs?: string

}) {

this.id = id;

this.selector = selector;

this.compileChildren = isPresent(compileChildren) ? compileChildren : true;

this.events = events;

this.hostListeners = hostListeners;

this.hostAttributes = hostAttributes;

this.hostProperties = hostProperties;

this.hostActions = hostActions;

this.properties = properties;

this.readAttributes = readAttributes;

this.type = type;

this.callOnDestroy = callOnDestroy;

this.callOnChange = callOnChange;

this.callOnCheck = callOnCheck;

this.callOnInit = callOnInit;

this.callOnAllChangesDone = callOnAllChangesDone;

this.changeDetection = changeDetection;

this.exportAs = exportAs;

}

static create({id, selector, compileChildren, events, host, properties, readAttributes, type,

callOnDestroy, callOnChange, callOnCheck, callOnInit, callOnAllChangesDone,

changeDetection, exportAs}: {

id?: string,

selector?: string,

compileChildren?: boolean,

events?: List<string>,

host?: Map<string, string>,

properties?: List<string>,

readAttributes?: List<string>,

type?: number,

callOnDestroy?: boolean,

callOnChange?: boolean,

callOnCheck?: boolean,

callOnInit?: boolean,

callOnAllChangesDone?: boolean,

changeDetection?: string,

exportAs?: string

}): RenderDirectiveMetadata {

let hostListeners = new Map();

let hostProperties = new Map();

let hostAttributes = new Map();

let hostActions = new Map();

if (isPresent(host)) {

MapWrapper.forEach(host, (value: string, key: string) => {

var matches = RegExpWrapper.firstMatch(RenderDirectiveMetadata._hostRegExp, key);

if (isBlank(matches)) {

hostAttributes.set(key, value);

} else if (isPresent(matches[1])) {

hostProperties.set(matches[1], value);

} else if (isPresent(matches[2])) {

hostListeners.set(matches[2], value);

} else if (isPresent(matches[3])) {

hostActions.set(matches[3], value);

}

});

}

return new RenderDirectiveMetadata({

id: id,

selector: selector,

compileChildren: compileChildren,

events: events,

hostListeners: hostListeners,

hostProperties: hostProperties,

hostAttributes: hostAttributes,

hostActions: hostActions,

properties: properties,

readAttributes: readAttributes,

type: type,

callOnDestroy: callOnDestroy,

callOnChange: callOnChange,

callOnCheck: callOnCheck,

callOnInit: callOnInit,

callOnAllChangesDone: callOnAllChangesDone,

changeDetection: changeDetection,

exportAs: exportAs

});

}

/**

EMULATED,

/**

NATIVE,

/**

NONE

componentId: string;

templateAbsUrl: string;

template: string;

directives: List<RenderDirectiveMetadata>;

styleAbsUrls: List<string>;

styles: List<string>;

encapsulation: ViewEncapsulation;

constructor({componentId, templateAbsUrl, template, styleAbsUrls, styles, directives,

encapsulation}: {

componentId?: string,

templateAbsUrl?: string,

template?: string,

styleAbsUrls?: List<string>,

styles?: List<string>,

directives?: List<RenderDirectiveMetadata>,

encapsulation?: ViewEncapsulation

} = {}) {

this.componentId = componentId;

this.templateAbsUrl = templateAbsUrl;

this.template = template;

this.styleAbsUrls = styleAbsUrls;

this.styles = styles;

this.directives = directives;

this.encapsulation = isPresent(encapsulation) ? encapsulation : ViewEncapsulation.EMULATED;

}

constructor(public mergedProtoViewRef: RenderProtoViewRef,

// Number of fragments in the merged ProtoView.

// Fragments are stored in depth first order of nested ProtoViews.

public fragmentCount: number,

// Mapping from app element index to render element index.

// Mappings of nested ProtoViews are in depth first order, with all

// indices for one ProtoView in a consecuitve block.

public mappedElementIndices: number[],

// Number of bound render element.

// Note: This could be more than the original ones

// as we might have bound a new element for projecting bound text nodes.

public mappedElementCount: number,

// Mapping from app text index to render text index.

// Mappings of nested ProtoViews are in depth first order, with all

// indices for one ProtoView in a consecuitve block.

public mappedTextIndices: number[],

// Mapping from view index to app element index

public hostElementIndicesByViewIndex: number[],

// Number of contained views by view index

public nestedViewCountByViewIndex: number[]) {}

/**

compileHost(directiveMetadata: RenderDirectiveMetadata): Promise<ProtoViewDto> { return null; }

/**

compile(view: ViewDefinition): Promise<ProtoViewDto> { return null; }

/**

mergeProtoViewsRecursively(

protoViewRefs: List<RenderProtoViewRef | List<any>>): Promise<RenderProtoViewMergeMapping> {

return null;

}

/**

renderView: RenderViewRef;

/**

renderBoundElementIndex: number;

/**

createRootHostView(hostProtoViewRef: RenderProtoViewRef, fragmentCount: number,

hostElementSelector: string): RenderViewWithFragments {

return null;

}

/**

createView(protoViewRef: RenderProtoViewRef, fragmentCount: number): RenderViewWithFragments {

return null;

}

/**

destroyView(viewRef: RenderViewRef) {}

/**

attachFragmentAfterFragment(previousFragmentRef: RenderFragmentRef,

fragmentRef: RenderFragmentRef) {}

/**

attachFragmentAfterElement(elementRef: RenderElementRef, fragmentRef: RenderFragmentRef) {}

/**

detachFragment(fragmentRef: RenderFragmentRef) {}

/**

hydrateView(viewRef: RenderViewRef) {}

/**

dehydrateView(viewRef: RenderViewRef) {}

/**

getNativeElementSync(location: RenderElementRef): any { return null; }

/**

setElementProperty(location: RenderElementRef, propertyName: string, propertyValue: any) {}

/**

setElementAttribute(location: RenderElementRef, attributeName: string, attributeValue: string) {}

/**

setElementClass(location: RenderElementRef, className: string, isAdd: boolean) {}

/**

setElementStyle(location: RenderElementRef, styleName: string, styleValue: string) {}

/**

invokeElementMethod(location: RenderElementRef, methodName: string, args: List<any>) {}

/**

setText(viewRef: RenderViewRef, textNodeIndex: number, text: string) {}

/**

setEventDispatcher(viewRef: RenderViewRef, dispatcher: RenderEventDispatcher) {}

/**

dispatchRenderEvent(elementIndex: number, eventName: string, locals: Map<string, any>);