@angular/core 7.2.0-beta.0 → 7.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular/core",
-  "version": "7.2.0-beta.0",
+  "version": "7.2.0",
   "description": "Angular - the core framework",
   "main": "./bundles/core.umd.js",
   "module": "./fesm5/core.js",

package/src/change_detection/constants.d.ts

@@ -15,7 +15,7 @@ export declare enum ChangeDetectionStrategy {
     /**
      * Use the `CheckOnce` strategy, meaning that automatic change detection is deactivated
      * until reactivated by setting the strategy to `Default` (`CheckAlways`).
-     * Change detection can still be explictly invoked.
+     * Change detection can still be explicitly invoked.
      */
     OnPush = 0,
     /**
@@ -40,7 +40,7 @@ export declare enum ChangeDetectorStatus {
      */
     Checked = 1,
     /**
-     * A state in which change detection continues automatically until explictly
+     * A state in which change detection continues automatically until explicitly
      * deactivated.
      */
     CheckAlways = 2,

package/src/core_render3_private_export.d.ts

@@ -5,14 +5,14 @@
  * 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
  */
-export { defineBase as ɵdefineBase, defineComponent as ɵdefineComponent, defineDirective as ɵdefineDirective, definePipe as ɵdefinePipe, defineNgModule as ɵdefineNgModule, detectChanges as ɵdetectChanges, renderComponent as ɵrenderComponent, ComponentType as ɵComponentType, ComponentFactory as ɵRender3ComponentFactory, ComponentRef as ɵRender3ComponentRef, DirectiveType as ɵDirectiveType, RenderFlags as ɵRenderFlags, directiveInject as ɵdirectiveInject, injectAttribute as ɵinjectAttribute, getFactoryOf as ɵgetFactoryOf, getInheritedFactory as ɵgetInheritedFactory, templateRefExtractor as ɵtemplateRefExtractor, ProvidersFeature as ɵProvidersFeature, InheritDefinitionFeature as ɵInheritDefinitionFeature, NgOnChangesFeature as ɵNgOnChangesFeature, LifecycleHooksFeature as ɵLifecycleHooksFeature, NgModuleType as ɵNgModuleType, NgModuleRef as ɵRender3NgModuleRef, CssSelectorList as ɵCssSelectorList, markDirty as ɵmarkDirty, NgModuleFactory as ɵNgModuleFactory, NO_CHANGE as ɵNO_CHANGE, container as ɵcontainer, nextContext as ɵnextContext, elementStart as ɵelementStart, namespaceHTML as ɵnamespaceHTML, namespaceMathML as ɵnamespaceMathML, namespaceSVG as ɵnamespaceSVG, element as ɵelement, listener as ɵlistener, text as ɵtext, embeddedViewStart as ɵembeddedViewStart, query as ɵquery, registerContentQuery as ɵregisterContentQuery, projection as ɵprojection, bind as ɵbind, interpolation1 as ɵinterpolation1, interpolation2 as ɵinterpolation2, interpolation3 as ɵinterpolation3, interpolation4 as ɵinterpolation4, interpolation5 as ɵinterpolation5, interpolation6 as ɵinterpolation6, interpolation7 as ɵinterpolation7, interpolation8 as ɵinterpolation8, interpolationV as ɵinterpolationV, pipeBind1 as ɵpipeBind1, pipeBind2 as ɵpipeBind2, pipeBind3 as ɵpipeBind3, pipeBind4 as ɵpipeBind4, pipeBindV as ɵpipeBindV, pureFunction0 as ɵpureFunction0, pureFunction1 as ɵpureFunction1, pureFunction2 as ɵpureFunction2, pureFunction3 as ɵpureFunction3, pureFunction4 as ɵpureFunction4, pureFunction5 as ɵpureFunction5, pureFunction6 as ɵpureFunction6, pureFunction7 as ɵpureFunction7, pureFunction8 as ɵpureFunction8, pureFunctionV as ɵpureFunctionV, getCurrentView as ɵgetCurrentView, restoreView as ɵrestoreView, containerRefreshStart as ɵcontainerRefreshStart, containerRefreshEnd as ɵcontainerRefreshEnd, queryRefresh as ɵqueryRefresh, loadQueryList as ɵloadQueryList, elementEnd as ɵelementEnd, elementProperty as ɵelementProperty, projectionDef as ɵprojectionDef, reference as ɵreference, enableBindings as ɵenableBindings, disableBindings as ɵdisableBindings, elementAttribute as ɵelementAttribute, elementContainerStart as ɵelementContainerStart, elementContainerEnd as ɵelementContainerEnd, elementStyling as ɵelementStyling, elementStylingMap as ɵelementStylingMap, elementStyleProp as ɵelementStyleProp, elementStylingApply as ɵelementStylingApply, elementClassProp as ɵelementClassProp, textBinding as ɵtextBinding, template as ɵtemplate, embeddedViewEnd as ɵembeddedViewEnd, store as ɵstore, load as ɵload, pipe as ɵpipe, BaseDef as ɵBaseDef, ComponentDef as ɵComponentDef, ComponentDefWithMeta as ɵComponentDefWithMeta, DirectiveDef as ɵDirectiveDef, DirectiveDefWithMeta as ɵDirectiveDefWithMeta, PipeDef as ɵPipeDef, PipeDefWithMeta as ɵPipeDefWithMeta, whenRendered as ɵwhenRendered, i18n as ɵi18n, i18nAttributes as ɵi18nAttributes, i18nExp as ɵi18nExp, i18nStart as ɵi18nStart, i18nEnd as ɵi18nEnd, i18nApply as ɵi18nApply, i18nPostprocess as ɵi18nPostprocess, setClassMetadata as ɵsetClassMetadata, } from './render3/index';
+export { defineBase as ɵdefineBase, defineComponent as ɵdefineComponent, defineDirective as ɵdefineDirective, definePipe as ɵdefinePipe, defineNgModule as ɵdefineNgModule, detectChanges as ɵdetectChanges, renderComponent as ɵrenderComponent, AttributeMarker as ɵAttributeMarker, ComponentType as ɵComponentType, ComponentFactory as ɵRender3ComponentFactory, ComponentRef as ɵRender3ComponentRef, DirectiveType as ɵDirectiveType, RenderFlags as ɵRenderFlags, directiveInject as ɵdirectiveInject, injectAttribute as ɵinjectAttribute, getFactoryOf as ɵgetFactoryOf, getInheritedFactory as ɵgetInheritedFactory, templateRefExtractor as ɵtemplateRefExtractor, ProvidersFeature as ɵProvidersFeature, InheritDefinitionFeature as ɵInheritDefinitionFeature, NgOnChangesFeature as ɵNgOnChangesFeature, LifecycleHooksFeature as ɵLifecycleHooksFeature, NgModuleType as ɵNgModuleType, NgModuleRef as ɵRender3NgModuleRef, CssSelectorList as ɵCssSelectorList, markDirty as ɵmarkDirty, NgModuleFactory as ɵNgModuleFactory, NO_CHANGE as ɵNO_CHANGE, container as ɵcontainer, nextContext as ɵnextContext, elementStart as ɵelementStart, namespaceHTML as ɵnamespaceHTML, namespaceMathML as ɵnamespaceMathML, namespaceSVG as ɵnamespaceSVG, element as ɵelement, listener as ɵlistener, text as ɵtext, embeddedViewStart as ɵembeddedViewStart, query as ɵquery, registerContentQuery as ɵregisterContentQuery, projection as ɵprojection, bind as ɵbind, interpolation1 as ɵinterpolation1, interpolation2 as ɵinterpolation2, interpolation3 as ɵinterpolation3, interpolation4 as ɵinterpolation4, interpolation5 as ɵinterpolation5, interpolation6 as ɵinterpolation6, interpolation7 as ɵinterpolation7, interpolation8 as ɵinterpolation8, interpolationV as ɵinterpolationV, pipeBind1 as ɵpipeBind1, pipeBind2 as ɵpipeBind2, pipeBind3 as ɵpipeBind3, pipeBind4 as ɵpipeBind4, pipeBindV as ɵpipeBindV, pureFunction0 as ɵpureFunction0, pureFunction1 as ɵpureFunction1, pureFunction2 as ɵpureFunction2, pureFunction3 as ɵpureFunction3, pureFunction4 as ɵpureFunction4, pureFunction5 as ɵpureFunction5, pureFunction6 as ɵpureFunction6, pureFunction7 as ɵpureFunction7, pureFunction8 as ɵpureFunction8, pureFunctionV as ɵpureFunctionV, getCurrentView as ɵgetCurrentView, getHostElement as ɵgetHostElement, restoreView as ɵrestoreView, containerRefreshStart as ɵcontainerRefreshStart, containerRefreshEnd as ɵcontainerRefreshEnd, queryRefresh as ɵqueryRefresh, loadQueryList as ɵloadQueryList, elementEnd as ɵelementEnd, elementProperty as ɵelementProperty, componentHostSyntheticProperty as ɵcomponentHostSyntheticProperty, projectionDef as ɵprojectionDef, reference as ɵreference, enableBindings as ɵenableBindings, disableBindings as ɵdisableBindings, allocHostVars as ɵallocHostVars, elementAttribute as ɵelementAttribute, elementContainerStart as ɵelementContainerStart, elementContainerEnd as ɵelementContainerEnd, elementStyling as ɵelementStyling, elementHostAttrs as ɵelementHostAttrs, elementStylingMap as ɵelementStylingMap, elementStyleProp as ɵelementStyleProp, elementStylingApply as ɵelementStylingApply, elementClassProp as ɵelementClassProp, textBinding as ɵtextBinding, template as ɵtemplate, embeddedViewEnd as ɵembeddedViewEnd, store as ɵstore, load as ɵload, pipe as ɵpipe, BaseDef as ɵBaseDef, ComponentDef as ɵComponentDef, ComponentDefWithMeta as ɵComponentDefWithMeta, DirectiveDef as ɵDirectiveDef, DirectiveDefWithMeta as ɵDirectiveDefWithMeta, PipeDef as ɵPipeDef, PipeDefWithMeta as ɵPipeDefWithMeta, whenRendered as ɵwhenRendered, i18n as ɵi18n, i18nAttributes as ɵi18nAttributes, i18nExp as ɵi18nExp, i18nStart as ɵi18nStart, i18nEnd as ɵi18nEnd, i18nApply as ɵi18nApply, i18nPostprocess as ɵi18nPostprocess, setClassMetadata as ɵsetClassMetadata, } from './render3/index';
 export { compileComponent as ɵcompileComponent, compileDirective as ɵcompileDirective, } from './render3/jit/directive';
-export { compileNgModule as ɵcompileNgModule, compileNgModuleDefs as ɵcompileNgModuleDefs, patchComponentDefWithScope as ɵpatchComponentDefWithScope, } from './render3/jit/module';
+export { compileNgModule as ɵcompileNgModule, compileNgModuleDefs as ɵcompileNgModuleDefs, patchComponentDefWithScope as ɵpatchComponentDefWithScope, resetCompiledComponents as ɵresetCompiledComponents, } from './render3/jit/module';
 export { compilePipe as ɵcompilePipe, } from './render3/jit/pipe';
 export { NgModuleDef as ɵNgModuleDef, NgModuleDefWithMeta as ɵNgModuleDefWithMeta, NgModuleTransitiveScopes as ɵNgModuleTransitiveScopes, } from './metadata/ng_module';
 export { sanitizeHtml as ɵsanitizeHtml, sanitizeStyle as ɵsanitizeStyle, sanitizeUrl as ɵsanitizeUrl, sanitizeResourceUrl as ɵsanitizeResourceUrl, } from './sanitization/sanitization';
 export { bypassSanitizationTrustHtml as ɵbypassSanitizationTrustHtml, bypassSanitizationTrustStyle as ɵbypassSanitizationTrustStyle, bypassSanitizationTrustScript as ɵbypassSanitizationTrustScript, bypassSanitizationTrustUrl as ɵbypassSanitizationTrustUrl, bypassSanitizationTrustResourceUrl as ɵbypassSanitizationTrustResourceUrl, } from './sanitization/bypass';
-export { getContext as ɵgetContext } from './render3/context_discovery';
+export { getLContext as ɵgetLContext } from './render3/context_discovery';
 export { Player as ɵPlayer, PlayerFactory as ɵPlayerFactory, PlayState as ɵPlayState, PlayerHandler as ɵPlayerHandler, } from './render3/interfaces/player';
 export { LContext as ɵLContext, } from './render3/interfaces/context';
 export { bindPlayerFactory as ɵbindPlayerFactory, } from './render3/styling/player_factory';
@@ -20,12 +20,15 @@ export { addPlayer as ɵaddPlayer, getPlayers as ɵgetPlayers, } from './render3
 export { compileNgModuleFactory__POST_R3__ as ɵcompileNgModuleFactory__POST_R3__ } from './application_ref';
 export { SWITCH_COMPILE_COMPONENT__POST_R3__ as ɵSWITCH_COMPILE_COMPONENT__POST_R3__, SWITCH_COMPILE_DIRECTIVE__POST_R3__ as ɵSWITCH_COMPILE_DIRECTIVE__POST_R3__, SWITCH_COMPILE_PIPE__POST_R3__ as ɵSWITCH_COMPILE_PIPE__POST_R3__, } from './metadata/directives';
 export { SWITCH_COMPILE_NGMODULE__POST_R3__ as ɵSWITCH_COMPILE_NGMODULE__POST_R3__, } from './metadata/ng_module';
+export { getDebugNode__POST_R3__ as ɵgetDebugNode__POST_R3__, } from './debug/debug_node';
 export { SWITCH_COMPILE_INJECTABLE__POST_R3__ as ɵSWITCH_COMPILE_INJECTABLE__POST_R3__, } from './di/injectable';
 export { SWITCH_IVY_ENABLED__POST_R3__ as ɵSWITCH_IVY_ENABLED__POST_R3__, } from './ivy_switch';
 export { SWITCH_CHANGE_DETECTOR_REF_FACTORY__POST_R3__ as ɵSWITCH_CHANGE_DETECTOR_REF_FACTORY__POST_R3__, } from './change_detection/change_detector_ref';
+export { Compiler_compileModuleSync__POST_R3__ as ɵCompiler_compileModuleSync__POST_R3__, Compiler_compileModuleAsync__POST_R3__ as ɵCompiler_compileModuleAsync__POST_R3__, Compiler_compileModuleAndAllComponentsSync__POST_R3__ as ɵCompiler_compileModuleAndAllComponentsSync__POST_R3__, Compiler_compileModuleAndAllComponentsAsync__POST_R3__ as ɵCompiler_compileModuleAndAllComponentsAsync__POST_R3__, } from './linker/compiler';
 export { SWITCH_ELEMENT_REF_FACTORY__POST_R3__ as ɵSWITCH_ELEMENT_REF_FACTORY__POST_R3__, } from './linker/element_ref';
 export { SWITCH_TEMPLATE_REF_FACTORY__POST_R3__ as ɵSWITCH_TEMPLATE_REF_FACTORY__POST_R3__, } from './linker/template_ref';
 export { SWITCH_VIEW_CONTAINER_REF_FACTORY__POST_R3__ as ɵSWITCH_VIEW_CONTAINER_REF_FACTORY__POST_R3__, } from './linker/view_container_ref';
 export { SWITCH_RENDERER2_FACTORY__POST_R3__ as ɵSWITCH_RENDERER2_FACTORY__POST_R3__, } from './render/api';
+export { getModuleFactory__POST_R3__ as ɵgetModuleFactory__POST_R3__ } from './linker/ng_module_factory_loader';
 export { publishGlobalUtil as ɵpublishGlobalUtil, publishDefaultGlobalUtils as ɵpublishDefaultGlobalUtils } from './render3/global_utils';
 export { SWITCH_INJECTOR_FACTORY__POST_R3__ as ɵSWITCH_INJECTOR_FACTORY__POST_R3__, } from './di/injector';

package/src/di/injectable.d.ts

@@ -7,6 +7,7 @@
  */
 import { compileInjectable as render3CompileInjectable } from '../render3/jit/injectable';
 import { Type } from '../type';
+import { TypeDecorator } from '../util/decorators';
 import { InjectableDef } from './defs';
 import { ClassSansProvider, ConstructorSansProvider, ExistingSansProvider, FactorySansProvider, StaticClassSansProvider, ValueSansProvider } from './provider';
 /**
@@ -37,10 +38,10 @@ export interface InjectableDecorator {
      * {@example core/di/ts/metadata_spec.ts region='InjectableThrows'}
      *
      */
-    (): any;
+    (): TypeDecorator;
     (options?: {
         providedIn: Type<any> | 'root' | null;
-    } & InjectableProvider): any;
+    } & InjectableProvider): TypeDecorator;
     new (): Injectable;
     new (options?: {
         providedIn: Type<any> | 'root' | null;

package/src/di/r3_injector.d.ts

@@ -71,6 +71,6 @@ export declare class R3Injector {
  *
  * @param provider provider to convert to factory
  */
-export declare function providerToFactory(provider: SingleProvider): () => any;
+export declare function providerToFactory(provider: SingleProvider, ngModuleType?: InjectorType<any>, providers?: any[]): () => any;
 export declare function isTypeProvider(value: SingleProvider): value is TypeProvider;
 export {};

package/src/linker/ng_module_factory_loader.d.ts

@@ -5,6 +5,7 @@
  * 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 { NgModuleType } from '../render3/ng_module_ref';
 import { NgModuleFactory } from './ng_module_factory';
 /**
  * Used to load ng module factories.
@@ -19,11 +20,14 @@ export declare abstract class NgModuleFactoryLoader {
  * @publicApi
  */
 export declare function registerModuleFactory(id: string, factory: NgModuleFactory<any>): void;
+export declare function registerNgModuleType(id: string, ngModuleType: NgModuleType): void;
 export declare function clearModulesForTest(): void;
+export declare function getModuleFactory__PRE_R3__(id: string): NgModuleFactory<any>;
+export declare function getModuleFactory__POST_R3__(id: string): NgModuleFactory<any>;
 /**
  * Returns the NgModuleFactory with the given id, if it exists and has been loaded.
  * Factories for modules that do not specify an `id` cannot be retrieved. Throws if the module
  * cannot be found.
  * @publicApi
  */
-export declare function getModuleFactory(id: string): NgModuleFactory<any>;
+export declare const getModuleFactory: (id: string) => NgModuleFactory<any>;

package/src/render3/assert.d.ts

@@ -5,6 +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 { TNode } from './interfaces/node';
+import { LView } from './interfaces/view';
 export declare function assertNumber(actual: any, msg: string): void;
 export declare function assertEqual<T>(actual: T, expected: T, msg: string): void;
 export declare function assertNotEqual<T>(actual: T, expected: T, msg: string): void;
@@ -16,3 +18,7 @@ export declare function assertDefined<T>(actual: T, msg: string): void;
 export declare function assertComponentType(actual: any, msg?: string): void;
 export declare function assertNgModuleType(actual: any, msg?: string): void;
 export declare function assertDomNode(node: any): void;
+export declare function assertPreviousIsParent(isParent: boolean): void;
+export declare function assertHasParent(tNode: TNode): void;
+export declare function assertDataNext(lView: LView, index: number, arr?: any[]): void;
+export declare function assertDataInRange(arr: any[], index: number): void;

package/src/render3/bindings.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @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 { LView } from './interfaces/view';
+/** Updates binding and returns the value. */
+export declare function updateBinding(lView: LView, bindingIndex: number, value: any): any;
+/** Gets the current binding value. */
+export declare function getBinding(lView: LView, bindingIndex: number): any;
+/** Updates binding if changed, then returns whether it was updated. */
+export declare function bindingUpdated(lView: LView, bindingIndex: number, value: any): boolean;
+/** Updates 2 bindings if changed, then returns whether either was updated. */
+export declare function bindingUpdated2(lView: LView, bindingIndex: number, exp1: any, exp2: any): boolean;
+/** Updates 3 bindings if changed, then returns whether any was updated. */
+export declare function bindingUpdated3(lView: LView, bindingIndex: number, exp1: any, exp2: any, exp3: any): boolean;
+/** Updates 4 bindings if changed, then returns whether any was updated. */
+export declare function bindingUpdated4(lView: LView, bindingIndex: number, exp1: any, exp2: any, exp3: any, exp4: any): boolean;

package/src/render3/component.d.ts

@@ -11,7 +11,7 @@ import { Sanitizer } from '../sanitization/security';
 import { ComponentDef, ComponentType } from './interfaces/definition';
 import { PlayerHandler } from './interfaces/player';
 import { RElement, Renderer3, RendererFactory3 } from './interfaces/renderer';
-import { LViewData, RootContext } from './interfaces/view';
+import { LView, RootContext } from './interfaces/view';
 /** Options that control how the component should be bootstrapped. */
 export interface CreateComponentOptions {
     /** Which renderer factory to use. */
@@ -82,12 +82,12 @@ export declare function renderComponent<T>(componentType: ComponentType<T> | Typ
  *
  * @returns Component view created
  */
-export declare function createRootComponentView(rNode: RElement | null, def: ComponentDef<any>, rootView: LViewData, rendererFactory: RendererFactory3, renderer: Renderer3, sanitizer?: Sanitizer | null): LViewData;
+export declare function createRootComponentView(rNode: RElement | null, def: ComponentDef<any>, rootView: LView, rendererFactory: RendererFactory3, renderer: Renderer3, sanitizer?: Sanitizer | null): LView;
 /**
  * Creates a root component and sets it up with features and host bindings. Shared by
  * renderComponent() and ViewContainerRef.createComponent().
  */
-export declare function createRootComponent<T>(componentView: LViewData, componentDef: ComponentDef<T>, rootView: LViewData, rootContext: RootContext, hostFeatures: HostFeature[] | null): any;
+export declare function createRootComponent<T>(componentView: LView, componentDef: ComponentDef<T>, rootView: LView, rootContext: RootContext, hostFeatures: HostFeature[] | null): any;
 export declare function createRootContext(scheduler?: (workFn: () => void) => void, playerHandler?: PlayerHandler | null): RootContext;
 /**
  * Used to enable lifecycle hooks on the root component.

package/src/render3/component_ref.d.ts

@@ -15,9 +15,14 @@ import { NgModuleRef as viewEngine_NgModuleRef } from '../linker/ng_module_facto
 import { Type } from '../type';
 import { ComponentDef } from './interfaces/definition';
 import { TContainerNode, TElementContainerNode, TElementNode } from './interfaces/node';
-import { LViewData, RootContext } from './interfaces/view';
+import { LView, RootContext } from './interfaces/view';
 import { ViewRef } from './view_ref';
 export declare class ComponentFactoryResolver extends viewEngine_ComponentFactoryResolver {
+    private ngModule?;
+    /**
+     * @param ngModule The NgModuleRef to which all resolved factories are bound.
+     */
+    constructor(ngModule?: viewEngine_NgModuleRef<any> | undefined);
     resolveComponentFactory<T>(component: Type<T>): viewEngine_ComponentFactory<T>;
 }
 /**
@@ -34,6 +39,7 @@ export declare const SCHEDULER: InjectionToken<(fn: () => void) => void>;
  */
 export declare class ComponentFactory<T> extends viewEngine_ComponentFactory<T> {
     private componentDef;
+    private ngModule?;
     selector: string;
     componentType: Type<any>;
     ngContentSelectors: string[];
@@ -45,7 +51,11 @@ export declare class ComponentFactory<T> extends viewEngine_ComponentFactory<T>
         propName: string;
         templateName: string;
     }[];
-    constructor(componentDef: ComponentDef<any>);
+    /**
+     * @param componentDef The component definition.
+     * @param ngModule The NgModuleRef to which the factory is bound.
+     */
+    constructor(componentDef: ComponentDef<any>, ngModule?: viewEngine_NgModuleRef<any> | undefined);
     create(injector: Injector, projectableNodes?: any[][] | undefined, rootSelectorOrNode?: any, ngModule?: viewEngine_NgModuleRef<any> | undefined): viewEngine_ComponentRef<T>;
 }
 /**
@@ -66,14 +76,14 @@ export declare function injectComponentFactoryResolver(): viewEngine_ComponentFa
  */
 export declare class ComponentRef<T> extends viewEngine_ComponentRef<T> {
     location: viewEngine_ElementRef;
-    private _rootView;
+    private _rootLView;
     private _tNode;
     destroyCbs: (() => void)[] | null;
     instance: T;
     hostView: ViewRef<T>;
     changeDetectorRef: ViewEngine_ChangeDetectorRef;
     componentType: Type<T>;
-    constructor(componentType: Type<T>, instance: T, location: viewEngine_ElementRef, _rootView: LViewData, _tNode: TElementNode | TContainerNode | TElementContainerNode);
+    constructor(componentType: Type<T>, instance: T, location: viewEngine_ElementRef, _rootLView: LView, _tNode: TElementNode | TContainerNode | TElementContainerNode);
     readonly injector: Injector;
     destroy(): void;
     onDestroy(callback: () => void): void;

package/src/render3/context_discovery.d.ts

@@ -7,14 +7,14 @@
  */
 import './ng_dev_mode';
 import { LContext } from './interfaces/context';
-import { LViewData } from './interfaces/view';
+import { LView } from './interfaces/view';
 /** Returns the matching `LContext` data for a given DOM node, directive or component instance.
  *
  * This function will examine the provided DOM element, component, or directive instance\'s
  * monkey-patched property to derive the `LContext` data. Once called then the monkey-patched
  * value will be that of the newly created `LContext`.
  *
- * If the monkey-patched value is the `LViewData` instance then the context value for that
+ * If the monkey-patched value is the `LView` instance then the context value for that
  * target will be created and the monkey-patch reference will be updated. Therefore when this
  * function is called it may mutate the provided element\'s, component\'s or any of the associated
  * directive\'s monkey-patch values.
@@ -27,19 +27,19 @@ import { LViewData } from './interfaces/view';
  *
  * @param target Component, Directive or DOM Node.
  */
-export declare function getContext(target: any): LContext | null;
+export declare function getLContext(target: any): LContext | null;
 /**
  * Takes a component instance and returns the view for that component.
  *
  * @param componentInstance
  * @returns The component's view
  */
-export declare function getComponentViewByInstance(componentInstance: {}): LViewData;
+export declare function getComponentViewByInstance(componentInstance: {}): LView;
 /**
  * Assigns the given data to the given target (which could be a component,
  * directive or DOM node instance) using monkey-patching.
  */
-export declare function attachPatchData(target: any, data: LViewData | LContext): void;
+export declare function attachPatchData(target: any, data: LView | LContext): void;
 export declare function isComponentInstance(instance: any): boolean;
 export declare function isDirectiveInstance(instance: any): boolean;
 /**
@@ -47,15 +47,15 @@ export declare function isDirectiveInstance(instance: any): boolean;
  * provided list of directive index values.
  *
  * @param nodeIndex The node index
- * @param lViewData The target view data
+ * @param lView The target view data
  * @param includeComponents Whether or not to include components in returned directives
  */
-export declare function getDirectivesAtNodeIndex(nodeIndex: number, lViewData: LViewData, includeComponents: boolean): any[] | null;
-export declare function getComponentAtNodeIndex(nodeIndex: number, lViewData: LViewData): {} | null;
+export declare function getDirectivesAtNodeIndex(nodeIndex: number, lView: LView, includeComponents: boolean): any[] | null;
+export declare function getComponentAtNodeIndex(nodeIndex: number, lView: LView): {} | null;
 /**
  * Returns a map of local references (local reference name => element or directive instance) that
  * exist on a given element.
  */
-export declare function discoverLocalRefs(lViewData: LViewData, nodeIndex: number): {
+export declare function discoverLocalRefs(lView: LView, nodeIndex: number): {
     [key: string]: any;
 } | null;

package/src/render3/definition.d.ts

@@ -11,9 +11,7 @@ import { NgModuleDef } from '../metadata/ng_module';
 import { ViewEncapsulation } from '../metadata/view';
 import { Type } from '../type';
 import { BaseDef, ComponentDef, ComponentDefFeature, ComponentQuery, ComponentTemplate, ComponentType, DirectiveDef, DirectiveDefFeature, DirectiveType, DirectiveTypesOrFactory, HostBindingsFunction, PipeDef, PipeType, PipeTypesOrFactory } from './interfaces/definition';
-import { CssSelectorList, SelectorFlags } from './interfaces/projection';
-export declare const EMPTY: {};
-export declare const EMPTY_ARRAY: any[];
+import { CssSelectorList } from './interfaces/projection';
 /**
  * Create a component definition object.
  *
@@ -43,24 +41,17 @@ export declare function defineComponent<T>(componentDefinition: {
     /**
      * The number of nodes, local refs, and pipes in this component template.
      *
-     * Used to calculate the length of this component's LViewData array, so we
+     * Used to calculate the length of this component's LView array, so we
      * can pre-fill the array and set the binding start index.
      */
     consts: number;
     /**
      * The number of bindings in this component template (including pure fn bindings).
      *
-     * Used to calculate the length of this component's LViewData array, so we
+     * Used to calculate the length of this component's LView array, so we
      * can pre-fill the array and set the host binding start index.
      */
     vars: number;
-    /**
-     * The number of host bindings (including pure fn bindings) in this component.
-     *
-     * Used to calculate the length of the LViewData array for the *parent* component
-     * of this component.
-     */
-    hostVars?: number;
     /**
      * Static attributes to set on host element.
      *
@@ -88,7 +79,7 @@ export declare function defineComponent<T>(componentDefinition: {
      * ```
      * {
      *   publicInput1: 'publicInput1',
-     *   declaredInput2: ['declaredInput2', 'publicInput2'],
+     *   declaredInput2: ['publicInput2', 'declaredInput2'],
      * }
      * ```
      *
@@ -96,7 +87,7 @@ export declare function defineComponent<T>(componentDefinition: {
      * ```
      * {
      *   minifiedPublicInput1: 'publicInput1',
-     *   minifiedDeclaredInput2: [ 'publicInput2', 'declaredInput2'],
+     *   minifiedDeclaredInput2: ['publicInput2', 'declaredInput2'],
      * }
      * ```
      *
@@ -105,7 +96,7 @@ export declare function defineComponent<T>(componentDefinition: {
      *
      * NOTE:
      *  - Because declared and public name are usually same we only generate the array
-     *    `['declared', 'public']` format when they differ.
+     *    `['public', 'declared']` format when they differ.
      *  - The reason why this API and `outputs` API is not the same is that `NgOnChanges` has
      *    inconsistent behavior in that it uses declared names rather than minified or public. For
      *    this reason `NgOnChanges` will be deprecated and removed in future version and this
@@ -323,7 +314,7 @@ export declare const defineDirective: <T>(directiveDefinition: {
      */
     type: Type<T>;
     /** The selectors that will be used to match nodes to this directive. */
-    selectors: (string | SelectorFlags)[][];
+    selectors: (string | import("@angular/core/src/render3/interfaces/projection").SelectorFlags)[][];
     /**
      * Factory method used to create an instance of directive.
      */
@@ -396,13 +387,6 @@ export declare const defineDirective: <T>(directiveDefinition: {
      * See: {@link NgOnChangesFeature}, {@link ProvidersFeature}, {@link InheritDefinitionFeature}
      */
     features?: DirectiveDefFeature[] | undefined;
-    /**
-     * The number of host bindings (including pure fn bindings) in this directive.
-     *
-     * Used to calculate the length of the LViewData array for the *parent* component
-     * of this directive.
-     */
-    hostVars?: number | undefined;
     /**
      * Function executed by the parent template to allow child directive to apply host bindings.
      */
@@ -452,4 +436,5 @@ export declare function definePipe<T>(pipeDef: {
 export declare function getComponentDef<T>(type: any): ComponentDef<T> | null;
 export declare function getDirectiveDef<T>(type: any): DirectiveDef<T> | null;
 export declare function getPipeDef<T>(type: any): PipeDef<T> | null;
+export declare function getNgModuleDef<T>(type: any, throwNotFound: true): NgModuleDef<T>;
 export declare function getNgModuleDef<T>(type: any): NgModuleDef<T> | null;

package/src/render3/di.d.ts

@@ -11,7 +11,7 @@ import { InjectFlags } from '../di/injector_compatibility';
 import { Type } from '../type';
 import { RelativeInjectorLocation } from './interfaces/injector';
 import { TContainerNode, TElementContainerNode, TElementNode, TNode } from './interfaces/node';
-import { LViewData, TData, TView } from './interfaces/view';
+import { LView, TData, TView } from './interfaces/view';
 /**
  * Registers this directive as present in its node's injector by flipping the directive's
  * corresponding bit in the injector's bloom filter.
@@ -20,7 +20,7 @@ import { LViewData, TData, TView } from './interfaces/view';
  * @param tView The TView for the injector's bloom filters
  * @param type The directive token to register
  */
-export declare function bloomAdd(injectorIndex: number, tView: TView, type: Type<any> | InjectionToken<any>): void;
+export declare function bloomAdd(injectorIndex: number, tView: TView, type: Type<any> | InjectionToken<any> | string): void;
 /**
  * Creates (or gets an existing) injector for a given element or container.
  *
@@ -28,15 +28,15 @@ export declare function bloomAdd(injectorIndex: number, tView: TView, type: Type
  * @param hostView View where the node is stored
  * @returns Node injector
  */
-export declare function getOrCreateNodeInjectorForNode(tNode: TElementNode | TContainerNode | TElementContainerNode, hostView: LViewData): number;
-export declare function getInjectorIndex(tNode: TNode, hostView: LViewData): number;
+export declare function getOrCreateNodeInjectorForNode(tNode: TElementNode | TContainerNode | TElementContainerNode, hostView: LView): number;
+export declare function getInjectorIndex(tNode: TNode, hostView: LView): number;
 /**
  * Finds the index of the parent injector, with a view offset if applicable. Used to set the
  * parent injector initially.
  *
  * Returns a combination of number of `ViewData` we have to go up and index in that `Viewdata`
  */
-export declare function getParentInjectorLocation(tNode: TNode, view: LViewData): RelativeInjectorLocation;
+export declare function getParentInjectorLocation(tNode: TNode, view: LView): RelativeInjectorLocation;
 /**
  * Makes a type or an injection token public to the DI system by adding it to an
  * injector's bloom filter.
@@ -44,7 +44,7 @@ export declare function getParentInjectorLocation(tNode: TNode, view: LViewData)
  * @param di The node injector in which a directive will be added
  * @param token The type or the injection token to be made public
  */
-export declare function diPublicInInjector(injectorIndex: number, view: LViewData, token: InjectionToken<any> | Type<any>): void;
+export declare function diPublicInInjector(injectorIndex: number, view: LView, token: InjectionToken<any> | Type<any>): void;
 /**
  * Inject static attribute value into directive constructor.
  *
@@ -83,22 +83,25 @@ export declare function injectAttributeImpl(tNode: TNode, attrNameToInject: stri
  * Look for the injector providing the token by walking up the node injector tree and then
  * the module injector tree.
  *
- * @param nodeInjector Node injector where the search should start
+ * @param tNode The Node where the search for the injector should start
+ * @param lView The `LView` that contains the `tNode`
  * @param token The token to look for
  * @param flags Injection flags
- * @returns the value from the injector or `null` when not found
+ * @param notFoundValue The value to return when the injection flags is `InjectFlags.Optional`
+ * @returns the value from the injector, `null` when not found, or `notFoundValue` if provided
  */
-export declare function getOrCreateInjectable<T>(tNode: TElementNode | TContainerNode | TElementContainerNode, lViewData: LViewData, token: Type<T> | InjectionToken<T>, flags?: InjectFlags, notFoundValue?: any): T | null;
+export declare function getOrCreateInjectable<T>(tNode: TElementNode | TContainerNode | TElementContainerNode | null, lView: LView, token: Type<T> | InjectionToken<T>, flags?: InjectFlags, notFoundValue?: any): T | null;
 /**
  * Searches for the given token among the node's directives and providers.
  *
  * @param tNode TNode on which directives are present.
- * @param view The view we are currently processing
+ * @param lView The view we are currently processing
  * @param token Provider token or type of a directive to look for.
  * @param canAccessViewProviders Whether view providers should be considered.
+ * @param isHostSpecialCase Whether the host special case applies.
  * @returns Index of a found directive or provider, or null when none found.
  */
-export declare function locateDirectiveOrProvider<T>(tNode: TNode, view: LViewData, token: Type<T> | InjectionToken<T>, canAccessViewProviders: boolean): number | null;
+export declare function locateDirectiveOrProvider<T>(tNode: TNode, lView: LView, token: Type<T> | InjectionToken<T>, canAccessViewProviders: boolean, isHostSpecialCase: boolean | number): number | null;
 /**
 * Retrieve or instantiate the injectable from the `lData` at particular `index`.
 *
@@ -106,7 +109,7 @@ export declare function locateDirectiveOrProvider<T>(tNode: TNode, view: LViewDa
 * cached `injectable`. Otherwise if it detects that the value is still a factory it
 * instantiates the `injectable` and caches the value.
 */
-export declare function getNodeInjectable(tData: TData, lData: LViewData, index: number, tNode: TElementNode): any;
+export declare function getNodeInjectable(tData: TData, lData: LView, index: number, tNode: TElementNode): any;
 /**
  * Returns the bit in an injector's bloom filter that should be used to determine whether or not
  * the directive might be provided by the injector.
@@ -118,15 +121,14 @@ export declare function getNodeInjectable(tData: TData, lData: LViewData, index:
  * @param token the injection token
  * @returns the matching bit to check in the bloom filter or `null` if the token is not known.
  */
-export declare function bloomHashBitOrFactory(token: Type<any> | InjectionToken<any>): number | Function | undefined;
-export declare function bloomHasToken(bloomHash: number, injectorIndex: number, injectorView: LViewData | TData): boolean;
+export declare function bloomHashBitOrFactory(token: Type<any> | InjectionToken<any> | string): number | Function | undefined;
+export declare function bloomHasToken(bloomHash: number, injectorIndex: number, injectorView: LView | TData): boolean;
 export declare function injectInjector(): NodeInjector;
 export declare class NodeInjector implements Injector {
     private _tNode;
     private _lView;
-    private _injectorIndex;
-    constructor(_tNode: TElementNode | TContainerNode | TElementContainerNode, _lView: LViewData);
-    get(token: any): any;
+    constructor(_tNode: TElementNode | TContainerNode | TElementContainerNode | null, _lView: LView);
+    get(token: any, notFoundValue?: any): any;
 }
 export declare function getFactoryOf<T>(type: Type<any>): ((type: Type<T> | null) => T) | null;
 export declare function getInheritedFactory<T>(type: Type<any>): (type: Type<T>) => T;

package/src/render3/discovery_utils.d.ts

@@ -7,12 +7,12 @@
  */
 import { Injector } from '../di/injector';
 import { LContext } from './interfaces/context';
-import { LViewData, RootContext } from './interfaces/view';
+import { LView, RootContext } from './interfaces/view';
 /**
  * Returns the component instance associated with a given DOM host element.
  * Elements which don't represent components return `null`.
  *
- * @param element Host DOM element from which the component should be retrieved for.
+ * @param element Host DOM element from which the component should be retrieved.
  *
  * ```
  * <my-app>
@@ -29,6 +29,27 @@ import { LViewData, RootContext } from './interfaces/view';
  * @publicApi
  */
 export declare function getComponent<T = {}>(element: Element): T | null;
+/**
+ * Returns the component instance associated with a given DOM host element.
+ * Elements which don't represent components return `null`.
+ *
+ * @param element Host DOM element from which the component should be retrieved.
+ *
+ * ```
+ * <my-app>
+ *   #VIEW
+ *     <div>
+ *       <child-comp></child-comp>
+ *     </div>
+ * </mp-app>
+ *
+ * expect(getComponent(<child-comp>) instanceof ChildComponent).toBeTruthy();
+ * expect(getComponent(<my-app>) instanceof MyApp).toBeTruthy();
+ * ```
+ *
+ * @publicApi
+ */
+export declare function getContext<T = {}>(element: Element): T | null;
 /**
  * Returns the component instance associated with view which owns the DOM element (`null`
  * otherwise).
@@ -55,7 +76,7 @@ export declare function getViewComponent<T = {}>(element: Element | {}): T | nul
  * the application where the target is situated.
  *
  */
-export declare function getRootContext(target: LViewData | {}): RootContext;
+export declare function getRootContext(target: LView | {}): RootContext;
 /**
  * Retrieve all root components.
  *
@@ -74,6 +95,13 @@ export declare function getRootComponents(target: {}): any[];
  * @publicApi
  */
 export declare function getInjector(target: {}): Injector;
+/**
+ * Retrieve a set of injection tokens at a given DOM node.
+ *
+ * @param element Element for which the injection tokens should be retrieved.
+ * @publicApi
+ */
+export declare function getInjectionTokens(element: Element): any[];
 /**
  * Retrieves directives associated with a given DOM host element.
  *
@@ -87,16 +115,16 @@ export declare function getDirectives(target: {}): Array<{}>;
  * Throws if a given target doesn't have associated LContext.
  *
  */
-export declare function loadContext(target: {}): LContext;
-export declare function loadContext(target: {}, throwOnNotFound: false): LContext | null;
+export declare function loadLContext(target: {}): LContext;
+export declare function loadLContext(target: {}, throwOnNotFound: false): LContext | null;
 /**
- * Retrieve the root view from any component by walking the parent `LViewData` until
- * reaching the root `LViewData`.
+ * Retrieve the root view from any component by walking the parent `LView` until
+ * reaching the root `LView`.
  *
  * @param componentOrView any component or view
  *
  */
-export declare function getRootView(componentOrView: LViewData | {}): LViewData;
+export declare function getRootView(componentOrView: LView | {}): LView;
 /**
  * Retrieve map of local references.
  *
@@ -131,3 +159,33 @@ export declare function getHostElement<T>(directive: T): Element;
  * @param component The component to return the content text for.
  */
 export declare function getRenderedText(component: any): string;
+export declare function loadLContextFromNode(node: Node): LContext;
+export interface Listener {
+    name: string;
+    element: Element;
+    callback: (value: any) => any;
+    useCapture: boolean | null;
+}
+export declare function isBrowserEvents(listener: Listener): boolean;
+/**
+ * Retrieves a list of DOM listeners.
+ *
+ * ```
+ * <my-app>
+ *   #VIEW
+ *     <div (click)="doSomething()">
+ *     </div>
+ * </mp-app>
+ *
+ * expect(getListeners(<div>)).toEqual({
+ *   name: 'click',
+ *   element: <div>,
+ *   callback: () => doSomething(),
+ *   useCapture: false
+ * });
+ * ```
+ *
+ * @param element Element for which the DOM listeners should be retrieved.
+ * @publicApi
+ */
+export declare function getListeners(element: Element): Listener[];