@angular/core 17.0.3 → 17.0.5

package/fesm2022/core.mjs

@@ -1,5 +1,5 @@
 /**
- * @license Angular v17.0.3
+ * @license Angular v17.0.5
  * (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
@@ -10428,7 +10427,7 @@ class Version {
 /**
  * @publicApi
  */
-const VERSION = new Version('17.0.3');
+const VERSION = new Version('17.0.5');
 
 // 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. ' +
@@ -13584,7 +13582,7 @@ function detectChangesInViewIfAttached(lView, mode) {
  *
  * The view is refreshed if:
  * - If the view is CheckAlways or Dirty and ChangeDetectionMode is `Global`
- * - If the view has the `RefreshTransplantedView` flag
+ * - If the view has the `RefreshView` flag
  *
  * The view is not refreshed, but descendants are traversed in `ChangeDetectionMode.Targeted` if the
  * view HasChildViewsToRefresh flag is set.
@@ -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) {
@@ -20335,7 +20340,7 @@ function ɵɵconditional(containerIndex, matchingTemplateIndex, value) {
             // Index -1 is a special case where none of the conditions evaluates to
             // a truthy value and as the consequence we've got no view to show.
             if (matchingTemplateIndex !== -1) {
-                const templateTNode = getExistingTNode(hostLView[TVIEW], matchingTemplateIndex);
+                const templateTNode = getExistingTNode(hostLView[TVIEW], HEADER_OFFSET + matchingTemplateIndex);
                 const dehydratedView = findMatchingDehydratedView(lContainer, templateTNode.tView.ssrId);
                 const embeddedLView = createAndRenderEmbeddedLView(hostLView, templateTNode, value, { dehydratedView });
                 addLViewToLContainer(lContainer, embeddedLView, viewInContainerIdx, shouldAddViewToDom(templateTNode, dehydratedView));
@@ -20493,21 +20498,19 @@ class LiveCollectionLContainerImpl extends LiveCollection {
  * The repeater instruction does update-time diffing of a provided collection (against the
  * collection seen previously) and maps changes in the collection to views structure (by adding,
  * removing or moving views as needed).
- * @param metadataSlotIdx - index in data where we can find an instance of RepeaterMetadata with
- *     additional information (ex. differ) needed to process collection diffing and view
- *     manipulation
  * @param collection - the collection instance to be checked for changes
  * @codeGenApi
  */
-function ɵɵrepeater(metadataSlotIdx, collection) {
+function ɵɵrepeater(collection) {
     const prevConsumer = setActiveConsumer$1(null);
+    const metadataSlotIdx = getSelectedIndex();
     try {
         const hostLView = getLView();
         const hostTView = hostLView[TVIEW];
-        const metadata = hostLView[HEADER_OFFSET + metadataSlotIdx];
+        const metadata = hostLView[metadataSlotIdx];
         if (metadata.liveCollection === undefined) {
             const containerIndex = metadataSlotIdx + 1;
-            const lContainer = getLContainer(hostLView, HEADER_OFFSET + containerIndex);
+            const lContainer = getLContainer(hostLView, containerIndex);
             const itemTemplateTNode = getExistingTNode(hostTView, containerIndex);
             metadata.liveCollection =
                 new LiveCollectionLContainerImpl(lContainer, hostLView, itemTemplateTNode);
@@ -20525,7 +20528,7 @@ function ɵɵrepeater(metadataSlotIdx, collection) {
             const isCollectionEmpty = liveCollection.length === 0;
             if (bindingUpdated(hostLView, bindingIndex, isCollectionEmpty)) {
                 const emptyTemplateIndex = metadataSlotIdx + 2;
-                const lContainerForEmpty = getLContainer(hostLView, HEADER_OFFSET + emptyTemplateIndex);
+                const lContainerForEmpty = getLContainer(hostLView, emptyTemplateIndex);
                 if (isCollectionEmpty) {
                     const emptyTemplateTNode = getExistingTNode(hostTView, emptyTemplateIndex);
                     const dehydratedView = findMatchingDehydratedView(lContainerForEmpty, emptyTemplateTNode.tView.ssrId);
@@ -20558,7 +20561,7 @@ function getExistingLViewFromLContainer(lContainer, index) {
     return existingLView;
 }
 function getExistingTNode(tView, index) {
-    const tNode = getTNode(tView, index + HEADER_OFFSET);
+    const tNode = getTNode(tView, index);
     ngDevMode && assertTNode(tNode);
     return tNode;
 }
@@ -20782,7 +20785,7 @@ function assertDeferredDependenciesLoaded(tDetails) {
  * that a primary template exists. All the other template options are optional.
  */
 function isTDeferBlockDetails(value) {
-    return (typeof value === 'object') &&
+    return value !== null && (typeof value === 'object') &&
         (typeof value.primaryTmplIndex === 'number');
 }
 
@@ -21836,10 +21839,11 @@ function triggerResourceLoading(tDetails, lView, tNode) {
         }
     }
     // The `dependenciesFn` might be `null` when all dependencies within
-    // a given defer block were eagerly references elsewhere in a file,
+    // a given defer block were eagerly referenced elsewhere in a file,
     // thus no dynamic `import()`s were produced.
     if (!dependenciesFn) {
         tDetails.loadingPromise = Promise.resolve().then(() => {
+            tDetails.loadingPromise = null;
             tDetails.loadingState = DeferDependenciesLoadingState.COMPLETE;
         });
         return;
@@ -30004,7 +30008,7 @@ const ITS_JUST_ANGULAR = true;
  *     provideHttpClient(),
  *     {
  *       provide: APP_INITIALIZER,
- *       useFactory: initializeApp,
+ *       useFactory: initializeAppFactory,
  *       multi: true,
  *       deps: [HttpClient],
  *     },
@@ -30289,7 +30293,8 @@ class ImagePerformanceWarning {
             return;
         }
         this.observer = this.initPerformanceObserver();
-        const win = getDocument().defaultView;
+        const doc = getDocument();
+        const win = doc.defaultView;
         if (typeof win !== 'undefined') {
             this.window = win;
             // Wait to avoid race conditions where LCP image triggers
@@ -30300,7 +30305,17 @@ class ImagePerformanceWarning {
             // Angular doesn't have to run change detection whenever any asynchronous tasks are invoked in
             // the scope of this functionality.
             this.ngZone.runOutsideAngular(() => {
-                this.window?.addEventListener('load', waitToScan);
+                // Consider the case when the application is created and destroyed multiple times.
+                // Typically, applications are created instantly once the page is loaded, and the
+                // `window.load` listener is always triggered. However, the `window.load` event will never
+                // be fired if the page is loaded, and the application is created later. Checking for
+                // `readyState` is the easiest way to determine whether the page has been loaded or not.
+                if (doc.readyState === 'complete') {
+                    waitToScan();
+                }
+                else {
+                    this.window?.addEventListener('load', waitToScan, { once: true });
+                }
             });
         }
     }