@angular/core 16.2.4 → 16.2.5

package/fesm2022/rxjs-interop.mjs

@@ -1,5 +1,5 @@
 /**
- * @license Angular v16.2.4
+ * @license Angular v16.2.5
  * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */

package/fesm2022/testing.mjs

@@ -1,5 +1,5 @@
 /**
- * @license Angular v16.2.4
+ * @license Angular v16.2.5
  * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -10905,7 +10905,7 @@ class Version {
 /**
  * @publicApi
  */
-const VERSION = new Version('16.2.4');
+const VERSION = new Version('16.2.5');
 
 // This default value is when checking the hierarchy for a token.
 //
@@ -10926,6 +10926,66 @@ const VERSION = new Version('16.2.4');
 // - mod2.injector.get(token, default)
 const NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR = {};
 
+const ERROR_ORIGINAL_ERROR = 'ngOriginalError';
+function wrappedError(message, originalError) {
+    const msg = `${message} caused by: ${originalError instanceof Error ? originalError.message : originalError}`;
+    const error = Error(msg);
+    error[ERROR_ORIGINAL_ERROR] = originalError;
+    return error;
+}
+function getOriginalError(error) {
+    return error[ERROR_ORIGINAL_ERROR];
+}
+
+/**
+ * Provides a hook for centralized exception handling.
+ *
+ * The default implementation of `ErrorHandler` prints error messages to the `console`. To
+ * intercept error handling, write a custom exception handler that replaces this default as
+ * appropriate for your app.
+ *
+ * @usageNotes
+ * ### Example
+ *
+ * ```
+ * class MyErrorHandler implements ErrorHandler {
+ *   handleError(error) {
+ *     // do something with the exception
+ *   }
+ * }
+ *
+ * @NgModule({
+ *   providers: [{provide: ErrorHandler, useClass: MyErrorHandler}]
+ * })
+ * class MyModule {}
+ * ```
+ *
+ * @publicApi
+ */
+class ErrorHandler {
+    constructor() {
+        /**
+         * @internal
+         */
+        this._console = console;
+    }
+    handleError(error) {
+        const originalError = this._findOriginalError(error);
+        this._console.error('ERROR', error);
+        if (originalError) {
+            this._console.error('ORIGINAL ERROR', originalError);
+        }
+    }
+    /** @internal */
+    _findOriginalError(error) {
+        let e = error && getOriginalError(error);
+        while (e && getOriginalError(e)) {
+            e = getOriginalError(e);
+        }
+        return e || null;
+    }
+}
+
 /**
  * `DestroyRef` lets you set callbacks to run for any cleanup or destruction behavior.
  * The scope of this destruction depends on where `DestroyRef` is injected. If `DestroyRef`
@@ -11580,14 +11640,18 @@ function afterRender(callback, options) {
     }
     let destroy;
     const unregisterFn = injector.get(DestroyRef).onDestroy(() => destroy?.());
-    const manager = injector.get(AfterRenderEventManager);
+    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 instance = new AfterRenderCallback(() => ngZone.runOutsideAngular(callback));
+    const errorHandler = injector.get(ErrorHandler, null, { optional: true });
+    const instance = new AfterRenderCallback(ngZone, errorHandler, callback);
     destroy = () => {
-        manager.unregister(instance);
+        callbackHandler.unregister(instance);
         unregisterFn();
     };
-    manager.register(instance);
+    callbackHandler.register(instance);
     return { destroy };
 }
 /**
@@ -11640,89 +11704,117 @@ function afterNextRender(callback, options) {
     }
     let destroy;
     const unregisterFn = injector.get(DestroyRef).onDestroy(() => destroy?.());
-    const manager = injector.get(AfterRenderEventManager);
+    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 instance = new AfterRenderCallback(() => {
+    const errorHandler = injector.get(ErrorHandler, null, { optional: true });
+    const instance = new AfterRenderCallback(ngZone, errorHandler, () => {
         destroy?.();
-        ngZone.runOutsideAngular(callback);
+        callback();
     });
     destroy = () => {
-        manager.unregister(instance);
+        callbackHandler.unregister(instance);
         unregisterFn();
     };
-    manager.register(instance);
+    callbackHandler.register(instance);
     return { destroy };
 }
 /**
  * A wrapper around a function to be used as an after render callback.
- * @private
  */
 class AfterRenderCallback {
-    constructor(callback) {
-        this.callback = callback;
+    constructor(zone, errorHandler, callbackFn) {
+        this.zone = zone;
+        this.errorHandler = errorHandler;
+        this.callbackFn = callbackFn;
     }
     invoke() {
-        this.callback();
+        try {
+            this.zone.runOutsideAngular(this.callbackFn);
+        }
+        catch (err) {
+            this.errorHandler?.handleError(err);
+        }
     }
 }
 /**
- * Implements `afterRender` and `afterNextRender` callback manager logic.
+ * Core functionality for `afterRender` and `afterNextRender`. Kept separate from
+ * `AfterRenderEventManager` for tree-shaking.
  */
-class AfterRenderEventManager {
+class AfterRenderCallbackHandlerImpl {
     constructor() {
+        this.executingCallbacks = false;
         this.callbacks = new Set();
         this.deferredCallbacks = new Set();
-        this.renderDepth = 0;
-        this.runningCallbacks = false;
     }
-    /**
-     * Mark the beginning of a render operation (i.e. CD cycle).
-     * Throws if called from an `afterRender` callback.
-     */
-    begin() {
-        if (this.runningCallbacks) {
+    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?');
         }
-        this.renderDepth++;
-    }
-    /**
-     * Mark the end of a render operation. Registered callbacks
-     * are invoked if there are no more pending operations.
-     */
-    end() {
-        this.renderDepth--;
-        if (this.renderDepth === 0) {
-            try {
-                this.runningCallbacks = true;
-                for (const callback of this.callbacks) {
-                    callback.invoke();
-                }
-            }
-            finally {
-                this.runningCallbacks = false;
-                for (const callback of this.deferredCallbacks) {
-                    this.callbacks.add(callback);
-                }
-                this.deferredCallbacks.clear();
-            }
-        }
     }
     register(callback) {
         // If we're currently running callbacks, new callbacks should be deferred
         // until the next render operation.
-        const target = this.runningCallbacks ? this.deferredCallbacks : this.callbacks;
+        const target = this.executingCallbacks ? this.deferredCallbacks : this.callbacks;
         target.add(callback);
     }
     unregister(callback) {
         this.callbacks.delete(callback);
         this.deferredCallbacks.delete(callback);
     }
-    ngOnDestroy() {
+    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.
+ */
+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,
@@ -11756,66 +11848,6 @@ function markViewDirty(lView) {
     return null;
 }
 
-const ERROR_ORIGINAL_ERROR = 'ngOriginalError';
-function wrappedError(message, originalError) {
-    const msg = `${message} caused by: ${originalError instanceof Error ? originalError.message : originalError}`;
-    const error = Error(msg);
-    error[ERROR_ORIGINAL_ERROR] = originalError;
-    return error;
-}
-function getOriginalError(error) {
-    return error[ERROR_ORIGINAL_ERROR];
-}
-
-/**
- * Provides a hook for centralized exception handling.
- *
- * The default implementation of `ErrorHandler` prints error messages to the `console`. To
- * intercept error handling, write a custom exception handler that replaces this default as
- * appropriate for your app.
- *
- * @usageNotes
- * ### Example
- *
- * ```
- * class MyErrorHandler implements ErrorHandler {
- *   handleError(error) {
- *     // do something with the exception
- *   }
- * }
- *
- * @NgModule({
- *   providers: [{provide: ErrorHandler, useClass: MyErrorHandler}]
- * })
- * class MyModule {}
- * ```
- *
- * @publicApi
- */
-class ErrorHandler {
-    constructor() {
-        /**
-         * @internal
-         */
-        this._console = console;
-    }
-    handleError(error) {
-        const originalError = this._findOriginalError(error);
-        this._console.error('ERROR', error);
-        if (originalError) {
-            this._console.error('ORIGINAL ERROR', originalError);
-        }
-    }
-    /** @internal */
-    _findOriginalError(error) {
-        let e = error && getOriginalError(error);
-        while (e && getOriginalError(e)) {
-            e = getOriginalError(e);
-        }
-        return e || null;
-    }
-}
-
 /**
  * Internal token that specifies whether DOM reuse logic
  * during hydration is enabled.