@angular/core 20.2.1 → 20.2.2

package/fesm2022/debug_node.mjs

@@ -1,5 +1,5 @@
 /**
- * @license Angular v20.2.1
+ * @license Angular v20.2.2
  * (c) 2010-2025 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -13515,7 +13515,7 @@ class ComponentFactory extends ComponentFactory$1 {
 }
 function createRootTView(rootSelectorOrNode, componentDef, componentBindings, directives) {
     const tAttributes = rootSelectorOrNode
-        ? ['ng-version', '20.2.1']
+        ? ['ng-version', '20.2.2']
         : // Extract attributes and classes from the first selector only to match VE behavior.
             extractAttrsAndClassesFromSelector(componentDef.selectors[0]);
     let creationBindings = null;
@@ -21997,11 +21997,39 @@ const longestAnimations = new WeakMap();
 // used to prevent duplicate nodes from showing up when nodes have been toggled quickly
 // from an `@if` or `@for`.
 const leavingNodes = new WeakMap();
-function clearLeavingNodes(tNode) {
-    if (leavingNodes.get(tNode)?.length === 0) {
+function clearLeavingNodes(tNode, el) {
+    const nodes = leavingNodes.get(tNode);
+    if (nodes && nodes.length > 0) {
+        const ix = nodes.findIndex((node) => node === el);
+        if (ix > -1)
+            nodes.splice(ix, 1);
+    }
+    if (nodes?.length === 0) {
         leavingNodes.delete(tNode);
     }
 }
+/**
+ * In the case that we have an existing node that's animating away, like when
+ * an `@if` toggles quickly, we need to end the animation for the former node
+ * and remove it right away to prevent duplicate nodes showing up.
+ */
+function cancelLeavingNodes(tNode, lView) {
+    const leavingEl = leavingNodes.get(tNode)?.shift();
+    const lContainer = lView[DECLARATION_LCONTAINER];
+    if (lContainer) {
+        // this is the insertion point for the new TNode element.
+        // it will be inserted before the declaring containers anchor.
+        const beforeNode = getBeforeNodeForView(tNode.index, lContainer);
+        // here we need to check the previous sibling of that anchor
+        const previousNode = beforeNode?.previousSibling;
+        // We really only want to cancel animations if the leaving node is the
+        // same as the node before where the new node will be inserted. This is
+        // the control flow scenario where an if was toggled.
+        if (leavingEl && previousNode && leavingEl === previousNode) {
+            leavingEl.dispatchEvent(new CustomEvent('animationend', { detail: { cancel: true } }));
+        }
+    }
+}
 function trackLeavingNodes(tNode, el) {
     // We need to track this tNode's element just to be sure we don't add
     // a new RNode for this TNode while this one is still animating away.
@@ -22033,6 +22061,7 @@ function ɵɵanimateEnter(value) {
     }
     const tNode = getCurrentTNode();
     const nativeElement = getNativeByTNode(tNode, lView);
+    ngDevMode && assertElementNodes(nativeElement, 'animate.enter');
     const renderer = lView[RENDERER];
     const ngZone = lView[INJECTOR].get(NgZone);
     // Retrieve the actual class list from the value. This will resolve any resolver functions from
@@ -22060,14 +22089,7 @@ function ɵɵanimateEnter(value) {
             cleanupFns.push(renderer.listen(nativeElement, 'animationstart', handleAnimationStart));
             cleanupFns.push(renderer.listen(nativeElement, 'transitionstart', handleAnimationStart));
         });
-        // In the case that we have an existing node that's animating away, like when
-        // an `@if` toggles quickly or `@for` adds and removes elements quickly, we
-        // need to end the animation for the former node and remove it right away to
-        // prevent duplicate nodes showing up.
-        leavingNodes
-            .get(tNode)
-            ?.pop()
-            ?.dispatchEvent(new CustomEvent('animationend', { detail: { cancel: true } }));
+        cancelLeavingNodes(tNode, lView);
         trackEnterClasses(nativeElement, activeClasses, cleanupFns);
         for (const klass of activeClasses) {
             renderer.addClass(nativeElement, klass);
@@ -22130,14 +22152,8 @@ function ɵɵanimateEnterListener(value) {
     }
     const tNode = getCurrentTNode();
     const nativeElement = getNativeByTNode(tNode, lView);
-    // In the case that we have an existing node that's animating away, like when
-    // an `@if` toggles quickly or `@for` adds and removes elements quickly, we
-    // need to end the animation for the former node and remove it right away to
-    // prevent duplicate nodes showing up.
-    leavingNodes
-        .get(tNode)
-        ?.pop()
-        ?.dispatchEvent(new CustomEvent('animationend', { detail: { cancel: true } }));
+    ngDevMode && assertElementNodes(nativeElement, 'animate.enter');
+    cancelLeavingNodes(tNode, lView);
     value.call(lView[CONTEXT], { target: nativeElement, animationComplete: noOpAnimationComplete });
     return ɵɵanimateEnterListener;
 }
@@ -22165,6 +22181,7 @@ function ɵɵanimateLeave(value) {
     const tView = getTView();
     const tNode = getCurrentTNode();
     const nativeElement = getNativeByTNode(tNode, lView);
+    ngDevMode && assertElementNodes(nativeElement, 'animate.leave');
     // This instruction is called in the update pass.
     const renderer = lView[RENDERER];
     const elementRegistry = getAnimationElementRemovalRegistry();
@@ -22209,9 +22226,7 @@ function ɵɵanimateLeaveListener(value) {
     const tNode = getCurrentTNode();
     const tView = getTView();
     const nativeElement = getNativeByTNode(tNode, lView);
-    if (nativeElement.nodeType !== Node.ELEMENT_NODE) {
-        return ɵɵanimateLeaveListener;
-    }
+    ngDevMode && assertElementNodes(nativeElement, 'animate.leave');
     const elementRegistry = getAnimationElementRemovalRegistry();
     ngDevMode &&
         assertDefined(elementRegistry.elements, 'Expected `ElementRegistry` to be present in animations subsystem');
@@ -22227,7 +22242,7 @@ function ɵɵanimateLeaveListener(value) {
                 const event = {
                     target: nativeElement,
                     animationComplete: () => {
-                        clearLeavingNodes(tNode);
+                        clearLeavingNodes(tNode, _el);
                         removeFn();
                     },
                 };
@@ -22253,15 +22268,12 @@ function getClassList(value, resolvers) {
     const classList = new Set(value);
     if (resolvers && resolvers.length) {
         for (const resolverFn of resolvers) {
-            const resolvedValue = resolverFn();
-            if (resolvedValue instanceof Array) {
+            const resolvedValue = getClassListFromValue(resolverFn);
+            if (resolvedValue) {
                 for (const rv of resolvedValue) {
                     classList.add(rv);
                 }
             }
-            else {
-                classList.add(resolvedValue);
-            }
         }
     }
     return classList;
@@ -22337,6 +22349,11 @@ function assertAnimationTypes(value, instruction) {
         throw new RuntimeError(650 /* RuntimeErrorCode.ANIMATE_INVALID_VALUE */, `'${instruction}' value must be a string of CSS classes or an animation function, got ${stringify(value)}`);
     }
 }
+function assertElementNodes(nativeElement, instruction) {
+    if (nativeElement.nodeType !== Node.ELEMENT_NODE) {
+        throw new RuntimeError(650 /* RuntimeErrorCode.ANIMATE_INVALID_VALUE */, `'${instruction}' can only be used on an element node, got ${stringify(nativeElement.nodeType)}`);
+    }
+}
 /**
  * This function actually adds the classes that animate element that's leaving the DOM.
  * Once it finishes, it calls the remove function that was provided by the DOM renderer.
@@ -22356,7 +22373,7 @@ function animateLeaveClassRunner(el, tNode, classList, finalRemoveFn, renderer,
             // affect any other animations on the page.
             event.stopImmediatePropagation();
             longestAnimations.delete(el);
-            clearLeavingNodes(tNode);
+            clearLeavingNodes(tNode, el);
             finalRemoveFn();
         }
     };
@@ -22375,7 +22392,7 @@ function animateLeaveClassRunner(el, tNode, classList, finalRemoveFn, renderer,
         requestAnimationFrame(() => {
             determineLongestAnimation(el, longestAnimations, areAnimationSupported);
             if (!longestAnimations.has(el)) {
-                clearLeavingNodes(tNode);
+                clearLeavingNodes(tNode, el);
                 finalRemoveFn();
             }
         });