@angular/core 16.0.0-rc.1 → 16.0.0-rc.2

package/fesm2022/core.mjs

@@ -1,5 +1,5 @@
 /**
- * @license Angular v16.0.0-rc.1
+ * @license Angular v16.0.0-rc.2
  * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -9963,7 +9963,7 @@ class Version {
 /**
  * @publicApi
  */
-const VERSION = new Version('16.0.0-rc.1');
+const VERSION = new Version('16.0.0-rc.2');
 
 // This default value is when checking the hierarchy for a token.
 //
@@ -10111,12 +10111,11 @@ function isInSkipHydrationBlock(tNode) {
     return false;
 }
 
-const NG_DEV_MODE$1 = typeof ngDevMode === 'undefined' || !!ngDevMode;
 /**
  * Internal token that specifies whether DOM reuse logic
  * during hydration is enabled.
  */
-const IS_HYDRATION_DOM_REUSE_ENABLED = new InjectionToken(NG_DEV_MODE$1 ? 'IS_HYDRATION_DOM_REUSE_ENABLED' : '');
+const IS_HYDRATION_DOM_REUSE_ENABLED = new InjectionToken((typeof ngDevMode === 'undefined' || !!ngDevMode) ? 'IS_HYDRATION_DOM_REUSE_ENABLED' : '');
 // By default (in client rendering mode), we remove all the contents
 // of the host element and render an application after that.
 const PRESERVE_HOST_CONTENT_DEFAULT = false;
@@ -10124,7 +10123,7 @@ const PRESERVE_HOST_CONTENT_DEFAULT = false;
  * Internal token that indicates whether host element content should be
  * retained during the bootstrap.
  */
-const PRESERVE_HOST_CONTENT = new InjectionToken(NG_DEV_MODE$1 ? 'PRESERVE_HOST_CONTENT' : '', {
+const PRESERVE_HOST_CONTENT = new InjectionToken((typeof ngDevMode === 'undefined' || !!ngDevMode) ? 'PRESERVE_HOST_CONTENT' : '', {
     providedIn: 'root',
     factory: () => PRESERVE_HOST_CONTENT_DEFAULT,
 });
@@ -10282,7 +10281,6 @@ function getExpressionChangedErrorDetails(lView, bindingIndex, oldValue, newValu
     return { propName: undefined, oldValue, newValue };
 }
 
-const NG_DEV_MODE = typeof ngDevMode === 'undefined' || ngDevMode;
 class ReactiveLViewConsumer extends ReactiveNode {
     constructor() {
         super(...arguments);
@@ -10290,11 +10288,12 @@ class ReactiveLViewConsumer extends ReactiveNode {
         this._lView = null;
     }
     set lView(lView) {
-        NG_DEV_MODE && assertEqual(this._lView, null, 'Consumer already associated with a view.');
+        (typeof ngDevMode === 'undefined' || ngDevMode) &&
+            assertEqual(this._lView, null, 'Consumer already associated with a view.');
         this._lView = lView;
     }
     onConsumerDependencyMayHaveChanged() {
-        NG_DEV_MODE &&
+        (typeof ngDevMode === 'undefined' || ngDevMode) &&
             assertDefined(this._lView, 'Updating a signal during template or host binding execution is not allowed.');
         markViewDirty(this._lView);
     }
@@ -10712,8 +10711,9 @@ function processHostBindingOpCodes(tView, lView) {
         }
     }
     finally {
-        lView[REACTIVE_HOST_BINDING_CONSUMER] === null &&
+        if (lView[REACTIVE_HOST_BINDING_CONSUMER] === null) {
             commitLViewConsumerIfHasProducers(lView, REACTIVE_HOST_BINDING_CONSUMER);
+        }
         setSelectedIndex(-1);
     }
 }
@@ -10768,7 +10768,6 @@ function createLView(parentLView, tView, context, flags, host, tHostNode, enviro
     lView[ID] = getUniqueLViewId();
     lView[HYDRATION] = hydrationInfo;
     lView[EMBEDDED_VIEW_INJECTOR] = embeddedViewInjector;
-    lView[REACTIVE_TEMPLATE_CONSUMER] = null;
     ngDevMode &&
         assertEqual(tView.type == 2 /* TViewType.Embedded */ ? parentLView !== null : true, true, 'Embedded views must have parentLView');
     lView[DECLARATION_COMPONENT_VIEW] =
@@ -11066,10 +11065,21 @@ function executeTemplate(tView, lView, templateFn, rf, context) {
         }
         const preHookType = isUpdatePhase ? 2 /* ProfilerEvent.TemplateUpdateStart */ : 0 /* ProfilerEvent.TemplateCreateStart */;
         profiler(preHookType, context);
-        consumer.runInContext(templateFn, rf, context);
+        if (isUpdatePhase) {
+            consumer.runInContext(templateFn, rf, context);
+        }
+        else {
+            const prevConsumer = setActiveConsumer(null);
+            try {
+                templateFn(rf, context);
+            }
+            finally {
+                setActiveConsumer(prevConsumer);
+            }
+        }
     }
     finally {
-        if (lView[REACTIVE_TEMPLATE_CONSUMER] === null) {
+        if (isUpdatePhase && lView[REACTIVE_TEMPLATE_CONSUMER] === null) {
             commitLViewConsumerIfHasProducers(lView, REACTIVE_TEMPLATE_CONSUMER);
         }
         setSelectedIndex(prevSelectedIndex);
@@ -11082,14 +11092,20 @@ function executeTemplate(tView, lView, templateFn, rf, context) {
 //////////////////////////
 function executeContentQueries(tView, tNode, lView) {
     if (isContentQueryHost(tNode)) {
-        const start = tNode.directiveStart;
-        const end = tNode.directiveEnd;
-        for (let directiveIndex = start; directiveIndex < end; directiveIndex++) {
-            const def = tView.data[directiveIndex];
-            if (def.contentQueries) {
-                def.contentQueries(1 /* RenderFlags.Create */, lView[directiveIndex], directiveIndex);
+        const prevConsumer = setActiveConsumer(null);
+        try {
+            const start = tNode.directiveStart;
+            const end = tNode.directiveEnd;
+            for (let directiveIndex = start; directiveIndex < end; directiveIndex++) {
+                const def = tView.data[directiveIndex];
+                if (def.contentQueries) {
+                    def.contentQueries(1 /* RenderFlags.Create */, lView[directiveIndex], directiveIndex);
+                }
             }
         }
+        finally {
+            setActiveConsumer(prevConsumer);
+        }
     }
 }
 /**
@@ -11908,17 +11924,11 @@ function setElementAttribute(renderer, element, namespace, tagName, name, value,
 function setInputsFromAttrs(lView, directiveIndex, instance, def, tNode, initialInputData) {
     const initialInputs = initialInputData[directiveIndex];
     if (initialInputs !== null) {
-        const setInput = def.setInput;
         for (let i = 0; i < initialInputs.length;) {
             const publicName = initialInputs[i++];
             const privateName = initialInputs[i++];
             const value = initialInputs[i++];
-            if (setInput !== null) {
-                def.setInput(instance, value, publicName, privateName);
-            }
-            else {
-                instance[privateName] = value;
-            }
+            writeToDirectiveInput(def, instance, publicName, privateName, value);
             if (ngDevMode) {
                 const nativeElement = getNativeByTNode(tNode, lView);
                 setNgReflectProperty(lView, nativeElement, tNode.type, privateName, value);
@@ -11926,6 +11936,20 @@ function setInputsFromAttrs(lView, directiveIndex, instance, def, tNode, initial
         }
     }
 }
+function writeToDirectiveInput(def, instance, publicName, privateName, value) {
+    const prevConsumer = setActiveConsumer(null);
+    try {
+        if (def.setInput !== null) {
+            def.setInput(instance, value, publicName, privateName);
+        }
+        else {
+            instance[privateName] = value;
+        }
+    }
+    finally {
+        setActiveConsumer(prevConsumer);
+    }
+}
 /**
  * Generates initialInputData for a node and stores it in the template's static storage
  * so subsequent template invocations don't have to recalculate it.
@@ -12220,7 +12244,13 @@ function checkNoChangesInternal(tView, lView, context, notifyErrorHandler = true
 function executeViewQueryFn(flags, viewQueryFn, component) {
     ngDevMode && assertDefined(viewQueryFn, 'View queries function to execute must be defined.');
     setCurrentQueryIndex(0);
-    viewQueryFn(flags, component);
+    const prevConsumer = setActiveConsumer(null);
+    try {
+        viewQueryFn(flags, component);
+    }
+    finally {
+        setActiveConsumer(prevConsumer);
+    }
 }
 ///////////////////////////////
 //// Bindings & interpolations
@@ -12308,12 +12338,7 @@ function setInputsForProperty(tView, lView, inputs, publicName, value) {
         const instance = lView[index];
         ngDevMode && assertIndexInRange(lView, index);
         const def = tView.data[index];
-        if (def.setInput !== null) {
-            def.setInput(instance, value, publicName, privateName);
-        }
-        else {
-            instance[privateName] = value;
-        }
+        writeToDirectiveInput(def, instance, publicName, privateName, value);
     }
 }
 /**
@@ -12371,7 +12396,7 @@ class EffectManager {
         this.queue = new Map();
     }
     create(effectFn, destroyRef, allowSignalWrites) {
-        const zone = Zone.current;
+        const zone = (typeof Zone === 'undefined') ? null : Zone.current;
         const watch = new Watch(effectFn, (watch) => {
             if (!this.all.has(watch)) {
                 return;
@@ -12399,7 +12424,12 @@ class EffectManager {
         }
         for (const [watch, zone] of this.queue) {
             this.queue.delete(watch);
-            zone.run(() => watch.run());
+            if (zone) {
+                zone.run(() => watch.run());
+            }
+            else {
+                watch.run();
+            }
         }
     }
     get isQueueEmpty() {
@@ -12481,6 +12511,21 @@ function collectNativeNodes(tView, lView, tNode, result, isProjection = false) {
                     collectNativeNodes(lViewInAContainer[TVIEW], lViewInAContainer, lViewFirstChildTNode, result);
                 }
             }
+            // When an LContainer is created, the anchor (comment) node is:
+            // - (1) either reused in case of an ElementContainer (<ng-container>)
+            // - (2) or a new comment node is created
+            // In the first case, the anchor comment node would be added to the final
+            // list by the code above (`result.push(unwrapRNode(lNode))`), but the second
+            // case requires extra handling: the anchor node needs to be added to the
+            // final list manually. See additional information in the `createAnchorNode`
+            // function in the `view_container_ref.ts`.
+            //
+            // In the first case, the same reference would be stored in the `NATIVE`
+            // and `HOST` slots in an LContainer. Otherwise, this is the second case and
+            // we should add an element to the final list.
+            if (lNode[NATIVE] !== lNode[HOST]) {
+                result.push(lNode[NATIVE]);
+            }
         }
         const tNodeType = tNode.type;
         if (tNodeType & 8 /* TNodeType.ElementContainer */) {
@@ -14748,10 +14793,10 @@ function locateRNodeByPath(path, lView) {
     const [referenceNode, ...navigationInstructions] = decompressNodeLocation(path);
     let ref;
     if (referenceNode === REFERENCE_NODE_HOST) {
-        ref = lView[0];
+        ref = lView[DECLARATION_COMPONENT_VIEW][HOST];
     }
     else if (referenceNode === REFERENCE_NODE_BODY) {
-        ref = ɵɵresolveBody(lView[0]);
+        ref = ɵɵresolveBody(lView[DECLARATION_COMPONENT_VIEW][HOST]);
     }
     else {
         const parentElementId = Number(referenceNode);
@@ -14795,6 +14840,7 @@ function navigateBetween(start, finish) {
 }
 /**
  * Calculates a path between 2 sibling nodes (generates a number of `NextSibling` navigations).
+ * Returns `null` if no such path exists between the given nodes.
  */
 function navigateBetweenSiblings(start, finish) {
     const nav = [];
@@ -14802,7 +14848,10 @@ function navigateBetweenSiblings(start, finish) {
     for (node = start; node != null && node !== finish; node = node.nextSibling) {
         nav.push(NodeNavigationStep.NextSibling);
     }
-    return node === null ? [] : nav;
+    // If the `node` becomes `null` or `undefined` at the end, that means that we
+    // didn't find the `end` node, thus return `null` (which would trigger serialization
+    // error to be produced).
+    return node == null ? null : nav;
 }
 /**
  * Calculates a path between 2 nodes in terms of `nextSibling` and `firstChild`
@@ -14825,10 +14874,11 @@ function calcPathForNode(tNode, lView) {
     let parentIndex;
     let parentRNode;
     let referenceNodeName;
-    if (parentTNode === null) {
-        // No parent TNode - use host element as a reference node.
+    if (parentTNode === null || !(parentTNode.type & 3 /* TNodeType.AnyRNode */)) {
+        // If there is no parent TNode or a parent TNode does not represent an RNode
+        // (i.e. not a DOM node), use component host element as a reference node.
         parentIndex = referenceNodeName = REFERENCE_NODE_HOST;
-        parentRNode = lView[HOST];
+        parentRNode = lView[DECLARATION_COMPONENT_VIEW][HOST];
     }
     else {
         // Use parent TNode as a reference node.
@@ -14880,7 +14930,7 @@ function templateFirstCreatePass(index, tView, lView, templateFn, decls, vars, t
     const hydrationInfo = lView[HYDRATION];
     if (hydrationInfo) {
         const noOffsetIndex = index - HEADER_OFFSET;
-        ssrId = (hydrationInfo && hydrationInfo.data[TEMPLATES]?.[noOffsetIndex]) ?? null;
+        ssrId = hydrationInfo.data[TEMPLATES]?.[noOffsetIndex] ?? null;
     }
     // TODO(pk): refactor getOrCreateTNode to have the "create" only version
     const tNode = getOrCreateTNode(tView, index, 4 /* TNodeType.Container */, tagName || null, getConstant(tViewConsts, attrsIndex));
@@ -16997,7 +17047,7 @@ function styleStringParser(keyValueArray, text) {
  * @codeGenApi
  */
 function ɵɵclassMap(classes) {
-    checkStylingMap(keyValueArraySet, classStringParser, classes, true);
+    checkStylingMap(classKeyValueArraySet, classStringParser, classes, true);
 }
 /**
  * Parse text as class and add values to KeyValueArray.
@@ -17439,6 +17489,26 @@ function toStylingKeyValueArray(keyValueArraySet, stringParser, value) {
 function styleKeyValueArraySet(keyValueArray, key, value) {
     keyValueArraySet(keyValueArray, key, unwrapSafeValue(value));
 }
+/**
+ * Class-binding-specific function for setting the `value` for a `key`.
+ *
+ * See: `keyValueArraySet` for details
+ *
+ * @param keyValueArray KeyValueArray to add to.
+ * @param key Style key to add.
+ * @param value The value to set.
+ */
+function classKeyValueArraySet(keyValueArray, key, value) {
+    // We use `classList.add` to eventually add the CSS classes to the DOM node. Any value passed into
+    // `add` is stringified and added to the `class` attribute, e.g. even null, undefined or numbers
+    // will be added. Stringify the key here so that our internal data structure matches the value in
+    // the DOM. The only exceptions are empty strings and strings that contain spaces for which
+    // the browser throws an error. We ignore such values, because the error is somewhat cryptic.
+    const stringKey = String(key);
+    if (stringKey !== '' && !stringKey.includes(' ')) {
+        keyValueArraySet(keyValueArray, stringKey, value);
+    }
+}
 /**
  * Update map based styling.
  *
@@ -20168,11 +20238,10 @@ const MARKER = `�`;
 const SUBTEMPLATE_REGEXP = /�\/?\*(\d+:\d+)�/gi;
 const PH_REGEXP = /�(\/?[#*]\d+):?\d*�/gi;
 /**
- * Angular Dart introduced &ngsp; as a placeholder for non-removable space, see:
- * https://github.com/dart-lang/angular/blob/0bb611387d29d65b5af7f9d2515ab571fd3fbee4/_tests/test/compiler/preserve_whitespace_test.dart#L25-L32
- * In Angular Dart &ngsp; is converted to the 0xE500 PUA (Private Use Areas) unicode character
- * and later on replaced by a space. We are re-implementing the same idea here, since translations
- * might contain this special character.
+ * Angular uses the special entity &ngsp; as a placeholder for non-removable space.
+ * It's replaced by the 0xE500 PUA (Private Use Areas) unicode character and later on replaced by a
+ * space.
+ * We are re-implementing the same idea since translations might contain this special character.
  */
 const NGSP_UNICODE_REGEXP = /\uE500/g;
 function replaceNgsp(value) {
@@ -29509,7 +29578,10 @@ function serializeLView(lView, context) {
                 //     live DOM has exactly the same state as it was before serialization.
                 if (tNode.type & 1 /* TNodeType.Text */) {
                     const rNode = unwrapRNode(lView[i]);
-                    if (rNode.textContent?.replace(/\s/gm, '') === '') {
+                    // Collect this node as required special annotation only when its
+                    // contents is empty. Otherwise, such text node would be present on
+                    // the client after server-side rendering and no special handling needed.
+                    if (rNode.textContent === '') {
                         context.corruptedTextNodes.set(rNode, "ngetn" /* TextNodeMarker.EmptyNode */);
                     }
                     else if (rNode.nextSibling?.nodeType === Node.TEXT_NODE) {
@@ -29750,7 +29822,7 @@ function withDomHydration() {
                     // hydration annotations. Otherwise, keep hydration disabled.
                     const transferState = inject(TransferState, { optional: true });
                     isEnabled = !!transferState?.get(NGH_DATA_KEY, null);
-                    if (!isEnabled) {
+                    if (!isEnabled && (typeof ngDevMode !== 'undefined' && ngDevMode)) {
                         const console = inject(Console);
                         const message = formatRuntimeError(-505 /* RuntimeErrorCode.MISSING_HYDRATION_ANNOTATIONS */, 'Angular hydration was requested on the client, but there was no ' +
                             'serialized information present in the server response, ' +