@angular/core 7.0.0-rc.1 → 7.0.3

package/src/render3/instructions.d.ts

@@ -11,11 +11,12 @@ import { Sanitizer } from '../sanitization/security';
 import { StyleSanitizeFn } from '../sanitization/style_sanitizer';
 import { LContainer } from './interfaces/container';
 import { ComponentDef, ComponentQuery, ComponentTemplate, DirectiveDef, DirectiveDefListOrFactory, InitialStylingFlags, PipeDefListOrFactory, RenderFlags } from './interfaces/definition';
-import { LContainerNode, LElementNode, LNode, LProjectionNode, LTextNode, LViewNode, LocalRefExtractor, TAttributes, TContainerNode, TElementContainerNode, TElementNode, TNode, TNodeType, TProjectionNode, TViewNode } from './interfaces/node';
+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 { CurrentMatchesList, LViewData, LViewFlags, OpaqueViewState, RootContext, TView } from './interfaces/view';
+import { RComment, RElement, RNode, RText, Renderer3, RendererFactory3 } from './interfaces/renderer';
+import { CurrentMatchesList, LViewData, LViewFlags, OpaqueViewState, RootContext, RootContextFlags, TView } from './interfaces/view';
 /**
  * Function used to sanitize the value before writing it into the renderer.
  */
@@ -48,7 +49,6 @@ export declare function getCurrentView(): OpaqueViewState;
  * @param viewToRestore The OpaqueViewState instance to restore.
  */
 export declare function restoreView(viewToRestore: OpaqueViewState): void;
-export declare function getPreviousOrParentNode(): LNode | null;
 export declare function getPreviousOrParentTNode(): TNode;
 export declare function setEnvironment(tNode: TNode, view: LViewData): void;
 /**
@@ -96,30 +96,22 @@ export declare function setHostBindings(): void;
 export declare function executeInitAndContentHooks(): void;
 export declare function createLViewData<T>(renderer: Renderer3, tView: TView, context: T | null, flags: LViewFlags, sanitizer?: Sanitizer | null): LViewData;
 /**
- * Creation of LNode object is extracted to a separate function so we always create LNode object
- * with the same shape
- * (same properties assigned in the same order).
- */
-export declare function createLNodeObject(type: TNodeType, native: RText | RElement | RComment | null, state: any): LElementNode & LTextNode & LViewNode & LContainerNode & LProjectionNode;
-/**
- * A common way of creating the LNode to make sure that all of them have same shape to
- * keep the execution code monomorphic and fast.
+ * Create and stores the TNode, and hooks it up to the tree.
  *
- * @param index The index at which the LNode should be saved (null if view, since they are not
+ * @param index The index at which the TNode should be saved (null if view, since they are not
  * saved).
- * @param type The type of LNode to create
- * @param native The native element for this LNode, if applicable
+ * @param type The type of TNode to create
+ * @param native The native element for this node, if applicable
  * @param name The tag name of the associated native element, if applicable
  * @param attrs Any attrs for the native element, if applicable
- * @param data Any data that should be saved on the LNode
  */
-export declare function createNodeAtIndex(index: number, type: TNodeType.Element, native: RElement | RText | null, name: string | null, attrs: TAttributes | null, lViewData?: LViewData | null): TElementNode;
-export declare function createNodeAtIndex(index: number, type: TNodeType.View, native: null, name: null, attrs: null, lViewData: LViewData): TViewNode;
-export declare function createNodeAtIndex(index: number, type: TNodeType.Container, native: RComment, name: string | null, attrs: TAttributes | null, lContainer: LContainer): TContainerNode;
-export declare function createNodeAtIndex(index: number, type: TNodeType.Projection, native: null, name: null, attrs: TAttributes | null, lProjection: null): TProjectionNode;
-export declare function createNodeAtIndex(index: number, type: TNodeType.ElementContainer, native: RComment, name: null, attrs: TAttributes | null, data: null): TElementContainerNode;
+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 createViewNode(index: number, view: LViewData): TViewNode;
 /**
- * When LNodes are created dynamically after a view blueprint is created (e.g. through
+ * 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.
  */
@@ -139,7 +131,7 @@ export declare function resetComponentState(): 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, host: LElementNode | null, directives?: DirectiveDefListOrFactory | null, pipes?: PipeDefListOrFactory | null, sanitizer?: Sanitizer | null): LElementNode;
+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;
 /**
  * Used for creating the LViewNode of a dynamic embedded view,
  * either through ViewContainerRef.createEmbeddedView() or TemplateRef.createEmbeddedView().
@@ -226,6 +218,18 @@ export declare function resolveDirective(def: DirectiveDef<any>, valueIndex: num
 /** Stores index of directive and host element so it will be queued for binding refresh during CD.
  */
 export declare function queueHostBindingForCheck(dirIndex: number, def: DirectiveDef<any> | ComponentDef<any>): void;
+/**
+ * Gets TView from a template function or creates a new TView
+ * if it doesn't already exist.
+ *
+ * @param templateFn The template from which to get static data
+ * @param consts The number of nodes, local refs, and pipes in this view
+ * @param vars The number of bindings and pure function bindings in this view
+ * @param directives Directive defs that should be saved on TView
+ * @param pipes Pipe defs that should be saved on TView
+ * @returns TView
+ */
+export declare function getOrCreateTView(templateFn: ComponentTemplate<any>, consts: number, vars: number, directives: DirectiveDefListOrFactory | null, pipes: PipeDefListOrFactory | null, viewQuery: ComponentQuery<any> | null): TView;
 /**
  * Creates a TView instance
  *
@@ -243,15 +247,6 @@ export declare function createError(text: string, token: any): Error;
  * @param elementOrSelector Render element or CSS selector to locate the element.
  */
 export declare function locateHostElement(factory: RendererFactory3, elementOrSelector: RElement | string): RElement | null;
-/**
- * Creates the host LNode.
- *
- * @param rNode Render host element.
- * @param def ComponentDef
- *
- * @returns LElementNode created
- */
-export declare function hostElement(tag: string, rNode: RElement | null, def: ComponentDef<any>, sanitizer?: Sanitizer | null): LElementNode;
 /**
  * Adds an event listener to the current node.
  *
@@ -349,11 +344,10 @@ export declare function disableBindings(): void;
  * @param adjustedIndex The index of the TNode in TView.data, adjusted for HEADER_OFFSET
  * @param tagName The tag name of the node
  * @param attrs The attributes defined on this node
- * @param parent The parent of this node
  * @param tViews Any TViews attached to this node
  * @returns the TNode object
  */
-export declare function createTNode(type: TNodeType, adjustedIndex: number, tagName: string | null, attrs: TAttributes | null, parent: TElementNode | TContainerNode | null, tViews: TView[] | null): TNode;
+export declare function createTNode(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.
  *
@@ -364,7 +358,7 @@ export declare function createTNode(type: TNodeType, adjustedIndex: number, tagN
  *        renaming as part of minification.
  * @param value A value indicating if a given class should be added or removed.
  */
-export declare function elementClassProp<T>(index: number, stylingIndex: number, value: T | NO_CHANGE): void;
+export declare function elementClassProp(index: number, stylingIndex: number, value: boolean | PlayerFactory): void;
 /**
  * Assign any inline style values to the element during creation mode.
  *
@@ -393,7 +387,7 @@ export declare function elementClassProp<T>(index: number, stylingIndex: number,
  * @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).
  */
-export declare function elementStyling<T>(classDeclarations?: (string | boolean | InitialStylingFlags)[] | null, styleDeclarations?: (string | boolean | InitialStylingFlags)[] | null, styleSanitizer?: StyleSanitizeFn | null): void;
+export declare function elementStyling(classDeclarations?: (string | boolean | InitialStylingFlags)[] | null, styleDeclarations?: (string | boolean | InitialStylingFlags)[] | null, styleSanitizer?: StyleSanitizeFn | null): void;
 /**
  * Apply all styling values to the element which have been queued by any styling instructions.
  *
@@ -408,7 +402,7 @@ export declare function elementStyling<T>(classDeclarations?: (string | boolean
  *        specifically for element styling--the index must be the next index after the element
  *        index.)
  */
-export declare function elementStylingApply<T>(index: number): void;
+export declare function elementStylingApply(index: number): void;
 /**
  * Queue a given style to be rendered on an Element.
  *
@@ -424,14 +418,12 @@ export declare function elementStylingApply<T>(index: number): void;
  *        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 styleName 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 (null to remove).
  * @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.
  */
-export declare function elementStyleProp<T>(index: number, styleIndex: number, value: T | null, suffix?: string): void;
+export declare function elementStyleProp(index: number, styleIndex: number, value: string | number | String | PlayerFactory | null, suffix?: string): void;
 /**
  * Queue a key/value map of styles to be rendered on an Element.
  *
@@ -489,17 +481,20 @@ export declare function directiveCreate<T>(directiveDefIdx: number, directive: T
  * This version does not contain features that we don't already support at root in
  * current Angular. Example: local refs and inputs on root component.
  */
-export declare function baseDirectiveCreate<T>(index: number, directive: T, directiveDef: DirectiveDef<T> | ComponentDef<T>, hostNode: LNode): T;
+export declare function baseDirectiveCreate<T>(index: number, directive: T, directiveDef: DirectiveDef<T> | ComponentDef<T>, native: RNode | null): T;
 /**
  * Creates a LContainer, either from a container instruction, or for a ViewContainerRef.
  *
+ * @param hostNative The host element for the LContainer
+ * @param hostTNode The host TNode for the LContainer
  * @param currentView The parent view of the LContainer
+ * @param native The native comment element
  * @param isForViewContainerRef Optional a flag indicating the ViewContainerRef case
  * @returns LContainer
  */
-export declare function createLContainer(currentView: LViewData, isForViewContainerRef?: boolean): LContainer;
+export declare function createLContainer(hostNative: RElement | RComment, hostTNode: TElementNode | TContainerNode | TElementContainerNode, currentView: LViewData, native: RComment, isForViewContainerRef?: boolean): LContainer;
 /**
- * Creates an LContainerNode for an ng-template (dynamically-inserted view), e.g.
+ * Creates an LContainer for an ng-template (dynamically-inserted view), e.g.
  *
  * <ng-template #foo>
  *    <div></div>
@@ -517,7 +512,7 @@ export declare function createLContainer(currentView: LViewData, isForViewContai
  */
 export declare function template(index: number, templateFn: ComponentTemplate<any> | null, consts: number, vars: number, tagName?: string | null, attrs?: TAttributes | null, localRefs?: string[] | null, localRefExtractor?: LocalRefExtractor): void;
 /**
- * Creates an LContainerNode for inline views, e.g.
+ * Creates an LContainer for inline views, e.g.
  *
  * % if (showing) {
  *   <div></div>
@@ -533,9 +528,9 @@ export declare function container(index: number): void;
  */
 export declare function containerRefreshStart(index: number): void;
 /**
- * Marks the end of the LContainerNode.
+ * Marks the end of the LContainer.
  *
- * Marking the end of LContainerNode is the time when to child Views get inserted or removed.
+ * Marking the end of LContainer is the time when to child views get inserted or removed.
  */
 export declare function containerRefreshEnd(): void;
 /**
@@ -600,7 +595,7 @@ export declare function projection(nodeIndex: number, selectorIndex?: number, at
  */
 export declare function addToViewTree<T extends LViewData | LContainer>(currentView: LViewData, adjustedHostIndex: number, state: T): T;
 /** If node is an OnPush component, marks its LViewData dirty. */
-export declare function markDirtyIfOnPush(node: LElementNode): void;
+export declare function markDirtyIfOnPush(viewIndex: number): void;
 /** Wraps an event listener with preventDefault behavior. */
 export declare function wrapListenerWithPreventDefault(listenerFn: (e?: any) => any): EventListener;
 /** Marks current view and all ancestors dirty */
@@ -616,7 +611,7 @@ export declare function markViewDirty(view: LViewData): void;
  * `scheduleTick` requests. The scheduling function can be overridden in
  * `renderComponent`'s `scheduler` option.
  */
-export declare function scheduleTick<T>(rootContext: RootContext): void;
+export declare function scheduleTick<T>(rootContext: RootContext, flags: RootContextFlags): void;
 /**
  * Used to perform change detection on the whole application.
  *
@@ -744,8 +739,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;
-export declare function loadElement(index: number): LElementNode;
-export declare function getTNode(index: number): TNode;
 /** Gets the current binding value. */
 export declare function getBinding(bindingIndex: number): any;
 /** Updates binding if changed, then returns whether it was updated. */

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

@@ -5,19 +5,21 @@
  * 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 { LElementNode } from './node';
 import { LQueries } from './query';
-import { LViewData, NEXT, PARENT, QUERIES } from './view';
+import { RComment, RElement } from './renderer';
+import { StylingContext } from './styling';
+import { HOST, LViewData, NEXT, PARENT, QUERIES } from './view';
 /**
  * Below are constants for LContainer indices to help us look up LContainer members
  * without having to remember the specific indices.
  * Uglify will inline these when minifying so there shouldn't be a cost.
  */
 export declare const ACTIVE_INDEX = 0;
-export declare const VIEWS = 4;
-export declare const RENDER_PARENT = 5;
+export declare const VIEWS = 1;
+export declare const NATIVE = 6;
+export declare const RENDER_PARENT = 7;
 /**
- * The state associated with an LContainerNode.
+ * The state associated with a container.
  *
  * This is an array so that its structure is closer to LViewData. This helps
  * when traversing the view tree (which is a mix of containers and component
@@ -32,7 +34,15 @@ export interface LContainer extends Array<any> {
      * it is set to null to identify this scenario, as indices are "absolute" in that case,
      * i.e. provided directly by the user of the ViewContainerRef API.
      */
-    [ACTIVE_INDEX]: number | null;
+    [ACTIVE_INDEX]: number;
+    /**
+     * A list of the container's currently active child views. Views will be inserted
+     * here as they are added and spliced from here when they are removed. We need
+     * to keep a record of current views so we know which views are already in the DOM
+     * (and don't need to be re-added) and so we can remove views from the DOM when they
+     * are no longer required.
+     */
+    [VIEWS]: LViewData[];
     /**
      * Access to the parent view is necessary so we can propagate back
      * up from inside a container to parent[NEXT].
@@ -49,33 +59,37 @@ export interface LContainer extends Array<any> {
      */
     [QUERIES]: LQueries | null;
     /**
-     * A list of the container's currently active child views. Views will be inserted
-     * here as they are added and spliced from here when they are removed. We need
-     * to keep a record of current views so we know which views are already in the DOM
-     * (and don't need to be re-added) and so we can remove views from the DOM when they
-     * are no longer required.
+     * The host element of this LContainer.
+     *
+     * The host could be an LViewData if this container is on a component node.
+     * In that case, the component LViewData is its HOST.
+     *
+     * It could also be a styling context if this is a node with a style/class
+     * binding.
      */
-    [VIEWS]: LViewData[];
+    [HOST]: RElement | RComment | StylingContext | LViewData;
+    /** The comment element that serves as an anchor for this LContainer. */
+    [NATIVE]: RComment;
     /**
-     * Parent Element which will contain the location where all of the Views will be
+     * Parent Element which will contain the location where all of the views will be
      * inserted into to.
      *
      * If `renderParent` is `null` it is headless. This means that it is contained
-     * in another `LViewNode` which in turn is contained in another `LContainerNode` and
+     * in another view which in turn is contained in another container and
      * therefore it does not yet have its own parent.
      *
      * If `renderParent` is not `null` then it may be:
-     * - same as `LContainerNode.parent` in which case it is just a normal container.
-     * - different from `LContainerNode.parent` in which case it has been re-projected.
-     *   In other words `LContainerNode.parent` is logical parent where as
-     *   `LContainer.projectedParent` is render parent.
+     * - same as `tContainerNode.parent` in which case it is just a normal container.
+     * - different from `tContainerNode.parent` in which case it has been re-projected.
+     *   In other words `tContainerNode.parent` is logical parent where as
+     *   `tContainerNode.projectedParent` is render parent.
      *
-     * When views are inserted into `LContainerNode` then `renderParent` is:
-     * - `null`, we are in `LViewNode` keep going up a hierarchy until actual
+     * When views are inserted into `LContainer` then `renderParent` is:
+     * - `null`, we are in a view, keep going up a hierarchy until actual
      *   `renderParent` is found.
      * - not `null`, then use the `projectedParent.native` as the `RElement` to insert
-     *   `LViewNode`s into.
+     * views into.
      */
-    [RENDER_PARENT]: LElementNode | null;
+    [RENDER_PARENT]: RElement | null;
 }
 export declare const unusedValueExportToPlacateAjd = 1;

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

@@ -0,0 +1,52 @@
+/**
+ * @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 { RElement } from './renderer';
+import { LViewData } from './view';
+/**
+ * This property will be monkey-patched on elements, components and directives
+ */
+export declare const MONKEY_PATCH_KEY_NAME = "__ngContext__";
+/**
+ * The internal view context which is specific to a given DOM element, directive or
+ * component instance. Each value in here (besides the LViewData and element node details)
+ * can be present, null or undefined. If undefined then it implies the value has not been
+ * looked up yet, otherwise, if null, then a lookup was executed and nothing was found.
+ *
+ * Each value will get filled when the respective value is examined within the getContext
+ * function. The component, element and each directive instance will share the same instance
+ * of the context.
+ */
+export interface LContext {
+    /**
+     * The component's parent view data.
+     */
+    lViewData: LViewData;
+    /**
+     * The index instance of the node.
+     */
+    nodeIndex: number;
+    /**
+     * The instance of the DOM node that is attached to the lNode.
+     */
+    native: RElement;
+    /**
+     * The instance of the Component node.
+     */
+    component: {} | null | undefined;
+    /**
+     * The list of active directives that exist on this element.
+     */
+    directives: any[] | null | undefined;
+    /**
+     * The map of local references (local reference name => element or directive instance) that exist
+     * on this element.
+     */
+    localRefs: {
+        [key: string]: any;
+    } | null | undefined;
+}

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

@@ -178,7 +178,7 @@ export interface ComponentDef<T> extends DirectiveDef<T> {
     /**
      * Runtime unique component ID.
      */
-    id: string;
+    readonly id: string;
     /**
      * The View template of the component.
      */
@@ -193,14 +193,14 @@ export interface ComponentDef<T> extends DirectiveDef<T> {
      * Used to calculate the length of the component's LViewData array, so we
      * can pre-fill the array and set the binding start index.
      */
-    consts: number;
+    readonly consts: number;
     /**
      * The number of bindings in this component template (including pure fn bindings).
      *
      * Used to calculate the length of the component's LViewData array, so we
      * can pre-fill the array and set the host binding start index.
      */
-    vars: number;
+    readonly vars: number;
     /**
      * Query-related instructions for a component.
      */
@@ -248,6 +248,11 @@ export interface ComponentDef<T> extends DirectiveDef<T> {
      * `PipeDefs`s. The function is necessary to be able to support forward declarations.
      */
     pipeDefs: PipeDefListOrFactory | null;
+    /**
+     * Used to store the result of `noSideEffects` function so that it is not removed by closure
+     * compiler. The property should never be read.
+     */
+    readonly _?: never;
 }
 /**
  * Runtime link information for Pipes.