@angular/core 16.2.4 → 16.2.6

package/fesm2022/testing.mjs

@@ -1,5 +1,5 @@
 /**
- * @license Angular v16.2.4
+ * @license Angular v16.2.6
  * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -3556,7 +3556,7 @@ function getFactoryDef(type, throwNotFound) {
  *
  * This can be used to auto-unwrap signals in various cases, or to auto-wrap non-signal values.
  */
-const SIGNAL = Symbol('SIGNAL');
+const SIGNAL = /* @__PURE__ */ Symbol('SIGNAL');
 /**
  * Checks if the given `value` is a reactive `Signal`.
  *
@@ -3734,7 +3734,9 @@ function consumerAfterComputation(node, prevConsumer) {
         }
     }
     // Truncate the producer tracking arrays.
-    for (let i = node.nextProducerIndex; i < node.producerNode.length; i++) {
+    // Perf note: this is essentially truncating the length to `node.nextProducerIndex`, but
+    // benchmarking has shown that individual pop operations are faster.
+    while (node.producerNode.length > node.nextProducerIndex) {
         node.producerNode.pop();
         node.producerLastReadVersion.pop();
         node.producerIndexOfThis.pop();
@@ -3808,6 +3810,9 @@ function producerAddLiveConsumer(node, consumer, indexOfThis) {
 function producerRemoveLiveConsumerAtIndex(node, idx) {
     assertProducerNode(node);
     assertConsumerNode(node);
+    if (typeof ngDevMode !== 'undefined' && ngDevMode && idx >= node.liveConsumerNode.length) {
+        throw new Error(`Assertion error: active consumer index ${idx} is out of bounds of ${node.liveConsumerNode.length} consumers)`);
+    }
     if (node.liveConsumerNode.length === 1) {
         // When removing the last live consumer, we will no longer be live. We need to remove
         // ourselves from our producers' tracking (which may cause consumer-producers to lose
@@ -3872,60 +3877,65 @@ function computed(computation, options) {
  * A dedicated symbol used before a computed value has been calculated for the first time.
  * Explicitly typed as `any` so we can use it as signal's value.
  */
-const UNSET = Symbol('UNSET');
+const UNSET = /* @__PURE__ */ Symbol('UNSET');
 /**
  * A dedicated symbol used in place of a computed signal value to indicate that a given computation
  * is in progress. Used to detect cycles in computation chains.
  * Explicitly typed as `any` so we can use it as signal's value.
  */
-const COMPUTING = Symbol('COMPUTING');
+const COMPUTING = /* @__PURE__ */ Symbol('COMPUTING');
 /**
  * A dedicated symbol used in place of a computed signal value to indicate that a given computation
  * failed. The thrown error is cached until the computation gets dirty again.
  * Explicitly typed as `any` so we can use it as signal's value.
  */
-const ERRORED = Symbol('ERRORED');
-const COMPUTED_NODE = {
-    ...REACTIVE_NODE,
-    value: UNSET,
-    dirty: true,
-    error: null,
-    equal: defaultEquals,
-    producerMustRecompute(node) {
-        // Force a recomputation if there's no current value, or if the current value is in the process
-        // of being calculated (which should throw an error).
-        return node.value === UNSET || node.value === COMPUTING;
-    },
-    producerRecomputeValue(node) {
-        if (node.value === COMPUTING) {
-            // Our computation somehow led to a cyclic read of itself.
-            throw new Error('Detected cycle in computations.');
-        }
-        const oldValue = node.value;
-        node.value = COMPUTING;
-        const prevConsumer = consumerBeforeComputation(node);
-        let newValue;
-        try {
-            newValue = node.computation();
-        }
-        catch (err) {
-            newValue = ERRORED;
-            node.error = err;
-        }
-        finally {
-            consumerAfterComputation(node, prevConsumer);
-        }
-        if (oldValue !== UNSET && oldValue !== ERRORED && newValue !== ERRORED &&
-            node.equal(oldValue, newValue)) {
-            // No change to `valueVersion` - old and new values are
-            // semantically equivalent.
-            node.value = oldValue;
-            return;
-        }
-        node.value = newValue;
-        node.version++;
-    },
-};
+const ERRORED = /* @__PURE__ */ Symbol('ERRORED');
+// Note: Using an IIFE here to ensure that the spread assignment is not considered
+// a side-effect, ending up preserving `COMPUTED_NODE` and `REACTIVE_NODE`.
+// TODO: remove when https://github.com/evanw/esbuild/issues/3392 is resolved.
+const COMPUTED_NODE = /* @__PURE__ */ (() => {
+    return {
+        ...REACTIVE_NODE,
+        value: UNSET,
+        dirty: true,
+        error: null,
+        equal: defaultEquals,
+        producerMustRecompute(node) {
+            // Force a recomputation if there's no current value, or if the current value is in the
+            // process of being calculated (which should throw an error).
+            return node.value === UNSET || node.value === COMPUTING;
+        },
+        producerRecomputeValue(node) {
+            if (node.value === COMPUTING) {
+                // Our computation somehow led to a cyclic read of itself.
+                throw new Error('Detected cycle in computations.');
+            }
+            const oldValue = node.value;
+            node.value = COMPUTING;
+            const prevConsumer = consumerBeforeComputation(node);
+            let newValue;
+            try {
+                newValue = node.computation();
+            }
+            catch (err) {
+                newValue = ERRORED;
+                node.error = err;
+            }
+            finally {
+                consumerAfterComputation(node, prevConsumer);
+            }
+            if (oldValue !== UNSET && oldValue !== ERRORED && newValue !== ERRORED &&
+                node.equal(oldValue, newValue)) {
+                // No change to `valueVersion` - old and new values are
+                // semantically equivalent.
+                node.value = oldValue;
+                return;
+            }
+            node.value = newValue;
+            node.version++;
+        },
+    };
+})();
 
 function defaultThrowError() {
     throw new Error();
@@ -3970,11 +3980,16 @@ function setPostSignalSetFn(fn) {
     postSignalSetFn = fn;
     return prev;
 }
-const SIGNAL_NODE = {
-    ...REACTIVE_NODE,
-    equal: defaultEquals,
-    readonlyFn: undefined,
-};
+// Note: Using an IIFE here to ensure that the spread assignment is not considered
+// a side-effect, ending up preserving `COMPUTED_NODE` and `REACTIVE_NODE`.
+// TODO: remove when https://github.com/evanw/esbuild/issues/3392 is resolved.
+const SIGNAL_NODE = /* @__PURE__ */ (() => {
+    return {
+        ...REACTIVE_NODE,
+        equal: defaultEquals,
+        readonlyFn: undefined,
+    };
+})();
 function signalValueChanged(node) {
     node.version++;
     producerNotifyConsumers(node);
@@ -4067,16 +4082,21 @@ function watch(fn, schedule, allowSignalWrites) {
     return node.ref;
 }
 const NOOP_CLEANUP_FN = () => { };
-const WATCH_NODE = {
-    ...REACTIVE_NODE,
-    consumerIsAlwaysLive: true,
-    consumerAllowSignalWrites: false,
-    consumerMarkedDirty: (node) => {
-        node.schedule(node.ref);
-    },
-    hasRun: false,
-    cleanupFn: NOOP_CLEANUP_FN,
-};
+// Note: Using an IIFE here to ensure that the spread assignment is not considered
+// a side-effect, ending up preserving `COMPUTED_NODE` and `REACTIVE_NODE`.
+// TODO: remove when https://github.com/evanw/esbuild/issues/3392 is resolved.
+const WATCH_NODE = /* @__PURE__ */ (() => {
+    return {
+        ...REACTIVE_NODE,
+        consumerIsAlwaysLive: true,
+        consumerAllowSignalWrites: false,
+        consumerMarkedDirty: (node) => {
+            node.schedule(node.ref);
+        },
+        hasRun: false,
+        cleanupFn: NOOP_CLEANUP_FN,
+    };
+})();
 
 function setAlternateWeakRefImpl(impl) {
     // TODO: remove this function
@@ -10905,7 +10925,7 @@ class Version {
 /**
  * @publicApi
  */
-const VERSION = new Version('16.2.4');
+const VERSION = new Version('16.2.6');
 
 // This default value is when checking the hierarchy for a token.
 //
@@ -10926,6 +10946,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 +11660,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 +11724,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 +11868,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.