@angular/core 20.2.1 → 20.2.3

package/fesm2022/debug_node.mjs

@@ -1,5 +1,5 @@
 /**
- * @license Angular v20.2.1
+ * @license Angular v20.2.3
  * (c) 2010-2025 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -8398,7 +8398,13 @@ function handleUncaughtError(lView, error) {
     if (!injector) {
         return;
     }
-    const errorHandler = injector.get(INTERNAL_APPLICATION_ERROR_HANDLER, null);
+    let errorHandler;
+    try {
+        errorHandler = injector.get(INTERNAL_APPLICATION_ERROR_HANDLER, null);
+    }
+    catch {
+        errorHandler = null;
+    }
     errorHandler?.(error);
 }
 /**
@@ -13515,7 +13521,7 @@ class ComponentFactory extends ComponentFactory$1 {
 }
 function createRootTView(rootSelectorOrNode, componentDef, componentBindings, directives) {
     const tAttributes = rootSelectorOrNode
-        ? ['ng-version', '20.2.1']
+        ? ['ng-version', '20.2.3']
         : // Extract attributes and classes from the first selector only to match VE behavior.
             extractAttrsAndClassesFromSelector(componentDef.selectors[0]);
     let creationBindings = null;
@@ -21781,6 +21787,7 @@ class ElementRegistry {
         const details = this.outElements.get(el) ?? {
             classes: null,
             animateFn: () => { },
+            isEventBinding: true,
         };
         details.animateFn = animateWrapperFn(el, value);
         this.outElements.set(el, details);
@@ -21790,6 +21797,7 @@ class ElementRegistry {
         const details = this.outElements.get(el) ?? {
             classes: new Set(),
             animateFn: () => { },
+            isEventBinding: false,
         };
         if (typeof value === 'function') {
             this.trackResolver(details, value);
@@ -21825,8 +21833,11 @@ class ElementRegistry {
         };
         // this timeout is used to ensure elements actually get removed in the case
         // that the user forgot to call the remove callback. The timeout is cleared
-        // in the DOM renderer during the remove child process.
-        timeoutId = setTimeout(remove, maxAnimationTimeout);
+        // in the DOM renderer during the remove child process. It only applies
+        // to the event binding use case.
+        if (details.isEventBinding) {
+            timeoutId = setTimeout(remove, maxAnimationTimeout);
+        }
         details.animateFn(remove);
     }
 }
@@ -21997,11 +22008,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 +22072,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
@@ -22044,7 +22084,6 @@ function ɵɵanimateEnter(value) {
     // This also allows us to setup cancellation of animations in progress if the
     // gets removed early.
     const handleAnimationStart = (event) => {
-        setupAnimationCancel(event, renderer);
         const eventName = event instanceof AnimationEvent ? 'animationend' : 'transitionend';
         ngZone.runOutsideAngular(() => {
             cleanupFns.push(renderer.listen(nativeElement, eventName, handleInAnimationEnd));
@@ -22060,14 +22099,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 +22162,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 +22191,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 +22236,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 +22252,7 @@ function ɵɵanimateLeaveListener(value) {
                 const event = {
                     target: nativeElement,
                     animationComplete: () => {
-                        clearLeavingNodes(tNode);
+                        clearLeavingNodes(tNode, _el);
                         removeFn();
                     },
                 };
@@ -22253,15 +22278,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;
@@ -22270,42 +22292,22 @@ function cancelAnimationsIfRunning(element, renderer) {
     if (!areAnimationSupported)
         return;
     const elementData = enterClassMap.get(element);
-    if (element.getAnimations().length > 0) {
-        for (const animation of element.getAnimations()) {
-            if (animation.playState === 'running') {
-                animation.cancel();
-            }
-        }
-    }
-    else {
-        if (elementData) {
-            for (const klass of elementData.classList) {
-                renderer.removeClass(element, klass);
-            }
+    if (elementData &&
+        elementData.classList.length > 0 &&
+        elementHasClassList(element, elementData.classList)) {
+        for (const klass of elementData.classList) {
+            renderer.removeClass(element, klass);
         }
     }
     // We need to prevent any enter animation listeners from firing if they exist.
     cleanupEnterClassData(element);
 }
-function setupAnimationCancel(event, renderer) {
-    if (!(event.target instanceof Element))
-        return;
-    const nativeElement = event.target;
-    if (areAnimationSupported) {
-        const elementData = enterClassMap.get(nativeElement);
-        const animations = nativeElement.getAnimations();
-        if (animations.length === 0)
-            return;
-        for (let animation of animations) {
-            animation.addEventListener('cancel', (event) => {
-                if (nativeElement === event.target && elementData?.classList) {
-                    for (const klass of elementData.classList) {
-                        renderer.removeClass(nativeElement, klass);
-                    }
-                }
-            });
-        }
+function elementHasClassList(element, classList) {
+    for (const className of classList) {
+        if (element.classList.contains(className))
+            return true;
     }
+    return false;
 }
 function isLongestAnimation(event, nativeElement) {
     const longestAnimation = longestAnimations.get(nativeElement);
@@ -22337,6 +22339,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 +22363,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 +22382,7 @@ function animateLeaveClassRunner(el, tNode, classList, finalRemoveFn, renderer,
         requestAnimationFrame(() => {
             determineLongestAnimation(el, longestAnimations, areAnimationSupported);
             if (!longestAnimations.has(el)) {
-                clearLeavingNodes(tNode);
+                clearLeavingNodes(tNode, el);
                 finalRemoveFn();
             }
         });