@angular/core
Version:
Angular - the core framework
355 lines • 40.5 kB
JavaScript
/**
* @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 { assertNotInReactiveContext } from '../core_reactivity_export_internal';
import { assertInInjectionContext, Injector, ɵɵdefineInjectable } from '../di';
import { inject } from '../di/injector_compatibility';
import { ErrorHandler } from '../error_handler';
import { DestroyRef } from '../linker/destroy_ref';
import { performanceMarkFeature } from '../util/performance';
import { NgZone } from '../zone/ng_zone';
import { isPlatformBrowser } from './util/misc_utils';
/**
* The phase to run an `afterRender` or `afterNextRender` callback in.
*
* Callbacks in the same phase run in the order they are registered. Phases run in the
* following order after each render:
*
* 1. `AfterRenderPhase.EarlyRead`
* 2. `AfterRenderPhase.Write`
* 3. `AfterRenderPhase.MixedReadWrite`
* 4. `AfterRenderPhase.Read`
*
* Angular is unable to verify or enforce that phases are used correctly, and instead
* relies on each developer to follow the guidelines documented for each value and
* carefully choose the appropriate one, refactoring their code if necessary. By doing
* so, Angular is better able to minimize the performance degradation associated with
* manual DOM access, ensuring the best experience for the end users of your application
* or library.
*
* @developerPreview
*/
export var AfterRenderPhase;
(function (AfterRenderPhase) {
/**
* Use `AfterRenderPhase.EarlyRead` for callbacks that only need to **read** from the
* DOM before a subsequent `AfterRenderPhase.Write` callback, for example to perform
* custom layout that the browser doesn't natively support. **Never** use this phase
* for callbacks that can write to the DOM or when `AfterRenderPhase.Read` is adequate.
*
* <div class="alert is-important">
*
* Using this value can degrade performance.
* Instead, prefer using built-in browser functionality when possible.
*
* </div>
*/
AfterRenderPhase[AfterRenderPhase["EarlyRead"] = 0] = "EarlyRead";
/**
* Use `AfterRenderPhase.Write` for callbacks that only **write** to the DOM. **Never**
* use this phase for callbacks that can read from the DOM.
*/
AfterRenderPhase[AfterRenderPhase["Write"] = 1] = "Write";
/**
* Use `AfterRenderPhase.MixedReadWrite` for callbacks that read from or write to the
* DOM, that haven't been refactored to use a different phase. **Never** use this phase
* for callbacks that can use a different phase instead.
*
* <div class="alert is-critical">
*
* Using this value can **significantly** degrade performance.
* Instead, prefer refactoring into multiple callbacks using a more specific phase.
*
* </div>
*/
AfterRenderPhase[AfterRenderPhase["MixedReadWrite"] = 2] = "MixedReadWrite";
/**
* Use `AfterRenderPhase.Read` for callbacks that only **read** from the DOM. **Never**
* use this phase for callbacks that can write to the DOM.
*/
AfterRenderPhase[AfterRenderPhase["Read"] = 3] = "Read";
})(AfterRenderPhase || (AfterRenderPhase = {}));
/** `AfterRenderRef` that does nothing. */
const NOOP_AFTER_RENDER_REF = {
destroy() { }
};
/**
* Register a callback to run once before any userspace `afterRender` or
* `afterNextRender` callbacks.
*
* This function should almost always be used instead of `afterRender` or
* `afterNextRender` for implementing framework functionality. Consider:
*
* 1.) `AfterRenderPhase.EarlyRead` is intended to be used for implementing
* custom layout. If the framework itself mutates the DOM after *any*
* `AfterRenderPhase.EarlyRead` callbacks are run, the phase can no
* longer reliably serve its purpose.
*
* 2.) Importing `afterRender` in the framework can reduce the ability for it
* to be tree-shaken, and the framework shouldn't need much of the behavior.
*/
export function internalAfterNextRender(callback, options) {
const injector = options?.injector ?? inject(Injector);
// Similarly to the public `afterNextRender` function, an internal one
// is only invoked in a browser.
if (!isPlatformBrowser(injector))
return;
const afterRenderEventManager = injector.get(AfterRenderEventManager);
afterRenderEventManager.internalCallbacks.push(callback);
}
/**
* Register a callback to be invoked each time the application
* finishes rendering.
*
* <div class="alert is-critical">
*
* You should always explicitly specify a non-default [phase](api/core/AfterRenderPhase), or you
* risk significant performance degradation.
*
* </div>
*
* Note that the callback will run
* - in the order it was registered
* - once per render
* - on browser platforms only
*
* <div class="alert is-important">
*
* Components are not guaranteed to be [hydrated](guide/hydration) before the callback runs.
* You must use caution when directly reading or writing the DOM and layout.
*
* </div>
*
* @param callback A callback function to register
*
* @usageNotes
*
* Use `afterRender` to read or write the DOM after each render.
*
* ### Example
* ```ts
* @Component({
* selector: 'my-cmp',
* template: `<span #content>{{ ... }}</span>`,
* })
* export class MyComponent {
* @ViewChild('content') contentRef: ElementRef;
*
* constructor() {
* afterRender(() => {
* console.log('content height: ' + this.contentRef.nativeElement.scrollHeight);
* }, {phase: AfterRenderPhase.Read});
* }
* }
* ```
*
* @developerPreview
*/
export function afterRender(callback, options) {
ngDevMode &&
assertNotInReactiveContext(afterRender, 'Call `afterRender` outside of a reactive context. For example, schedule the render ' +
'callback inside the component constructor`.');
!options && assertInInjectionContext(afterRender);
const injector = options?.injector ?? inject(Injector);
if (!isPlatformBrowser(injector)) {
return NOOP_AFTER_RENDER_REF;
}
performanceMarkFeature('NgAfterRender');
const afterRenderEventManager = injector.get(AfterRenderEventManager);
// Lazily initialize the handler implementation, if necessary. This is so that it can be
// tree-shaken if `afterRender` and `afterNextRender` aren't used.
const callbackHandler = afterRenderEventManager.handler ??= new AfterRenderCallbackHandlerImpl();
const phase = options?.phase ?? AfterRenderPhase.MixedReadWrite;
const destroy = () => {
callbackHandler.unregister(instance);
unregisterFn();
};
const unregisterFn = injector.get(DestroyRef).onDestroy(destroy);
const instance = new AfterRenderCallback(injector, phase, callback);
callbackHandler.register(instance);
return { destroy };
}
/**
* Register a callback to be invoked the next time the application
* finishes rendering.
*
* <div class="alert is-critical">
*
* You should always explicitly specify a non-default [phase](api/core/AfterRenderPhase), or you
* risk significant performance degradation.
*
* </div>
*
* Note that the callback will run
* - in the order it was registered
* - on browser platforms only
*
* <div class="alert is-important">
*
* Components are not guaranteed to be [hydrated](guide/hydration) before the callback runs.
* You must use caution when directly reading or writing the DOM and layout.
*
* </div>
*
* @param callback A callback function to register
*
* @usageNotes
*
* Use `afterNextRender` to read or write the DOM once,
* for example to initialize a non-Angular library.
*
* ### Example
* ```ts
* @Component({
* selector: 'my-chart-cmp',
* template: `<div #chart>{{ ... }}</div>`,
* })
* export class MyChartCmp {
* @ViewChild('chart') chartRef: ElementRef;
* chart: MyChart|null;
*
* constructor() {
* afterNextRender(() => {
* this.chart = new MyChart(this.chartRef.nativeElement);
* }, {phase: AfterRenderPhase.Write});
* }
* }
* ```
*
* @developerPreview
*/
export function afterNextRender(callback, options) {
!options && assertInInjectionContext(afterNextRender);
const injector = options?.injector ?? inject(Injector);
if (!isPlatformBrowser(injector)) {
return NOOP_AFTER_RENDER_REF;
}
performanceMarkFeature('NgAfterNextRender');
const afterRenderEventManager = injector.get(AfterRenderEventManager);
// Lazily initialize the handler implementation, if necessary. This is so that it can be
// tree-shaken if `afterRender` and `afterNextRender` aren't used.
const callbackHandler = afterRenderEventManager.handler ??= new AfterRenderCallbackHandlerImpl();
const phase = options?.phase ?? AfterRenderPhase.MixedReadWrite;
const destroy = () => {
callbackHandler.unregister(instance);
unregisterFn();
};
const unregisterFn = injector.get(DestroyRef).onDestroy(destroy);
const instance = new AfterRenderCallback(injector, phase, () => {
destroy();
callback();
});
callbackHandler.register(instance);
return { destroy };
}
/**
* A wrapper around a function to be used as an after render callback.
*/
class AfterRenderCallback {
constructor(injector, phase, callbackFn) {
this.phase = phase;
this.callbackFn = callbackFn;
this.zone = injector.get(NgZone);
this.errorHandler = injector.get(ErrorHandler, null, { optional: true });
}
invoke() {
try {
this.zone.runOutsideAngular(this.callbackFn);
}
catch (err) {
this.errorHandler?.handleError(err);
}
}
}
/**
* Core functionality for `afterRender` and `afterNextRender`. Kept separate from
* `AfterRenderEventManager` for tree-shaking.
*/
class AfterRenderCallbackHandlerImpl {
constructor() {
this.executingCallbacks = false;
this.buckets = {
// Note: the order of these keys controls the order the phases are run.
[AfterRenderPhase.EarlyRead]: new Set(),
[AfterRenderPhase.Write]: new Set(),
[AfterRenderPhase.MixedReadWrite]: new Set(),
[AfterRenderPhase.Read]: new Set(),
};
this.deferredCallbacks = new Set();
}
register(callback) {
// If we're currently running callbacks, new callbacks should be deferred
// until the next render operation.
const target = this.executingCallbacks ? this.deferredCallbacks : this.buckets[callback.phase];
target.add(callback);
}
unregister(callback) {
this.buckets[callback.phase].delete(callback);
this.deferredCallbacks.delete(callback);
}
execute() {
let callbacksExecuted = false;
this.executingCallbacks = true;
for (const bucket of Object.values(this.buckets)) {
for (const callback of bucket) {
callbacksExecuted = true;
callback.invoke();
}
}
this.executingCallbacks = false;
for (const callback of this.deferredCallbacks) {
this.buckets[callback.phase].add(callback);
}
this.deferredCallbacks.clear();
return callbacksExecuted;
}
destroy() {
for (const bucket of Object.values(this.buckets)) {
bucket.clear();
}
this.deferredCallbacks.clear();
}
}
/**
* Implements core timing for `afterRender` and `afterNextRender` events.
* Delegates to an optional `AfterRenderCallbackHandler` for implementation.
*/
export class AfterRenderEventManager {
constructor() {
/* @internal */
this.handler = null;
/* @internal */
this.internalCallbacks = [];
}
/**
* Executes callbacks. Returns `true` if any callbacks executed.
*/
execute() {
// Note: internal callbacks power `internalAfterNextRender`. Since internal callbacks
// are fairly trivial, they are kept separate so that `AfterRenderCallbackHandlerImpl`
// can still be tree-shaken unless used by the application.
const callbacks = [...this.internalCallbacks];
this.internalCallbacks.length = 0;
for (const callback of callbacks) {
callback();
}
const handlerCallbacksExecuted = this.handler?.execute();
return !!handlerCallbacksExecuted || callbacks.length > 0;
}
ngOnDestroy() {
this.handler?.destroy();
this.handler = null;
this.internalCallbacks.length = 0;
}
/** @nocollapse */
static { this.ɵprov = ɵɵdefineInjectable({
token: AfterRenderEventManager,
providedIn: 'root',
factory: () => new AfterRenderEventManager(),
}); }
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"after_render_hooks.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/render3/after_render_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 {assertNotInReactiveContext} from '../core_reactivity_export_internal';\nimport {assertInInjectionContext, Injector, ɵɵdefineInjectable} from '../di';\nimport {inject} from '../di/injector_compatibility';\nimport {ErrorHandler} from '../error_handler';\nimport {RuntimeError, RuntimeErrorCode} from '../errors';\nimport {DestroyRef} from '../linker/destroy_ref';\nimport {assertGreaterThan} from '../util/assert';\nimport {performanceMarkFeature} from '../util/performance';\nimport {NgZone} from '../zone/ng_zone';\n\nimport {isPlatformBrowser} from './util/misc_utils';\n\n/**\n * The phase to run an `afterRender` or `afterNextRender` callback in.\n *\n * Callbacks in the same phase run in the order they are registered. Phases run in the\n * following order after each render:\n *\n *   1. `AfterRenderPhase.EarlyRead`\n *   2. `AfterRenderPhase.Write`\n *   3. `AfterRenderPhase.MixedReadWrite`\n *   4. `AfterRenderPhase.Read`\n *\n * Angular is unable to verify or enforce that phases are used correctly, and instead\n * relies on each developer to follow the guidelines documented for each value and\n * carefully choose the appropriate one, refactoring their code if necessary. By doing\n * so, Angular is better able to minimize the performance degradation associated with\n * manual DOM access, ensuring the best experience for the end users of your application\n * or library.\n *\n * @developerPreview\n */\nexport enum AfterRenderPhase {\n  /**\n   * Use `AfterRenderPhase.EarlyRead` for callbacks that only need to **read** from the\n   * DOM before a subsequent `AfterRenderPhase.Write` callback, for example to perform\n   * custom layout that the browser doesn't natively support. **Never** use this phase\n   * for callbacks that can write to the DOM or when `AfterRenderPhase.Read` is adequate.\n   *\n   * <div class=\"alert is-important\">\n   *\n   * Using this value can degrade performance.\n   * Instead, prefer using built-in browser functionality when possible.\n   *\n   * </div>\n   */\n  EarlyRead,\n\n  /**\n   * Use `AfterRenderPhase.Write` for callbacks that only **write** to the DOM. **Never**\n   * use this phase for callbacks that can read from the DOM.\n   */\n  Write,\n\n  /**\n   * Use `AfterRenderPhase.MixedReadWrite` for callbacks that read from or write to the\n   * DOM, that haven't been refactored to use a different phase. **Never** use this phase\n   * for callbacks that can use a different phase instead.\n   *\n   * <div class=\"alert is-critical\">\n   *\n   * Using this value can **significantly** degrade performance.\n   * Instead, prefer refactoring into multiple callbacks using a more specific phase.\n   *\n   * </div>\n   */\n  MixedReadWrite,\n\n  /**\n   * Use `AfterRenderPhase.Read` for callbacks that only **read** from the DOM. **Never**\n   * use this phase for callbacks that can write to the DOM.\n   */\n  Read,\n}\n\n/**\n * Options passed to `afterRender` and `afterNextRender`.\n *\n * @developerPreview\n */\nexport interface AfterRenderOptions {\n  /**\n   * The `Injector` to use during creation.\n   *\n   * If this is not provided, the current injection context will be used instead (via `inject`).\n   */\n  injector?: Injector;\n\n  /**\n   * The phase the callback should be invoked in.\n   *\n   * <div class=\"alert is-critical\">\n   *\n   * Defaults to `AfterRenderPhase.MixedReadWrite`. You should choose a more specific\n   * phase instead. See `AfterRenderPhase` for more information.\n   *\n   * </div>\n   */\n  phase?: AfterRenderPhase;\n}\n\n/**\n * A callback that runs after render.\n *\n * @developerPreview\n */\nexport interface AfterRenderRef {\n  /**\n   * Shut down the callback, preventing it from being called again.\n   */\n  destroy(): void;\n}\n\n/**\n * Options passed to `internalAfterNextRender`.\n */\nexport interface InternalAfterNextRenderOptions {\n  /**\n   * The `Injector` to use during creation.\n   *\n   * If this is not provided, the current injection context will be used instead (via `inject`).\n   */\n  injector?: Injector;\n}\n\n/** `AfterRenderRef` that does nothing. */\nconst NOOP_AFTER_RENDER_REF: AfterRenderRef = {\n  destroy() {}\n};\n\n/**\n * Register a callback to run once before any userspace `afterRender` or\n * `afterNextRender` callbacks.\n *\n * This function should almost always be used instead of `afterRender` or\n * `afterNextRender` for implementing framework functionality. Consider:\n *\n *   1.) `AfterRenderPhase.EarlyRead` is intended to be used for implementing\n *       custom layout. If the framework itself mutates the DOM after *any*\n *       `AfterRenderPhase.EarlyRead` callbacks are run, the phase can no\n *       longer reliably serve its purpose.\n *\n *   2.) Importing `afterRender` in the framework can reduce the ability for it\n *       to be tree-shaken, and the framework shouldn't need much of the behavior.\n */\nexport function internalAfterNextRender(\n    callback: VoidFunction, options?: InternalAfterNextRenderOptions) {\n  const injector = options?.injector ?? inject(Injector);\n\n  // Similarly to the public `afterNextRender` function, an internal one\n  // is only invoked in a browser.\n  if (!isPlatformBrowser(injector)) return;\n\n  const afterRenderEventManager = injector.get(AfterRenderEventManager);\n  afterRenderEventManager.internalCallbacks.push(callback);\n}\n\n/**\n * Register a callback to be invoked each time the application\n * finishes rendering.\n *\n * <div class=\"alert is-critical\">\n *\n * You should always explicitly specify a non-default [phase](api/core/AfterRenderPhase), or you\n * risk significant performance degradation.\n *\n * </div>\n *\n * Note that the callback will run\n * - in the order it was registered\n * - once per render\n * - on browser platforms only\n *\n * <div class=\"alert is-important\">\n *\n * Components are not guaranteed to be [hydrated](guide/hydration) before the callback runs.\n * You must use caution when directly reading or writing the DOM and layout.\n *\n * </div>\n *\n * @param callback A callback function to register\n *\n * @usageNotes\n *\n * Use `afterRender` to read or write the DOM after each render.\n *\n * ### Example\n * ```ts\n * @Component({\n *   selector: 'my-cmp',\n *   template: `<span #content>{{ ... }}</span>`,\n * })\n * export class MyComponent {\n *   @ViewChild('content') contentRef: ElementRef;\n *\n *   constructor() {\n *     afterRender(() => {\n *       console.log('content height: ' + this.contentRef.nativeElement.scrollHeight);\n *     }, {phase: AfterRenderPhase.Read});\n *   }\n * }\n * ```\n *\n * @developerPreview\n */\nexport function afterRender(callback: VoidFunction, options?: AfterRenderOptions): AfterRenderRef {\n  ngDevMode &&\n      assertNotInReactiveContext(\n          afterRender,\n          'Call `afterRender` outside of a reactive context. For example, schedule the render ' +\n              'callback inside the component constructor`.');\n\n  !options && assertInInjectionContext(afterRender);\n  const injector = options?.injector ?? inject(Injector);\n\n  if (!isPlatformBrowser(injector)) {\n    return NOOP_AFTER_RENDER_REF;\n  }\n\n  performanceMarkFeature('NgAfterRender');\n\n  const afterRenderEventManager = injector.get(AfterRenderEventManager);\n  // Lazily initialize the handler implementation, if necessary. This is so that it can be\n  // tree-shaken if `afterRender` and `afterNextRender` aren't used.\n  const callbackHandler = afterRenderEventManager.handler ??= new AfterRenderCallbackHandlerImpl();\n  const phase = options?.phase ?? AfterRenderPhase.MixedReadWrite;\n  const destroy = () => {\n    callbackHandler.unregister(instance);\n    unregisterFn();\n  };\n  const unregisterFn = injector.get(DestroyRef).onDestroy(destroy);\n  const instance = new AfterRenderCallback(injector, phase, callback);\n\n  callbackHandler.register(instance);\n  return {destroy};\n}\n\n/**\n * Register a callback to be invoked the next time the application\n * finishes rendering.\n *\n * <div class=\"alert is-critical\">\n *\n * You should always explicitly specify a non-default [phase](api/core/AfterRenderPhase), or you\n * risk significant performance degradation.\n *\n * </div>\n *\n * Note that the callback will run\n * - in the order it was registered\n * - on browser platforms only\n *\n * <div class=\"alert is-important\">\n *\n * Components are not guaranteed to be [hydrated](guide/hydration) before the callback runs.\n * You must use caution when directly reading or writing the DOM and layout.\n *\n * </div>\n *\n * @param callback A callback function to register\n *\n * @usageNotes\n *\n * Use `afterNextRender` to read or write the DOM once,\n * for example to initialize a non-Angular library.\n *\n * ### Example\n * ```ts\n * @Component({\n *   selector: 'my-chart-cmp',\n *   template: `<div #chart>{{ ... }}</div>`,\n * })\n * export class MyChartCmp {\n *   @ViewChild('chart') chartRef: ElementRef;\n *   chart: MyChart|null;\n *\n *   constructor() {\n *     afterNextRender(() => {\n *       this.chart = new MyChart(this.chartRef.nativeElement);\n *     }, {phase: AfterRenderPhase.Write});\n *   }\n * }\n * ```\n *\n * @developerPreview\n */\nexport function afterNextRender(\n    callback: VoidFunction, options?: AfterRenderOptions): AfterRenderRef {\n  !options && assertInInjectionContext(afterNextRender);\n  const injector = options?.injector ?? inject(Injector);\n\n  if (!isPlatformBrowser(injector)) {\n    return NOOP_AFTER_RENDER_REF;\n  }\n\n  performanceMarkFeature('NgAfterNextRender');\n\n  const afterRenderEventManager = injector.get(AfterRenderEventManager);\n  // Lazily initialize the handler implementation, if necessary. This is so that it can be\n  // tree-shaken if `afterRender` and `afterNextRender` aren't used.\n  const callbackHandler = afterRenderEventManager.handler ??= new AfterRenderCallbackHandlerImpl();\n  const phase = options?.phase ?? AfterRenderPhase.MixedReadWrite;\n  const destroy = () => {\n    callbackHandler.unregister(instance);\n    unregisterFn();\n  };\n  const unregisterFn = injector.get(DestroyRef).onDestroy(destroy);\n  const instance = new AfterRenderCallback(injector, phase, () => {\n    destroy();\n    callback();\n  });\n\n  callbackHandler.register(instance);\n  return {destroy};\n}\n\n/**\n * A wrapper around a function to be used as an after render callback.\n */\nclass AfterRenderCallback {\n  private zone: NgZone;\n  private errorHandler: ErrorHandler|null;\n\n  constructor(\n      injector: Injector, public readonly phase: AfterRenderPhase,\n      private callbackFn: VoidFunction) {\n    this.zone = injector.get(NgZone);\n    this.errorHandler = injector.get(ErrorHandler, null, {optional: true});\n  }\n\n  invoke() {\n    try {\n      this.zone.runOutsideAngular(this.callbackFn);\n    } catch (err) {\n      this.errorHandler?.handleError(err);\n    }\n  }\n}\n\n/**\n * Implements `afterRender` and `afterNextRender` callback handler logic.\n */\ninterface AfterRenderCallbackHandler {\n  /**\n   * Register a new callback.\n   */\n  register(callback: AfterRenderCallback): void;\n\n  /**\n   * Unregister an existing callback.\n   */\n  unregister(callback: AfterRenderCallback): void;\n\n  /**\n   * Execute callbacks. Returns `true` if any callbacks were executed.\n   */\n  execute(): boolean;\n\n  /**\n   * Perform any necessary cleanup.\n   */\n  destroy(): void;\n}\n\n/**\n * Core functionality for `afterRender` and `afterNextRender`. Kept separate from\n * `AfterRenderEventManager` for tree-shaking.\n */\nclass AfterRenderCallbackHandlerImpl implements AfterRenderCallbackHandler {\n  private executingCallbacks = false;\n  private buckets = {\n    // Note: the order of these keys controls the order the phases are run.\n    [AfterRenderPhase.EarlyRead]: new Set<AfterRenderCallback>(),\n    [AfterRenderPhase.Write]: new Set<AfterRenderCallback>(),\n    [AfterRenderPhase.MixedReadWrite]: new Set<AfterRenderCallback>(),\n    [AfterRenderPhase.Read]: new Set<AfterRenderCallback>(),\n  };\n  private deferredCallbacks = new Set<AfterRenderCallback>();\n\n  register(callback: AfterRenderCallback): void {\n    // If we're currently running callbacks, new callbacks should be deferred\n    // until the next render operation.\n    const target = this.executingCallbacks ? this.deferredCallbacks : this.buckets[callback.phase];\n    target.add(callback);\n  }\n\n  unregister(callback: AfterRenderCallback): void {\n    this.buckets[callback.phase].delete(callback);\n    this.deferredCallbacks.delete(callback);\n  }\n\n  execute(): boolean {\n    let callbacksExecuted = false;\n    this.executingCallbacks = true;\n    for (const bucket of Object.values(this.buckets)) {\n      for (const callback of bucket) {\n        callbacksExecuted = true;\n        callback.invoke();\n      }\n    }\n    this.executingCallbacks = false;\n\n    for (const callback of this.deferredCallbacks) {\n      this.buckets[callback.phase].add(callback);\n    }\n    this.deferredCallbacks.clear();\n    return callbacksExecuted;\n  }\n\n  destroy(): void {\n    for (const bucket of Object.values(this.buckets)) {\n      bucket.clear();\n    }\n    this.deferredCallbacks.clear();\n  }\n}\n\n/**\n * Implements core timing for `afterRender` and `afterNextRender` events.\n * Delegates to an optional `AfterRenderCallbackHandler` for implementation.\n */\nexport class AfterRenderEventManager {\n  /* @internal */\n  handler: AfterRenderCallbackHandler|null = null;\n\n  /* @internal */\n  internalCallbacks: VoidFunction[] = [];\n\n  /**\n   * Executes callbacks. Returns `true` if any callbacks executed.\n   */\n  execute(): boolean {\n    // Note: internal callbacks power `internalAfterNextRender`. Since internal callbacks\n    // are fairly trivial, they are kept separate so that `AfterRenderCallbackHandlerImpl`\n    // can still be tree-shaken unless used by the application.\n    const callbacks = [...this.internalCallbacks];\n    this.internalCallbacks.length = 0;\n    for (const callback of callbacks) {\n      callback();\n    }\n    const handlerCallbacksExecuted = this.handler?.execute();\n    return !!handlerCallbacksExecuted || callbacks.length > 0;\n  }\n\n  ngOnDestroy() {\n    this.handler?.destroy();\n    this.handler = null;\n    this.internalCallbacks.length = 0;\n  }\n\n  /** @nocollapse */\n  static ɵprov = /** @pureOrBreakMyCode */ ɵɵdefineInjectable({\n    token: AfterRenderEventManager,\n    providedIn: 'root',\n    factory: () => new AfterRenderEventManager(),\n  });\n}\n"]}