/**
 * @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 { assertInInjectionContext, Injector, ɵɵdefineInjectable } from '../di';
import { inject } from '../di/injector_compatibility';
import { ErrorHandler } from '../error_handler';
import { RuntimeError } from '../errors';
import { DestroyRef } from '../linker/destroy_ref';
import { assertGreaterThan } from '../util/assert';
import { NgZone } from '../zone';
import { isPlatformBrowser } from './util/misc_utils';
/**
 * Register a callback to be invoked each time the application
 * finishes rendering.
 *
 * 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);
 *     });
 *   }
 * }
 * ```
 *
 * @developerPreview
 */
export function afterRender(callback, options) {
    !options && assertInInjectionContext(afterRender);
    const injector = options?.injector ?? inject(Injector);
    if (!isPlatformBrowser(injector)) {
        return { destroy() { } };
    }
    let destroy;
    const unregisterFn = injector.get(DestroyRef).onDestroy(() => destroy?.());
    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 ngZone = injector.get(NgZone);
    const errorHandler = injector.get(ErrorHandler, null, { optional: true });
    const instance = new AfterRenderCallback(ngZone, errorHandler, callback);
    destroy = () => {
        callbackHandler.unregister(instance);
        unregisterFn();
    };
    callbackHandler.register(instance);
    return { destroy };
}
/**
 * Register a callback to be invoked the next time the application
 * finishes rendering.
 *
 * 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);
 *     });
 *   }
 * }
 * ```
 *
 * @developerPreview
 */
export function afterNextRender(callback, options) {
    !options && assertInInjectionContext(afterNextRender);
    const injector = options?.injector ?? inject(Injector);
    if (!isPlatformBrowser(injector)) {
        return { destroy() { } };
    }
    let destroy;
    const unregisterFn = injector.get(DestroyRef).onDestroy(() => destroy?.());
    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 ngZone = injector.get(NgZone);
    const errorHandler = injector.get(ErrorHandler, null, { optional: true });
    const instance = new AfterRenderCallback(ngZone, errorHandler, () => {
        destroy?.();
        callback();
    });
    destroy = () => {
        callbackHandler.unregister(instance);
        unregisterFn();
    };
    callbackHandler.register(instance);
    return { destroy };
}
/**
 * A wrapper around a function to be used as an after render callback.
 */
class AfterRenderCallback {
    constructor(zone, errorHandler, callbackFn) {
        this.zone = zone;
        this.errorHandler = errorHandler;
        this.callbackFn = callbackFn;
    }
    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.callbacks = new Set();
        this.deferredCallbacks = new Set();
    }
    validateBegin() {
        if (this.executingCallbacks) {
            throw new RuntimeError(102 /* RuntimeErrorCode.RECURSIVE_APPLICATION_RENDER */, ngDevMode &&
                'A new render operation began before the previous operation ended. ' +
                    'Did you trigger change detection from afterRender or afterNextRender?');
        }
    }
    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.callbacks;
        target.add(callback);
    }
    unregister(callback) {
        this.callbacks.delete(callback);
        this.deferredCallbacks.delete(callback);
    }
    execute() {
        this.executingCallbacks = true;
        for (const callback of this.callbacks) {
            callback.invoke();
        }
        this.executingCallbacks = false;
        for (const callback of this.deferredCallbacks) {
            this.callbacks.add(callback);
        }
        this.deferredCallbacks.clear();
    }
    destroy() {
        this.callbacks.clear();
        this.deferredCallbacks.clear();
    }
}
/**
 * Implements core timing for `afterRender` and `afterNextRender` events.
 * Delegates to an optional `AfterRenderCallbackHandler` for implementation.
 */
export class AfterRenderEventManager {
    constructor() {
        this.renderDepth = 0;
        /* @internal */
        this.handler = null;
    }
    /**
     * Mark the beginning of a render operation (i.e. CD cycle).
     * Throws if called while executing callbacks.
     */
    begin() {
        this.handler?.validateBegin();
        this.renderDepth++;
    }
    /**
     * Mark the end of a render operation. Callbacks will be
     * executed if there are no more pending operations.
     */
    end() {
        ngDevMode && assertGreaterThan(this.renderDepth, 0, 'renderDepth must be greater than 0');
        this.renderDepth--;
        if (this.renderDepth === 0) {
            this.handler?.execute();
        }
    }
    ngOnDestroy() {
        this.handler?.destroy();
        this.handler = null;
    }
    /** @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 {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 {NgZone} from '../zone';\n\nimport {isPlatformBrowser} from './util/misc_utils';\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/**\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 * Register a callback to be invoked each time the application\n * finishes rendering.\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 *     });\n *   }\n * }\n * ```\n *\n * @developerPreview\n */\nexport function afterRender(callback: VoidFunction, options?: AfterRenderOptions): AfterRenderRef {\n  !options && assertInInjectionContext(afterRender);\n  const injector = options?.injector ?? inject(Injector);\n\n  if (!isPlatformBrowser(injector)) {\n    return {destroy() {}};\n  }\n\n  let destroy: VoidFunction|undefined;\n  const unregisterFn = injector.get(DestroyRef).onDestroy(() => destroy?.());\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 ngZone = injector.get(NgZone);\n  const errorHandler = injector.get(ErrorHandler, null, {optional: true});\n  const instance = new AfterRenderCallback(ngZone, errorHandler, callback);\n\n  destroy = () => {\n    callbackHandler.unregister(instance);\n    unregisterFn();\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 * 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 *     });\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 {destroy() {}};\n  }\n\n  let destroy: VoidFunction|undefined;\n  const unregisterFn = injector.get(DestroyRef).onDestroy(() => destroy?.());\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 ngZone = injector.get(NgZone);\n  const errorHandler = injector.get(ErrorHandler, null, {optional: true});\n  const instance = new AfterRenderCallback(ngZone, errorHandler, () => {\n    destroy?.();\n    callback();\n  });\n\n  destroy = () => {\n    callbackHandler.unregister(instance);\n    unregisterFn();\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  constructor(\n      private zone: NgZone, private errorHandler: ErrorHandler|null,\n      private callbackFn: VoidFunction) {}\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   * Validate that it's safe for a render operation to begin,\n   * throwing if not. Not guaranteed to be called if a render\n   * operation is started before handler was registered.\n   */\n  validateBegin(): void;\n\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.\n   */\n  execute(): void;\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 callbacks = new Set<AfterRenderCallback>();\n  private deferredCallbacks = new Set<AfterRenderCallback>();\n\n  validateBegin(): void {\n    if (this.executingCallbacks) {\n      throw new RuntimeError(\n          RuntimeErrorCode.RECURSIVE_APPLICATION_RENDER,\n          ngDevMode &&\n              'A new render operation began before the previous operation ended. ' +\n                  'Did you trigger change detection from afterRender or afterNextRender?');\n    }\n  }\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.callbacks;\n    target.add(callback);\n  }\n\n  unregister(callback: AfterRenderCallback): void {\n    this.callbacks.delete(callback);\n    this.deferredCallbacks.delete(callback);\n  }\n\n  execute(): void {\n    this.executingCallbacks = true;\n    for (const callback of this.callbacks) {\n      callback.invoke();\n    }\n    this.executingCallbacks = false;\n\n    for (const callback of this.deferredCallbacks) {\n      this.callbacks.add(callback);\n    }\n    this.deferredCallbacks.clear();\n  }\n\n  destroy(): void {\n    this.callbacks.clear();\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  private renderDepth = 0;\n\n  /* @internal */\n  handler: AfterRenderCallbackHandler|null = null;\n\n  /**\n   * Mark the beginning of a render operation (i.e. CD cycle).\n   * Throws if called while executing callbacks.\n   */\n  begin() {\n    this.handler?.validateBegin();\n    this.renderDepth++;\n  }\n\n  /**\n   * Mark the end of a render operation. Callbacks will be\n   * executed if there are no more pending operations.\n   */\n  end() {\n    ngDevMode && assertGreaterThan(this.renderDepth, 0, 'renderDepth must be greater than 0');\n    this.renderDepth--;\n\n    if (this.renderDepth === 0) {\n      this.handler?.execute();\n    }\n  }\n\n  ngOnDestroy() {\n    this.handler?.destroy();\n    this.handler = null;\n  }\n\n  /** @nocollapse */\n  static ɵprov = /** @pureOrBreakMyCode */ ɵɵdefineInjectable({\n    token: AfterRenderEventManager,\n    providedIn: 'root',\n    factory: () => new AfterRenderEventManager(),\n  });\n}\n"]}