@angular/core 17.0.4 → 17.0.6

package/fesm2022/core.mjs

@@ -1,5 +1,5 @@
 /**
- * @license Angular v17.0.4
+ * @license Angular v17.0.6
  * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -2722,20 +2722,19 @@ function walkUpViews(nestingLevel, currentView) {
     }
     return currentView;
 }
+function requiresRefreshOrTraversal(lView) {
+    return lView[FLAGS] & (1024 /* LViewFlags.RefreshView */ | 8192 /* LViewFlags.HasChildViewsToRefresh */) ||
+        lView[REACTIVE_TEMPLATE_CONSUMER]?.dirty;
+}
 /**
- * Updates the `DESCENDANT_VIEWS_TO_REFRESH` counter on the parents of the `LView` as well as the
- * parents above that whose
- *  1. counter goes from 0 to 1, indicating that there is a new child that has a view to refresh
- *  or
- *  2. counter goes from 1 to 0, indicating there are no more descendant views to refresh
- * When attaching/re-attaching an `LView` to the change detection tree, we need to ensure that the
- * views above it are traversed during change detection if this one is marked for refresh or has
- * some child or descendant that needs to be refreshed.
+ * Updates the `HasChildViewsToRefresh` flag on the parents of the `LView` as well as the
+ * parents above.
  */
 function updateAncestorTraversalFlagsOnAttach(lView) {
-    if (lView[FLAGS] & (1024 /* LViewFlags.RefreshView */ | 8192 /* LViewFlags.HasChildViewsToRefresh */)) {
-        markAncestorsForTraversal(lView);
+    if (!requiresRefreshOrTraversal(lView)) {
+        return;
     }
+    markAncestorsForTraversal(lView);
 }
 /**
  * Ensures views above the given `lView` are traversed during change detection even when they are
@@ -8268,7 +8267,6 @@ function detachView(lContainer, removeIndex) {
 function destroyLView(tView, lView) {
     if (!(lView[FLAGS] & 256 /* LViewFlags.Destroyed */)) {
         const renderer = lView[RENDERER];
-        lView[REACTIVE_TEMPLATE_CONSUMER] && consumerDestroy$1(lView[REACTIVE_TEMPLATE_CONSUMER]);
         if (renderer.destroyNode) {
             applyView(tView, lView, renderer, 3 /* WalkTNodeTreeAction.Destroy */, null, null);
         }
@@ -8294,6 +8292,7 @@ function cleanUpView(tView, lView) {
         // This also aligns with the ViewEngine behavior. It also means that the onDestroy hook is
         // really more of an "afterDestroy" hook if you think about it.
         lView[FLAGS] |= 256 /* LViewFlags.Destroyed */;
+        lView[REACTIVE_TEMPLATE_CONSUMER] && consumerDestroy$1(lView[REACTIVE_TEMPLATE_CONSUMER]);
         executeOnDestroys(tView, lView);
         processCleanups(tView, lView);
         // For component views only, the local renderer is destroyed at clean up time.
@@ -10428,7 +10427,7 @@ class Version {
 /**
  * @publicApi
  */
-const VERSION = new Version('17.0.4');
+const VERSION = new Version('17.0.6');
 
 // This default value is when checking the hierarchy for a token.
 //
@@ -13335,8 +13334,7 @@ function detectChangesInViewWhileDirty(lView) {
     // descendants views that need to be refreshed due to re-dirtying during the change detection
     // run, detect changes on the view again. We run change detection in `Targeted` mode to only
     // refresh views with the `RefreshView` flag.
-    while (lView[FLAGS] & (1024 /* LViewFlags.RefreshView */ | 8192 /* LViewFlags.HasChildViewsToRefresh */) ||
-        lView[REACTIVE_TEMPLATE_CONSUMER]?.dirty) {
+    while (requiresRefreshOrTraversal(lView)) {
         if (retries === MAXIMUM_REFRESH_RERUNS) {
             throw new RuntimeError(103 /* RuntimeErrorCode.INFINITE_CHANGE_DETECTION */, ngDevMode &&
                 'Infinite change detection while trying to refresh views. ' +
@@ -15986,19 +15984,26 @@ function ɵɵCopyDefinitionFeature(definition) {
  * @codeGenApi
  */
 function ɵɵHostDirectivesFeature(rawHostDirectives) {
-    return (definition) => {
-        definition.findHostDirectiveDefs = findHostDirectiveDefs;
-        definition.hostDirectives =
-            (Array.isArray(rawHostDirectives) ? rawHostDirectives : rawHostDirectives()).map(dir => {
-                return typeof dir === 'function' ?
-                    { directive: resolveForwardRef(dir), inputs: EMPTY_OBJ, outputs: EMPTY_OBJ } :
-                    {
-                        directive: resolveForwardRef(dir.directive),
-                        inputs: bindingArrayToMap(dir.inputs),
-                        outputs: bindingArrayToMap(dir.outputs)
-                    };
-            });
+    const feature = (definition) => {
+        const resolved = (Array.isArray(rawHostDirectives) ? rawHostDirectives : rawHostDirectives()).map(dir => {
+            return typeof dir === 'function' ?
+                { directive: resolveForwardRef(dir), inputs: EMPTY_OBJ, outputs: EMPTY_OBJ } :
+                {
+                    directive: resolveForwardRef(dir.directive),
+                    inputs: bindingArrayToMap(dir.inputs),
+                    outputs: bindingArrayToMap(dir.outputs)
+                };
+        });
+        if (definition.hostDirectives === null) {
+            definition.findHostDirectiveDefs = findHostDirectiveDefs;
+            definition.hostDirectives = resolved;
+        }
+        else {
+            definition.hostDirectives.unshift(...resolved);
+        }
     };
+    feature.ngInherit = true;
+    return feature;
 }
 function findHostDirectiveDefs(currentDef, matchedDefs, hostDirectiveDefs) {
     if (currentDef.hostDirectives !== null) {
@@ -19112,6 +19117,17 @@ function isFirstElementInNgContainer(tNode) {
 function getNoOffsetIndex(tNode) {
     return tNode.index - HEADER_OFFSET;
 }
+/**
+ * Check whether a given node exists, but is disconnected from the DOM.
+ *
+ * Note: we leverage the fact that we have this information available in the DOM emulation
+ * layer (in Domino) for now. Longer-term solution should not rely on the DOM emulation and
+ * only use internal data structures and state to compute this information.
+ */
+function isDisconnectedNode(tNode, lView) {
+    return !(tNode.type & 16 /* TNodeType.Projection */) && !!lView[tNode.index] &&
+        !unwrapRNode(lView[tNode.index])?.isConnected;
+}
 /**
  * Locate a node in DOM tree that corresponds to a given TNode.
  *
@@ -19313,10 +19329,20 @@ function calcPathBetween(from, to, fromNodeName) {
  * instructions needs to be generated for a TNode.
  */
 function calcPathForNode(tNode, lView) {
-    const parentTNode = tNode.parent;
+    let parentTNode = tNode.parent;
     let parentIndex;
     let parentRNode;
     let referenceNodeName;
+    // Skip over all parent nodes that are disconnected from the DOM, such nodes
+    // can not be used as anchors.
+    //
+    // This might happen in certain content projection-based use-cases, where
+    // a content of an element is projected and used, when a parent element
+    // itself remains detached from DOM. In this scenario we try to find a parent
+    // element that is attached to DOM and can act as an anchor instead.
+    while (parentTNode !== null && isDisconnectedNode(parentTNode, lView)) {
+        parentTNode = parentTNode.parent;
+    }
     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.
@@ -19750,13 +19776,14 @@ function getLViewFromLContainer(lContainer, index) {
  * block (in which case view contents was re-created, thus needing insertion).
  */
 function shouldAddViewToDom(tNode, dehydratedView) {
-    return !dehydratedView || hasInSkipHydrationBlockFlag(tNode);
+    return !dehydratedView || dehydratedView.firstChild === null ||
+        hasInSkipHydrationBlockFlag(tNode);
 }
 function addLViewToLContainer(lContainer, lView, index, addToDOM = true) {
     const tView = lView[TVIEW];
-    // insert to the view tree so the new view can be change-detected
+    // Insert into the view tree so the new view can be change-detected
     insertView(tView, lView, lContainer, index);
-    // insert to the view to the DOM tree
+    // Insert elements that belong to this view into the DOM tree
     if (addToDOM) {
         const beforeNode = getBeforeNodeForView(index, lContainer);
         const renderer = lView[RENDERER];
@@ -19765,6 +19792,13 @@ function addLViewToLContainer(lContainer, lView, index, addToDOM = true) {
             addViewToDOM(tView, lContainer[T_HOST], renderer, lView, parentRNode, beforeNode);
         }
     }
+    // When in hydration mode, reset the pointer to the first child in
+    // the dehydrated view. This indicates that the view was hydrated and
+    // further attaching/detaching should work with this view as normal.
+    const hydrationInfo = lView[HYDRATION];
+    if (hydrationInfo !== null && hydrationInfo.firstChild !== null) {
+        hydrationInfo.firstChild = null;
+    }
 }
 function removeLViewFromLContainer(lContainer, index) {
     const lView = detachView(lContainer, index);
@@ -30003,7 +30037,7 @@ const ITS_JUST_ANGULAR = true;
  *     provideHttpClient(),
  *     {
  *       provide: APP_INITIALIZER,
- *       useFactory: initializeApp,
+ *       useFactory: initializeAppFactory,
  *       multi: true,
  *       deps: [HttpClient],
  *     },
@@ -34299,6 +34333,7 @@ function serializeLView(lView, context) {
                 }
             }
         }
+        conditionallyAnnotateNodePath(ngh, tNode, lView);
         if (isLContainer(lView[i])) {
             // Serialize information about a template.
             const embeddedTView = tNode.tView;
@@ -34390,18 +34425,38 @@ function serializeLView(lView, context) {
                         context.corruptedTextNodes.set(rNode, "ngtns" /* TextNodeMarker.Separator */);
                     }
                 }
-                if (tNode.projectionNext && tNode.projectionNext !== tNode.next &&
-                    !isInSkipHydrationBlock(tNode.projectionNext)) {
-                    // Check if projection next is not the same as next, in which case
-                    // the node would not be found at creation time at runtime and we
-                    // need to provide a location for that node.
-                    appendSerializedNodePath(ngh, tNode.projectionNext, lView);
-                }
             }
         }
     }
     return ngh;
 }
+/**
+ * Serializes node location in cases when it's needed, specifically:
+ *
+ *  1. If `tNode.projectionNext` is different from `tNode.next` - it means that
+ *     the next `tNode` after projection is different from the one in the original
+ *     template. Since hydration relies on `tNode.next`, this serialized info
+ *     if required to help runtime code find the node at the correct location.
+ *  2. In certain content projection-based use-cases, it's possible that only
+ *     a content of a projected element is rendered. In this case, content nodes
+ *     require an extra annotation, since runtime logic can't rely on parent-child
+ *     connection to identify the location of a node.
+ */
+function conditionallyAnnotateNodePath(ngh, tNode, lView) {
+    // Handle case #1 described above.
+    if (tNode.projectionNext && tNode.projectionNext !== tNode.next &&
+        !isInSkipHydrationBlock(tNode.projectionNext)) {
+        appendSerializedNodePath(ngh, tNode.projectionNext, lView);
+    }
+    // Handle case #2 described above.
+    // Note: we only do that for the first node (i.e. when `tNode.prev === null`),
+    // the rest of the nodes would rely on the current node location, so no extra
+    // annotation is needed.
+    if (tNode.prev === null && tNode.parent !== null && isDisconnectedNode(tNode.parent, lView) &&
+        !isDisconnectedNode(tNode, lView)) {
+        appendSerializedNodePath(ngh, tNode, lView);
+    }
+}
 /**
  * Determines whether a component instance that is represented
  * by a given LView uses `ViewEncapsulation.ShadowDom`.
@@ -34473,17 +34528,6 @@ function isContentProjectedNode(tNode) {
     }
     return false;
 }
-/**
- * Check whether a given node exists, but is disconnected from the DOM.
- *
- * Note: we leverage the fact that we have this information available in the DOM emulation
- * layer (in Domino) for now. Longer-term solution should not rely on the DOM emulation and
- * only use internal data structures and state to compute this information.
- */
-function isDisconnectedNode(tNode, lView) {
-    return !(tNode.type & 16 /* TNodeType.Projection */) && !!lView[tNode.index] &&
-        !unwrapRNode(lView[tNode.index]).isConnected;
-}
 
 /**
  * Indicates whether the hydration-related code was added,