/**
 * @license
 * Copyright Google LLC 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 { setActiveConsumer } from '../signals';
import { assertDefined, assertEqual, assertNotEqual } from '../util/assert';
import { assertFirstCreatePass } from './assert';
import { NgOnChangesFeatureImpl } from './features/ng_onchanges_feature';
import { FLAGS, PREORDER_HOOK_FLAGS } from './interfaces/view';
import { profiler } from './profiler';
import { isInCheckNoChangesMode } 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
 */
export function registerPreOrderHooks(directiveIndex, directiveDef, tView) {
    ngDevMode && assertFirstCreatePass(tView);
    const { ngOnChanges, ngOnInit, ngDoCheck } = directiveDef.type.prototype;
    if (ngOnChanges) {
        const wrappedOnChanges = NgOnChangesFeatureImpl(directiveDef);
        (tView.preOrderHooks ??= []).push(directiveIndex, wrappedOnChanges);
        (tView.preOrderCheckHooks ??= []).push(directiveIndex, wrappedOnChanges);
    }
    if (ngOnInit) {
        (tView.preOrderHooks ??= []).push(0 - directiveIndex, ngOnInit);
    }
    if (ngDoCheck) {
        (tView.preOrderHooks ??= []).push(directiveIndex, ngDoCheck);
        (tView.preOrderCheckHooks ??= []).push(directiveIndex, ngDoCheck);
    }
}
/**
 *
 * 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) {
    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++) {
        const directiveDef = tView.data[i];
        ngDevMode && assertDefined(directiveDef, 'Expecting DirectiveDef');
        const lifecycleHooks = directiveDef.type.prototype;
        const { ngAfterContentInit, ngAfterContentChecked, ngAfterViewInit, ngAfterViewChecked, ngOnDestroy } = lifecycleHooks;
        if (ngAfterContentInit) {
            (tView.contentHooks ??= []).push(-i, ngAfterContentInit);
        }
        if (ngAfterContentChecked) {
            (tView.contentHooks ??= []).push(i, ngAfterContentChecked);
            (tView.contentCheckHooks ??= []).push(i, ngAfterContentChecked);
        }
        if (ngAfterViewInit) {
            (tView.viewHooks ??= []).push(-i, ngAfterViewInit);
        }
        if (ngAfterViewChecked) {
            (tView.viewHooks ??= []).push(i, ngAfterViewChecked);
            (tView.viewCheckHooks ??= []).push(i, ngAfterViewChecked);
        }
        if (ngOnDestroy != null) {
            (tView.destroyHooks ??= []).push(i, ngOnDestroy);
        }
    }
}
/**
 * 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 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 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))
 */
export function executeCheckHooks(lView, hooks, nodeIndex) {
    callHooks(lView, hooks, 3 /* InitPhaseState.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))
 */
export function executeInitAndCheckHooks(lView, hooks, initPhase, nodeIndex) {
    ngDevMode &&
        assertNotEqual(initPhase, 3 /* InitPhaseState.InitPhaseCompleted */, 'Init pre-order hooks should not be called more than once');
    if ((lView[FLAGS] & 3 /* LViewFlags.InitPhaseStateMask */) === initPhase) {
        callHooks(lView, hooks, initPhase, nodeIndex);
    }
}
export function incrementInitPhaseFlags(lView, initPhase) {
    ngDevMode &&
        assertNotEqual(initPhase, 3 /* InitPhaseState.InitPhaseCompleted */, 'Init hooks phase should not be incremented after all init hooks have been run.');
    let flags = lView[FLAGS];
    if ((flags & 3 /* LViewFlags.InitPhaseStateMask */) === initPhase) {
        flags &= 8191 /* LViewFlags.IndexWithinInitPhaseReset */;
        flags += 1 /* LViewFlags.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 initPhaseState the current state of the init phase
 * @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))
 */
function callHooks(currentView, arr, initPhase, currentNodeIndex) {
    ngDevMode &&
        assertEqual(isInCheckNoChangesMode(), false, 'Hooks should never be run when in check no changes mode.');
    const startIndex = currentNodeIndex !== undefined ?
        (currentView[PREORDER_HOOK_FLAGS] & 65535 /* PreOrderHookFlags.IndexOfTheNextPreOrderHookMaskMask */) :
        0;
    const nodeIndexLimit = currentNodeIndex != null ? currentNodeIndex : -1;
    const max = arr.length - 1; // Stop the loop at length - 1, because we look for the hook at i + 1
    let lastNodeIndexFound = 0;
    for (let i = startIndex; i < max; i++) {
        const hook = arr[i + 1];
        if (typeof hook === 'number') {
            lastNodeIndexFound = arr[i];
            if (currentNodeIndex != null && lastNodeIndexFound >= currentNodeIndex) {
                break;
            }
        }
        else {
            const isInitHook = arr[i] < 0;
            if (isInitHook) {
                currentView[PREORDER_HOOK_FLAGS] += 65536 /* PreOrderHookFlags.NumberOfInitHooksCalledIncrementer */;
            }
            if (lastNodeIndexFound < nodeIndexLimit || nodeIndexLimit == -1) {
                callHook(currentView, initPhase, arr, i);
                currentView[PREORDER_HOOK_FLAGS] =
                    (currentView[PREORDER_HOOK_FLAGS] & 4294901760 /* PreOrderHookFlags.NumberOfInitHooksCalledMask */) + i +
                        2;
            }
            i++;
        }
    }
}
/**
 * Executes a single lifecycle hook, making sure that:
 * - it is called in the non-reactive context;
 * - profiling data are registered.
 */
function callHookInternal(directive, hook) {
    profiler(4 /* ProfilerEvent.LifecycleHookStart */, directive, hook);
    const prevConsumer = setActiveConsumer(null);
    try {
        hook.call(directive);
    }
    finally {
        setActiveConsumer(prevConsumer);
        profiler(5 /* ProfilerEvent.LifecycleHookEnd */, directive, hook);
    }
}
/**
 * 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) {
    const isInitHook = arr[i] < 0;
    const hook = arr[i + 1];
    const directiveIndex = isInitHook ? -arr[i] : arr[i];
    const directive = currentView[directiveIndex];
    if (isInitHook) {
        const indexWithintInitPhase = currentView[FLAGS] >> 13 /* LViewFlags.IndexWithinInitPhaseShift */;
        // The init phase state must be always checked here as it may have been recursively updated.
        if (indexWithintInitPhase <
            (currentView[PREORDER_HOOK_FLAGS] >> 16 /* PreOrderHookFlags.NumberOfInitHooksCalledShift */) &&
            (currentView[FLAGS] & 3 /* LViewFlags.InitPhaseStateMask */) === initPhase) {
            currentView[FLAGS] += 8192 /* LViewFlags.IndexWithinInitPhaseIncrementer */;
            callHookInternal(directive, hook);
        }
    }
    else {
        callHookInternal(directive, hook);
    }
}
//# 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 LLC 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 {AfterContentChecked, AfterContentInit, AfterViewChecked, AfterViewInit, DoCheck, OnChanges, OnDestroy, OnInit} from '../interface/lifecycle_hooks';\nimport {setActiveConsumer} from '../signals';\nimport {assertDefined, assertEqual, assertNotEqual} from '../util/assert';\n\nimport {assertFirstCreatePass} from './assert';\nimport {NgOnChangesFeatureImpl} from './features/ng_onchanges_feature';\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 {profiler, ProfilerEvent} from './profiler';\nimport {isInCheckNoChangesMode} 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 {ngOnChanges, ngOnInit, ngDoCheck} =\n      directiveDef.type.prototype as OnChanges & OnInit & DoCheck;\n\n  if (ngOnChanges as Function | undefined) {\n    const wrappedOnChanges = NgOnChangesFeatureImpl(directiveDef);\n    (tView.preOrderHooks ??= []).push(directiveIndex, wrappedOnChanges);\n    (tView.preOrderCheckHooks ??= []).push(directiveIndex, wrappedOnChanges);\n  }\n\n  if (ngOnInit) {\n    (tView.preOrderHooks ??= []).push(0 - directiveIndex, ngOnInit);\n  }\n\n  if (ngDoCheck) {\n    (tView.preOrderHooks ??= []).push(directiveIndex, ngDoCheck);\n    (tView.preOrderCheckHooks ??= []).push(directiveIndex, ngDoCheck);\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    ngDevMode && assertDefined(directiveDef, 'Expecting DirectiveDef');\n    const lifecycleHooks: AfterContentInit&AfterContentChecked&AfterViewInit&AfterViewChecked&\n        OnDestroy = directiveDef.type.prototype;\n    const {\n      ngAfterContentInit,\n      ngAfterContentChecked,\n      ngAfterViewInit,\n      ngAfterViewChecked,\n      ngOnDestroy\n    } = lifecycleHooks;\n\n    if (ngAfterContentInit) {\n      (tView.contentHooks ??= []).push(-i, ngAfterContentInit);\n    }\n\n    if (ngAfterContentChecked) {\n      (tView.contentHooks ??= []).push(i, ngAfterContentChecked);\n      (tView.contentCheckHooks ??= []).push(i, ngAfterContentChecked);\n    }\n\n    if (ngAfterViewInit) {\n      (tView.viewHooks ??= []).push(-i, ngAfterViewInit);\n    }\n\n    if (ngAfterViewChecked) {\n      (tView.viewHooks ??= []).push(i, ngAfterViewChecked);\n      (tView.viewCheckHooks ??= []).push(i, ngAfterViewChecked);\n    }\n\n    if (ngOnDestroy != null) {\n      (tView.destroyHooks ??= []).push(i, ngOnDestroy);\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 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 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          isInCheckNoChangesMode(), false,\n          'Hooks should never be run when in 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  const max = arr.length - 1;  // Stop the loop at length - 1, because we look for the hook at i + 1\n  let lastNodeIndexFound = 0;\n  for (let i = startIndex; i < max; i++) {\n    const hook = arr[i + 1] as number | (() => 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] as number) < 0;\n      if (isInitHook) {\n        currentView[PREORDER_HOOK_FLAGS] += PreOrderHookFlags.NumberOfInitHooksCalledIncrementer;\n      }\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 * Executes a single lifecycle hook, making sure that:\n * - it is called in the non-reactive context;\n * - profiling data are registered.\n */\nfunction callHookInternal(directive: any, hook: () => void) {\n  profiler(ProfilerEvent.LifecycleHookStart, directive, hook);\n  const prevConsumer = setActiveConsumer(null);\n  try {\n    hook.call(directive);\n  } finally {\n    setActiveConsumer(prevConsumer);\n    profiler(ProfilerEvent.LifecycleHookEnd, directive, hook);\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] as number) < 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 updated.\n    if (indexWithintInitPhase <\n            (currentView[PREORDER_HOOK_FLAGS] >> PreOrderHookFlags.NumberOfInitHooksCalledShift) &&\n        (currentView[FLAGS] & LViewFlags.InitPhaseStateMask) === initPhase) {\n      currentView[FLAGS] += LViewFlags.IndexWithinInitPhaseIncrementer;\n      callHookInternal(directive, hook);\n    }\n  } else {\n    callHookInternal(directive, hook);\n  }\n}\n"]}