@angular/core 7.2.0-beta.0 → 7.2.0

package/src/render3/empty.d.ts

@@ -0,0 +1,16 @@
+/**
+* @license
+* Copyright Google Inc. All Rights Reserved.
+*
+* Use of this source code is governed by an MIT-style license that can be
+* found in the LICENSE file at https://angular.io/license
+*/
+import './ng_dev_mode';
+/**
+ * This file contains reuseable "empty" symbols that can be used as default return values
+ * in different parts of the rendering code. Because the same symbols are returned, this
+ * allows for identity checks against these values to be consistently used by the framework
+ * code.
+ */
+export declare const EMPTY_OBJ: {};
+export declare const EMPTY_ARRAY: any[];

package/src/render3/errors.d.ts

@@ -11,4 +11,4 @@ export declare function throwCyclicDependencyError(token: any): never;
 /** Called when there are multiple component selectors that match a given node */
 export declare function throwMultipleComponentError(tNode: TNode): never;
 /** Throws an ExpressionChangedAfterChecked error if checkNoChanges mode is on. */
-export declare function throwErrorIfNoChangesMode(creationMode: boolean, checkNoChangesMode: boolean, oldValue: any, currValue: any): never | void;
+export declare function throwErrorIfNoChangesMode(creationMode: boolean, oldValue: any, currValue: any): never | void;

package/src/render3/global_utils_api.d.ts

@@ -13,6 +13,6 @@
  * to generate a d.ts file containing all the published symbols that is then compared to the golden
  * file in the public_api_guard test.
  */
-export { getComponent, getDirectives, getHostElement, getInjector, getRootComponents, getViewComponent } from './discovery_utils';
+export { getComponent, getContext, getDirectives, getHostElement, getInjector, getListeners, getRootComponents, getViewComponent } from './discovery_utils';
 export { markDirty } from './instructions';
 export { getPlayers } from './players';

package/src/render3/hooks.d.ts

@@ -5,7 +5,8 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-import { HookData, LViewData, TView } from './interfaces/view';
+import { TNode } from './interfaces/node';
+import { HookData, LView, TView } from './interfaces/view';
 /**
  * If this is the first template pass, any ngOnInit or ngDoCheck hooks will be queued into
  * TView.initHooks during directiveCreate.
@@ -14,7 +15,7 @@ import { HookData, LViewData, TView } from './interfaces/view';
  * directive index), then saved in the even indices of the initHooks array. The odd indices
  * hold the hook functions themselves.
  *
- * @param index The index of the directive in LViewData
+ * @param index The index of the directive in LView
  * @param hooks The static hooks map on the directive def
  * @param tView The current TView
  */
@@ -23,22 +24,22 @@ export declare function queueInitHooks(index: number, onInit: (() => void) | nul
  * Loops through the directives on a node and queues all their hooks except ngOnInit
  * and ngDoCheck, which are queued separately in directiveCreate.
  */
-export declare function queueLifecycleHooks(flags: number, tView: TView): void;
+export declare function queueLifecycleHooks(tView: TView, tNode: TNode): void;
 /**
  * Calls onInit and doCheck calls if they haven't already been called.
  *
  * @param currentView The current view
  */
-export declare function executeInitHooks(currentView: LViewData, tView: TView, creationMode: boolean): void;
+export declare function executeInitHooks(currentView: LView, tView: TView, checkNoChangesMode: boolean): void;
 /**
  * Iterates over afterViewInit and afterViewChecked functions and calls them.
  *
  * @param currentView The current view
  */
-export declare function executeHooks(data: LViewData, allHooks: HookData | null, checkHooks: HookData | null, creationMode: boolean): void;
+export declare function executeHooks(currentView: LView, allHooks: HookData | null, checkHooks: HookData | null, checkNoChangesMode: boolean): void;
 /**
  * Calls lifecycle hooks with their contexts, skipping init hooks if it's not
- * creation mode.
+ * the first LView pass.
  *
  * @param currentView The current view
  * @param arr The array in which the hooks are found

package/src/render3/index.d.ts

@@ -7,7 +7,7 @@
  */
 import { LifecycleHooksFeature, renderComponent, whenRendered } from './component';
 import { defineBase, defineComponent, defineDirective, defineNgModule, definePipe } from './definition';
-import { getHostElement, getRenderedText } from './discovery_utils';
+import { getComponent, getHostElement, getRenderedText } from './discovery_utils';
 import { InheritDefinitionFeature } from './features/inherit_definition_feature';
 import { NgOnChangesFeature } from './features/ng_onchanges_feature';
 import { ProvidersFeature } from './features/providers_feature';
@@ -16,8 +16,8 @@ export { ComponentFactory, ComponentFactoryResolver, ComponentRef, injectCompone
 export { getFactoryOf, getInheritedFactory } from './di';
 export { RenderFlags } from './interfaces/definition';
 export { CssSelectorList } from './interfaces/projection';
-export { bind, interpolation1, interpolation2, interpolation3, interpolation4, interpolation5, interpolation6, interpolation7, interpolation8, interpolationV, container, containerRefreshStart, containerRefreshEnd, nextContext, element, elementAttribute, elementClassProp, elementEnd, elementProperty, elementStart, elementContainerStart, elementContainerEnd, elementStyling, elementStylingMap, elementStyleProp, elementStylingApply, listener, store, load, namespaceHTML, namespaceMathML, namespaceSVG, projection, projectionDef, text, textBinding, template, reference, embeddedViewStart, embeddedViewEnd, detectChanges, markDirty, tick, directiveInject, injectAttribute, } from './instructions';
-export { getCurrentView, restoreView, enableBindings, disableBindings, } from './state';
+export { allocHostVars, bind, interpolation1, interpolation2, interpolation3, interpolation4, interpolation5, interpolation6, interpolation7, interpolation8, interpolationV, container, containerRefreshStart, containerRefreshEnd, nextContext, element, elementAttribute, elementClassProp, elementEnd, elementProperty, componentHostSyntheticProperty, elementStart, elementContainerStart, elementContainerEnd, elementStyling, elementHostAttrs, elementStylingMap, elementStyleProp, elementStylingApply, listener, store, load, namespaceHTML, namespaceMathML, namespaceSVG, projection, projectionDef, text, textBinding, template, reference, embeddedViewStart, embeddedViewEnd, detectChanges, markDirty, tick, directiveInject, injectAttribute, getCurrentView } from './instructions';
+export { restoreView, enableBindings, disableBindings, } from './state';
 export { i18n, i18nAttributes, i18nExp, i18nStart, i18nEnd, i18nApply, i18nPostprocess } from './i18n';
 export { NgModuleFactory, NgModuleRef, NgModuleType } from './ng_module_ref';
 export { AttributeMarker } from './interfaces/node';
@@ -27,5 +27,5 @@ export { QueryList, query, queryRefresh, } from './query';
 export { registerContentQuery, loadQueryList, } from './instructions';
 export { pureFunction0, pureFunction1, pureFunction2, pureFunction3, pureFunction4, pureFunction5, pureFunction6, pureFunction7, pureFunction8, pureFunctionV, } from './pure_function';
 export { templateRefExtractor } from './view_engine_compatibility_prebound';
-export { BaseDef, ComponentDef, ComponentDefWithMeta, ComponentTemplate, ComponentType, DirectiveDef, DirectiveDefFlags, DirectiveDefWithMeta, DirectiveType, NgOnChangesFeature, InheritDefinitionFeature, ProvidersFeature, PipeDef, PipeDefWithMeta, LifecycleHooksFeature, defineComponent, defineDirective, defineNgModule, defineBase, definePipe, getHostElement, getRenderedText, renderComponent, whenRendered, };
+export { BaseDef, ComponentDef, ComponentDefWithMeta, ComponentTemplate, ComponentType, DirectiveDef, DirectiveDefFlags, DirectiveDefWithMeta, DirectiveType, NgOnChangesFeature, InheritDefinitionFeature, ProvidersFeature, PipeDef, PipeDefWithMeta, LifecycleHooksFeature, defineComponent, defineDirective, defineNgModule, defineBase, definePipe, getHostElement, getComponent, getRenderedText, renderComponent, whenRendered, };
 export { NO_CHANGE } from './tokens';

package/src/render3/instructions.d.ts

@@ -13,14 +13,14 @@ import { Sanitizer } from '../sanitization/security';
 import { StyleSanitizeFn } from '../sanitization/style_sanitizer';
 import { Type } from '../type';
 import { LContainer } from './interfaces/container';
-import { ComponentDef, ComponentQuery, ComponentTemplate, DirectiveDefListOrFactory, InitialStylingFlags, PipeDefListOrFactory, RenderFlags } from './interfaces/definition';
+import { ComponentDef, ComponentQuery, ComponentTemplate, DirectiveDefListOrFactory, PipeDefListOrFactory, RenderFlags } from './interfaces/definition';
 import { LocalRefExtractor, TAttributes, TContainerNode, TElementContainerNode, TElementNode, TNode, TNodeType, TProjectionNode, TViewNode } from './interfaces/node';
 import { PlayerFactory } from './interfaces/player';
 import { CssSelectorList } from './interfaces/projection';
 import { LQueries } from './interfaces/query';
 import { RComment, RElement, RText, Renderer3, RendererFactory3 } from './interfaces/renderer';
 import { SanitizerFn } from './interfaces/sanitization';
-import { LViewData, LViewFlags, RootContext, RootContextFlags, TView } from './interfaces/view';
+import { LView, LViewFlags, OpaqueViewState, RootContext, RootContextFlags, TView } from './interfaces/view';
 import { NO_CHANGE } from './tokens';
 /**
  * Refreshes the view, executing the following steps in that order:
@@ -28,10 +28,10 @@ import { NO_CHANGE } from './tokens';
  * bindings, refreshes child components.
  * Note: view hooks are triggered later when leaving the view.
  */
-export declare function refreshDescendantViews(viewData: LViewData, rf: RenderFlags | null): void;
+export declare function refreshDescendantViews(lView: LView): void;
 /** Sets the host bindings for the current view. */
-export declare function setHostBindings(tView: TView, viewData: LViewData): void;
-export declare function createLViewData<T>(parentLView: LViewData | null, tView: TView, context: T | null, flags: LViewFlags, rendererFactory?: RendererFactory3 | null, renderer?: Renderer3 | null, sanitizer?: Sanitizer | null, injector?: Injector | null): LViewData;
+export declare function setHostBindings(tView: TView, viewData: LView): void;
+export declare function createLView<T>(parentLView: LView | null, tView: TView, context: T | null, flags: LViewFlags, rendererFactory?: RendererFactory3 | null, renderer?: Renderer3 | null, sanitizer?: Sanitizer | null, injector?: Injector | null): LView;
 /**
  * Create and stores the TNode, and hooks it up to the tree.
  *
@@ -45,15 +45,15 @@ export declare function createLViewData<T>(parentLView: LViewData | null, tView:
 export declare function createNodeAtIndex(index: number, type: TNodeType.Element, native: RElement | RText | null, name: string | null, attrs: TAttributes | null): TElementNode;
 export declare function createNodeAtIndex(index: number, type: TNodeType.Container, native: RComment, name: string | null, attrs: TAttributes | null): TContainerNode;
 export declare function createNodeAtIndex(index: number, type: TNodeType.Projection, native: null, name: null, attrs: TAttributes | null): TProjectionNode;
-export declare function createNodeAtIndex(index: number, type: TNodeType.ElementContainer, native: RComment, name: null, attrs: TAttributes | null): TElementContainerNode;
+export declare function createNodeAtIndex(index: number, type: TNodeType.ElementContainer, native: RComment, name: string | null, attrs: TAttributes | null): TElementContainerNode;
 export declare function createNodeAtIndex(index: number, type: TNodeType.IcuContainer, native: RComment, name: null, attrs: TAttributes | null): TElementContainerNode;
-export declare function createViewNode(index: number, view: LViewData): TViewNode;
+export declare function createViewNode(index: number, view: LView): TViewNode;
 /**
  * When elements are created dynamically after a view blueprint is created (e.g. through
  * i18nApply() or ComponentFactory.create), we need to adjust the blueprint for future
  * template passes.
  */
-export declare function allocExpando(view: LViewData): void;
+export declare function allocExpando(view: LView): void;
 /**
  *
  * @param hostNode Existing node to render into.
@@ -65,13 +65,13 @@ export declare function allocExpando(view: LViewData): void;
  * @param directives Directive defs that should be used for matching
  * @param pipes Pipe defs that should be used for matching
  */
-export declare function renderTemplate<T>(hostNode: RElement, templateFn: ComponentTemplate<T>, consts: number, vars: number, context: T, providedRendererFactory: RendererFactory3, hostView: LViewData | null, directives?: DirectiveDefListOrFactory | null, pipes?: PipeDefListOrFactory | null, sanitizer?: Sanitizer | null): LViewData;
+export declare function renderTemplate<T>(hostNode: RElement, templateFn: ComponentTemplate<T>, consts: number, vars: number, context: T, providedRendererFactory: RendererFactory3, hostView: LView | null, directives?: DirectiveDefListOrFactory | null, pipes?: PipeDefListOrFactory | null, sanitizer?: Sanitizer | null): LView;
 /**
  * Used for creating the LViewNode of a dynamic embedded view,
  * either through ViewContainerRef.createEmbeddedView() or TemplateRef.createEmbeddedView().
  * Such lViewNode will then be renderer with renderEmbeddedTemplate() (see below).
  */
-export declare function createEmbeddedViewAndNode<T>(tView: TView, context: T, declarationView: LViewData, renderer: Renderer3, queries: LQueries | null, injectorIndex: number): LViewData;
+export declare function createEmbeddedViewAndNode<T>(tView: TView, context: T, declarationView: LView, renderer: Renderer3, queries: LQueries | null, injectorIndex: number): LView;
 /**
  * Used for rendering embedded views (e.g. dynamically created views)
  *
@@ -82,7 +82,7 @@ export declare function createEmbeddedViewAndNode<T>(tView: TView, context: T, d
  * can't store TViews in the template function itself (as we do for comps). Instead, we store the
  * TView for dynamically created views on their host TNode, which only has one instance.
  */
-export declare function renderEmbeddedTemplate<T>(viewToRender: LViewData, tView: TView, context: T, rf: RenderFlags): void;
+export declare function renderEmbeddedTemplate<T>(viewToRender: LView, tView: TView, context: T): void;
 /**
  * Retrieves a context at the level specified and saves it as the global, contextViewData.
  * Will get the next level up if level is not specified.
@@ -102,7 +102,8 @@ export declare function namespaceHTML(): void;
  *
  * @param index Index of the element in the data array
  * @param name Name of the DOM Node
- * @param attrs Statically bound set of attributes to be written into the DOM element on creation.
+ * @param attrs Statically bound set of attributes, classes, and styles to be written into the DOM
+ *              element on creation. Use [AttributeMarker] to denote the meaning of this array.
  * @param localRefs A set of local reference bindings on the element.
  */
 export declare function element(index: number, name: string, attrs?: TAttributes | null, localRefs?: string[] | null): void;
@@ -110,7 +111,7 @@ export declare function element(index: number, name: string, attrs?: TAttributes
  * Creates a logical container for other nodes (<ng-container>) backed by a comment node in the DOM.
  * The instruction must later be followed by `elementContainerEnd()` call.
  *
- * @param index Index of the element in the LViewData array
+ * @param index Index of the element in the LView array
  * @param attrs Set of attributes to be used when matching directives.
  * @param localRefs A set of local reference bindings on the element.
  *
@@ -124,9 +125,10 @@ export declare function elementContainerEnd(): void;
 /**
  * Create DOM element. The instruction must later be followed by `elementEnd()` call.
  *
- * @param index Index of the element in the LViewData array
+ * @param index Index of the element in the LView array
  * @param name Name of the DOM Node
- * @param attrs Statically bound set of attributes to be written into the DOM element on creation.
+ * @param attrs Statically bound set of attributes, classes, and styles to be written into the DOM
+ *              element on creation. Use [AttributeMarker] to denote the meaning of this array.
  * @param localRefs A set of local reference bindings on the element.
  *
  * Attributes and localRefs are passed as an array of strings where elements with an even index
@@ -188,7 +190,7 @@ export declare function listener(eventName: string, listenerFn: (e?: any) => any
  * - Cleanup function
  * - Index of context we just saved in LView.cleanupInstances
  */
-export declare function storeCleanupWithContext(view: LViewData | null, context: any, cleanupFn: Function): void;
+export declare function storeCleanupWithContext(lView: LView, context: any, cleanupFn: Function): void;
 /**
  * Saves the cleanup function itself in LView.cleanupInstances.
  *
@@ -197,7 +199,7 @@ export declare function storeCleanupWithContext(view: LViewData | null, context:
  *
  * On the first template pass, the index of the cleanup function is saved in TView.
  */
-export declare function storeCleanupFn(view: LViewData, cleanupFn: Function): void;
+export declare function storeCleanupFn(view: LView, cleanupFn: Function): void;
 /** Mark the end of the element. */
 export declare function elementEnd(): void;
 /**
@@ -211,7 +213,7 @@ export declare function elementEnd(): void;
  */
 export declare function elementAttribute(index: number, name: string, value: any, sanitizer?: SanitizerFn | null): void;
 /**
- * Update a property on an Element.
+ * Update a property on an element.
  *
  * If the property name also exists as an input property on one of the element's directives,
  * the component property will be set instead of the element property. This check must
@@ -222,8 +224,32 @@ export declare function elementAttribute(index: number, name: string, value: any
  *        renaming as part of minification.
  * @param value New value to write.
  * @param sanitizer An optional function used to sanitize the value.
+ * @param nativeOnly Whether or not we should only set native properties and skip input check
+ * (this is necessary for host property bindings)
  */
-export declare function elementProperty<T>(index: number, propName: string, value: T | NO_CHANGE, sanitizer?: SanitizerFn | null): void;
+export declare function elementProperty<T>(index: number, propName: string, value: T | NO_CHANGE, sanitizer?: SanitizerFn | null, nativeOnly?: boolean): void;
+/**
+ * Updates a synthetic host binding (e.g. `[@foo]`) on a component.
+ *
+ * This instruction is for compatibility purposes and is designed to ensure that a
+ * synthetic host binding (e.g. `@HostBinding('@foo')`) properly gets rendered in
+ * the component's renderer. Normally all host bindings are evaluated with the parent
+ * component's renderer, but, in the case of animation @triggers, they need to be
+ * evaluated with the sub components renderer (because that's where the animation
+ * triggers are defined).
+ *
+ * Do not use this instruction as a replacement for `elementProperty`. This instruction
+ * only exists to ensure compatibility with the ViewEngine's host binding behavior.
+ *
+ * @param index The index of the element to update in the data array
+ * @param propName Name of property. Because it is going to DOM, this is not subject to
+ *        renaming as part of minification.
+ * @param value New value to write.
+ * @param sanitizer An optional function used to sanitize the value.
+ * @param nativeOnly Whether or not we should only set native properties and skip input check
+ * (this is necessary for host property bindings)
+ */
+export declare function componentHostSyntheticProperty<T>(index: number, propName: string, value: T | NO_CHANGE, sanitizer?: SanitizerFn | null, nativeOnly?: boolean): void;
 /**
  * Constructs a TNode object from the arguments.
  *
@@ -234,108 +260,130 @@ export declare function elementProperty<T>(index: number, propName: string, valu
  * @param tViews Any TViews attached to this node
  * @returns the TNode object
  */
-export declare function createTNode(viewData: LViewData, type: TNodeType, adjustedIndex: number, tagName: string | null, attrs: TAttributes | null, tViews: TView[] | null): TNode;
+export declare function createTNode(lView: LView, type: TNodeType, adjustedIndex: number, tagName: string | null, attrs: TAttributes | null, tViews: TView[] | null): TNode;
 /**
- * Add or remove a class in a `classList` on a DOM element.
+ * Assign any inline style values to the element during creation mode.
  *
- * This instruction is meant to handle the [class.foo]="exp" case
+ * This instruction is meant to be called during creation mode to register all
+ * dynamic style and class bindings on the element. Note for static values (no binding)
+ * see `elementStart` and `elementHostAttrs`.
+ *
+ * @param classBindingNames An array containing bindable class names.
+ *        The `elementClassProp` refers to the class name by index in this array.
+ *        (i.e. `['foo', 'bar']` means `foo=0` and `bar=1`).
+ * @param styleBindingNames An array containing bindable style properties.
+ *        The `elementStyleProp` refers to the class name by index in this array.
+ *        (i.e. `['width', 'height']` means `width=0` and `height=1`).
+ * @param styleSanitizer An optional sanitizer function that will be used to sanitize any CSS
+ *        property values that are applied to the element (during rendering).
+ *        Note that the sanitizer instance itself is tied to the `directive` (if  provided).
+ * @param directive A directive instance the styling is associated with. If not provided
+ *        current view's controller instance is assumed.
  *
- * @param index The index of the element to update in the data array
- * @param classIndex Index of class to toggle. Because it is going to DOM, this is not subject to
- *        renaming as part of minification.
- * @param value A value indicating if a given class should be added or removed.
- * @param directive the ref to the directive that is attempting to change styling.
+ * @publicApi
  */
-export declare function elementClassProp(index: number, classIndex: number, value: boolean | PlayerFactory, directive?: {}): void;
+export declare function elementStyling(classBindingNames?: string[] | null, styleBindingNames?: string[] | null, styleSanitizer?: StyleSanitizeFn | null, directive?: {}): void;
 /**
- * Assign any inline style values to the element during creation mode.
+ * Assign static styling values to a host element.
  *
- * This instruction is meant to be called during creation mode to apply all styling
- * (e.g. `style="..."`) values to the element. This is also where the provided index
- * value is allocated for the styling details for its corresponding element (the element
- * index is the previous index value from this one).
+ * NOTE: This instruction is meant to used from `hostBindings` function only.
  *
- * (Note this function calls `elementStylingApply` immediately when called.)
+ * @param directive A directive instance the styling is associated with.
+ * @param attrs An array containing class and styling information. The values must be marked with
+ *              `AttributeMarker`.
  *
+ *        ```
+ *        var attrs = [AttributeMarker.Classes, 'foo', 'bar',
+ *                     AttributeMarker.Styles, 'width', '100px', 'height, '200px']
+ *        elementHostAttrs(directive, attrs);
+ *        ```
  *
- * @param index Index value which will be allocated to store styling data for the element.
- *        (Note that this is not the element index, but rather an index value allocated
- *        specifically for element styling--the index must be the next index after the element
- *        index.)
- * @param classDeclarations A key/value array of CSS classes that will be registered on the element.
- *   Each individual style will be used on the element as long as it is not overridden
- *   by any classes placed on the element by multiple (`[class]`) or singular (`[class.named]`)
- *   bindings. If a class binding changes its value to a falsy value then the matching initial
- *   class value that are passed in here will be applied to the element (if matched).
- * @param styleDeclarations A key/value array of CSS styles that will be registered on the element.
- *   Each individual style will be used on the element as long as it is not overridden
- *   by any styles placed on the element by multiple (`[style]`) or singular (`[style.prop]`)
- *   bindings. If a style binding changes its value to null then the initial styling
- *   values that are passed in here will be applied to the element (if matched).
- * @param styleSanitizer An optional sanitizer function that will be used (if provided)
- *   to sanitize the any CSS property values that are applied to the element (during rendering).
- * @param directive the ref to the directive that is attempting to change styling.
+ * @publicApi
  */
-export declare function elementStyling(classDeclarations?: (string | boolean | InitialStylingFlags)[] | null, styleDeclarations?: (string | boolean | InitialStylingFlags)[] | null, styleSanitizer?: StyleSanitizeFn | null, directive?: {}): void;
+export declare function elementHostAttrs(directive: any, attrs: TAttributes): void;
 /**
- * Apply all styling values to the element which have been queued by any styling instructions.
+ * Apply styling binding to the element.
+ *
+ * This instruction is meant to be run after `elementStyle` and/or `elementStyleProp`.
+ * if any styling bindings have changed then the changes are flushed to the element.
  *
- * This instruction is meant to be run once one or more `elementStyle` and/or `elementStyleProp`
- * have been issued against the element. This function will also determine if any styles have
- * changed and will then skip the operation if there is nothing new to render.
  *
- * Once called then all queued styles will be flushed.
+ * @param index Index of the element's with which styling is associated.
+ * @param directive Directive instance that is attempting to change styling. (Defaults to the
+ *        component of the current view).
+components
  *
- * @param index Index of the element's styling storage that will be rendered.
- *        (Note that this is not the element index, but rather an index value allocated
- *        specifically for element styling--the index must be the next index after the element
- *        index.)
- * @param directive the ref to the directive that is attempting to change styling.
+ * @publicApi
  */
-export declare function elementStylingApply(index: number, directive?: {}): void;
+export declare function elementStylingApply(index: number, directive?: any): void;
 /**
- * Queue a given style to be rendered on an Element.
+ * Update a style bindings value on an element.
  *
  * If the style value is `null` then it will be removed from the element
  * (or assigned a different value depending if there are any styles placed
  * on the element with `elementStyle` or any styles that are present
  * from when the element was created (with `elementStyling`).
  *
- * (Note that the styling instruction will not be applied until `elementStylingApply` is called.)
+ * (Note that the styling element is updated as part of `elementStylingApply`.)
  *
- * @param index Index of the element's styling storage to change in the data array.
- *        (Note that this is not the element index, but rather an index value allocated
- *        specifically for element styling--the index must be the next index after the element
- *        index.)
- * @param styleIndex Index of the style property on this element. (Monotonically increasing.)
- * @param value New value to write (null to remove).
+ * @param index Index of the element's with which styling is associated.
+ * @param styleIndex Index of style to update. This index value refers to the
+ *        index of the style in the style bindings array that was passed into
+ *        `elementStlyingBindings`.
+ * @param value New value to write (null to remove). Note that if a directive also
+ *        attempts to write to the same binding value then it will only be able to
+ *        do so if the template binding value is `null` (or doesn't exist at all).
  * @param suffix Optional suffix. Used with scalar values to add unit such as `px`.
  *        Note that when a suffix is provided then the underlying sanitizer will
  *        be ignored.
- * @param directive the ref to the directive that is attempting to change styling.
+ * @param directive Directive instance that is attempting to change styling. (Defaults to the
+ *        component of the current view).
+components
+ *
+ * @publicApi
+ */
+export declare function elementStyleProp(index: number, styleIndex: number, value: string | number | String | PlayerFactory | null, suffix?: string | null, directive?: {}): void;
+/**
+ * Add or remove a class via a class binding on a DOM element.
+ *
+ * This instruction is meant to handle the [class.foo]="exp" case and, therefore,
+ * the class itself must already be applied using `elementStyling` within
+ * the creation block.
+ *
+ * @param index Index of the element's with which styling is associated.
+ * @param classIndex Index of class to toggle. This index value refers to the
+ *        index of the class in the class bindings array that was passed into
+ *        `elementStlyingBindings` (which is meant to be called before this
+ *        function is).
+ * @param value A true/false value which will turn the class on or off.
+ * @param directive Directive instance that is attempting to change styling. (Defaults to the
+ *        component of the current view).
+components
+ *
+ * @publicApi
  */
-export declare function elementStyleProp(index: number, styleIndex: number, value: string | number | String | PlayerFactory | null, suffix?: string, directive?: {}): void;
+export declare function elementClassProp(index: number, classIndex: number, value: boolean | PlayerFactory, directive?: {}): void;
 /**
- * Queue a key/value map of styles to be rendered on an Element.
+ * Update style and/or class bindings using object literal.
  *
- * This instruction is meant to handle the `[style]="exp"` usage. When styles are applied to
- * the Element they will then be placed with respect to any styles set with `elementStyleProp`.
- * If any styles are set to `null` then they will be removed from the element (unless the same
- * style properties have been assigned to the element during creation using `elementStyling`).
+ * This instruction is meant apply styling via the `[style]="exp"` and `[class]="exp"` template
+ * bindings. When styles are applied to the Element they will then be placed with respect to
+ * any styles set with `elementStyleProp`. If any styles are set to `null` then they will be
+ * removed from the element.
  *
  * (Note that the styling instruction will not be applied until `elementStylingApply` is called.)
  *
- * @param index Index of the element's styling storage to change in the data array.
- *        (Note that this is not the element index, but rather an index value allocated
- *        specifically for element styling--the index must be the next index after the element
- *        index.)
+ * @param index Index of the element's with which styling is associated.
  * @param classes A key/value style map of CSS classes that will be added to the given element.
  *        Any missing classes (that have already been applied to the element beforehand) will be
  *        removed (unset) from the element's list of CSS classes.
  * @param styles A key/value style map of the styles that will be applied to the given element.
  *        Any missing styles (that have already been applied to the element beforehand) will be
  *        removed (unset) from the element's styling.
- * @param directive the ref to the directive that is attempting to change styling.
+ * @param directive Directive instance that is attempting to change styling. (Defaults to the
+ *        component of the current view).
+ *
+ * @publicApi
  */
 export declare function elementStylingMap<T>(index: number, classes: {
     [key: string]: any;
@@ -360,7 +408,7 @@ export declare function textBinding<T>(index: number, value: T | NO_CHANGE): voi
 /**
  * Instantiate a root component.
  */
-export declare function instantiateRootComponent<T>(tView: TView, viewData: LViewData, def: ComponentDef<T>): T;
+export declare function instantiateRootComponent<T>(tView: TView, viewData: LView, def: ComponentDef<T>): T;
 /**
 * Generates a new block in TView.expandoInstructions for this node.
 *
@@ -368,12 +416,6 @@ export declare function instantiateRootComponent<T>(tView: TView, viewData: LVie
 * it from the hostVar count) and the directive count. See more in VIEW_DATA.md.
 */
 export declare function generateExpandoInstructionBlock(tView: TView, tNode: TNode, directiveCount: number): void;
-/**
-* On the first template pass, we need to reserve space for host binding values
-* after directives are matched (so all directives are saved, then bindings).
-* Because we are updating the blueprint, we only need to do this once.
-*/
-export declare function prefillHostVars(tView: TView, viewData: LViewData, totalHostVars: number): void;
 /** Stores index of component's host element so it will be queued for view refresh during CD. */
 export declare function queueComponentIndexForCheck(previousOrParentTNode: TNode): void;
 /**
@@ -392,7 +434,7 @@ export declare function initNodeFlags(tNode: TNode, index: number, numberOfDirec
  * @param isForViewContainerRef Optional a flag indicating the ViewContainerRef case
  * @returns LContainer
  */
-export declare function createLContainer(hostNative: RElement | RComment, hostTNode: TElementNode | TContainerNode | TElementContainerNode, currentView: LViewData, native: RComment, isForViewContainerRef?: boolean): LContainer;
+export declare function createLContainer(hostNative: RElement | RComment, hostTNode: TElementNode | TContainerNode | TElementContainerNode, currentView: LView, native: RComment, isForViewContainerRef?: boolean): LContainer;
 /**
  * Creates an LContainer for an ng-template (dynamically-inserted view), e.g.
  *
@@ -445,12 +487,11 @@ export declare function embeddedViewEnd(): void;
 /**
  * Refreshes components by entering the component view and processing its bindings, queries, etc.
  *
- * @param adjustedElementIndex  Element index in LViewData[] (adjusted for HEADER_OFFSET)
- * @param rf  The render flags that should be used to process this template
+ * @param adjustedElementIndex  Element index in LView[] (adjusted for HEADER_OFFSET)
  */
-export declare function componentRefresh<T>(adjustedElementIndex: number, rf: RenderFlags | null): void;
+export declare function componentRefresh<T>(adjustedElementIndex: number): void;
 /** Returns a boolean for whether the view is attached */
-export declare function viewAttached(view: LViewData): boolean;
+export declare function viewAttached(view: LView): boolean;
 /**
  * Instruction to distribute projectable nodes among <ng-content> occurrences in a given template.
  * It takes all the selectors from the entire component's template and decides where
@@ -484,19 +525,19 @@ export declare function projectionDef(selectors?: CssSelectorList[], textSelecto
  */
 export declare function projection(nodeIndex: number, selectorIndex?: number, attrs?: string[]): void;
 /**
- * Adds LViewData or LContainer to the end of the current view tree.
+ * Adds LView or LContainer to the end of the current view tree.
  *
  * This structure will be used to traverse through nested views to remove listeners
  * and call onDestroy callbacks.
  *
- * @param currentView The view where LViewData or LContainer should be added
- * @param adjustedHostIndex Index of the view's host node in LViewData[], adjusted for header
- * @param state The LViewData or LContainer to add to the view tree
+ * @param lView The view where LView or LContainer should be added
+ * @param adjustedHostIndex Index of the view's host node in LView[], adjusted for header
+ * @param state The LView or LContainer to add to the view tree
  * @returns The state passed in
  */
-export declare function addToViewTree<T extends LViewData | LContainer>(currentView: LViewData, adjustedHostIndex: number, state: T): T;
+export declare function addToViewTree<T extends LView | LContainer>(lView: LView, adjustedHostIndex: number, state: T): T;
 /** Marks current view and all ancestors dirty */
-export declare function markViewDirty(view: LViewData): void;
+export declare function markViewDirty(lView: LView): void;
 /**
  * Used to schedule change detection on the whole application.
  *
@@ -536,12 +577,13 @@ export declare function tick<T>(component: T): void;
  * @param component The component which the change detection should be performed on.
  */
 export declare function detectChanges<T>(component: T): void;
+export declare function detectChangesInternal<T>(view: LView, context: T): void;
 /**
  * Synchronously perform change detection on a root view and its components.
  *
- * @param lViewData The view which the change detection should be performed on.
+ * @param lView The view which the change detection should be performed on.
  */
-export declare function detectChangesInRootView(lViewData: LViewData): void;
+export declare function detectChangesInRootView(lView: LView): void;
 /**
  * Checks the change detector and its children, and throws if any changes are detected.
  *
@@ -556,9 +598,11 @@ export declare function checkNoChanges<T>(component: T): void;
  * This is used in development mode to verify that running change detection doesn't
  * introduce other changes.
  *
- * @param lViewData The view which the change detection should be checked on.
+ * @param lView The view which the change detection should be checked on.
  */
-export declare function checkNoChangesInRootView(lViewData: LViewData): void;
+export declare function checkNoChangesInRootView(lView: LView): void;
+/** Checks the view of the component provided. Does not gate on dirty checks or execute doCheck. */
+export declare function checkView<T>(hostView: LView, component: T): void;
 /**
  * Mark the component as dirty (needing change detection).
  *
@@ -582,6 +626,12 @@ export declare function markDirty<T>(component: T): void;
  * @param value Value to diff
  */
 export declare function bind<T>(value: T): T | NO_CHANGE;
+/**
+ * Allocates the necessary amount of slots for host vars.
+ *
+ * @param count Amount of vars to be allocated
+ */
+export declare function allocHostVars(count: number): void;
 /**
  * Create interpolation bindings with a variable number of expressions.
  *
@@ -631,18 +681,6 @@ export declare function reference<T>(index: number): T;
 export declare function loadQueryList<T>(queryListIdx: number): QueryList<T>;
 /** Retrieves a value from current `viewData`. */
 export declare function load<T>(index: number): T;
-/** Gets the current binding value. */
-export declare function getBinding(bindingIndex: number): any;
-/** Updates binding if changed, then returns whether it was updated. */
-export declare function bindingUpdated(bindingIndex: number, value: any): boolean;
-/** Updates binding and returns the value. */
-export declare function updateBinding(bindingIndex: number, value: any): any;
-/** Updates 2 bindings if changed, then returns whether either was updated. */
-export declare function bindingUpdated2(bindingIndex: number, exp1: any, exp2: any): boolean;
-/** Updates 3 bindings if changed, then returns whether any was updated. */
-export declare function bindingUpdated3(bindingIndex: number, exp1: any, exp2: any, exp3: any): boolean;
-/** Updates 4 bindings if changed, then returns whether any was updated. */
-export declare function bindingUpdated4(bindingIndex: number, exp1: any, exp2: any, exp3: any, exp4: any): boolean;
 /**
  * Returns the value associated to the given token from the injectors.
  *
@@ -676,4 +714,11 @@ export declare function injectAttribute(attrNameToInject: string): string | null
  */
 export declare function registerContentQuery<Q>(queryList: QueryList<Q>, currentDirectiveIndex: number): void;
 export declare const CLEAN_PROMISE: Promise<null>;
-export declare function delegateToClassInput(tNode: TNode): number;
+/**
+ * Returns the current OpaqueViewState instance.
+ *
+ * Used in conjunction with the restoreView() instruction to save a snapshot
+ * of the current view and restore it when listeners are invoked. This allows
+ * walking the declaration view tree in listeners to get vars from parent views.
+ */
+export declare function getCurrentView(): OpaqueViewState;