@angular/core 16.2.5 → 16.2.6

package/fesm2022/core.mjs

@@ -1,5 +1,5 @@
 /**
- * @license Angular v16.2.5
+ * @license Angular v16.2.6
  * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -2294,7 +2294,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`.
  *
@@ -2472,7 +2472,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();
@@ -2546,6 +2548,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
@@ -2610,60 +2615,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();
@@ -2708,11 +2718,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);
@@ -2805,16 +2820,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
@@ -10256,7 +10276,7 @@ class Version {
 /**
  * @publicApi
  */
-const VERSION = new Version('16.2.5');
+const VERSION = new Version('16.2.6');
 
 // This default value is when checking the hierarchy for a token.
 //