@angular/core 7.2.0-beta.0 → 7.2.0

package/esm2015/src/render3/interfaces/view.js

@@ -1,6 +1,6 @@
 /**
  * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
+ * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 /**
  * @license
@@ -9,6 +9,9 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
+// Below are constants for LView indices to help us look up LView members
+// without having to remember the specific indices.
+// Uglify will inline these when minifying so there shouldn't be a cost.
 /** @type {?} */
 export const TVIEW = 0;
 /** @type {?} */
@@ -23,6 +26,7 @@ export const QUERIES = 4;
 export const HOST = 5;
 /** @type {?} */
 export const HOST_NODE = 6;
+// Rename to `T_HOST`?
 /** @type {?} */
 export const BINDING_INDEX = 7;
 /** @type {?} */
@@ -45,57 +49,106 @@ export const CONTAINER_INDEX = 15;
 export const CONTENT_QUERIES = 16;
 /** @type {?} */
 export const DECLARATION_VIEW = 17;
-/** *
- * Size of LViewData's header. Necessary to adjust for it when setting slots.
-  @type {?} */
+/**
+ * Size of LView's header. Necessary to adjust for it when setting slots.
+ * @type {?}
+ */
 export const HEADER_OFFSET = 18;
 /**
  * @record
  */
 export function OpaqueViewState() { }
-/** @type {?} */
-OpaqueViewState.prototype.__brand__;
+if (false) {
+    /** @type {?} */
+    OpaqueViewState.prototype.__brand__;
+}
 /**
- * `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.
  * @record
  */
-export function LViewData() { }
+export function LView() { }
+if (false) {
+    /* Skipping unnamed member:
+    readonly[TVIEW]: TView;*/
+    /* Skipping unnamed member:
+    [FLAGS]: LViewFlags;*/
+    /* Skipping unnamed member:
+    [PARENT]: LView|null;*/
+    /* Skipping unnamed member:
+    [NEXT]: LView|LContainer|null;*/
+    /* Skipping unnamed member:
+    [QUERIES]: LQueries|null;*/
+    /* Skipping unnamed member:
+    [HOST]: RElement|StylingContext|null;*/
+    /* Skipping unnamed member:
+    [HOST_NODE]: TViewNode|TElementNode|null;*/
+    /* Skipping unnamed member:
+    [BINDING_INDEX]: number;*/
+    /* Skipping unnamed member:
+    [CLEANUP]: any[]|null;*/
+    /* Skipping unnamed member:
+    [CONTEXT]: {}|RootContext|null;*/
+    /* Skipping unnamed member:
+    readonly[INJECTOR]: Injector|null;*/
+    /* Skipping unnamed member:
+    [RENDERER_FACTORY]: RendererFactory3;*/
+    /* Skipping unnamed member:
+    [RENDERER]: Renderer3;*/
+    /* Skipping unnamed member:
+    [SANITIZER]: Sanitizer|null;*/
+    /* Skipping unnamed member:
+    [TAIL]: LView|LContainer|null;*/
+    /* Skipping unnamed member:
+    [CONTAINER_INDEX]: number;*/
+    /* Skipping unnamed member:
+    [CONTENT_QUERIES]: QueryList<any>[]|null;*/
+    /* Skipping unnamed member:
+    [DECLARATION_VIEW]: LView|null;*/
+}
 /** @enum {number} */
-var LViewFlags = {
-    /**
-       * Whether or not the view is in creationMode.
-       *
-       * This must be stored in the view rather than using `data` as a marker so that
-       * we can properly support embedded views. Otherwise, when exiting a child view
-       * back into the parent view, `data` will be defined and `creationMode` will be
-       * improperly reported as false.
-       */
+const LViewFlags = {
+    /**
+     * Whether or not the view is in creationMode.
+     *
+     * This must be stored in the view rather than using `data` as a marker so that
+     * we can properly support embedded views. Otherwise, when exiting a child view
+     * back into the parent view, `data` will be defined and `creationMode` will be
+     * 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,
-    /**
-       *  Whether or not the init hooks have run.
-       *
-       * If on, the init hooks haven't yet been run and should be executed by the first component that
-       * runs OR the first cR() instruction that runs (so inits are run for the top level view before
-       * any embedded views).
-       */
-    RunInit: 16,
+    Attached: 16,
+    /**
+     *  Whether or not the init hooks have run.
+     *
+     * If on, the init hooks haven't yet been run and should be executed by the first component that
+     * runs OR the first cR() instruction that runs (so inits are run for the top level view before
+     * any embedded views).
+     */
+    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,
 };
 export { LViewFlags };
 /**
@@ -106,235 +159,243 @@ export { LViewFlags };
  * @record
  */
 export function TView() { }
-/**
- * ID for inline views to determine whether a view is the same as the previous view
- * in a certain position. If it's not, we know the new view needs to be inserted
- * and the one that exists needs to be removed (e.g. if/else statements)
- *
- * If this is -1, then this is a component view or a dynamically created view.
- * @type {?}
- */
-TView.prototype.id;
-/**
- * This is a blueprint used to generate LViewData instances for this TView. Copying this
- * blueprint is faster than creating a new LViewData from scratch.
- * @type {?}
- */
-TView.prototype.blueprint;
-/**
- * The template function used to refresh the view of dynamically created views
- * and components. Will be null for inline views.
- * @type {?}
- */
-TView.prototype.template;
-/**
- * A function containing query-related instructions.
- * @type {?}
- */
-TView.prototype.viewQuery;
-/**
- * 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.
- * We need this pointer to be able to efficiently find this node when inserting the view
- * into an anchor.
- *
- * If this is a `TElementNode`, this is the view of a root component. It has exactly one
- * root TNode.
- *
- * If this is null, this is the view of a component that is not at root. We do not store
- * the host TNodes for child component views because they can potentially have several
- * different host TNodes, depending on where the component is being used. These host
- * TNodes cannot be shared (due to different indices, etc).
- * @type {?}
- */
-TView.prototype.node;
-/**
- * Whether or not this template has been processed.
- * @type {?}
- */
-TView.prototype.firstTemplatePass;
-/**
- * Static data equivalent of LView.data[]. Contains TNodes, PipeDefInternal or TI18n.
- * @type {?}
- */
-TView.prototype.data;
-/**
- * The binding start index is the index at which the data array
- * starts to store bindings only. Saving this value ensures that we
- * will begin reading bindings at the correct point in the array when
- * we are in update mode.
- * @type {?}
- */
-TView.prototype.bindingStartIndex;
-/**
- * The index where the "expando" section of `LViewData` begins. The expando
- * section contains injectors, directive instances, and host binding values.
- * Unlike the "consts" and "vars" sections of `LViewData`, the length of this
- * section cannot be calculated at compile-time because directives are matched
- * at runtime to preserve locality.
- *
- * We store this start index so we know where to start checking host bindings
- * in `setHostBindings`.
- * @type {?}
- */
-TView.prototype.expandoStartIndex;
-/**
- * Index of the host node of the first LView or LContainer beneath this LView in
- * the hierarchy.
- *
- * Necessary to store this so views can traverse through their nested views
- * to remove listeners and call onDestroy callbacks.
- *
- * For embedded views, we store the index of an LContainer's host rather than the first
- * LView to avoid managing splicing when views are added/removed.
- * @type {?}
- */
-TView.prototype.childIndex;
-/**
- * A reference to the first child node located in the view.
- * @type {?}
- */
-TView.prototype.firstChild;
-/**
- * Set of instructions used to process host bindings efficiently.
- *
- * See VIEW_DATA.md for more information.
- * @type {?}
- */
-TView.prototype.expandoInstructions;
-/**
- * Full registry of directives and components that may be found in this view.
- *
- * It's necessary to keep a copy of the full def list on the TView so it's possible
- * to render template functions without a host component.
- * @type {?}
- */
-TView.prototype.directiveRegistry;
-/**
- * Full registry of pipes that may be found in this view.
- *
- * The property is either an array of `PipeDefs`s or a function which returns the array of
- * `PipeDefs`s. The function is necessary to be able to support forward declarations.
- *
- * It's necessary to keep a copy of the full def list on the TView so it's possible
- * to render template functions without a host component.
- * @type {?}
- */
-TView.prototype.pipeRegistry;
-/**
- * Array of ngOnInit and ngDoCheck hooks that should be executed for this view in
- * creation mode.
- *
- * Even indices: Directive index
- * Odd indices: Hook function
- * @type {?}
- */
-TView.prototype.initHooks;
-/**
- * Array of ngDoCheck hooks that should be executed for this view in update mode.
- *
- * Even indices: Directive index
- * Odd indices: Hook function
- * @type {?}
- */
-TView.prototype.checkHooks;
-/**
- * Array of ngAfterContentInit and ngAfterContentChecked hooks that should be executed
- * for this view in creation mode.
- *
- * Even indices: Directive index
- * Odd indices: Hook function
- * @type {?}
- */
-TView.prototype.contentHooks;
-/**
- * Array of ngAfterContentChecked hooks that should be executed for this view in update
- * mode.
- *
- * Even indices: Directive index
- * Odd indices: Hook function
- * @type {?}
- */
-TView.prototype.contentCheckHooks;
-/**
- * Array of ngAfterViewInit and ngAfterViewChecked hooks that should be executed for
- * this view in creation mode.
- *
- * Even indices: Directive index
- * Odd indices: Hook function
- * @type {?}
- */
-TView.prototype.viewHooks;
-/**
- * Array of ngAfterViewChecked hooks that should be executed for this view in
- * update mode.
- *
- * Even indices: Directive index
- * Odd indices: Hook function
- * @type {?}
- */
-TView.prototype.viewCheckHooks;
-/**
- * Array of ngOnDestroy hooks that should be executed when this view is destroyed.
- *
- * Even indices: Directive index
- * Odd indices: Hook function
- * @type {?}
- */
-TView.prototype.destroyHooks;
-/**
- * Array of pipe ngOnDestroy hooks that should be executed when this view is destroyed.
- *
- * Even indices: Index of pipe in data
- * Odd indices: Hook function
- *
- * These must be stored separately from directive destroy hooks because their contexts
- * are stored in data.
- * @type {?}
- */
-TView.prototype.pipeDestroyHooks;
-/**
- * When a view is destroyed, listeners need to be released and outputs need to be
- * unsubscribed. This cleanup array stores both listener data (in chunks of 4)
- * and output data (in chunks of 2) for a particular view. Combining the arrays
- * 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 renderer2 style listener or ViewRef destroy hook being stored:
- * 1st index is: index of the cleanup function in LView.cleanupInstances[]
- * 2nd index is: null
- *
- * 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[]
- * @type {?}
- */
-TView.prototype.cleanup;
-/**
- * A list of element indices for child components that will need to be
- * refreshed when the current view has finished its check. These indices have
- * already been adjusted for the HEADER_OFFSET.
- *
- * @type {?}
- */
-TView.prototype.components;
-/**
- * A list of indices for child directives that have content queries.
- *
- * Even indices: Directive indices
- * Odd indices: Starting index of content queries (stored in CONTENT_QUERIES) for this directive
- * @type {?}
- */
-TView.prototype.contentQueries;
+if (false) {
+    /**
+     * ID for inline views to determine whether a view is the same as the previous view
+     * in a certain position. If it's not, we know the new view needs to be inserted
+     * and the one that exists needs to be removed (e.g. if/else statements)
+     *
+     * If this is -1, then this is a component view or a dynamically created view.
+     * @type {?}
+     */
+    TView.prototype.id;
+    /**
+     * This is a blueprint used to generate LView instances for this TView. Copying this
+     * blueprint is faster than creating a new LView from scratch.
+     * @type {?}
+     */
+    TView.prototype.blueprint;
+    /**
+     * The template function used to refresh the view of dynamically created views
+     * and components. Will be null for inline views.
+     * @type {?}
+     */
+    TView.prototype.template;
+    /**
+     * A function containing query-related instructions.
+     * @type {?}
+     */
+    TView.prototype.viewQuery;
+    /**
+     * Pointer to the `TNode` that represents the root of the view.
+     *
+     * 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.
+     *
+     * If this is a `TElementNode`, this is the view of a root component. It has exactly one
+     * root TNode.
+     *
+     * If this is null, this is the view of a component that is not at root. We do not store
+     * the host TNodes for child component views because they can potentially have several
+     * different host TNodes, depending on where the component is being used. These host
+     * TNodes cannot be shared (due to different indices, etc).
+     * @type {?}
+     */
+    TView.prototype.node;
+    /**
+     * Whether or not this template has been processed.
+     * @type {?}
+     */
+    TView.prototype.firstTemplatePass;
+    /**
+     * Static data equivalent of LView.data[]. Contains TNodes, PipeDefInternal or TI18n.
+     * @type {?}
+     */
+    TView.prototype.data;
+    /**
+     * The binding start index is the index at which the data array
+     * starts to store bindings only. Saving this value ensures that we
+     * will begin reading bindings at the correct point in the array when
+     * we are in update mode.
+     * @type {?}
+     */
+    TView.prototype.bindingStartIndex;
+    /**
+     * 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 `LView`, the length of this
+     * section cannot be calculated at compile-time because directives are matched
+     * at runtime to preserve locality.
+     *
+     * We store this start index so we know where to start checking host bindings
+     * in `setHostBindings`.
+     * @type {?}
+     */
+    TView.prototype.expandoStartIndex;
+    /**
+     * Index of the host node of the first LView or LContainer beneath this LView in
+     * the hierarchy.
+     *
+     * Necessary to store this so views can traverse through their nested views
+     * to remove listeners and call onDestroy callbacks.
+     *
+     * For embedded views, we store the index of an LContainer's host rather than the first
+     * LView to avoid managing splicing when views are added/removed.
+     * @type {?}
+     */
+    TView.prototype.childIndex;
+    /**
+     * A reference to the first child node located in the view.
+     * @type {?}
+     */
+    TView.prototype.firstChild;
+    /**
+     * Set of instructions used to process host bindings efficiently.
+     *
+     * See VIEW_DATA.md for more information.
+     * @type {?}
+     */
+    TView.prototype.expandoInstructions;
+    /**
+     * Full registry of directives and components that may be found in this view.
+     *
+     * It's necessary to keep a copy of the full def list on the TView so it's possible
+     * to render template functions without a host component.
+     * @type {?}
+     */
+    TView.prototype.directiveRegistry;
+    /**
+     * Full registry of pipes that may be found in this view.
+     *
+     * The property is either an array of `PipeDefs`s or a function which returns the array of
+     * `PipeDefs`s. The function is necessary to be able to support forward declarations.
+     *
+     * It's necessary to keep a copy of the full def list on the TView so it's possible
+     * to render template functions without a host component.
+     * @type {?}
+     */
+    TView.prototype.pipeRegistry;
+    /**
+     * Array of ngOnInit and ngDoCheck hooks that should be executed for this view in
+     * creation mode.
+     *
+     * Even indices: Directive index
+     * Odd indices: Hook function
+     * @type {?}
+     */
+    TView.prototype.initHooks;
+    /**
+     * Array of ngDoCheck hooks that should be executed for this view in update mode.
+     *
+     * Even indices: Directive index
+     * Odd indices: Hook function
+     * @type {?}
+     */
+    TView.prototype.checkHooks;
+    /**
+     * Array of ngAfterContentInit and ngAfterContentChecked hooks that should be executed
+     * for this view in creation mode.
+     *
+     * Even indices: Directive index
+     * Odd indices: Hook function
+     * @type {?}
+     */
+    TView.prototype.contentHooks;
+    /**
+     * Array of ngAfterContentChecked hooks that should be executed for this view in update
+     * mode.
+     *
+     * Even indices: Directive index
+     * Odd indices: Hook function
+     * @type {?}
+     */
+    TView.prototype.contentCheckHooks;
+    /**
+     * Array of ngAfterViewInit and ngAfterViewChecked hooks that should be executed for
+     * this view in creation mode.
+     *
+     * Even indices: Directive index
+     * Odd indices: Hook function
+     * @type {?}
+     */
+    TView.prototype.viewHooks;
+    /**
+     * Array of ngAfterViewChecked hooks that should be executed for this view in
+     * update mode.
+     *
+     * Even indices: Directive index
+     * Odd indices: Hook function
+     * @type {?}
+     */
+    TView.prototype.viewCheckHooks;
+    /**
+     * Array of ngOnDestroy hooks that should be executed when this view is destroyed.
+     *
+     * Even indices: Directive index
+     * Odd indices: Hook function
+     * @type {?}
+     */
+    TView.prototype.destroyHooks;
+    /**
+     * Array of pipe ngOnDestroy hooks that should be executed when this view is destroyed.
+     *
+     * Even indices: Index of pipe in data
+     * Odd indices: Hook function
+     *
+     * These must be stored separately from directive destroy hooks because their contexts
+     * are stored in data.
+     * @type {?}
+     */
+    TView.prototype.pipeDestroyHooks;
+    /**
+     * When a view is destroyed, listeners need to be released and outputs need to be
+     * unsubscribed. This cleanup array stores both listener data (in chunks of 4)
+     * and output data (in chunks of 2) for a particular view. Combining the arrays
+     * 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 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`
+     *               `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]])`
+     * @type {?}
+     */
+    TView.prototype.cleanup;
+    /**
+     * A list of element indices for child components that will need to be
+     * refreshed when the current view has finished its check. These indices have
+     * already been adjusted for the HEADER_OFFSET.
+     *
+     * @type {?}
+     */
+    TView.prototype.components;
+    /**
+     * A list of indices for child directives that have content queries.
+     *
+     * Even indices: Directive indices
+     * Odd indices: Starting index of content queries (stored in CONTENT_QUERIES) for this directive
+     * @type {?}
+     */
+    TView.prototype.contentQueries;
+}
 /** @enum {number} */
-var RootContextFlags = {
+const RootContextFlags = {
     Empty: 0, DetectChanges: 1, FlushPlayers: 2,
 };
 export { RootContextFlags };
@@ -344,42 +405,39 @@ export { RootContextFlags };
  * @record
  */
 export function RootContext() { }
-/**
- * A function used for scheduling change detection in the future. Usually
- * this is `requestAnimationFrame`.
- * @type {?}
- */
-RootContext.prototype.scheduler;
-/**
- * A promise which is resolved when all components are considered clean (not dirty).
- *
- * This promise is overwritten every time a first call to {\@link markDirty} is invoked.
- * @type {?}
- */
-RootContext.prototype.clean;
-/**
- * RootComponents - The components that were instantiated by the call to
- * {\@link renderComponent}.
- * @type {?}
- */
-RootContext.prototype.components;
-/**
- * The player flushing handler to kick off all animations
- * @type {?}
- */
-RootContext.prototype.playerHandler;
-/**
- * What render-related operations to run once a scheduler has been set
- * @type {?}
- */
-RootContext.prototype.flags;
-/** @typedef {?} */
-var HookData;
-export { HookData };
-/** @typedef {?} */
-var TData;
-export { TData };
+if (false) {
+    /**
+     * A function used for scheduling change detection in the future. Usually
+     * this is `requestAnimationFrame`.
+     * @type {?}
+     */
+    RootContext.prototype.scheduler;
+    /**
+     * A promise which is resolved when all components are considered clean (not dirty).
+     *
+     * This promise is overwritten every time a first call to {\@link markDirty} is invoked.
+     * @type {?}
+     */
+    RootContext.prototype.clean;
+    /**
+     * RootComponents - The components that were instantiated by the call to
+     * {\@link renderComponent}.
+     * @type {?}
+     */
+    RootContext.prototype.components;
+    /**
+     * The player flushing handler to kick off all animations
+     * @type {?}
+     */
+    RootContext.prototype.playerHandler;
+    /**
+     * What render-related operations to run once a scheduler has been set
+     * @type {?}
+     */
+    RootContext.prototype.flags;
+}
+// Note: This hack is necessary so we don't erroneously get a circular dependency
+// failure based on types.
 /** @type {?} */
 export const unusedValueExportToPlacateAjd = 1;
-
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"view.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/interfaces/view.ts"],"names":[],"mappings":";;;;;;;;;;;;AA0BA,aAAa,KAAK,GAAG,CAAC,CAAC;;AACvB,aAAa,KAAK,GAAG,CAAC,CAAC;;AACvB,aAAa,MAAM,GAAG,CAAC,CAAC;;AACxB,aAAa,IAAI,GAAG,CAAC,CAAC;;AACtB,aAAa,OAAO,GAAG,CAAC,CAAC;;AACzB,aAAa,IAAI,GAAG,CAAC,CAAC;;AACtB,aAAa,SAAS,GAAG,CAAC,CAAC;;AAC3B,aAAa,aAAa,GAAG,CAAC,CAAC;;AAC/B,aAAa,OAAO,GAAG,CAAC,CAAC;;AACzB,aAAa,OAAO,GAAG,CAAC,CAAC;;AACzB,aAAa,QAAQ,GAAG,EAAE,CAAC;;AAC3B,aAAa,gBAAgB,GAAG,EAAE,CAAC;;AACnC,aAAa,QAAQ,GAAG,EAAE,CAAC;;AAC3B,aAAa,SAAS,GAAG,EAAE,CAAC;;AAC5B,aAAa,IAAI,GAAG,EAAE,CAAC;;AACvB,aAAa,eAAe,GAAG,EAAE,CAAC;;AAClC,aAAa,eAAe,GAAG,EAAE,CAAC;;AAClC,aAAa,gBAAgB,GAAG,EAAE,CAAC;;;;AAEnC,aAAa,aAAa,GAAG,EAAE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAkL9B,eAAwB;;IAGxB,cAAuB;;IAGvB,QAAiB;;IAGjB,WAAoB;;;;;;;;IASpB,WAAmB;;IAGnB,aAAqB;;IAGrB,UAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA0OgB,QAAY,EAAE,gBAAoB,EAAE,eAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgE3F,aAAa,6BAA6B,GAAG,CAAC,CAAC","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {InjectionToken} from '../../di/injection_token';\nimport {Injector} from '../../di/injector';\nimport {QueryList} from '../../linker';\nimport {Sanitizer} from '../../sanitization/security';\nimport {Type} from '../../type';\nimport {LContainer} from './container';\nimport {ComponentDef, ComponentQuery, ComponentTemplate, DirectiveDef, DirectiveDefList, HostBindingsFunction, PipeDef, PipeDefList} from './definition';\nimport {I18nUpdateOpCodes, TI18n} from './i18n';\nimport {TElementNode, TNode, TViewNode} from './node';\nimport {PlayerHandler} from './player';\nimport {LQueries} from './query';\nimport {RElement, Renderer3, RendererFactory3} from './renderer';\nimport {StylingContext} from './styling';\n\n\n// Below are constants for LViewData indices to help us look up LViewData members\n// without having to remember the specific indices.\n// Uglify will inline these when minifying so there shouldn't be a cost.\nexport const TVIEW = 0;\nexport const FLAGS = 1;\nexport const PARENT = 2;\nexport const NEXT = 3;\nexport const QUERIES = 4;\nexport const HOST = 5;\nexport const HOST_NODE = 6;  // Rename to `T_HOST`?\nexport const BINDING_INDEX = 7;\nexport const CLEANUP = 8;\nexport const CONTEXT = 9;\nexport const INJECTOR = 10;\nexport const RENDERER_FACTORY = 11;\nexport const RENDERER = 12;\nexport const SANITIZER = 13;\nexport const TAIL = 14;\nexport const CONTAINER_INDEX = 15;\nexport const CONTENT_QUERIES = 16;\nexport const DECLARATION_VIEW = 17;\n/** Size of LViewData's header. Necessary to adjust for it when setting slots.  */\nexport const HEADER_OFFSET = 18;\n\n\n// This interface replaces the real LViewData interface if it is an arg or a\n// return value of a public instruction. This ensures we don't need to expose\n// the actual interface, which should be kept private.\nexport interface OpaqueViewState {\n  '__brand__': 'Brand for OpaqueViewState that nothing will match';\n}\n\n\n/**\n * `LViewData` stores all of the information needed to process the instructions as\n * they are invoked from the template. Each embedded view and component view has its\n * own `LViewData`. When processing a particular view, we set the `viewData` to that\n * `LViewData`. When that view is done processing, the `viewData` is set back to\n * whatever the original `viewData` was before (the parent `LViewData`).\n *\n * Keeping separate state for each view facilities view insertion / deletion, so we\n * don't have to edit the data array based on which views are present.\n */\nexport interface LViewData extends Array<any> {\n  /**\n   * The static data for this view. We need a reference to this so we can easily walk up the\n   * node tree in DI and get the TView.data array associated with a node (where the\n   * directive defs are stored).\n   */\n  readonly[TVIEW]: TView;\n\n  /** Flags for this view. See LViewFlags for more info. */\n  [FLAGS]: LViewFlags;\n\n  /**\n   * The parent view is needed when we exit the view and must restore the previous\n   * `LViewData`. Without this, the render method would have to keep a stack of\n   * views as it is recursively rendering templates.\n   *\n   * This is the \"insertion\" view for embedded views. This allows us to properly\n   * destroy embedded views.\n   */\n  [PARENT]: LViewData|null;\n\n  /**\n   *\n   * The next sibling LViewData or LContainer.\n   *\n   * Allows us to propagate between sibling view states that aren't in the same\n   * container. Embedded views already have a node.next, but it is only set for\n   * views in the same container. We need a way to link component views and views\n   * across containers as well.\n   */\n  [NEXT]: LViewData|LContainer|null;\n\n  /** Queries active for this view - nodes from a view are reported to those queries. */\n  [QUERIES]: LQueries|null;\n\n  /**\n   * The host node for this LViewData instance, if this is a component view.\n   *\n   * If this is an embedded view, HOST will be null.\n   */\n  [HOST]: RElement|StylingContext|null;\n\n  /**\n   * Pointer to the `TViewNode` or `TElementNode` which represents the root of the view.\n   *\n   * If `TViewNode`, this is an embedded view of a container. We need this to be able to\n   * efficiently find the `LViewNode` when inserting the view into an anchor.\n   *\n   * If `TElementNode`, this is the LView of a component.\n   *\n   * If null, this is the root view of an application (root component is in this view).\n   */\n  [HOST_NODE]: TViewNode|TElementNode|null;\n\n  /**\n   * The binding index we should access next.\n   *\n   * This is stored so that bindings can continue where they left off\n   * if a view is left midway through processing bindings (e.g. if there is\n   * a setter that creates an embedded view, like in ngIf).\n   */\n  [BINDING_INDEX]: number;\n\n  /**\n   * When a view is destroyed, listeners need to be released and outputs need to be\n   * unsubscribed. This context array stores both listener functions wrapped with\n   * their context and output subscription instances for a particular view.\n   *\n   * These change per LView instance, so they cannot be stored on TView. Instead,\n   * TView.cleanup saves an index to the necessary context in this array.\n   */\n  // TODO: flatten into LViewData[]\n  [CLEANUP]: any[]|null;\n\n  /**\n   * - For dynamic views, this is the context with which to render the template (e.g.\n   *   `NgForContext`), or `{}` if not defined explicitly.\n   * - For root view of the root component the context contains change detection data.\n   * - For non-root components, the context is the component instance,\n   * - For inline views, the context is null.\n   */\n  [CONTEXT]: {}|RootContext|null;\n\n  /** An optional Module Injector to be used as fall back after Element Injectors are consulted. */\n  readonly[INJECTOR]: Injector|null;\n\n  /** Renderer to be used for this view. */\n  [RENDERER_FACTORY]: RendererFactory3;\n\n  /** Renderer to be used for this view. */\n  [RENDERER]: Renderer3;\n\n  /** An optional custom sanitizer. */\n  [SANITIZER]: Sanitizer|null;\n\n  /**\n   * The last LViewData or LContainer beneath this LViewData in the hierarchy.\n   *\n   * The tail allows us to quickly add a new state to the end of the view list\n   * without having to propagate starting from the first child.\n   */\n  [TAIL]: LViewData|LContainer|null;\n\n  /**\n   * The index of the parent container's host node. Applicable only to embedded views that\n   * have been inserted dynamically. Will be -1 for component views and inline views.\n   *\n   * This is necessary to jump from dynamically created embedded views to their parent\n   * containers because their parent cannot be stored on the TViewNode (views may be inserted\n   * in multiple containers, so the parent cannot be shared between view instances).\n   */\n  [CONTAINER_INDEX]: number;\n\n  /**\n   * Stores QueryLists associated with content queries of a directive. This data structure is\n   * filled-in as part of a directive creation process and is later used to retrieve a QueryList to\n   * be refreshed.\n   */\n  [CONTENT_QUERIES]: QueryList<any>[]|null;\n\n  /**\n   * View where this view's template was declared.\n   *\n   * Only applicable for dynamically created views. Will be null for inline/component views.\n   *\n   * The template for a dynamically created view may be declared in a different view than\n   * it is inserted. We already track the \"insertion view\" (view where the template was\n   * inserted) in LViewData[PARENT], but we also need access to the \"declaration view\"\n   * (view where the template was declared). Otherwise, we wouldn't be able to call the\n   * view's template function with the proper contexts. Context should be inherited from\n   * the declaration view tree, not the insertion view tree.\n   *\n   * Example (AppComponent template):\n   *\n   * <ng-template #foo></ng-template>       <-- declared here -->\n   * <some-comp [tpl]=\"foo\"></some-comp>    <-- inserted inside this component -->\n   *\n   * The <ng-template> above is declared in the AppComponent template, but it will be passed into\n   * SomeComp and inserted there. In this case, the declaration view would be the AppComponent,\n   * but the insertion view would be SomeComp. When we are removing views, we would want to\n   * traverse through the insertion view to clean up listeners. When we are calling the\n   * template function during change detection, we need the declaration view to get inherited\n   * context.\n   */\n  [DECLARATION_VIEW]: LViewData|null;\n}\n\n/** Flags associated with an LView (saved in LViewData[FLAGS]) */\nexport const enum LViewFlags {\n  /**\n   * Whether or not the view is in creationMode.\n   *\n   * This must be stored in the view rather than using `data` as a marker so that\n   * we can properly support embedded views. Otherwise, when exiting a child view\n   * back into the parent view, `data` will be defined and `creationMode` will be\n   * improperly reported as false.\n   */\n  CreationMode = 0b0000001,\n\n  /** Whether this view has default change detection strategy (checks always) or onPush */\n  CheckAlways = 0b0000010,\n\n  /** Whether or not this view is currently dirty (needing check) */\n  Dirty = 0b0000100,\n\n  /** Whether or not this view is currently attached to change detection tree. */\n  Attached = 0b0001000,\n\n  /**\n   *  Whether or not the init hooks have run.\n   *\n   * If on, the init hooks haven't yet been run and should be executed by the first component that\n   * runs OR the first cR() instruction that runs (so inits are run for the top level view before\n   * any embedded views).\n   */\n  RunInit = 0b0010000,\n\n  /** Whether or not this view is destroyed. */\n  Destroyed = 0b0100000,\n\n  /** Whether or not this view is the root view */\n  IsRoot = 0b1000000,\n}\n\n/**\n * The static data for an LView (shared between all templates of a\n * given type).\n *\n * Stored on the template function as ngPrivateData.\n */\nexport interface TView {\n  /**\n   * ID for inline views to determine whether a view is the same as the previous view\n   * in a certain position. If it's not, we know the new view needs to be inserted\n   * and the one that exists needs to be removed (e.g. if/else statements)\n   *\n   * If this is -1, then this is a component view or a dynamically created view.\n   */\n  readonly id: number;\n\n  /**\n   * This is a blueprint used to generate LViewData instances for this TView. Copying this\n   * blueprint is faster than creating a new LViewData from scratch.\n   */\n  blueprint: LViewData;\n\n  /**\n   * The template function used to refresh the view of dynamically created views\n   * and components. Will be null for inline views.\n   */\n  template: ComponentTemplate<{}>|null;\n\n  /**\n   * A function containing query-related instructions.\n   */\n  viewQuery: ComponentQuery<{}>|null;\n\n  /**\n   * Pointer to the `TNode` that represents the root of the view.\n   *\n   * If this is a `TNode` for an `LViewNode`, this is an embedded view of a container.\n   * We need this pointer to be able to efficiently find this node when inserting the view\n   * into an anchor.\n   *\n   * If this is a `TElementNode`, this is the view of a root component. It has exactly one\n   * root TNode.\n   *\n   * If this is null, this is the view of a component that is not at root. We do not store\n   * the host TNodes for child component views because they can potentially have several\n   * different host TNodes, depending on where the component is being used. These host\n   * TNodes cannot be shared (due to different indices, etc).\n   */\n  node: TViewNode|TElementNode|null;\n\n  /** Whether or not this template has been processed. */\n  firstTemplatePass: boolean;\n\n  /** Static data equivalent of LView.data[]. Contains TNodes, PipeDefInternal or TI18n. */\n  data: TData;\n\n  /**\n   * The binding start index is the index at which the data array\n   * starts to store bindings only. Saving this value ensures that we\n   * will begin reading bindings at the correct point in the array when\n   * we are in update mode.\n   */\n  bindingStartIndex: number;\n\n  /**\n   * The index where the \"expando\" section of `LViewData` begins. The expando\n   * section contains injectors, directive instances, and host binding values.\n   * Unlike the \"consts\" and \"vars\" sections of `LViewData`, the length of this\n   * section cannot be calculated at compile-time because directives are matched\n   * at runtime to preserve locality.\n   *\n   * We store this start index so we know where to start checking host bindings\n   * in `setHostBindings`.\n   */\n  expandoStartIndex: number;\n\n  /**\n   * Index of the host node of the first LView or LContainer beneath this LView in\n   * the hierarchy.\n   *\n   * Necessary to store this so views can traverse through their nested views\n   * to remove listeners and call onDestroy callbacks.\n   *\n   * For embedded views, we store the index of an LContainer's host rather than the first\n   * LView to avoid managing splicing when views are added/removed.\n   */\n  childIndex: number;\n\n  /**\n   * A reference to the first child node located in the view.\n   */\n  firstChild: TNode|null;\n\n  /**\n   * Set of instructions used to process host bindings efficiently.\n   *\n   * See VIEW_DATA.md for more information.\n   */\n  expandoInstructions: (number|HostBindingsFunction<any>)[]|null;\n\n  /**\n   * Full registry of directives and components that may be found in this view.\n   *\n   * It's necessary to keep a copy of the full def list on the TView so it's possible\n   * to render template functions without a host component.\n   */\n  directiveRegistry: DirectiveDefList|null;\n\n  /**\n   * Full registry of pipes that may be found in this view.\n   *\n   * The property is either an array of `PipeDefs`s or a function which returns the array of\n   * `PipeDefs`s. The function is necessary to be able to support forward declarations.\n   *\n   * It's necessary to keep a copy of the full def list on the TView so it's possible\n   * to render template functions without a host component.\n   */\n  pipeRegistry: PipeDefList|null;\n\n  /**\n   * Array of ngOnInit and ngDoCheck hooks that should be executed for this view in\n   * creation mode.\n   *\n   * Even indices: Directive index\n   * Odd indices: Hook function\n   */\n  initHooks: HookData|null;\n\n  /**\n   * Array of ngDoCheck hooks that should be executed for this view in update mode.\n   *\n   * Even indices: Directive index\n   * Odd indices: Hook function\n   */\n  checkHooks: HookData|null;\n\n  /**\n   * Array of ngAfterContentInit and ngAfterContentChecked hooks that should be executed\n   * for this view in creation mode.\n   *\n   * Even indices: Directive index\n   * Odd indices: Hook function\n   */\n  contentHooks: HookData|null;\n\n  /**\n   * Array of ngAfterContentChecked hooks that should be executed for this view in update\n   * mode.\n   *\n   * Even indices: Directive index\n   * Odd indices: Hook function\n   */\n  contentCheckHooks: HookData|null;\n\n  /**\n   * Array of ngAfterViewInit and ngAfterViewChecked hooks that should be executed for\n   * this view in creation mode.\n   *\n   * Even indices: Directive index\n   * Odd indices: Hook function\n   */\n  viewHooks: HookData|null;\n\n  /**\n   * Array of ngAfterViewChecked hooks that should be executed for this view in\n   * update mode.\n   *\n   * Even indices: Directive index\n   * Odd indices: Hook function\n   */\n  viewCheckHooks: HookData|null;\n\n  /**\n   * Array of ngOnDestroy hooks that should be executed when this view is destroyed.\n   *\n   * Even indices: Directive index\n   * Odd indices: Hook function\n   */\n  destroyHooks: HookData|null;\n\n  /**\n   * Array of pipe ngOnDestroy hooks that should be executed when this view is destroyed.\n   *\n   * Even indices: Index of pipe in data\n   * Odd indices: Hook function\n   *\n   * These must be stored separately from directive destroy hooks because their contexts\n   * are stored in data.\n   */\n  pipeDestroyHooks: HookData|null;\n\n  /**\n   * When a view is destroyed, listeners need to be released and outputs need to be\n   * unsubscribed. This cleanup array stores both listener data (in chunks of 4)\n   * and output data (in chunks of 2) for a particular view. Combining the arrays\n   * saves on memory (70 bytes per array) and on a few bytes of code size (for two\n   * separate for loops).\n   *\n   * If it's a native DOM listener being stored:\n   * 1st index is: event name to remove\n   * 2nd index is: index of native element in LView.data[]\n   * 3rd index is: index of wrapped listener function in LView.cleanupInstances[]\n   * 4th index is: useCapture boolean\n   *\n   * If it's a renderer2 style listener or ViewRef destroy hook being stored:\n   * 1st index is: index of the cleanup function in LView.cleanupInstances[]\n   * 2nd index is: null\n   *\n   * If it's an output subscription or query list destroy hook:\n   * 1st index is: output unsubscribe function / query list destroy function\n   * 2nd index is: index of function context in LView.cleanupInstances[]\n   */\n  cleanup: any[]|null;\n\n  /**\n   * A list of element indices for child components that will need to be\n   * refreshed when the current view has finished its check. These indices have\n   * already been adjusted for the HEADER_OFFSET.\n   *\n   */\n  components: number[]|null;\n\n  /**\n   * A list of indices for child directives that have content queries.\n   *\n   * Even indices: Directive indices\n   * Odd indices: Starting index of content queries (stored in CONTENT_QUERIES) for this directive\n   */\n  contentQueries: number[]|null;\n}\n\nexport const enum RootContextFlags {Empty = 0b00, DetectChanges = 0b01, FlushPlayers = 0b10}\n\n\n/**\n * RootContext contains information which is shared for all components which\n * were bootstrapped with {@link renderComponent}.\n */\nexport interface RootContext {\n  /**\n   * A function used for scheduling change detection in the future. Usually\n   * this is `requestAnimationFrame`.\n   */\n  scheduler: (workFn: () => void) => void;\n\n  /**\n   * A promise which is resolved when all components are considered clean (not dirty).\n   *\n   * This promise is overwritten every time a first call to {@link markDirty} is invoked.\n   */\n  clean: Promise<null>;\n\n  /**\n   * RootComponents - The components that were instantiated by the call to\n   * {@link renderComponent}.\n   */\n  components: {}[];\n\n  /**\n   * The player flushing handler to kick off all animations\n   */\n  playerHandler: PlayerHandler|null;\n\n  /**\n   * What render-related operations to run once a scheduler has been set\n   */\n  flags: RootContextFlags;\n}\n\n/**\n * Array of hooks that should be executed for a view and their directive indices.\n *\n * Even indices: Directive index\n * Odd indices: Hook function\n */\nexport type HookData = (number | (() => void))[];\n\n/**\n * Static data that corresponds to the instance-specific data array on an LView.\n *\n * Each node's static data is stored in tData at the same index that it's stored\n * in the data array.  Any nodes that do not have static data store a null value in\n * tData to avoid a sparse array.\n *\n * Each pipe's definition is stored here at the same index as its pipe instance in\n * the data array.\n *\n * Injector bloom filters are also stored here.\n */\nexport type TData =\n    (TNode | PipeDef<any>| DirectiveDef<any>| ComponentDef<any>| number | Type<any>|\n     InjectionToken<any>| TI18n | I18nUpdateOpCodes | null)[];\n\n// Note: This hack is necessary so we don't erroneously get a circular dependency\n// failure based on types.\nexport const unusedValueExportToPlacateAjd = 1;\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"view.js","sourceRoot":"../../","sources":["packages/core/src/render3/interfaces/view.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AA0BA,MAAM,OAAO,KAAK,GAAG,CAAC;;AACtB,MAAM,OAAO,KAAK,GAAG,CAAC;;AACtB,MAAM,OAAO,MAAM,GAAG,CAAC;;AACvB,MAAM,OAAO,IAAI,GAAG,CAAC;;AACrB,MAAM,OAAO,OAAO,GAAG,CAAC;;AACxB,MAAM,OAAO,IAAI,GAAG,CAAC;;AACrB,MAAM,OAAO,SAAS,GAAG,CAAC;;;AAC1B,MAAM,OAAO,aAAa,GAAG,CAAC;;AAC9B,MAAM,OAAO,OAAO,GAAG,CAAC;;AACxB,MAAM,OAAO,OAAO,GAAG,CAAC;;AACxB,MAAM,OAAO,QAAQ,GAAG,EAAE;;AAC1B,MAAM,OAAO,gBAAgB,GAAG,EAAE;;AAClC,MAAM,OAAO,QAAQ,GAAG,EAAE;;AAC1B,MAAM,OAAO,SAAS,GAAG,EAAE;;AAC3B,MAAM,OAAO,IAAI,GAAG,EAAE;;AACtB,MAAM,OAAO,eAAe,GAAG,EAAE;;AACjC,MAAM,OAAO,eAAe,GAAG,EAAE;;AACjC,MAAM,OAAO,gBAAgB,GAAG,EAAE;;;;;AAElC,MAAM,OAAO,aAAa,GAAG,EAAE;;;;AAM/B,qCAEC;;;IADC,oCAAiE;;;;;;;;;;;;;AAcnE,2BAiJC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAIC;;;;;;;OAOG;IACH,eAA0B;IAE1B;;;;;;OAMG;IACH,iBAA4B;IAE5B,wFAAwF;IACxF,cAAyB;IAEzB,kEAAkE;IAClE,QAAmB;IAEnB,+EAA+E;IAC/E,YAAsB;IAEtB;;;;;;OAMG;IACH,WAAqB;IAErB,6CAA6C;IAC7C,aAAuB;IAEvB,gDAAgD;IAChD,WAAoB;;;;;;;;;;AAStB,2BAqOC;;;;;;;;;;IA7NC,mBAAoB;;;;;;IAMpB,0BAAiB;;;;;;IAMjB,yBAAqC;;;;;IAKrC,0BAAmC;;;;;;;;;;;;;;;;;IAiBnC,qBAAkC;;;;;IAGlC,kCAA2B;;;;;IAG3B,qBAAY;;;;;;;;IAQZ,kCAA0B;;;;;;;;;;;;IAY1B,kCAA0B;;;;;;;;;;;;IAY1B,2BAAmB;;;;;IAKnB,2BAAuB;;;;;;;IAOvB,oCAAoE;;;;;;;;IAQpE,kCAAyC;;;;;;;;;;;IAWzC,6BAA+B;;;;;;;;;IAS/B,0BAAyB;;;;;;;;IAQzB,2BAA0B;;;;;;;;;IAS1B,6BAA4B;;;;;;;;;IAS5B,kCAAiC;;;;;;;;;IASjC,0BAAyB;;;;;;;;;IASzB,+BAA8B;;;;;;;;IAQ9B,6BAA4B;;;;;;;;;;;IAW5B,iCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA6BhC,wBAAoB;;;;;;;;IAQpB,2BAA0B;;;;;;;;IAQ1B,+BAA8B;;;;IAGI,QAAY,EAAE,gBAAoB,EAAE,eAAmB;;;;;;;;AAO3F,iCA6BC;;;;;;;IAxBC,gCAAwC;;;;;;;IAOxC,4BAAqB;;;;;;IAMrB,iCAAiB;;;;;IAKjB,oCAAkC;;;;;IAKlC,4BAAwB;;;;;AA6B1B,MAAM,OAAO,6BAA6B,GAAG,CAAC","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {InjectionToken} from '../../di/injection_token';\nimport {Injector} from '../../di/injector';\nimport {QueryList} from '../../linker';\nimport {Sanitizer} from '../../sanitization/security';\nimport {Type} from '../../type';\nimport {LContainer} from './container';\nimport {ComponentDef, ComponentQuery, ComponentTemplate, DirectiveDef, DirectiveDefList, HostBindingsFunction, PipeDef, PipeDefList} from './definition';\nimport {I18nUpdateOpCodes, TI18n} from './i18n';\nimport {TElementNode, TNode, TViewNode} from './node';\nimport {PlayerHandler} from './player';\nimport {LQueries} from './query';\nimport {RElement, Renderer3, RendererFactory3} from './renderer';\nimport {StylingContext} from './styling';\n\n\n// Below are constants for LView indices to help us look up LView members\n// without having to remember the specific indices.\n// Uglify will inline these when minifying so there shouldn't be a cost.\nexport const TVIEW = 0;\nexport const FLAGS = 1;\nexport const PARENT = 2;\nexport const NEXT = 3;\nexport const QUERIES = 4;\nexport const HOST = 5;\nexport const HOST_NODE = 6;  // Rename to `T_HOST`?\nexport const BINDING_INDEX = 7;\nexport const CLEANUP = 8;\nexport const CONTEXT = 9;\nexport const INJECTOR = 10;\nexport const RENDERER_FACTORY = 11;\nexport const RENDERER = 12;\nexport const SANITIZER = 13;\nexport const TAIL = 14;\nexport const CONTAINER_INDEX = 15;\nexport const CONTENT_QUERIES = 16;\nexport const DECLARATION_VIEW = 17;\n/** Size of LView's header. Necessary to adjust for it when setting slots.  */\nexport const HEADER_OFFSET = 18;\n\n\n// This interface replaces the real LView interface if it is an arg or a\n// return value of a public instruction. This ensures we don't need to expose\n// the actual interface, which should be kept private.\nexport interface OpaqueViewState {\n  '__brand__': 'Brand for OpaqueViewState that nothing will match';\n}\n\n\n/**\n * `LView` stores all of the information needed to process the instructions as\n * they are invoked from the template. Each embedded view and component view has its\n * own `LView`. When processing a particular view, we set the `viewData` to that\n * `LView`. When that view is done processing, the `viewData` is set back to\n * whatever the original `viewData` was before (the parent `LView`).\n *\n * Keeping separate state for each view facilities view insertion / deletion, so we\n * don't have to edit the data array based on which views are present.\n */\nexport interface LView extends Array<any> {\n  /**\n   * The static data for this view. We need a reference to this so we can easily walk up the\n   * node tree in DI and get the TView.data array associated with a node (where the\n   * directive defs are stored).\n   */\n  readonly[TVIEW]: TView;\n\n  /** Flags for this view. See LViewFlags for more info. */\n  [FLAGS]: LViewFlags;\n\n  /**\n   * The parent view is needed when we exit the view and must restore the previous\n   * `LView`. Without this, the render method would have to keep a stack of\n   * views as it is recursively rendering templates.\n   *\n   * This is the \"insertion\" view for embedded views. This allows us to properly\n   * destroy embedded views.\n   */\n  [PARENT]: LView|null;\n\n  /**\n   *\n   * The next sibling LView or LContainer.\n   *\n   * Allows us to propagate between sibling view states that aren't in the same\n   * container. Embedded views already have a node.next, but it is only set for\n   * views in the same container. We need a way to link component views and views\n   * across containers as well.\n   */\n  [NEXT]: LView|LContainer|null;\n\n  /** Queries active for this view - nodes from a view are reported to those queries. */\n  [QUERIES]: LQueries|null;\n\n  /**\n   * The host node for this LView instance, if this is a component view.\n   *\n   * If this is an embedded view, HOST will be null.\n   */\n  [HOST]: RElement|StylingContext|null;\n\n  /**\n   * Pointer to the `TViewNode` or `TElementNode` which represents the root of the view.\n   *\n   * If `TViewNode`, this is an embedded view of a container. We need this to be able to\n   * efficiently find the `LViewNode` when inserting the view into an anchor.\n   *\n   * If `TElementNode`, this is the LView of a component.\n   *\n   * If null, this is the root view of an application (root component is in this view).\n   */\n  [HOST_NODE]: TViewNode|TElementNode|null;\n\n  /**\n   * The binding index we should access next.\n   *\n   * This is stored so that bindings can continue where they left off\n   * if a view is left midway through processing bindings (e.g. if there is\n   * a setter that creates an embedded view, like in ngIf).\n   */\n  [BINDING_INDEX]: number;\n\n  /**\n   * When a view is destroyed, listeners need to be released and outputs need to be\n   * unsubscribed. This context array stores both listener functions wrapped with\n   * their context and output subscription instances for a particular view.\n   *\n   * These change per LView instance, so they cannot be stored on TView. Instead,\n   * TView.cleanup saves an index to the necessary context in this array.\n   */\n  // TODO: flatten into LView[]\n  [CLEANUP]: any[]|null;\n\n  /**\n   * - For dynamic views, this is the context with which to render the template (e.g.\n   *   `NgForContext`), or `{}` if not defined explicitly.\n   * - For root view of the root component the context contains change detection data.\n   * - For non-root components, the context is the component instance,\n   * - For inline views, the context is null.\n   */\n  [CONTEXT]: {}|RootContext|null;\n\n  /** An optional Module Injector to be used as fall back after Element Injectors are consulted. */\n  readonly[INJECTOR]: Injector|null;\n\n  /** Renderer to be used for this view. */\n  [RENDERER_FACTORY]: RendererFactory3;\n\n  /** Renderer to be used for this view. */\n  [RENDERER]: Renderer3;\n\n  /** An optional custom sanitizer. */\n  [SANITIZER]: Sanitizer|null;\n\n  /**\n   * The last LView or LContainer beneath this LView in the hierarchy.\n   *\n   * The tail allows us to quickly add a new state to the end of the view list\n   * without having to propagate starting from the first child.\n   */\n  [TAIL]: LView|LContainer|null;\n\n  /**\n   * The index of the parent container's host node. Applicable only to embedded views that\n   * have been inserted dynamically. Will be -1 for component views and inline views.\n   *\n   * This is necessary to jump from dynamically created embedded views to their parent\n   * containers because their parent cannot be stored on the TViewNode (views may be inserted\n   * in multiple containers, so the parent cannot be shared between view instances).\n   */\n  [CONTAINER_INDEX]: number;\n\n  /**\n   * Stores QueryLists associated with content queries of a directive. This data structure is\n   * filled-in as part of a directive creation process and is later used to retrieve a QueryList to\n   * be refreshed.\n   */\n  [CONTENT_QUERIES]: QueryList<any>[]|null;\n\n  /**\n   * View where this view's template was declared.\n   *\n   * Only applicable for dynamically created views. Will be null for inline/component views.\n   *\n   * The template for a dynamically created view may be declared in a different view than\n   * it is inserted. We already track the \"insertion view\" (view where the template was\n   * inserted) in LView[PARENT], but we also need access to the \"declaration view\"\n   * (view where the template was declared). Otherwise, we wouldn't be able to call the\n   * view's template function with the proper contexts. Context should be inherited from\n   * the declaration view tree, not the insertion view tree.\n   *\n   * Example (AppComponent template):\n   *\n   * <ng-template #foo></ng-template>       <-- declared here -->\n   * <some-comp [tpl]=\"foo\"></some-comp>    <-- inserted inside this component -->\n   *\n   * The <ng-template> above is declared in the AppComponent template, but it will be passed into\n   * SomeComp and inserted there. In this case, the declaration view would be the AppComponent,\n   * but the insertion view would be SomeComp. When we are removing views, we would want to\n   * traverse through the insertion view to clean up listeners. When we are calling the\n   * template function during change detection, we need the declaration view to get inherited\n   * context.\n   */\n  [DECLARATION_VIEW]: LView|null;\n}\n\n/** Flags associated with an LView (saved in LView[FLAGS]) */\nexport const enum LViewFlags {\n  /**\n   * Whether or not the view is in creationMode.\n   *\n   * This must be stored in the view rather than using `data` as a marker so that\n   * we can properly support embedded views. Otherwise, when exiting a child view\n   * back into the parent view, `data` will be defined and `creationMode` will be\n   * improperly reported as false.\n   */\n  CreationMode = 0b000000001,\n\n  /**\n   * Whether or not this LView instance is on its first processing pass.\n   *\n   * An LView instance is considered to be on its \"first pass\" until it\n   * has completed one creation mode run and one update mode run. At this\n   * time, the flag is turned off.\n   */\n  FirstLViewPass = 0b000000010,\n\n  /** Whether this view has default change detection strategy (checks always) or onPush */\n  CheckAlways = 0b000000100,\n\n  /** Whether or not this view is currently dirty (needing check) */\n  Dirty = 0b000001000,\n\n  /** Whether or not this view is currently attached to change detection tree. */\n  Attached = 0b000010000,\n\n  /**\n   *  Whether or not the init hooks have run.\n   *\n   * If on, the init hooks haven't yet been run and should be executed by the first component that\n   * runs OR the first cR() instruction that runs (so inits are run for the top level view before\n   * any embedded views).\n   */\n  RunInit = 0b000100000,\n\n  /** Whether or not this view is destroyed. */\n  Destroyed = 0b001000000,\n\n  /** Whether or not this view is the root view */\n  IsRoot = 0b010000000,\n}\n\n/**\n * The static data for an LView (shared between all templates of a\n * given type).\n *\n * Stored on the template function as ngPrivateData.\n */\nexport interface TView {\n  /**\n   * ID for inline views to determine whether a view is the same as the previous view\n   * in a certain position. If it's not, we know the new view needs to be inserted\n   * and the one that exists needs to be removed (e.g. if/else statements)\n   *\n   * If this is -1, then this is a component view or a dynamically created view.\n   */\n  readonly id: number;\n\n  /**\n   * This is a blueprint used to generate LView instances for this TView. Copying this\n   * blueprint is faster than creating a new LView from scratch.\n   */\n  blueprint: LView;\n\n  /**\n   * The template function used to refresh the view of dynamically created views\n   * and components. Will be null for inline views.\n   */\n  template: ComponentTemplate<{}>|null;\n\n  /**\n   * A function containing query-related instructions.\n   */\n  viewQuery: ComponentQuery<{}>|null;\n\n  /**\n   * Pointer to the `TNode` that represents the root of the view.\n   *\n   * If this is a `TViewNode` for an `LViewNode`, this is an embedded view of a container.\n   * We need this pointer to be able to efficiently find this node when inserting the view\n   * into an anchor.\n   *\n   * If this is a `TElementNode`, this is the view of a root component. It has exactly one\n   * root TNode.\n   *\n   * If this is null, this is the view of a component that is not at root. We do not store\n   * the host TNodes for child component views because they can potentially have several\n   * different host TNodes, depending on where the component is being used. These host\n   * TNodes cannot be shared (due to different indices, etc).\n   */\n  node: TViewNode|TElementNode|null;\n\n  /** Whether or not this template has been processed. */\n  firstTemplatePass: boolean;\n\n  /** Static data equivalent of LView.data[]. Contains TNodes, PipeDefInternal or TI18n. */\n  data: TData;\n\n  /**\n   * The binding start index is the index at which the data array\n   * starts to store bindings only. Saving this value ensures that we\n   * will begin reading bindings at the correct point in the array when\n   * we are in update mode.\n   */\n  bindingStartIndex: number;\n\n  /**\n   * The index where the \"expando\" section of `LView` begins. The expando\n   * section contains injectors, directive instances, and host binding values.\n   * Unlike the \"consts\" and \"vars\" sections of `LView`, the length of this\n   * section cannot be calculated at compile-time because directives are matched\n   * at runtime to preserve locality.\n   *\n   * We store this start index so we know where to start checking host bindings\n   * in `setHostBindings`.\n   */\n  expandoStartIndex: number;\n\n  /**\n   * Index of the host node of the first LView or LContainer beneath this LView in\n   * the hierarchy.\n   *\n   * Necessary to store this so views can traverse through their nested views\n   * to remove listeners and call onDestroy callbacks.\n   *\n   * For embedded views, we store the index of an LContainer's host rather than the first\n   * LView to avoid managing splicing when views are added/removed.\n   */\n  childIndex: number;\n\n  /**\n   * A reference to the first child node located in the view.\n   */\n  firstChild: TNode|null;\n\n  /**\n   * Set of instructions used to process host bindings efficiently.\n   *\n   * See VIEW_DATA.md for more information.\n   */\n  expandoInstructions: (number|HostBindingsFunction<any>|null)[]|null;\n\n  /**\n   * Full registry of directives and components that may be found in this view.\n   *\n   * It's necessary to keep a copy of the full def list on the TView so it's possible\n   * to render template functions without a host component.\n   */\n  directiveRegistry: DirectiveDefList|null;\n\n  /**\n   * Full registry of pipes that may be found in this view.\n   *\n   * The property is either an array of `PipeDefs`s or a function which returns the array of\n   * `PipeDefs`s. The function is necessary to be able to support forward declarations.\n   *\n   * It's necessary to keep a copy of the full def list on the TView so it's possible\n   * to render template functions without a host component.\n   */\n  pipeRegistry: PipeDefList|null;\n\n  /**\n   * Array of ngOnInit and ngDoCheck hooks that should be executed for this view in\n   * creation mode.\n   *\n   * Even indices: Directive index\n   * Odd indices: Hook function\n   */\n  initHooks: HookData|null;\n\n  /**\n   * Array of ngDoCheck hooks that should be executed for this view in update mode.\n   *\n   * Even indices: Directive index\n   * Odd indices: Hook function\n   */\n  checkHooks: HookData|null;\n\n  /**\n   * Array of ngAfterContentInit and ngAfterContentChecked hooks that should be executed\n   * for this view in creation mode.\n   *\n   * Even indices: Directive index\n   * Odd indices: Hook function\n   */\n  contentHooks: HookData|null;\n\n  /**\n   * Array of ngAfterContentChecked hooks that should be executed for this view in update\n   * mode.\n   *\n   * Even indices: Directive index\n   * Odd indices: Hook function\n   */\n  contentCheckHooks: HookData|null;\n\n  /**\n   * Array of ngAfterViewInit and ngAfterViewChecked hooks that should be executed for\n   * this view in creation mode.\n   *\n   * Even indices: Directive index\n   * Odd indices: Hook function\n   */\n  viewHooks: HookData|null;\n\n  /**\n   * Array of ngAfterViewChecked hooks that should be executed for this view in\n   * update mode.\n   *\n   * Even indices: Directive index\n   * Odd indices: Hook function\n   */\n  viewCheckHooks: HookData|null;\n\n  /**\n   * Array of ngOnDestroy hooks that should be executed when this view is destroyed.\n   *\n   * Even indices: Directive index\n   * Odd indices: Hook function\n   */\n  destroyHooks: HookData|null;\n\n  /**\n   * Array of pipe ngOnDestroy hooks that should be executed when this view is destroyed.\n   *\n   * Even indices: Index of pipe in data\n   * Odd indices: Hook function\n   *\n   * These must be stored separately from directive destroy hooks because their contexts\n   * are stored in data.\n   */\n  pipeDestroyHooks: HookData|null;\n\n  /**\n   * When a view is destroyed, listeners need to be released and outputs need to be\n   * unsubscribed. This cleanup array stores both listener data (in chunks of 4)\n   * and output data (in chunks of 2) for a particular view. Combining the arrays\n   * saves on memory (70 bytes per array) and on a few bytes of code size (for two\n   * separate for loops).\n   *\n   * If it's a native DOM listener or output subscription being stored:\n   * 1st index is: event name  `name = tView.cleanup[i+0]`\n   * 2nd index is: index of native element `element = lView[tView.cleanup[i+1]]`\n   * 3rd index is: index of listener function `listener = lView[CLEANUP][tView.cleanup[i+2]]`\n   * 4th index is: `useCaptureOrIndx = tView.cleanup[i+3]`\n   *    `typeof useCaptureOrIndx == 'boolean' : useCapture boolean\n   *    `typeof useCaptureOrIndx == 'number':\n   *         `useCaptureOrIndx >= 0` `removeListener = LView[CLEANUP][useCaptureOrIndx]`\n   *         `useCaptureOrIndx <  0` `subscription = LView[CLEANUP][-useCaptureOrIndx]`\n   *\n   * If it's a renderer2 style listener or ViewRef destroy hook being stored:\n   * 1st index is: index of the cleanup function in LView.cleanupInstances[]\n   * 2nd index is: `null`\n   *               `lView[CLEANUP][tView.cleanup[i+0]]()`\n   *\n   * If it's an output subscription or query list destroy hook:\n   * 1st index is: output unsubscribe function / query list destroy function\n   * 2nd index is: index of function context in LView.cleanupInstances[]\n   *               `tView.cleanup[i+0].call(lView[CLEANUP][tView.cleanup[i+1]])`\n   */\n  cleanup: any[]|null;\n\n  /**\n   * A list of element indices for child components that will need to be\n   * refreshed when the current view has finished its check. These indices have\n   * already been adjusted for the HEADER_OFFSET.\n   *\n   */\n  components: number[]|null;\n\n  /**\n   * A list of indices for child directives that have content queries.\n   *\n   * Even indices: Directive indices\n   * Odd indices: Starting index of content queries (stored in CONTENT_QUERIES) for this directive\n   */\n  contentQueries: number[]|null;\n}\n\nexport const enum RootContextFlags {Empty = 0b00, DetectChanges = 0b01, FlushPlayers = 0b10}\n\n\n/**\n * RootContext contains information which is shared for all components which\n * were bootstrapped with {@link renderComponent}.\n */\nexport interface RootContext {\n  /**\n   * A function used for scheduling change detection in the future. Usually\n   * this is `requestAnimationFrame`.\n   */\n  scheduler: (workFn: () => void) => void;\n\n  /**\n   * A promise which is resolved when all components are considered clean (not dirty).\n   *\n   * This promise is overwritten every time a first call to {@link markDirty} is invoked.\n   */\n  clean: Promise<null>;\n\n  /**\n   * RootComponents - The components that were instantiated by the call to\n   * {@link renderComponent}.\n   */\n  components: {}[];\n\n  /**\n   * The player flushing handler to kick off all animations\n   */\n  playerHandler: PlayerHandler|null;\n\n  /**\n   * What render-related operations to run once a scheduler has been set\n   */\n  flags: RootContextFlags;\n}\n\n/**\n * Array of hooks that should be executed for a view and their directive indices.\n *\n * Even indices: Directive index\n * Odd indices: Hook function\n */\nexport type HookData = (number | (() => void))[];\n\n/**\n * Static data that corresponds to the instance-specific data array on an LView.\n *\n * Each node's static data is stored in tData at the same index that it's stored\n * in the data array.  Any nodes that do not have static data store a null value in\n * tData to avoid a sparse array.\n *\n * Each pipe's definition is stored here at the same index as its pipe instance in\n * the data array.\n *\n * Injector bloom filters are also stored here.\n */\nexport type TData =\n    (TNode | PipeDef<any>| DirectiveDef<any>| ComponentDef<any>| number | Type<any>|\n     InjectionToken<any>| TI18n | I18nUpdateOpCodes | null)[];\n\n// Note: This hack is necessary so we don't erroneously get a circular dependency\n// failure based on types.\nexport const unusedValueExportToPlacateAjd = 1;\n"]}