@angular/core
Version:
Angular - the core framework
241 lines • 35.9 kB
JavaScript
/**
* @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 } from '../util/assert';
import { FLAGS, PREORDER_HOOK_FLAGS } from './interfaces/view';
/**
* 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
* @param nodeIndex The index of the node to which the directive is attached
* @param initialPreOrderHooksLength the number of pre-order hooks already registered before the
* current process, used to know if the node index has to be added to the array. If it is -1,
* the node index is never added.
* @param initialPreOrderCheckHooksLength same as previous for pre-order check hooks
*/
export function registerPreOrderHooks(directiveIndex, directiveDef, tView, nodeIndex, initialPreOrderHooksLength, initialPreOrderCheckHooksLength) {
ngDevMode &&
assertEqual(tView.firstTemplatePass, true, 'Should only be called on first template pass');
var onChanges = directiveDef.onChanges, onInit = directiveDef.onInit, doCheck = directiveDef.doCheck;
if (initialPreOrderHooksLength >= 0 &&
(!tView.preOrderHooks || initialPreOrderHooksLength === tView.preOrderHooks.length) &&
(onChanges || onInit || doCheck)) {
(tView.preOrderHooks || (tView.preOrderHooks = [])).push(nodeIndex);
}
if (initialPreOrderCheckHooksLength >= 0 &&
(!tView.preOrderCheckHooks ||
initialPreOrderCheckHooksLength === tView.preOrderCheckHooks.length) &&
(onChanges || doCheck)) {
(tView.preOrderCheckHooks || (tView.preOrderCheckHooks = [])).push(nodeIndex);
}
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
*/
export function registerPostOrderHooks(tView, tNode) {
if (tView.firstTemplatePass) {
// 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 (var i = tNode.directiveStart, end = tNode.directiveEnd; i < end; i++) {
var directiveDef = 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 necessary hooks at the start of executing a template.
*
* Executes hooks that are to be run during the initialization of a directive such
* as `onChanges`, `onInit`, and `doCheck`.
*
* @param lView The current view
* @param tView Static data for the view containing the hooks to be executed
* @param checkNoChangesMode Whether or not we're in checkNoChanges mode.
* @param @param currentNodeIndex 2 cases depending the the value:
* - undefined: 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))
*/
export function executePreOrderHooks(currentView, tView, checkNoChangesMode, currentNodeIndex) {
if (!checkNoChangesMode) {
executeHooks(currentView, tView.preOrderHooks, tView.preOrderCheckHooks, checkNoChangesMode, 0 /* OnInitHooksToBeRun */, currentNodeIndex !== undefined ? currentNodeIndex : null);
}
}
/**
* Executes hooks against the given `LView` based off of whether or not
* This is the first pass.
*
* @param currentView The view instance data to run the hooks against
* @param firstPassHooks An array of hooks to run if we're in the first view pass
* @param checkHooks An Array of hooks to run if we're not in the first view pass.
* @param checkNoChangesMode Whether or not we're in no changes mode.
* @param initPhaseState the current state of the init phase
* @param currentNodeIndex 3 cases depending the 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))
*/
export function executeHooks(currentView, firstPassHooks, checkHooks, checkNoChangesMode, initPhaseState, currentNodeIndex) {
if (checkNoChangesMode)
return;
var hooksToCall = (currentView[FLAGS] & 3 /* InitPhaseStateMask */) === initPhaseState ?
firstPassHooks :
checkHooks;
if (hooksToCall) {
callHooks(currentView, hooksToCall, initPhaseState, currentNodeIndex);
}
// The init phase state must be always checked here as it may have been recursively updated
if (currentNodeIndex == null &&
(currentView[FLAGS] & 3 /* InitPhaseStateMask */) === initPhaseState &&
initPhaseState !== 3 /* InitPhaseCompleted */) {
currentView[FLAGS] &= 1023 /* IndexWithinInitPhaseReset */;
currentView[FLAGS] += 1 /* InitPhaseStateIncrementer */;
}
}
/**
* 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 initPhaseState the current state of the init phase
* @param currentNodeIndex 3 cases depending the 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))
*/
function callHooks(currentView, arr, initPhase, currentNodeIndex) {
var startIndex = currentNodeIndex !== undefined ?
(currentView[PREORDER_HOOK_FLAGS] & 65535 /* IndexOfTheNextPreOrderHookMaskMask */) :
0;
var nodeIndexLimit = currentNodeIndex != null ? currentNodeIndex : -1;
var lastNodeIndexFound = 0;
for (var i = startIndex; i < arr.length; i++) {
var hook = arr[i + 1];
if (typeof hook === 'number') {
lastNodeIndexFound = arr[i];
if (currentNodeIndex != null && lastNodeIndexFound >= currentNodeIndex) {
break;
}
}
else {
var 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 initPhaseState the current state of the init phase
* @param arr The array in which the hooks are found
* @param i The current index within the hook data array
*/
function callHook(currentView, initPhase, arr, i) {
var isInitHook = arr[i] < 0;
var hook = arr[i + 1];
var directiveIndex = isInitHook ? -arr[i] : arr[i];
var directive = currentView[directiveIndex];
if (isInitHook) {
var indexWithintInitPhase = currentView[FLAGS] >> 10 /* 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] += 1024 /* 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} from '../util/assert';\n\nimport {DirectiveDef} from './interfaces/definition';\nimport {TNode} from './interfaces/node';\nimport {FLAGS, HookData, InitPhaseState, LView, LViewFlags, PREORDER_HOOK_FLAGS, PreOrderHookFlags, TView} from './interfaces/view';\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 * @param nodeIndex The index of the node to which the directive is attached\n * @param initialPreOrderHooksLength the number of pre-order hooks already registered before the\n * current process, used to know if the node index has to be added to the array. If it is -1,\n * the node index is never added.\n * @param initialPreOrderCheckHooksLength same as previous for pre-order check hooks\n */\nexport function registerPreOrderHooks(\n    directiveIndex: number, directiveDef: DirectiveDef<any>, tView: TView, nodeIndex: number,\n    initialPreOrderHooksLength: number, initialPreOrderCheckHooksLength: number): void {\n  ngDevMode &&\n      assertEqual(tView.firstTemplatePass, true, 'Should only be called on first template pass');\n\n  const {onChanges, onInit, doCheck} = directiveDef;\n  if (initialPreOrderHooksLength >= 0 &&\n      (!tView.preOrderHooks || initialPreOrderHooksLength === tView.preOrderHooks.length) &&\n      (onChanges || onInit || doCheck)) {\n    (tView.preOrderHooks || (tView.preOrderHooks = [])).push(nodeIndex);\n  }\n\n  if (initialPreOrderCheckHooksLength >= 0 &&\n      (!tView.preOrderCheckHooks ||\n       initialPreOrderCheckHooksLength === tView.preOrderCheckHooks.length) &&\n      (onChanges || doCheck)) {\n    (tView.preOrderCheckHooks || (tView.preOrderCheckHooks = [])).push(nodeIndex);\n  }\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  if (tView.firstTemplatePass) {\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 = [\n         ])).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/**\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 * Executes necessary hooks at the start of executing a template.\n *\n * Executes hooks that are to be run during the initialization of a directive such\n * as `onChanges`, `onInit`, and `doCheck`.\n *\n * @param lView The current view\n * @param tView Static data for the view containing the hooks to be executed\n * @param checkNoChangesMode Whether or not we're in checkNoChanges mode.\n * @param @param currentNodeIndex 2 cases depending the the value:\n * - undefined: execute hooks only from the saved index until the end of the array (pre-order case,\n * when 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 executePreOrderHooks(\n    currentView: LView, tView: TView, checkNoChangesMode: boolean,\n    currentNodeIndex: number | undefined): void {\n  if (!checkNoChangesMode) {\n    executeHooks(\n        currentView, tView.preOrderHooks, tView.preOrderCheckHooks, checkNoChangesMode,\n        InitPhaseState.OnInitHooksToBeRun,\n        currentNodeIndex !== undefined ? currentNodeIndex : null);\n  }\n}\n\n/**\n * Executes hooks against the given `LView` based off of whether or not\n * This is the first pass.\n *\n * @param currentView The view instance data to run the hooks against\n * @param firstPassHooks An array of hooks to run if we're in the first view pass\n * @param checkHooks An Array of hooks to run if we're not in the first view pass.\n * @param checkNoChangesMode Whether or not we're in no changes mode.\n * @param initPhaseState the current state of the init phase\n * @param currentNodeIndex 3 cases depending the 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 executeHooks(\n    currentView: LView, firstPassHooks: HookData | null, checkHooks: HookData | null,\n    checkNoChangesMode: boolean, initPhaseState: InitPhaseState,\n    currentNodeIndex: number | null | undefined): void {\n  if (checkNoChangesMode) return;\n  const hooksToCall = (currentView[FLAGS] & LViewFlags.InitPhaseStateMask) === initPhaseState ?\n      firstPassHooks :\n      checkHooks;\n  if (hooksToCall) {\n    callHooks(currentView, hooksToCall, initPhaseState, currentNodeIndex);\n  }\n  // The init phase state must be always checked here as it may have been recursively updated\n  if (currentNodeIndex == null &&\n      (currentView[FLAGS] & LViewFlags.InitPhaseStateMask) === initPhaseState &&\n      initPhaseState !== InitPhaseState.InitPhaseCompleted) {\n    currentView[FLAGS] &= LViewFlags.IndexWithinInitPhaseReset;\n    currentView[FLAGS] += LViewFlags.InitPhaseStateIncrementer;\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 the 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  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"]}