@angular/core
Version:
Angular - the core framework
249 lines • 32.8 kB
JavaScript
/**
* @fileoverview added by tsickle
* Generated from: packages/core/src/render3/hooks.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @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 { assertEqual, assertNotEqual } from '../util/assert';
import { assertFirstCreatePass } from './assert';
import { FLAGS, PREORDER_HOOK_FLAGS } from './interfaces/view';
import { getCheckNoChangesMode } from './state';
/**
* Adds all directive lifecycle hooks from the given `DirectiveDef` to the given `TView`.
*
* Must be run *only* on the first template pass.
*
* Sets up the pre-order hooks on the provided `tView`,
* see {\@link HookData} for details about the data structure.
*
* @param {?} directiveIndex The index of the directive in LView
* @param {?} directiveDef The definition containing the hooks to setup in tView
* @param {?} tView The current TView
* @return {?}
*/
export function registerPreOrderHooks(directiveIndex, directiveDef, tView) {
ngDevMode && assertFirstCreatePass(tView);
const { onChanges, onInit, doCheck } = directiveDef;
if (onChanges) {
(tView.preOrderHooks || (tView.preOrderHooks = [])).push(directiveIndex, onChanges);
(tView.preOrderCheckHooks || (tView.preOrderCheckHooks = [])).push(directiveIndex, onChanges);
}
if (onInit) {
(tView.preOrderHooks || (tView.preOrderHooks = [])).push(-directiveIndex, onInit);
}
if (doCheck) {
(tView.preOrderHooks || (tView.preOrderHooks = [])).push(directiveIndex, doCheck);
(tView.preOrderCheckHooks || (tView.preOrderCheckHooks = [])).push(directiveIndex, doCheck);
}
}
/**
*
* Loops through the directives on the provided `tNode` and queues hooks to be
* run that are not initialization hooks.
*
* Should be executed during `elementEnd()` and similar to
* preserve hook execution order. Content, view, and destroy hooks for projected
* components and directives must be called *before* their hosts.
*
* Sets up the content, view, and destroy hooks on the provided `tView`,
* see {\@link HookData} for details about the data structure.
*
* NOTE: This does not set up `onChanges`, `onInit` or `doCheck`, those are set up
* separately at `elementStart`.
*
* @param {?} tView The current TView
* @param {?} tNode The TNode whose directives are to be searched for hooks to queue
* @return {?}
*/
export function registerPostOrderHooks(tView, tNode) {
ngDevMode && assertFirstCreatePass(tView);
// It's necessary to loop through the directives at elementEnd() (rather than processing in
// directiveCreate) so we can preserve the current hook order. Content, view, and destroy
// hooks for projected components and directives must be called *before* their hosts.
for (let i = tNode.directiveStart, end = tNode.directiveEnd; i < end; i++) {
/** @type {?} */
const directiveDef = (/** @type {?} */ (tView.data[i]));
if (directiveDef.afterContentInit) {
(tView.contentHooks || (tView.contentHooks = [])).push(-i, directiveDef.afterContentInit);
}
if (directiveDef.afterContentChecked) {
(tView.contentHooks || (tView.contentHooks = [])).push(i, directiveDef.afterContentChecked);
(tView.contentCheckHooks || (tView.contentCheckHooks = []))
.push(i, directiveDef.afterContentChecked);
}
if (directiveDef.afterViewInit) {
(tView.viewHooks || (tView.viewHooks = [])).push(-i, directiveDef.afterViewInit);
}
if (directiveDef.afterViewChecked) {
(tView.viewHooks || (tView.viewHooks = [])).push(i, directiveDef.afterViewChecked);
(tView.viewCheckHooks || (tView.viewCheckHooks = [])).push(i, directiveDef.afterViewChecked);
}
if (directiveDef.onDestroy != null) {
(tView.destroyHooks || (tView.destroyHooks = [])).push(i, directiveDef.onDestroy);
}
}
}
/**
* Executing hooks requires complex logic as we need to deal with 2 constraints.
*
* 1. Init hooks (ngOnInit, ngAfterContentInit, ngAfterViewInit) must all be executed once and only
* once, across many change detection cycles. This must be true even if some hooks throw, or if
* some recursively trigger a change detection cycle.
* To solve that, it is required to track the state of the execution of these init hooks.
* This is done by storing and maintaining flags in the view: the {@link InitPhaseState},
* and the index within that phase. They can be seen as a cursor in the following structure:
* [[onInit1, onInit2], [afterContentInit1], [afterViewInit1, afterViewInit2, afterViewInit3]]
* They are are stored as flags in LView[FLAGS].
*
* 2. Pre-order hooks can be executed in batches, because of the select instruction.
* To be able to pause and resume their execution, we also need some state about the hook's array
* that is being processed:
* - the index of the next hook to be executed
* - the number of init hooks already found in the processed part of the array
* They are are stored as flags in LView[PREORDER_HOOK_FLAGS].
*/
/**
* Executes pre-order check hooks ( OnChanges, DoChanges) given a view where all the init hooks were
* executed once. This is a light version of executeInitAndCheckPreOrderHooks where we can skip read
* / write of the init-hooks related flags.
* @param {?} lView The LView where hooks are defined
* @param {?} hooks Hooks to be run
* @param {?=} nodeIndex 3 cases depending on the value:
* - undefined: all hooks from the array should be executed (post-order case)
* - null: execute hooks only from the saved index until the end of the array (pre-order case, when
* flushing the remaining hooks)
* - number: execute hooks only from the saved index until that node index exclusive (pre-order
* case, when executing select(number))
* @return {?}
*/
export function executeCheckHooks(lView, hooks, nodeIndex) {
callHooks(lView, hooks, 3 /* InitPhaseCompleted */, nodeIndex);
}
/**
* Executes post-order init and check hooks (one of AfterContentInit, AfterContentChecked,
* AfterViewInit, AfterViewChecked) given a view where there are pending init hooks to be executed.
* @param {?} lView The LView where hooks are defined
* @param {?} hooks Hooks to be run
* @param {?} initPhase A phase for which hooks should be run
* @param {?=} nodeIndex 3 cases depending on the value:
* - undefined: all hooks from the array should be executed (post-order case)
* - null: execute hooks only from the saved index until the end of the array (pre-order case, when
* flushing the remaining hooks)
* - number: execute hooks only from the saved index until that node index exclusive (pre-order
* case, when executing select(number))
* @return {?}
*/
export function executeInitAndCheckHooks(lView, hooks, initPhase, nodeIndex) {
ngDevMode &&
assertNotEqual(initPhase, 3 /* InitPhaseCompleted */, 'Init pre-order hooks should not be called more than once');
if ((lView[FLAGS] & 3 /* InitPhaseStateMask */) === initPhase) {
callHooks(lView, hooks, initPhase, nodeIndex);
}
}
/**
* @param {?} lView
* @param {?} initPhase
* @return {?}
*/
export function incrementInitPhaseFlags(lView, initPhase) {
ngDevMode &&
assertNotEqual(initPhase, 3 /* InitPhaseCompleted */, 'Init hooks phase should not be incremented after all init hooks have been run.');
/** @type {?} */
let flags = lView[FLAGS];
if ((flags & 3 /* InitPhaseStateMask */) === initPhase) {
flags &= 2047 /* IndexWithinInitPhaseReset */;
flags += 1 /* InitPhaseStateIncrementer */;
lView[FLAGS] = flags;
}
}
/**
* Calls lifecycle hooks with their contexts, skipping init hooks if it's not
* the first LView pass
*
* @param {?} currentView The current view
* @param {?} arr The array in which the hooks are found
* @param {?} initPhase
* @param {?} currentNodeIndex 3 cases depending on the value:
* - undefined: all hooks from the array should be executed (post-order case)
* - null: execute hooks only from the saved index until the end of the array (pre-order case, when
* flushing the remaining hooks)
* - number: execute hooks only from the saved index until that node index exclusive (pre-order
* case, when executing select(number))
* @return {?}
*/
function callHooks(currentView, arr, initPhase, currentNodeIndex) {
ngDevMode &&
assertEqual(getCheckNoChangesMode(), false, 'Hooks should never be run in the check no changes mode.');
/** @type {?} */
const startIndex = currentNodeIndex !== undefined ?
(currentView[PREORDER_HOOK_FLAGS] & 65535 /* IndexOfTheNextPreOrderHookMaskMask */) :
0;
/** @type {?} */
const nodeIndexLimit = currentNodeIndex != null ? currentNodeIndex : -1;
/** @type {?} */
let lastNodeIndexFound = 0;
for (let i = startIndex; i < arr.length; i++) {
/** @type {?} */
const hook = (/** @type {?} */ (arr[i + 1]));
if (typeof hook === 'number') {
lastNodeIndexFound = (/** @type {?} */ (arr[i]));
if (currentNodeIndex != null && lastNodeIndexFound >= currentNodeIndex) {
break;
}
}
else {
/** @type {?} */
const isInitHook = arr[i] < 0;
if (isInitHook)
currentView[PREORDER_HOOK_FLAGS] += 65536 /* NumberOfInitHooksCalledIncrementer */;
if (lastNodeIndexFound < nodeIndexLimit || nodeIndexLimit == -1) {
callHook(currentView, initPhase, arr, i);
currentView[PREORDER_HOOK_FLAGS] =
(currentView[PREORDER_HOOK_FLAGS] & 4294901760 /* NumberOfInitHooksCalledMask */) + i +
2;
}
i++;
}
}
}
/**
* Execute one hook against the current `LView`.
*
* @param {?} currentView The current view
* @param {?} initPhase
* @param {?} arr The array in which the hooks are found
* @param {?} i The current index within the hook data array
* @return {?}
*/
function callHook(currentView, initPhase, arr, i) {
/** @type {?} */
const isInitHook = arr[i] < 0;
/** @type {?} */
const hook = (/** @type {?} */ (arr[i + 1]));
/** @type {?} */
const directiveIndex = isInitHook ? -arr[i] : (/** @type {?} */ (arr[i]));
/** @type {?} */
const directive = currentView[directiveIndex];
if (isInitHook) {
/** @type {?} */
const indexWithintInitPhase = currentView[FLAGS] >> 11 /* IndexWithinInitPhaseShift */;
// The init phase state must be always checked here as it may have been recursively
// updated
if (indexWithintInitPhase <
(currentView[PREORDER_HOOK_FLAGS] >> 16 /* NumberOfInitHooksCalledShift */) &&
(currentView[FLAGS] & 3 /* InitPhaseStateMask */) === initPhase) {
currentView[FLAGS] += 2048 /* IndexWithinInitPhaseIncrementer */;
hook.call(directive);
}
}
else {
hook.call(directive);
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"hooks.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/render3/hooks.ts"],"names":[],"mappings":"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","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 {assertEqual, assertNotEqual} from '../util/assert';\n\nimport {assertFirstCreatePass} from './assert';\nimport {DirectiveDef} from './interfaces/definition';\nimport {TNode} from './interfaces/node';\nimport {FLAGS, HookData, InitPhaseState, LView, LViewFlags, PREORDER_HOOK_FLAGS, PreOrderHookFlags, TView} from './interfaces/view';\nimport {getCheckNoChangesMode} from './state';\n\n\n\n/**\n * Adds all directive lifecycle hooks from the given `DirectiveDef` to the given `TView`.\n *\n * Must be run *only* on the first template pass.\n *\n * Sets up the pre-order hooks on the provided `tView`,\n * see {@link HookData} for details about the data structure.\n *\n * @param directiveIndex The index of the directive in LView\n * @param directiveDef The definition containing the hooks to setup in tView\n * @param tView The current TView\n */\nexport function registerPreOrderHooks(\n    directiveIndex: number, directiveDef: DirectiveDef<any>, tView: TView): void {\n  ngDevMode && assertFirstCreatePass(tView);\n  const {onChanges, onInit, doCheck} = directiveDef;\n\n  if (onChanges) {\n    (tView.preOrderHooks || (tView.preOrderHooks = [])).push(directiveIndex, onChanges);\n    (tView.preOrderCheckHooks || (tView.preOrderCheckHooks = [])).push(directiveIndex, onChanges);\n  }\n\n  if (onInit) {\n    (tView.preOrderHooks || (tView.preOrderHooks = [])).push(-directiveIndex, onInit);\n  }\n\n  if (doCheck) {\n    (tView.preOrderHooks || (tView.preOrderHooks = [])).push(directiveIndex, doCheck);\n    (tView.preOrderCheckHooks || (tView.preOrderCheckHooks = [])).push(directiveIndex, doCheck);\n  }\n}\n\n/**\n *\n * Loops through the directives on the provided `tNode` and queues hooks to be\n * run that are not initialization hooks.\n *\n * Should be executed during `elementEnd()` and similar to\n * preserve hook execution order. Content, view, and destroy hooks for projected\n * components and directives must be called *before* their hosts.\n *\n * Sets up the content, view, and destroy hooks on the provided `tView`,\n * see {@link HookData} for details about the data structure.\n *\n * NOTE: This does not set up `onChanges`, `onInit` or `doCheck`, those are set up\n * separately at `elementStart`.\n *\n * @param tView The current TView\n * @param tNode The TNode whose directives are to be searched for hooks to queue\n */\nexport function registerPostOrderHooks(tView: TView, tNode: TNode): void {\n  ngDevMode && assertFirstCreatePass(tView);\n  // It's necessary to loop through the directives at elementEnd() (rather than processing in\n  // directiveCreate) so we can preserve the current hook order. Content, view, and destroy\n  // hooks for projected components and directives must be called *before* their hosts.\n  for (let i = tNode.directiveStart, end = tNode.directiveEnd; i < end; i++) {\n    const directiveDef = tView.data[i] as DirectiveDef<any>;\n    if (directiveDef.afterContentInit) {\n      (tView.contentHooks || (tView.contentHooks = [])).push(-i, directiveDef.afterContentInit);\n    }\n\n    if (directiveDef.afterContentChecked) {\n      (tView.contentHooks || (tView.contentHooks = [])).push(i, directiveDef.afterContentChecked);\n      (tView.contentCheckHooks || (tView.contentCheckHooks = []))\n          .push(i, directiveDef.afterContentChecked);\n    }\n\n    if (directiveDef.afterViewInit) {\n      (tView.viewHooks || (tView.viewHooks = [])).push(-i, directiveDef.afterViewInit);\n    }\n\n    if (directiveDef.afterViewChecked) {\n      (tView.viewHooks || (tView.viewHooks = [])).push(i, directiveDef.afterViewChecked);\n      (tView.viewCheckHooks || (tView.viewCheckHooks = [])).push(i, directiveDef.afterViewChecked);\n    }\n\n    if (directiveDef.onDestroy != null) {\n      (tView.destroyHooks || (tView.destroyHooks = [])).push(i, directiveDef.onDestroy);\n    }\n  }\n}\n\n/**\n * Executing hooks requires complex logic as we need to deal with 2 constraints.\n *\n * 1. Init hooks (ngOnInit, ngAfterContentInit, ngAfterViewInit) must all be executed once and only\n * once, across many change detection cycles. This must be true even if some hooks throw, or if\n * some recursively trigger a change detection cycle.\n * To solve that, it is required to track the state of the execution of these init hooks.\n * This is done by storing and maintaining flags in the view: the {@link InitPhaseState},\n * and the index within that phase. They can be seen as a cursor in the following structure:\n * [[onInit1, onInit2], [afterContentInit1], [afterViewInit1, afterViewInit2, afterViewInit3]]\n * They are are stored as flags in LView[FLAGS].\n *\n * 2. Pre-order hooks can be executed in batches, because of the select instruction.\n * To be able to pause and resume their execution, we also need some state about the hook's array\n * that is being processed:\n * - the index of the next hook to be executed\n * - the number of init hooks already found in the processed part of the  array\n * They are are stored as flags in LView[PREORDER_HOOK_FLAGS].\n */\n\n\n/**\n * Executes pre-order check hooks ( OnChanges, DoChanges) given a view where all the init hooks were\n * executed once. This is a light version of executeInitAndCheckPreOrderHooks where we can skip read\n * / write of the init-hooks related flags.\n * @param lView The LView where hooks are defined\n * @param hooks Hooks to be run\n * @param nodeIndex 3 cases depending on the value:\n * - undefined: all hooks from the array should be executed (post-order case)\n * - null: execute hooks only from the saved index until the end of the array (pre-order case, when\n * flushing the remaining hooks)\n * - number: execute hooks only from the saved index until that node index exclusive (pre-order\n * case, when executing select(number))\n */\nexport function executeCheckHooks(lView: LView, hooks: HookData, nodeIndex?: number|null) {\n  callHooks(lView, hooks, InitPhaseState.InitPhaseCompleted, nodeIndex);\n}\n\n/**\n * Executes post-order init and check hooks (one of AfterContentInit, AfterContentChecked,\n * AfterViewInit, AfterViewChecked) given a view where there are pending init hooks to be executed.\n * @param lView The LView where hooks are defined\n * @param hooks Hooks to be run\n * @param initPhase A phase for which hooks should be run\n * @param nodeIndex 3 cases depending on the value:\n * - undefined: all hooks from the array should be executed (post-order case)\n * - null: execute hooks only from the saved index until the end of the array (pre-order case, when\n * flushing the remaining hooks)\n * - number: execute hooks only from the saved index until that node index exclusive (pre-order\n * case, when executing select(number))\n */\nexport function executeInitAndCheckHooks(\n    lView: LView, hooks: HookData, initPhase: InitPhaseState, nodeIndex?: number|null) {\n  ngDevMode &&\n      assertNotEqual(\n          initPhase, InitPhaseState.InitPhaseCompleted,\n          'Init pre-order hooks should not be called more than once');\n  if ((lView[FLAGS] & LViewFlags.InitPhaseStateMask) === initPhase) {\n    callHooks(lView, hooks, initPhase, nodeIndex);\n  }\n}\n\nexport function incrementInitPhaseFlags(lView: LView, initPhase: InitPhaseState): void {\n  ngDevMode &&\n      assertNotEqual(\n          initPhase, InitPhaseState.InitPhaseCompleted,\n          'Init hooks phase should not be incremented after all init hooks have been run.');\n  let flags = lView[FLAGS];\n  if ((flags & LViewFlags.InitPhaseStateMask) === initPhase) {\n    flags &= LViewFlags.IndexWithinInitPhaseReset;\n    flags += LViewFlags.InitPhaseStateIncrementer;\n    lView[FLAGS] = flags;\n  }\n}\n\n/**\n * Calls lifecycle hooks with their contexts, skipping init hooks if it's not\n * the first LView pass\n *\n * @param currentView The current view\n * @param arr The array in which the hooks are found\n * @param initPhaseState the current state of the init phase\n * @param currentNodeIndex 3 cases depending on the value:\n * - undefined: all hooks from the array should be executed (post-order case)\n * - null: execute hooks only from the saved index until the end of the array (pre-order case, when\n * flushing the remaining hooks)\n * - number: execute hooks only from the saved index until that node index exclusive (pre-order\n * case, when executing select(number))\n */\nfunction callHooks(\n    currentView: LView, arr: HookData, initPhase: InitPhaseState,\n    currentNodeIndex: number|null|undefined): void {\n  ngDevMode &&\n      assertEqual(\n          getCheckNoChangesMode(), false,\n          'Hooks should never be run in the check no changes mode.');\n  const startIndex = currentNodeIndex !== undefined ?\n      (currentView[PREORDER_HOOK_FLAGS] & PreOrderHookFlags.IndexOfTheNextPreOrderHookMaskMask) :\n      0;\n  const nodeIndexLimit = currentNodeIndex != null ? currentNodeIndex : -1;\n  let lastNodeIndexFound = 0;\n  for (let i = startIndex; i < arr.length; i++) {\n    const hook = arr[i + 1] as () => void;\n    if (typeof hook === 'number') {\n      lastNodeIndexFound = arr[i] as number;\n      if (currentNodeIndex != null && lastNodeIndexFound >= currentNodeIndex) {\n        break;\n      }\n    } else {\n      const isInitHook = arr[i] < 0;\n      if (isInitHook)\n        currentView[PREORDER_HOOK_FLAGS] += PreOrderHookFlags.NumberOfInitHooksCalledIncrementer;\n      if (lastNodeIndexFound < nodeIndexLimit || nodeIndexLimit == -1) {\n        callHook(currentView, initPhase, arr, i);\n        currentView[PREORDER_HOOK_FLAGS] =\n            (currentView[PREORDER_HOOK_FLAGS] & PreOrderHookFlags.NumberOfInitHooksCalledMask) + i +\n            2;\n      }\n      i++;\n    }\n  }\n}\n\n/**\n * Execute one hook against the current `LView`.\n *\n * @param currentView The current view\n * @param initPhaseState the current state of the init phase\n * @param arr The array in which the hooks are found\n * @param i The current index within the hook data array\n */\nfunction callHook(currentView: LView, initPhase: InitPhaseState, arr: HookData, i: number) {\n  const isInitHook = arr[i] < 0;\n  const hook = arr[i + 1] as () => void;\n  const directiveIndex = isInitHook ? -arr[i] : arr[i] as number;\n  const directive = currentView[directiveIndex];\n  if (isInitHook) {\n    const indexWithintInitPhase = currentView[FLAGS] >> LViewFlags.IndexWithinInitPhaseShift;\n    // The init phase state must be always checked here as it may have been recursively\n    // updated\n    if (indexWithintInitPhase <\n            (currentView[PREORDER_HOOK_FLAGS] >> PreOrderHookFlags.NumberOfInitHooksCalledShift) &&\n        (currentView[FLAGS] & LViewFlags.InitPhaseStateMask) === initPhase) {\n      currentView[FLAGS] += LViewFlags.IndexWithinInitPhaseIncrementer;\n      hook.call(directive);\n    }\n  } else {\n    hook.call(directive);\n  }\n}\n"]}