@angular/core 7.0.0-rc.1 → 7.0.3

package/src/render3/interfaces/view.d.ts

@@ -8,30 +8,32 @@
 import { Injector } from '../../di/injector';
 import { QueryList } from '../../linker';
 import { Sanitizer } from '../../sanitization/security';
-import { PlayerHandler } from '../interfaces/player';
 import { LContainer } from './container';
 import { ComponentDef, ComponentQuery, ComponentTemplate, DirectiveDef, DirectiveDefList, HostBindingsFunction, PipeDef, PipeDefList } from './definition';
 import { TElementNode, TNode, TViewNode } from './node';
+import { PlayerHandler } from './player';
 import { LQueries } from './query';
-import { Renderer3 } from './renderer';
+import { RElement, Renderer3 } from './renderer';
+import { StylingContext } from './styling';
 /** Size of LViewData's header. Necessary to adjust for it when setting slots.  */
-export declare const HEADER_OFFSET = 16;
+export declare const HEADER_OFFSET = 17;
 export declare const TVIEW = 0;
-export declare const PARENT = 1;
-export declare const NEXT = 2;
-export declare const QUERIES = 3;
-export declare const FLAGS = 4;
-export declare const HOST_NODE = 5;
-export declare const BINDING_INDEX = 6;
-export declare const CLEANUP = 7;
-export declare const CONTEXT = 8;
-export declare const INJECTOR = 9;
-export declare const RENDERER = 10;
-export declare const SANITIZER = 11;
-export declare const TAIL = 12;
-export declare const CONTAINER_INDEX = 13;
-export declare const CONTENT_QUERIES = 14;
-export declare const DECLARATION_VIEW = 15;
+export declare const FLAGS = 1;
+export declare const PARENT = 2;
+export declare const NEXT = 3;
+export declare const QUERIES = 4;
+export declare const HOST = 5;
+export declare const HOST_NODE = 6;
+export declare const BINDING_INDEX = 7;
+export declare const CLEANUP = 8;
+export declare const CONTEXT = 9;
+export declare const INJECTOR = 10;
+export declare const RENDERER = 11;
+export declare const SANITIZER = 12;
+export declare const TAIL = 13;
+export declare const CONTAINER_INDEX = 14;
+export declare const CONTENT_QUERIES = 15;
+export declare const DECLARATION_VIEW = 16;
 export interface OpaqueViewState {
     '__brand__': 'Brand for OpaqueViewState that nothing will match';
 }
@@ -52,6 +54,8 @@ export interface LViewData extends Array<any> {
      * directive defs are stored).
      */
     [TVIEW]: TView;
+    /** Flags for this view. See LViewFlags for more info. */
+    [FLAGS]: LViewFlags;
     /**
      * The parent view is needed when we exit the view and must restore the previous
      * `LViewData`. Without this, the render method would have to keep a stack of
@@ -73,8 +77,12 @@ export interface LViewData extends Array<any> {
     [NEXT]: LViewData | LContainer | null;
     /** Queries active for this view - nodes from a view are reported to those queries. */
     [QUERIES]: LQueries | null;
-    /** Flags for this view. See LViewFlags for more info. */
-    [FLAGS]: LViewFlags;
+    /**
+     * The host node for this LViewData instance, if this is a component view.
+     *
+     * If this is an embedded view, HOST will be null.
+     */
+    [HOST]: RElement | StylingContext | null;
     /**
      * Pointer to the `TViewNode` or `TElementNode` which represents the root of the view.
      *
@@ -294,14 +302,6 @@ export interface TView {
      *   - String, temporary 'CIRCULAR' token set while dependencies are being resolved
      */
     currentMatches: CurrentMatchesList | null;
-    /**
-     * Directive and component defs that have already been matched to nodes on
-     * this view.
-     *
-     * Defs are stored at the same index in TView.directives[] as their instances
-     * are stored in LView.directives[]. This simplifies lookup in DI.
-     */
-    directives: DirectiveDefList | null;
     /**
      * Set of instructions used to process host bindings efficiently.
      *

package/src/render3/jit/compiler_facade.d.ts

@@ -0,0 +1,3 @@
+import { CompilerFacade } from './compiler_facade_interface';
+export * from './compiler_facade_interface';
+export declare function getCompilerFacade(): CompilerFacade;

package/src/render3/jit/compiler_facade_interface.d.ts

@@ -0,0 +1,131 @@
+/**
+ * @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
+ */
+/**
+ * A set of interfaces which are shared between `@angular/core` and `@angular/compiler` to allow
+ * for late binding of `@angular/compiler` for JIT purposes.
+ *
+ * This file has two copies. Please ensure that they are in sync:
+ *  - packages/compiler/src/compiler_facade_interface.ts             (master)
+ *  - packages/core/src/render3/jit/compiler_facade_interface.ts     (copy)
+ *
+ * Please ensure that the two files are in sync using this command:
+ * ```
+ * cp packages/compiler/src/compiler_facade_interface.ts \
+ *    packages/core/src/render3/jit/compiler_facade_interface.ts
+ * ```
+ */
+export interface ExportedCompilerFacade {
+    ɵcompilerFacade: CompilerFacade;
+}
+export interface CompilerFacade {
+    compilePipe(angularCoreEnv: CoreEnvironment, sourceMapUrl: string, meta: R3PipeMetadataFacade): any;
+    compileInjectable(angularCoreEnv: CoreEnvironment, sourceMapUrl: string, meta: R3InjectableMetadataFacade): any;
+    compileInjector(angularCoreEnv: CoreEnvironment, sourceMapUrl: string, meta: R3InjectorMetadataFacade): any;
+    compileNgModule(angularCoreEnv: CoreEnvironment, sourceMapUrl: string, meta: R3NgModuleMetadataFacade): any;
+    compileDirective(angularCoreEnv: CoreEnvironment, sourceMapUrl: string, meta: R3DirectiveMetadataFacade): any;
+    compileComponent(angularCoreEnv: CoreEnvironment, sourceMapUrl: string, meta: R3ComponentMetadataFacade): any;
+    R3ResolvedDependencyType: typeof R3ResolvedDependencyType;
+}
+export interface CoreEnvironment {
+    [name: string]: Function;
+}
+export declare type StringMap = {
+    [key: string]: string;
+};
+export declare type StringMapWithRename = {
+    [key: string]: string | [string, string];
+};
+export declare type Provider = any;
+export declare enum R3ResolvedDependencyType {
+    Token = 0,
+    Attribute = 1,
+    Injector = 2
+}
+export interface R3DependencyMetadataFacade {
+    token: any;
+    resolved: R3ResolvedDependencyType;
+    host: boolean;
+    optional: boolean;
+    self: boolean;
+    skipSelf: boolean;
+}
+export interface R3PipeMetadataFacade {
+    name: string;
+    type: any;
+    pipeName: string;
+    deps: R3DependencyMetadataFacade[] | null;
+    pure: boolean;
+}
+export interface R3InjectableMetadataFacade {
+    name: string;
+    type: any;
+    ctorDeps: R3DependencyMetadataFacade[] | null;
+    providedIn: any;
+    useClass?: any;
+    useFactory?: any;
+    useExisting?: any;
+    useValue?: any;
+    userDeps?: R3DependencyMetadataFacade[];
+}
+export interface R3NgModuleMetadataFacade {
+    type: any;
+    bootstrap: Function[];
+    declarations: Function[];
+    imports: Function[];
+    exports: Function[];
+    emitInline: boolean;
+}
+export interface R3InjectorMetadataFacade {
+    name: string;
+    type: any;
+    deps: R3DependencyMetadataFacade[] | null;
+    providers: any;
+    imports: any;
+}
+export interface R3DirectiveMetadataFacade {
+    name: string;
+    type: any;
+    typeArgumentCount: number;
+    typeSourceSpan: null;
+    deps: R3DependencyMetadataFacade[] | null;
+    selector: string | null;
+    queries: R3QueryMetadataFacade[];
+    host: {
+        [key: string]: string;
+    };
+    propMetadata: {
+        [key: string]: any[];
+    };
+    lifecycle: {
+        usesOnChanges: boolean;
+    };
+    inputs: string[];
+    outputs: string[];
+    usesInheritance: boolean;
+    exportAs: string | null;
+    providers: Provider[] | null;
+}
+export interface R3ComponentMetadataFacade extends R3DirectiveMetadataFacade {
+    template: string;
+    preserveWhitespaces: boolean;
+    animations: any[] | undefined;
+    viewQueries: R3QueryMetadataFacade[];
+    pipes: Map<string, any>;
+    directives: Map<string, any>;
+    styles: string[];
+    encapsulation: ViewEncapsulation;
+    viewProviders: Provider[] | null;
+}
+export declare type ViewEncapsulation = number;
+export interface R3QueryMetadataFacade {
+    propertyName: string;
+    first: boolean;
+    predicate: any | string[];
+    descendants: boolean;
+    read: any | null;
+}

package/src/render3/jit/directive.d.ts

@@ -5,8 +5,10 @@
  * 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 { Query } from '../../metadata/di';
 import { Component, Directive } from '../../metadata/directives';
 import { Type } from '../../type';
+import { R3QueryMetadataFacade } from './compiler_facade_interface';
 /**
  * Compile an Angular component according to its decorator metadata, and patch the resulting
  * ngComponentDef onto the component type.
@@ -26,3 +28,4 @@ export declare function compileComponent(type: Type<any>, metadata: Component):
  */
 export declare function compileDirective(type: Type<any>, directive: Directive): void;
 export declare function extendsDirectlyFromObject(type: Type<any>): boolean;
+export declare function convertToR3QueryMetadata(propertyName: string, ann: Query): R3QueryMetadataFacade;

package/src/render3/jit/util.d.ts

@@ -5,9 +5,9 @@
  * 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 { R3DependencyMetadata } from '@angular/compiler';
 import { ReflectionCapabilities } from '../../reflection/reflection_capabilities';
 import { Type } from '../../type';
+import { R3DependencyMetadataFacade } from './compiler_facade';
 export declare function getReflect(): ReflectionCapabilities;
-export declare function reflectDependencies(type: Type<any>): R3DependencyMetadata[];
-export declare function convertDependencies(deps: any[]): R3DependencyMetadata[];
+export declare function reflectDependencies(type: Type<any>): R3DependencyMetadataFacade[];
+export declare function convertDependencies(deps: any[]): R3DependencyMetadataFacade[];

package/src/render3/node_manipulation.d.ts

@@ -6,22 +6,22 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import { LContainer } from './interfaces/container';
-import { LContainerNode, LElementContainerNode, LElementNode, LTextNode, TContainerNode, TNode, TViewNode } from './interfaces/node';
-import { RComment, RNode, RText, Renderer3 } from './interfaces/renderer';
+import { TContainerNode, TElementContainerNode, TElementNode, TNode, TViewNode } from './interfaces/node';
+import { RComment, RElement, RNode, RText, Renderer3 } from './interfaces/renderer';
 import { LViewData } from './interfaces/view';
-/** Retrieves the parent LNode of a given node. */
-export declare function getParentLNode(tNode: TNode, currentView: LViewData): LElementNode | LElementContainerNode | LContainerNode | null;
+/** Retrieves the parent element of a given node. */
+export declare function getParentNative(tNode: TNode, currentView: LViewData): RElement | RComment | null;
 /**
- * Gets the host LElementNode given a view. Will return null if the host element is an
- * LViewNode, since they are being phased out.
+ * Gets the host element given a view. Will return null if the current view is an embedded view,
+ * which does not have a host element.
  */
-export declare function getHostElementNode(currentView: LViewData): LElementNode | null;
-export declare function getContainerNode(tNode: TNode, embeddedView: LViewData): LContainerNode | null;
+export declare function getHostNative(currentView: LViewData): RElement | null;
+export declare function getLContainer(tNode: TViewNode, embeddedView: LViewData): LContainer | null;
 /**
- * Retrieves render parent LElementNode for a given view.
+ * Retrieves render parent for a given view.
  * Might be null if a view is not yet attached to any container.
  */
-export declare function getContainerRenderParent(tViewNode: TViewNode, view: LViewData): LElementNode | null;
+export declare function getContainerRenderParent(tViewNode: TViewNode, view: LViewData): RElement | null;
 /**
  * Given a current view, finds the nearest component's host (LElement).
  *
@@ -90,7 +90,7 @@ export declare function detachView(lContainer: LContainer, removeIndex: number,
  * @param tContainer The TContainer node associated with the LContainer
  * @param removeIndex The index of the view to remove
  */
-export declare function removeView(lContainer: LContainer, tContainer: TContainerNode, removeIndex: number): void;
+export declare function removeView(lContainer: LContainer, containerHost: TElementNode | TContainerNode | TElementContainerNode, removeIndex: number): void;
 /** Gets the child of the given LViewData */
 export declare function getLViewChild(viewData: LViewData): LViewData | LContainer | null;
 /**
@@ -113,7 +113,7 @@ export declare function destroyLView(view: LViewData): void;
  * @returns The correct parent LViewOrLContainer
  */
 export declare function getParentState(state: LViewData | LContainer, rootView: LViewData): LViewData | LContainer | null;
-export declare function getRenderParent(tNode: TNode, currentView: LViewData): LElementNode | null;
+export declare function getRenderParent(tNode: TNode, currentView: LViewData): RElement | null;
 /**
  * Returns whether a native element can be inserted into the given parent.
  *
@@ -144,24 +144,23 @@ export declare function canInsertNativeNode(tNode: TNode, currentView: LViewData
  * @returns Whether or not the child was appended
  */
 export declare function appendChild(childEl: RNode | null, childTNode: TNode, currentView: LViewData): boolean;
-export declare function getBeforeNodeForView(index: number, views: LViewData[], container: LContainerNode): RComment;
+export declare function getBeforeNodeForView(index: number, views: LViewData[], containerNative: RComment): RComment;
 /**
- * Removes the `child` element of the `parent` from the DOM.
+ * Removes the `child` element from the DOM if not in view and not projected.
  *
- * @param parentEl The parent element from which to remove the child
- * @param child The child that should be removed
+ * @param childTNode The TNode of the child to remove
+ * @param childEl The child that should be removed
  * @param currentView The current LView
  * @returns Whether or not the child was removed
  */
-export declare function removeChild(tNode: TNode, child: RNode | null, currentView: LViewData): boolean;
+export declare function removeChild(childTNode: TNode, childEl: RNode | null, currentView: LViewData): boolean;
 /**
  * Appends a projected node to the DOM, or in the case of a projected container,
  * appends the nodes from all of the container's active views to the DOM.
  *
- * @param projectedLNode The node to process
- * @param parentNode The last parent element to be processed
- * @param tProjectionNode
+ * @param projectedTNode The TNode to be projected
+ * @param tProjectionNode The projection (ng-content) TNode
  * @param currentView Current LView
- * @param projectionView Projection view
+ * @param projectionView Projection view (view above current)
  */
-export declare function appendProjectedNode(projectedLNode: LElementNode | LElementContainerNode | LTextNode | LContainerNode, projectedTNode: TNode, tProjectionNode: TNode, currentView: LViewData, projectionView: LViewData): void;
+export declare function appendProjectedNode(projectedTNode: TNode, tProjectionNode: TNode, currentView: LViewData, projectionView: LViewData): void;

package/src/render3/players.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @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';
+import { ComponentInstance, DirectiveInstance, Player } from './interfaces/player';
+/**
+ * Adds a player to an element, directive or component instance that will later be
+ * animated once change detection has passed.
+ *
+ * When a player is added to a reference it will stay active until `player.destroy()`
+ * is called. Once called then the player will be removed from the active players
+ * present on the associated ref instance.
+ *
+ * To get a list of all the active players on an element see [getPlayers].
+ *
+ * @param ref The element, directive or component that the player will be placed on.
+ * @param player The player that will be triggered to play once change detection has run.
+ */
+export declare function addPlayer(ref: ComponentInstance | DirectiveInstance | HTMLElement, player: Player): void;
+/**
+ * Returns a list of all the active players present on the provided ref instance (which can
+ * be an instance of a directive, component or element).
+ *
+ * This function will only return players that have been added to the ref instance using
+ * `addPlayer` or any players that are active through any template styling bindings
+ * (`[style]`, `[style.prop]`, `[class]` and `[class.name]`).
+ */
+export declare function getPlayers(ref: ComponentInstance | DirectiveInstance | HTMLElement): Player[];

package/src/render3/styling/class_and_style_bindings.d.ts

@@ -7,16 +7,11 @@
  */
 import { StyleSanitizeFn } from '../../sanitization/style_sanitizer';
 import { InitialStylingFlags } from '../interfaces/definition';
-import { LElementNode } from '../interfaces/node';
+import { BindingStore, BindingType, Player, PlayerBuilder, PlayerFactory } from '../interfaces/player';
 import { Renderer3 } from '../interfaces/renderer';
 import { StylingContext } from '../interfaces/styling';
-/**
- * Used clone a copy of a pre-computed template of a styling context.
- *
- * A pre-computed template is designed to be computed once for a given element
- * (instructions.ts has logic for caching this).
- */
-export declare function allocStylingContext(lElement: LElementNode | null, templateStyleContext: StylingContext): StylingContext;
+import { LViewData, RootContext } from '../interfaces/view';
+import { BoundPlayerFactory } from './player_factory';
 /**
  * Creates a styling context template where styling information is stored.
  * Any styles that are later referenced using `updateStyleProp` must be
@@ -42,7 +37,7 @@ export declare function allocStylingContext(lElement: LElementNode | null, templ
 export declare function createStylingContextTemplate(initialClassDeclarations?: (string | boolean | InitialStylingFlags)[] | null, initialStyleDeclarations?: (string | boolean | InitialStylingFlags)[] | null, styleSanitizer?: StyleSanitizeFn | null): StylingContext;
 /**
  * Sets and resolves all `multi` styling on an `StylingContext` so that they can be
- * applied to the element once `renderStyling` is called.
+ * applied to the element once `renderStyleAndClassBindings` is called.
  *
  * All missing styles/class (any values that are not provided in the new `styles`
  * or `classes` params) will resolve to `null` within their respective positions
@@ -50,17 +45,21 @@ export declare function createStylingContextTemplate(initialClassDeclarations?:
  *
  * @param context The styling context that will be updated with the
  *    newly provided style values.
- * @param classes The key/value map of CSS class names that will be used for the update.
- * @param styles The key/value map of CSS styles that will be used for the update.
+ * @param classesInput The key/value map of CSS class names that will be used for the update.
+ * @param stylesInput The key/value map of CSS styles that will be used for the update.
  */
-export declare function updateStylingMap(context: StylingContext, classes: {
+export declare function updateStylingMap(context: StylingContext, classesInput: {
     [key: string]: any;
-} | string | null, styles?: {
+} | string | BoundPlayerFactory<null | string | {
     [key: string]: any;
-} | null): void;
+}> | null, stylesInput?: {
+    [key: string]: any;
+} | BoundPlayerFactory<null | {
+    [key: string]: any;
+}> | null): void;
 /**
  * Sets and resolves a single styling property/value on the provided `StylingContext` so
- * that they can be applied to the element once `renderStyling` is called.
+ * that they can be applied to the element once `renderStyleAndClassBindings` is called.
  *
  * Note that prop-level styling values are considered higher priority than any styling that
  * has been applied using `updateStylingMap`, therefore, when styling values are rendered
@@ -72,7 +71,7 @@ export declare function updateStylingMap(context: StylingContext, classes: {
  * @param index The index of the property which is being updated.
  * @param value The CSS style value that will be assigned
  */
-export declare function updateStyleProp(context: StylingContext, index: number, value: string | boolean | null): void;
+export declare function updateStyleProp(context: StylingContext, index: number, input: string | boolean | null | BoundPlayerFactory<string | boolean | null>): void;
 /**
  * This method will toggle the referenced CSS class (by the provided index)
  * within the given context.
@@ -82,7 +81,7 @@ export declare function updateStyleProp(context: StylingContext, index: number,
  * @param index The index of the CSS class which is being updated.
  * @param addOrRemove Whether or not to add or remove the CSS class
  */
-export declare function updateClassProp(context: StylingContext, index: number, addOrRemove: boolean): void;
+export declare function updateClassProp(context: StylingContext, index: number, addOrRemove: boolean | BoundPlayerFactory<boolean>): void;
 /**
  * Renders all queued styling using a renderer onto the given element.
  *
@@ -96,15 +95,23 @@ export declare function updateClassProp(context: StylingContext, index: number,
  * @param context The styling context that will be used to determine
  *      what styles will be rendered
  * @param renderer the renderer that will be used to apply the styling
- * @param styleStore if provided, the updated style values will be applied
+ * @param classesStore if provided, the updated class values will be applied
  *    to this key/value map instead of being renderered via the renderer.
- * @param classStore if provided, the updated class values will be applied
+ * @param stylesStore if provided, the updated style values will be applied
  *    to this key/value map instead of being renderered via the renderer.
+ * @returns number the total amount of players that got queued for animation (if any)
  */
-export declare function renderStyling(context: StylingContext, renderer: Renderer3, styleStore?: {
-    [key: string]: any;
-}, classStore?: {
-    [key: string]: boolean;
-}): void;
+export declare function renderStyleAndClassBindings(context: StylingContext, renderer: Renderer3, rootOrView: RootContext | LViewData, classesStore?: BindingStore | null, stylesStore?: BindingStore | null): number;
 export declare function isContextDirty(context: StylingContext): boolean;
 export declare function setContextDirty(context: StylingContext, isDirtyYes: boolean): void;
+export declare function setContextPlayersDirty(context: StylingContext, isDirtyYes: boolean): void;
+export declare class ClassAndStylePlayerBuilder<T> implements PlayerBuilder {
+    private _element;
+    private _type;
+    private _values;
+    private _dirty;
+    private _factory;
+    constructor(factory: PlayerFactory, _element: HTMLElement, _type: BindingType);
+    setValue(prop: string, value: any): void;
+    buildPlayer(currentPlayer?: Player | null): Player | undefined | null;
+}

package/src/render3/styling/player_factory.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @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 { PlayerFactory, PlayerFactoryBuildFn } from '../interfaces/player';
+/**
+ * Combines the binding value and a factory for an animation player.
+ *
+ * Used to bind a player to an element template binding (currently only
+ * `[style]`, `[style.prop]`, `[class]` and `[class.name]` bindings
+ * supported). The provided `factoryFn` function will be run once all
+ * the associated bindings have been evaluated on the element and is
+ * designed to return a player which will then be placed on the element.
+ *
+ * @param factoryFn The function that is used to create a player
+ *   once all the rendering-related (styling values) have been
+ *   processed for the element binding.
+ * @param value The raw value that will be exposed to the binding
+ *   so that the binding can update its internal values when
+ *   any changes are evaluated.
+ */
+export declare function bindPlayerFactory<T>(factoryFn: PlayerFactoryBuildFn, value: T): PlayerFactory;
+export declare class BoundPlayerFactory<T> {
+    fn: PlayerFactoryBuildFn;
+    value: T;
+    '__brand__': 'Brand for PlayerFactory that nothing will match';
+    constructor(fn: PlayerFactoryBuildFn, value: T);
+}

package/src/render3/styling/util.d.ts

@@ -5,14 +5,36 @@
  * 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';
 import { StyleSanitizeFn } from '../../sanitization/style_sanitizer';
-import { LContext } from '../context_discovery';
-import { LElementNode } from '../interfaces/node';
-import { PlayerContext } from '../interfaces/player';
+import { LContext } from '../interfaces/context';
+import { Player, PlayerContext } from '../interfaces/player';
+import { RElement } from '../interfaces/renderer';
 import { InitialStyles, StylingContext } from '../interfaces/styling';
-export declare const EMPTY_ARR: any[];
-export declare const EMPTY_OBJ: {
-    [key: string]: any;
-};
-export declare function createEmptyStylingContext(element?: LElementNode | null, sanitizer?: StyleSanitizeFn | null, initialStylingValues?: InitialStyles): StylingContext;
-export declare function getOrCreatePlayerContext(target: {}, context?: LContext | null): PlayerContext;
+import { LViewData, RootContext } from '../interfaces/view';
+export declare function createEmptyStylingContext(element?: RElement | null, sanitizer?: StyleSanitizeFn | null, initialStylingValues?: InitialStyles): StylingContext;
+/**
+ * Used clone a copy of a pre-computed template of a styling context.
+ *
+ * A pre-computed template is designed to be computed once for a given element
+ * (instructions.ts has logic for caching this).
+ */
+export declare function allocStylingContext(element: RElement | null, templateStyleContext: StylingContext): StylingContext;
+/**
+ * Retrieve the `StylingContext` at a given index.
+ *
+ * This method lazily creates the `StylingContext`. This is because in most cases
+ * we have styling without any bindings. Creating `StylingContext` eagerly would mean that
+ * every style declaration such as `<div style="color: red">` would result `StyleContext`
+ * which would create unnecessary memory pressure.
+ *
+ * @param index Index of the style allocation. See: `elementStyling`.
+ * @param viewData The view to search for the styling context
+ */
+export declare function getStylingContext(index: number, viewData: LViewData): StylingContext;
+export declare function addPlayerInternal(playerContext: PlayerContext, rootContext: RootContext, element: HTMLElement, player: Player | null, playerContextIndex: number, ref?: any): boolean;
+export declare function getPlayersInternal(playerContext: PlayerContext): Player[];
+export declare function getOrCreatePlayerContext(target: {}, context?: LContext | null): PlayerContext | null;
+export declare function getPlayerContext(stylingContext: StylingContext): PlayerContext | null;
+export declare function allocPlayerContext(data: StylingContext): PlayerContext;
+export declare function throwInvalidRefError(): void;

package/src/render3/util.d.ts

@@ -5,7 +5,11 @@
  * 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 { LContainerNode, LElementContainerNode, LElementNode, TNode } from './interfaces/node';
+import { LContainer } from './interfaces/container';
+import { LContext } from './interfaces/context';
+import { TNode } from './interfaces/node';
+import { RComment, RElement, RText } from './interfaces/renderer';
+import { StylingContext } from './interfaces/styling';
 import { LViewData, RootContext, TData } from './interfaces/view';
 /**
  * Returns whether the values are different from a change detection stand point.
@@ -14,13 +18,6 @@ import { LViewData, RootContext, TData } from './interfaces/view';
  */
 export declare function isDifferent(a: any, b: any, checkNoChangesMode: boolean): boolean;
 export declare function stringify(value: any): string;
-/**
- *  Function that throws a "not implemented" error so it's clear certain
- *  behaviors/methods aren't yet ready.
- *
- * @returns Not implemented error
- */
-export declare function notImplemented(): Error;
 /**
  * Flattens an array in non-recursive way. Input arrays are not modified.
  */
@@ -28,15 +25,29 @@ export declare function flatten(list: any[]): any[];
 /** Retrieves a value from any `LViewData` or `TData`. */
 export declare function loadInternal<T>(index: number, arr: LViewData | TData): T;
 export declare function assertDataInRangeInternal(index: number, arr: any[]): void;
-/** Retrieves an element value from the provided `viewData`.
-  *
-  * Elements that are read may be wrapped in a style context,
-  * therefore reading the value may involve unwrapping that.
-  */
-export declare function loadElementInternal(index: number, arr: LViewData): LElementNode;
-export declare function getLNode(tNode: TNode, hostView: LViewData): LElementNode | LContainerNode | LElementContainerNode;
+/**
+ * Takes the value of a slot in `LViewData` and returns the element node.
+ *
+ * Normally, element nodes are stored flat, but if the node has styles/classes on it,
+ * it might be wrapped in a styling context. Or if that node has a directive that injects
+ * ViewContainerRef, it may be wrapped in an LContainer. Or if that node is a component,
+ * it will be wrapped in LViewData. It could even have all three, so we keep looping
+ * until we find something that isn't an array.
+ *
+ * @param value The initial value in `LViewData`
+ */
+export declare function readElementValue(value: RElement | StylingContext | LContainer | LViewData): RElement;
+/**
+ * Retrieves an element value from the provided `viewData`, by unwrapping
+ * from any containers, component views, or style contexts.
+ */
+export declare function getNativeByIndex(index: number, arr: LViewData): RElement;
+export declare function getNativeByTNode(tNode: TNode, hostView: LViewData): RElement | RText | RComment;
+export declare function getTNode(index: number, view: LViewData): TNode;
+export declare function getComponentViewByIndex(nodeIndex: number, hostView: LViewData): LViewData;
 export declare function isContentQueryHost(tNode: TNode): boolean;
 export declare function isComponent(tNode: TNode): boolean;
+export declare function isLContainer(value: RElement | RComment | LContainer | StylingContext): boolean;
 /**
  * Retrieve the root view from any component by walking the parent `LViewData` until
  * reaching the root `LViewData`.
@@ -45,3 +56,9 @@ export declare function isComponent(tNode: TNode): boolean;
  */
 export declare function getRootView(target: LViewData | {}): LViewData;
 export declare function getRootContext(viewOrComponent: LViewData | {}): RootContext;
+/**
+ * Returns the monkey-patch value data present on the target (which could be
+ * a component, directive or a DOM node).
+ */
+export declare function readPatchedData(target: any): LViewData | LContext | null;
+export declare function readPatchedLViewData(target: any): LViewData | null;

package/src/render3/view_engine_compatibility.d.ts

@@ -9,6 +9,7 @@ import { ChangeDetectorRef as ViewEngine_ChangeDetectorRef } from '../change_det
 import { ElementRef as ViewEngine_ElementRef } from '../linker/element_ref';
 import { TemplateRef as ViewEngine_TemplateRef } from '../linker/template_ref';
 import { ViewContainerRef as ViewEngine_ViewContainerRef } from '../linker/view_container_ref';
+import { Renderer2 } from '../render/api';
 import { TContainerNode, TElementContainerNode, TElementNode, TNode } from './interfaces/node';
 import { LViewData } from './interfaces/view';
 /**
@@ -70,3 +71,5 @@ export declare function injectChangeDetectorRef(): ViewEngine_ChangeDetectorRef;
  * @returns The ChangeDetectorRef to use
  */
 export declare function createViewRef(hostTNode: TNode, hostView: LViewData, context: any): ViewEngine_ChangeDetectorRef;
+/** Returns a Renderer2 (or throws when application was bootstrapped with Renderer3) */
+export declare function injectRenderer2(): Renderer2;