@angular/core 7.2.0-beta.0 → 7.2.0

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

@@ -36,22 +36,22 @@ export declare const TAIL = 14;
 export declare const CONTAINER_INDEX = 15;
 export declare const CONTENT_QUERIES = 16;
 export declare const DECLARATION_VIEW = 17;
-/** Size of LViewData's header. Necessary to adjust for it when setting slots.  */
+/** Size of LView's header. Necessary to adjust for it when setting slots.  */
 export declare const HEADER_OFFSET = 18;
 export interface OpaqueViewState {
     '__brand__': 'Brand for OpaqueViewState that nothing will match';
 }
 /**
- * `LViewData` stores all of the information needed to process the instructions as
+ * `LView` stores all of the information needed to process the instructions as
  * they are invoked from the template. Each embedded view and component view has its
- * own `LViewData`. When processing a particular view, we set the `viewData` to that
- * `LViewData`. When that view is done processing, the `viewData` is set back to
- * whatever the original `viewData` was before (the parent `LViewData`).
+ * own `LView`. When processing a particular view, we set the `viewData` to that
+ * `LView`. When that view is done processing, the `viewData` is set back to
+ * whatever the original `viewData` was before (the parent `LView`).
  *
  * Keeping separate state for each view facilities view insertion / deletion, so we
  * don't have to edit the data array based on which views are present.
  */
-export interface LViewData extends Array<any> {
+export interface LView extends Array<any> {
     /**
      * The static data for this view. We need a reference to this so we can easily walk up the
      * node tree in DI and get the TView.data array associated with a node (where the
@@ -62,27 +62,27 @@ export interface LViewData extends Array<any> {
     [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
+     * `LView`. Without this, the render method would have to keep a stack of
      * views as it is recursively rendering templates.
      *
      * This is the "insertion" view for embedded views. This allows us to properly
      * destroy embedded views.
      */
-    [PARENT]: LViewData | null;
+    [PARENT]: LView | null;
     /**
      *
-     * The next sibling LViewData or LContainer.
+     * The next sibling LView or LContainer.
      *
      * Allows us to propagate between sibling view states that aren't in the same
      * container. Embedded views already have a node.next, but it is only set for
      * views in the same container. We need a way to link component views and views
      * across containers as well.
      */
-    [NEXT]: LViewData | LContainer | null;
+    [NEXT]: LView | LContainer | null;
     /** Queries active for this view - nodes from a view are reported to those queries. */
     [QUERIES]: LQueries | null;
     /**
-     * The host node for this LViewData instance, if this is a component view.
+     * The host node for this LView instance, if this is a component view.
      *
      * If this is an embedded view, HOST will be null.
      */
@@ -132,12 +132,12 @@ export interface LViewData extends Array<any> {
     /** An optional custom sanitizer. */
     [SANITIZER]: Sanitizer | null;
     /**
-     * The last LViewData or LContainer beneath this LViewData in the hierarchy.
+     * The last LView or LContainer beneath this LView in the hierarchy.
      *
      * The tail allows us to quickly add a new state to the end of the view list
      * without having to propagate starting from the first child.
      */
-    [TAIL]: LViewData | LContainer | null;
+    [TAIL]: LView | LContainer | null;
     /**
      * The index of the parent container's host node. Applicable only to embedded views that
      * have been inserted dynamically. Will be -1 for component views and inline views.
@@ -160,7 +160,7 @@ export interface LViewData extends Array<any> {
      *
      * The template for a dynamically created view may be declared in a different view than
      * it is inserted. We already track the "insertion view" (view where the template was
-     * inserted) in LViewData[PARENT], but we also need access to the "declaration view"
+     * inserted) in LView[PARENT], but we also need access to the "declaration view"
      * (view where the template was declared). Otherwise, we wouldn't be able to call the
      * view's template function with the proper contexts. Context should be inherited from
      * the declaration view tree, not the insertion view tree.
@@ -177,9 +177,9 @@ export interface LViewData extends Array<any> {
      * template function during change detection, we need the declaration view to get inherited
      * context.
      */
-    [DECLARATION_VIEW]: LViewData | null;
+    [DECLARATION_VIEW]: LView | null;
 }
-/** Flags associated with an LView (saved in LViewData[FLAGS]) */
+/** Flags associated with an LView (saved in LView[FLAGS]) */
 export declare const enum LViewFlags {
     /**
      * Whether or not the view is in creationMode.
@@ -190,12 +190,20 @@ export declare const enum LViewFlags {
      * improperly reported as false.
      */
     CreationMode = 1,
+    /**
+     * Whether or not this LView instance is on its first processing pass.
+     *
+     * An LView instance is considered to be on its "first pass" until it
+     * has completed one creation mode run and one update mode run. At this
+     * time, the flag is turned off.
+     */
+    FirstLViewPass = 2,
     /** Whether this view has default change detection strategy (checks always) or onPush */
-    CheckAlways = 2,
+    CheckAlways = 4,
     /** Whether or not this view is currently dirty (needing check) */
-    Dirty = 4,
+    Dirty = 8,
     /** Whether or not this view is currently attached to change detection tree. */
-    Attached = 8,
+    Attached = 16,
     /**
      *  Whether or not the init hooks have run.
      *
@@ -203,11 +211,11 @@ export declare const enum LViewFlags {
      * runs OR the first cR() instruction that runs (so inits are run for the top level view before
      * any embedded views).
      */
-    RunInit = 16,
+    RunInit = 32,
     /** Whether or not this view is destroyed. */
-    Destroyed = 32,
+    Destroyed = 64,
     /** Whether or not this view is the root view */
-    IsRoot = 64
+    IsRoot = 128
 }
 /**
  * The static data for an LView (shared between all templates of a
@@ -225,10 +233,10 @@ export interface TView {
      */
     readonly id: number;
     /**
-     * This is a blueprint used to generate LViewData instances for this TView. Copying this
-     * blueprint is faster than creating a new LViewData from scratch.
+     * This is a blueprint used to generate LView instances for this TView. Copying this
+     * blueprint is faster than creating a new LView from scratch.
      */
-    blueprint: LViewData;
+    blueprint: LView;
     /**
      * The template function used to refresh the view of dynamically created views
      * and components. Will be null for inline views.
@@ -241,7 +249,7 @@ export interface TView {
     /**
      * Pointer to the `TNode` that represents the root of the view.
      *
-     * If this is a `TNode` for an `LViewNode`, this is an embedded view of a container.
+     * If this is a `TViewNode` for an `LViewNode`, this is an embedded view of a container.
      * We need this pointer to be able to efficiently find this node when inserting the view
      * into an anchor.
      *
@@ -266,9 +274,9 @@ export interface TView {
      */
     bindingStartIndex: number;
     /**
-     * The index where the "expando" section of `LViewData` begins. The expando
+     * The index where the "expando" section of `LView` begins. The expando
      * section contains injectors, directive instances, and host binding values.
-     * Unlike the "consts" and "vars" sections of `LViewData`, the length of this
+     * Unlike the "consts" and "vars" sections of `LView`, the length of this
      * section cannot be calculated at compile-time because directives are matched
      * at runtime to preserve locality.
      *
@@ -296,7 +304,7 @@ export interface TView {
      *
      * See VIEW_DATA.md for more information.
      */
-    expandoInstructions: (number | HostBindingsFunction<any>)[] | null;
+    expandoInstructions: (number | HostBindingsFunction<any> | null)[] | null;
     /**
      * Full registry of directives and components that may be found in this view.
      *
@@ -385,19 +393,25 @@ export interface TView {
      * saves on memory (70 bytes per array) and on a few bytes of code size (for two
      * separate for loops).
      *
-     * If it's a native DOM listener being stored:
-     * 1st index is: event name to remove
-     * 2nd index is: index of native element in LView.data[]
-     * 3rd index is: index of wrapped listener function in LView.cleanupInstances[]
-     * 4th index is: useCapture boolean
+     * If it's a native DOM listener or output subscription being stored:
+     * 1st index is: event name  `name = tView.cleanup[i+0]`
+     * 2nd index is: index of native element `element = lView[tView.cleanup[i+1]]`
+     * 3rd index is: index of listener function `listener = lView[CLEANUP][tView.cleanup[i+2]]`
+     * 4th index is: `useCaptureOrIndx = tView.cleanup[i+3]`
+     *    `typeof useCaptureOrIndx == 'boolean' : useCapture boolean
+     *    `typeof useCaptureOrIndx == 'number':
+     *         `useCaptureOrIndx >= 0` `removeListener = LView[CLEANUP][useCaptureOrIndx]`
+     *         `useCaptureOrIndx <  0` `subscription = LView[CLEANUP][-useCaptureOrIndx]`
      *
      * If it's a renderer2 style listener or ViewRef destroy hook being stored:
      * 1st index is: index of the cleanup function in LView.cleanupInstances[]
-     * 2nd index is: null
+     * 2nd index is: `null`
+     *               `lView[CLEANUP][tView.cleanup[i+0]]()`
      *
      * If it's an output subscription or query list destroy hook:
      * 1st index is: output unsubscribe function / query list destroy function
      * 2nd index is: index of function context in LView.cleanupInstances[]
+     *               `tView.cleanup[i+0].call(lView[CLEANUP][tView.cleanup[i+1]])`
      */
     cleanup: any[] | null;
     /**

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

@@ -63,6 +63,7 @@ export interface R3PipeMetadataFacade {
 export interface R3InjectableMetadataFacade {
     name: string;
     type: any;
+    typeArgumentCount: number;
     ctorDeps: R3DependencyMetadataFacade[] | null;
     providedIn: any;
     useClass?: any;
@@ -83,8 +84,8 @@ export interface R3InjectorMetadataFacade {
     name: string;
     type: any;
     deps: R3DependencyMetadataFacade[] | null;
-    providers: any;
-    imports: any;
+    providers: any[];
+    imports: any[];
 }
 export interface R3DirectiveMetadataFacade {
     name: string;
@@ -115,12 +116,18 @@ export interface R3ComponentMetadataFacade extends R3DirectiveMetadataFacade {
     animations: any[] | undefined;
     viewQueries: R3QueryMetadataFacade[];
     pipes: Map<string, any>;
-    directives: Map<string, any>;
+    directives: {
+        selector: string;
+        expression: any;
+    }[];
     styles: string[];
     encapsulation: ViewEncapsulation;
     viewProviders: Provider[] | null;
+    interpolation?: [string, string];
+    changeDetection?: ChangeDetectionStrategy;
 }
 export declare type ViewEncapsulation = number;
+export declare type ChangeDetectionStrategy = number;
 export interface R3QueryMetadataFacade {
     propertyName: string;
     first: boolean;

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

@@ -8,6 +8,13 @@
 import { NgModule, NgModuleTransitiveScopes } from '../../metadata/ng_module';
 import { Type } from '../../type';
 import { ComponentDef } from '../interfaces/definition';
+import { NgModuleType } from '../ng_module_ref';
+/**
+ * Loops over queued module definitions, if a given module definition has all of its
+ * declarations resolved, it dequeues that module definition and sets the scope on
+ * its declarations.
+ */
+export declare function flushModuleScopingQueueAsMuchAsPossible(): void;
 /**
  * Compiles a module in JIT mode.
  *
@@ -17,7 +24,8 @@ export declare function compileNgModule(moduleType: Type<any>, ngModule?: NgModu
 /**
  * Compiles and adds the `ngModuleDef` and `ngInjectorDef` properties to the module class.
  */
-export declare function compileNgModuleDefs(moduleType: Type<any>, ngModule: NgModule): void;
+export declare function compileNgModuleDefs(moduleType: NgModuleType, ngModule: NgModule): void;
+export declare function resetCompiledComponents(): void;
 /**
  * Patch the definition of a component with directives and pipes from the compilation scope of
  * a given module.

package/src/render3/metadata.d.ts

@@ -15,6 +15,6 @@ import { Type } from '../type';
  * Calls to `setClassMetadata` can be marked as pure, resulting in the metadata assignments being
  * tree-shaken away during production builds.
  */
-export declare function setClassMetadata(type: Type<any>, decorators: any[] | null, ctorParameters: any[] | null, propDecorators: {
+export declare function setClassMetadata(type: Type<any>, decorators: any[] | null, ctorParameters: (() => any[]) | null, propDecorators: {
     [field: string]: any;
 } | null): void;

package/src/render3/ng_module_ref.d.ts

@@ -6,22 +6,24 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import { Injector } from '../di/injector';
-import { StaticProvider } from '../di/provider';
+import { InjectFlags } from '../di/injector_compatibility';
 import { ComponentFactoryResolver as viewEngine_ComponentFactoryResolver } from '../linker/component_factory_resolver';
 import { InternalNgModuleRef, NgModuleFactory as viewEngine_NgModuleFactory, NgModuleRef as viewEngine_NgModuleRef } from '../linker/ng_module_factory';
 import { NgModuleDef } from '../metadata/ng_module';
 import { Type } from '../type';
-export interface NgModuleType {
-    ngModuleDef: NgModuleDef<any>;
+export interface NgModuleType<T = any> extends Type<T> {
+    ngModuleDef: NgModuleDef<T>;
 }
-export declare const COMPONENT_FACTORY_RESOLVER: StaticProvider;
 export declare class NgModuleRef<T> extends viewEngine_NgModuleRef<T> implements InternalNgModuleRef<T> {
+    _parent: Injector | null;
     _bootstrapComponents: Type<any>[];
+    _r3Injector: Injector;
     injector: Injector;
-    componentFactoryResolver: viewEngine_ComponentFactoryResolver;
     instance: T;
     destroyCbs: (() => void)[] | null;
-    constructor(ngModuleType: Type<T>, parentInjector: Injector | null);
+    constructor(ngModuleType: Type<T>, _parent: Injector | null);
+    get(token: any, notFoundValue?: any, injectFlags?: InjectFlags): any;
+    readonly componentFactoryResolver: viewEngine_ComponentFactoryResolver;
     destroy(): void;
     onDestroy(callback: () => void): void;
 }

package/src/render3/node_manipulation.d.ts

@@ -8,27 +8,20 @@
 import { LContainer } from './interfaces/container';
 import { TContainerNode, TElementContainerNode, TElementNode, TNode, TViewNode } from './interfaces/node';
 import { RComment, RElement, RNode, RText, Renderer3 } from './interfaces/renderer';
-import { LViewData } from './interfaces/view';
+import { LView } from './interfaces/view';
 /** Retrieves the parent element of a given node. */
-export declare function getParentNative(tNode: TNode, currentView: LViewData): RElement | RComment | null;
+export declare function getParentNative(tNode: TNode, currentView: LView): RElement | RComment | null;
 /**
  * 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 getHostNative(currentView: LViewData): RElement | null;
-export declare function getLContainer(tNode: TViewNode, embeddedView: LViewData): LContainer | null;
+export declare function getHostNative(currentView: LView): RElement | null;
+export declare function getLContainer(tNode: TViewNode, embeddedView: LView): LContainer | null;
 /**
  * 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): RElement | null;
-/**
- * Given a current view, finds the nearest component's host (LElement).
- *
- * @param lViewData LViewData for which we want a host element node
- * @returns The host node
- */
-export declare function findComponentView(lViewData: LViewData): LViewData;
+export declare function getContainerRenderParent(tViewNode: TViewNode, view: LView): RElement | null;
 export declare function createTextNode(value: any, renderer: Renderer3): RText;
 /**
  * Adds or removes all DOM elements associated with a view.
@@ -41,8 +34,8 @@ export declare function createTextNode(value: any, renderer: Renderer3): RText;
  * @param insertMode Whether or not elements should be added (if false, removing)
  * @param beforeNode The node before which elements should be added, if insert mode
  */
-export declare function addRemoveViewFromContainer(viewToWalk: LViewData, insertMode: true, beforeNode: RNode | null): void;
-export declare function addRemoveViewFromContainer(viewToWalk: LViewData, insertMode: false): void;
+export declare function addRemoveViewFromContainer(viewToWalk: LView, insertMode: true, beforeNode: RNode | null): void;
+export declare function addRemoveViewFromContainer(viewToWalk: LView, insertMode: false): void;
 /**
  * Traverses down and up the tree of views and containers to remove listeners and
  * call onDestroy callbacks.
@@ -56,7 +49,7 @@ export declare function addRemoveViewFromContainer(viewToWalk: LViewData, insert
  *
  *  @param rootView The view to destroy
  */
-export declare function destroyViewTree(rootView: LViewData): void;
+export declare function destroyViewTree(rootView: LView): void;
 /**
  * Inserts a view into a container.
  *
@@ -71,7 +64,7 @@ export declare function destroyViewTree(rootView: LViewData): void;
  * @param index The index at which to insert the view
  * @param containerIndex The index of the container node, if dynamic
  */
-export declare function insertView(lView: LViewData, lContainer: LContainer, parentView: LViewData, index: number, containerIndex: number): void;
+export declare function insertView(lView: LView, lContainer: LContainer, parentView: LView, index: number, containerIndex: number): void;
 /**
  * Detaches a view from a container.
  *
@@ -81,8 +74,9 @@ export declare function insertView(lView: LViewData, lContainer: LContainer, par
  * @param lContainer The container from which to detach a view
  * @param removeIndex The index of the view to detach
  * @param detached Whether or not this view is already detached.
+ * @returns Detached LView instance.
  */
-export declare function detachView(lContainer: LContainer, removeIndex: number, detached: boolean): void;
+export declare function detachView(lContainer: LContainer, removeIndex: number, detached: boolean): LView;
 /**
  * Removes a view from a container, i.e. detaches it and then destroys the underlying LView.
  *
@@ -91,15 +85,15 @@ export declare function detachView(lContainer: LContainer, removeIndex: number,
  * @param removeIndex The index of the view to remove
  */
 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;
+/** Gets the child of the given LView */
+export declare function getLViewChild(lView: LView): LView | LContainer | null;
 /**
  * A standalone function which destroys an LView,
  * conducting cleanup (e.g. removing listeners, calling onDestroys).
  *
  * @param view The view to be destroyed.
  */
-export declare function destroyLView(view: LViewData): void;
+export declare function destroyLView(view: LView): void;
 /**
  * Determines which LViewOrLContainer to jump to when traversing back up the
  * tree in destroyViewTree.
@@ -112,8 +106,8 @@ export declare function destroyLView(view: LViewData): void;
  * @param rootView The rootView, so we don't propagate too far up the view tree
  * @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): RElement | null;
+export declare function getParentState(state: LView | LContainer, rootView: LView): LView | LContainer | null;
+export declare function getRenderParent(tNode: TNode, currentView: LView): RElement | null;
 /**
  * Returns whether a native element can be inserted into the given parent.
  *
@@ -132,7 +126,7 @@ export declare function getRenderParent(tNode: TNode, currentView: LViewData): R
  * @param currentView Current LView being processed.
  * @return boolean Whether the node should be inserted now (or delayed until later).
  */
-export declare function canInsertNativeNode(tNode: TNode, currentView: LViewData): boolean;
+export declare function canInsertNativeNode(tNode: TNode, currentView: LView): boolean;
 /**
  * Inserts a native node before another native node for a given parent using {@link Renderer3}.
  * This is a utility function that can be used when native nodes were determined - it abstracts an
@@ -157,8 +151,8 @@ export declare function nativeNextSibling(renderer: Renderer3, node: RNode): RNo
  * @param currentView The current LView
  * @returns Whether or not the child was appended
  */
-export declare function appendChild(childEl: RNode | null | undefined, childTNode: TNode, currentView: LViewData): boolean;
-export declare function getBeforeNodeForView(index: number, views: LViewData[], containerNative: RComment): RComment;
+export declare function appendChild(childEl: RNode | null | undefined, childTNode: TNode, currentView: LView): boolean;
+export declare function getBeforeNodeForView(index: number, views: LView[], containerNative: RComment): RComment | RElement;
 /**
  * Removes the `child` element from the DOM if not in view and not projected.
  *
@@ -167,7 +161,7 @@ export declare function getBeforeNodeForView(index: number, views: LViewData[],
  * @param currentView The current LView
  * @returns Whether or not the child was removed
  */
-export declare function removeChild(childTNode: TNode, childEl: RNode | null, currentView: LViewData): boolean;
+export declare function removeChild(childTNode: TNode, childEl: RNode | null, currentView: LView): 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.
@@ -177,4 +171,4 @@ export declare function removeChild(childTNode: TNode, childEl: RNode | null, cu
  * @param currentView Current LView
  * @param projectionView Projection view (view above current)
  */
-export declare function appendProjectedNode(projectedTNode: TNode, tProjectionNode: TNode, currentView: LViewData, projectionView: LViewData): void;
+export declare function appendProjectedNode(projectedTNode: TNode, tProjectionNode: TNode, currentView: LView, projectionView: LView): void;

package/src/render3/node_selector_matcher.d.ts

@@ -15,8 +15,8 @@ import { CssSelector, CssSelectorList } from './interfaces/projection';
  * @param selector
  * @returns true if node matches the selector.
  */
-export declare function isNodeMatchingSelector(tNode: TNode, selector: CssSelector): boolean;
-export declare function isNodeMatchingSelectorList(tNode: TNode, selector: CssSelectorList): boolean;
+export declare function isNodeMatchingSelector(tNode: TNode, selector: CssSelector, isProjectionMode: boolean): boolean;
+export declare function isNodeMatchingSelectorList(tNode: TNode, selector: CssSelectorList, isProjectionMode?: boolean): boolean;
 export declare function getProjectAsAttrValue(tNode: TNode): string | null;
 /**
  * Checks a given node against matching selectors and returns

package/src/render3/state.d.ts

@@ -5,18 +5,15 @@
  * 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 { Sanitizer } from '../sanitization/security';
+import { ComponentDef, DirectiveDef } from './interfaces/definition';
 import { TElementNode, TNode, TViewNode } from './interfaces/node';
 import { LQueries } from './interfaces/query';
-import { Renderer3, RendererFactory3 } from './interfaces/renderer';
-import { LViewData, OpaqueViewState, TView } from './interfaces/view';
-export declare function getRenderer(): Renderer3;
-export declare function setRenderer(r: Renderer3): void;
-export declare function getRendererFactory(): RendererFactory3;
-export declare function getCurrentSanitizer(): Sanitizer | null;
+import { LView, OpaqueViewState } from './interfaces/view';
 export declare function getElementDepthCount(): number;
 export declare function increaseElementDepthCount(): void;
 export declare function decreaseElementDepthCount(): void;
+export declare function getCurrentDirectiveDef(): DirectiveDef<any> | ComponentDef<any> | null;
+export declare function setCurrentDirectiveDef(def: DirectiveDef<any> | ComponentDef<any> | null): void;
 export declare function getBindingsEnabled(): boolean;
 /**
  * Enables directive matching on elements.
@@ -54,15 +51,7 @@ export declare function enableBindings(): void;
  * ```
  */
 export declare function disableBindings(): void;
-/**
- * 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;
-export declare function _getViewData(): LViewData;
+export declare function getLView(): LView;
 /**
  * Restores `contextViewData` to the given OpaqueViewState instance.
  *
@@ -75,12 +64,9 @@ export declare function _getViewData(): LViewData;
 export declare function restoreView(viewToRestore: OpaqueViewState): void;
 export declare function getPreviousOrParentTNode(): TNode;
 export declare function setPreviousOrParentTNode(tNode: TNode): void;
-export declare function setTNodeAndViewData(tNode: TNode, view: LViewData): void;
+export declare function setTNodeAndViewData(tNode: TNode, view: LView): void;
 export declare function getIsParent(): boolean;
 export declare function setIsParent(value: boolean): void;
-export declare function getTView(): TView;
-export declare function getCurrentQueries(): LQueries | null;
-export declare function setCurrentQueries(queries: LQueries | null): void;
 /**
  * Query instructions can ask for "current queries" in 2 different cases:
  * - when creating view queries (at the root of a component view, before any node is created - in
@@ -91,16 +77,9 @@ export declare function setCurrentQueries(queries: LQueries | null): void;
 export declare function getOrCreateCurrentQueries(QueryType: {
     new (parent: null, shallow: null, deep: null): LQueries;
 }): LQueries;
-export declare function getCreationMode(): boolean;
-/**
- * Internal function that returns the current LViewData instance.
- *
- * The getCurrentView() instruction should be used for anything public.
- */
-export declare function getViewData(): LViewData;
-export declare function getContextViewData(): LViewData;
-export declare function getCleanup(view: LViewData): any[];
-export declare function getTViewCleanup(view: LViewData): any[];
+/** Checks whether a given view is in creation mode */
+export declare function isCreationMode(view?: LView): boolean;
+export declare function getContextLView(): LView;
 export declare function getCheckNoChangesMode(): boolean;
 export declare function setCheckNoChangesMode(mode: boolean): void;
 export declare function getFirstTemplatePass(): boolean;
@@ -119,7 +98,7 @@ export declare function setBindingRoot(value: number): void;
  * @param host Element to which the View is a child of
  * @returns the previous state;
  */
-export declare function enterView(newView: LViewData, hostTNode: TElementNode | TViewNode | null): LViewData;
+export declare function enterView(newView: LView, hostTNode: TElementNode | TViewNode | null): LView;
 export declare function nextContextImpl<T = any>(level?: number): T;
 /**
  * Resets the application state.
@@ -130,11 +109,5 @@ export declare function resetComponentState(): void;
  * the direction of traversal (up or down the view tree) a bit clearer.
  *
  * @param newView New state to become active
- * @param creationOnly An optional boolean to indicate that the view was processed in creation mode
- * only, i.e. the first update will be done later. Only possible for dynamically created views.
  */
-export declare function leaveView(newView: LViewData, creationOnly?: boolean): void;
-export declare function assertPreviousIsParent(): void;
-export declare function assertHasParent(): void;
-export declare function assertDataInRange(index: number, arr?: any[]): void;
-export declare function assertDataNext(index: number, arr?: any[]): void;
+export declare function leaveView(newView: LView): void;