Backtestsvuerun-20261002-115633#11910

Issue #11910 Merged fix PR #11959 Run 2 Oct 2026 · run-20261002-115633 vuejs/core

Transition should sniff for teleport in custom components

Worse

The merged fix was judged better than our patch.

In this judgment, Patch A = our agent, Patch B = the merged fix.

Both patches fix the root cause the same way. When a component inside <Transition> renders a <Teleport> root, they skip the teleport and attach the transition hooks to the teleport's first non-comment child. Each covers both paths: the initial render in renderComponentRoot and the leaving/updated hooks applied to `component.subTree` in setTransitionHooks. A nested HOC also works in both, because the hooks travel through `vnode.transition` down to the inner component's render. So both should make `<Transition><Modal/></Transition>` animate the teleported element.

The difference is where the change lives.

- **Patch A** adds a TELEPORT branch inside the generic setTransitionHooks. That changes behavior for every caller that hands it a Teleport vnode, such as TransitionGroup children or KeepAlive inner children, not only the component-root case the issue is about.
- **Patch A's dev warning** is suppressed for any teleport root. A component rendering an empty <Teleport> inside <Transition> would therefore get silently swallowed hooks with no warning.
- **Patch B** confines the unwrapping to the two component-root sites. It reuses the existing getInnerChild, which BaseTransition already uses for the direct <Teleport> case, so the convention stays consistent.
- **Patch B's warning** still evaluates the real animated child. An empty teleport still warns and falls back safely, and its test checks this explicitly.

On tests:

- **Patch A** has good unit tests: enter and leave callbacks on the teleported element, the HOC case, and out-in timing.
- **Patch B** has an e2e test that reproduces the issue exactly, asserting real enter/leave classes on the teleported DOM node. It also has a unit test that updated leave hooks reach the teleported child (exercising the subTree path) and the empty-teleport edge case.
- Patch B's KeepAlive test is unrelated but harmless.

Overall, Patch B is the more targeted and lower-risk fix, with tests that match the reported scenario, so it edges out Patch A.

The judge saw only the two patches, labelled A and B in random order, with issue links and version numbers removed. The reasoning above is shown verbatim.

Solve

9m 43s

Wall-clock time in the container

Full test suite

No new failures

3,638 passed · 6 skipped · 3,644 total

Contamination audit

Clean

No sign the agent saw the real fix

Patch size

120vs 160 merged

Changed lines, ours vs merged

Vue version

3.5.4

Link to minimal reproduction

https://play.vuejs.org/#eNqNVE1v2zAM/SuadugGNHaG7pS5xT5QYNthG9YcfVFsOlEjS4JEOwmC/PdRUpw6RVrsZIt87+mRErXnX6zN+g74jBe+ctIi84CdvSu1bK1xyPbMQcMOrHGmZVcEvTqlvpnWHuNZHhZB6epTqUtdGe1JamU27DYIvGuE8vC+1EWetqENaIHQWiUQaMVYsegQjWafKyWr9W3Jj/Q34Vvyuwf65N9lDUWekIk1d0J7iZKYWrRAvEbUQPiQpXx02U9kc1QsOcsTM3+iRjv/ITYHBbF2NJRbmHpHcmfiRyRha9kzWQcJYyhe5BQYdPJB6JKTIh/1hZYedyr8ZsHLBDSCm4S2Xw8hBaKHCRq2D2rGikribsamdBSHoDAmonlGiwd4TvxwiSgqlD08I6dgouOphhkTSrFpduMZCA+D2ltqRIIuRLVeOtPpesYWqgsIxjayxhVtPp3abQysQC5XOI4sjKvBUcRumTdK1sQmqbQBXa3YKH7N0dMFbOQye/RG092Om5a8oqsgFbjfNrj0JZ8lOyFHjs3mZ4yh60KdKV6toFpfiD/6bYiV/I8DD66nS3LKoXBLwJS+f/gFW/o/JVtTd4rQryT/AhXXBY8J9pUaRbZHuOj2RxxDqZdzf79FoOYfiwpGA/IQ8SWnsQxT8FLpT3Zvso+RR/2kLg4jfeFxGD0Pp5EYvxHxEXht1i8N0jAcLw7O2dicTQk//AP1sJ3y

Steps to reproduce

Click the button

What is expected?

Both should transition in

What is actually happening?

One transitions correctly, the other throws a warning and blinks into existance

System Info

System:
    OS: Linux 5.15 Ubuntu 22.04.4 LTS 22.04.4 LTS (Jammy Jellyfish)
    CPU: (16) x64 AMD Ryzen 7 PRO 6850HS with Radeon Graphics
    Memory: 11.86 GB / 15.28 GB
    Container: Yes
    Shell: 5.1.16 - /bin/bash
  Binaries:
    Node: 22.2.0 - ~/.nvm/versions/node/v22.2.0/bin/node
    Yarn: 3.2.2 - ~/.nvm/versions/node/v22.2.0/bin/yarn
    npm: 10.7.0 - ~/.nvm/versions/node/v22.2.0/bin/npm
    pnpm: 7.25.0 - ~/.nvm/versions/node/v22.2.0/bin/pnpm
    bun: 1.1.8 - ~/.bun/bin/bun
  Browsers:
    Chrome: 126.0.6478.55

Any additional comments?

This is a follow up from

  • #5836

My Intention in #5836 was, that a user should be able to do this:

<Transition>
  <CustomComp />
</Transition>

<!-- Custom Comp -->
<Teleport>
  <div></div>
</Teleport>

However, the fix for #5836 only allows:

<Transition>
  <Teleport>
    <div></div>
  </Teleport>
</Transition>

For me as a user those 2 should feel equivalent.
The way it is now is not really useful. If you are not gonna use a custom component inside transition, you could just easily swap teleport and transition around (which already worked before the fix):

<teleport>
  <transition>
    <div></div>
  </transition>
</teleport>

But the whole point of #5836 was to allow to transition any component that teleports internally.
And since nesting a custom component into a transition works already, teleport should just be transparent in this case

Usecase:

  • modals <transition><Modal /></transition>
  • popovers
  • ...

The two patches

Our patch+119 −1
packages/runtime-core/__tests__/components/BaseTransition.spec.tsindex c541d5fc4..c9542a2b4 100644@@ -2,6 +2,7 @@ import {   BaseTransition,   type BaseTransitionProps,   KeepAlive,+  Teleport,   type TestElement,   type VNodeProps,   h,@@ -1293,4 +1294,104 @@ describe('BaseTransition', () => {     await runTestWithKeepAlive(testOutIn)     __DEV__ = true   })++  describe('w/ component rendering Teleport as root', () => {+    async function testTeleportInComponent(Comp: any) {+      const target = nodeOps.createElement('div')+      const toggle = ref(false)+      const { props, cbs } = mockProps()+      const { root } = mount(props, () =>+        toggle.value ? h(Comp, { target }) : null,+      )+      expect(serializeInner(target)).toBe(``)++      // enter+      toggle.value = true+      await nextTick()+      expect(serializeInner(target)).toBe(`<div>teleported</div>`)+      expect(serializeInner(root)).toBe(+        `<!--teleport start--><!--teleport end-->`,+      )+      expect(props.onBeforeEnter).toHaveBeenCalledTimes(1)+      assertCalledWithEl(props.onBeforeEnter, `<div>teleported</div>`)+      expect(props.onEnter).toHaveBeenCalledTimes(1)+      assertCalledWithEl(props.onEnter, `<div>teleported</div>`)+      expect(props.onAfterEnter).not.toHaveBeenCalled()+      cbs.doneEnter[`<div>teleported</div>`]()+      expect(props.onAfterEnter).toHaveBeenCalledTimes(1)+      assertCalledWithEl(props.onAfterEnter, `<div>teleported</div>`)++      // leave+      toggle.value = false+      await nextTick()+      // element stays in the target until leave is done+      expect(serializeInner(target)).toBe(`<div>teleported</div>`)+      expect(props.onBeforeLeave).toHaveBeenCalledTimes(1)+      assertCalledWithEl(props.onBeforeLeave, `<div>teleported</div>`)+      expect(props.onLeave).toHaveBeenCalledTimes(1)+      assertCalledWithEl(props.onLeave, `<div>teleported</div>`)+      expect(props.onAfterLeave).not.toHaveBeenCalled()+      cbs.doneLeave[`<div>teleported</div>`]()+      expect(serializeInner(target)).toBe(``)+      expect(serializeInner(root)).toBe(`<!---->`)+      expect(props.onAfterLeave).toHaveBeenCalledTimes(1)++      assertCalls(props, {+        onBeforeEnter: 1,+        onEnter: 1,+        onAfterEnter: 1,+        onEnterCancelled: 0,+        onBeforeLeave: 1,+        onLeave: 1,+        onAfterLeave: 1,+        onLeaveCancelled: 0,+      })+      expect(+        'renders non-element root node that cannot be animated',+      ).not.toHaveBeenWarned()+    }++    test('w/ component', async () => {+      const Comp = ({ target }: { target: TestElement }) =>+        h(Teleport, { to: target }, [h('div', 'teleported')])+      await testTeleportInComponent(Comp)+    })++    test('w/ nested component (HOC)', async () => {+      const Inner = ({ target }: { target: TestElement }) =>+        h(Teleport, { to: target }, [h('div', 'teleported')])+      const Outer = ({ target }: { target: TestElement }) =>+        h(Inner, { target })+      await testTeleportInComponent(Outer)+    })++    test('mode: "out-in"', async () => {+      const target = nodeOps.createElement('div')+      const toggle = ref(true)+      const { props, cbs } = mockProps({ mode: 'out-in' })+      const CompA = () => h(Teleport, { to: target }, [h('div', 'a')])+      const CompB = () => h(Teleport, { to: target }, [h('span', 'b')])+      mount(props, () => (toggle.value ? h(CompA) : h(CompB)))+      expect(serializeInner(target)).toBe(`<div>a</div>`)++      toggle.value = false+      await nextTick()+      // new branch must not enter until the old one has left+      expect(serializeInner(target)).toBe(`<div>a</div>`)+      expect(props.onLeave).toHaveBeenCalledTimes(1)+      assertCalledWithEl(props.onLeave, `<div>a</div>`)+      expect(props.onAfterLeave).not.toHaveBeenCalled()+      expect(props.onBeforeEnter).not.toHaveBeenCalled()++      cbs.doneLeave[`<div>a</div>`]()+      expect(props.onAfterLeave).toHaveBeenCalledTimes(1)+      await nextTick()+      expect(serializeInner(target)).toBe(`<span>b</span>`)+      expect(props.onBeforeEnter).toHaveBeenCalledTimes(1)+      assertCalledWithEl(props.onBeforeEnter, `<span>b</span>`)+      expect(props.onEnter).toHaveBeenCalledTimes(1)+      cbs.doneEnter[`<span>b</span>`]()+      expect(props.onAfterEnter).toHaveBeenCalledTimes(1)+    })+  }) })packages/runtime-core/src/componentRenderUtils.tsindex 0b46130c0..4d6845f56 100644@@ -255,7 +255,12 @@ export function renderComponentRoot(   }   // inherit transition data   if (vnode.transition) {-    if (__DEV__ && !isElementRoot(root)) {+    if (+      __DEV__ &&+      !isElementRoot(root) &&+      // transition hooks are forwarded to the teleported child+      !(root.shapeFlag & ShapeFlags.TELEPORT)+    ) {       warn(         `Component inside <Transition> renders non-element root node ` +           `that cannot be animated.`,packages/runtime-core/src/components/BaseTransition.tsindex 4a9d5098e..70763404b 100644@@ -542,6 +542,18 @@ export function setTransitionHooks(vnode: VNode, hooks: TransitionHooks): void {   } else if (__FEATURE_SUSPENSE__ && vnode.shapeFlag & ShapeFlags.SUSPENSE) {     vnode.ssContent!.transition = hooks.clone(vnode.ssContent!)     vnode.ssFallback!.transition = hooks.clone(vnode.ssFallback!)+  } else if (+    vnode.shapeFlag & ShapeFlags.TELEPORT &&+    vnode.shapeFlag & ShapeFlags.ARRAY_CHILDREN+  ) {+    // a component rendering <Teleport> as its root: the teleport itself+    // has no element to animate, so forward the hooks to its child.+    // hooks are intentionally not set on the teleport vnode itself, otherwise+    // its removal would call afterLeave before the child has finished leaving.+    const child = findNonCommentChild(vnode.children as VNode[])+    if (child) {+      setTransitionHooks(child, hooks)+    }   } else {     vnode.transition = hooks   } 
Merged fix · PR #11959+155 −5
packages/runtime-core/__tests__/components/BaseTransition.spec.tsindex c541d5fc4..65abcc6ff 100644@@ -2,6 +2,7 @@ import {   BaseTransition,   type BaseTransitionProps,   KeepAlive,+  Teleport,   type TestElement,   type VNodeProps,   h,@@ -1293,4 +1294,66 @@ describe('BaseTransition', () => {     await runTestWithKeepAlive(testOutIn)     __DEV__ = true   })++  test('should preserve transition for component with KeepAlive root', async () => {+    const root = nodeOps.createElement('div')+    const show = ref(false)+    const onBeforeEnter = vi.fn()+    const Child = { render: () => h('div', 'content') }+    const Comp = {+      render: () => h(KeepAlive, null, { default: () => h(Child) }),+    }+    const App = () =>+      h(BaseTransition, { onBeforeEnter }, () => (show.value ? h(Comp) : null))++    render(h(App), root)++    show.value = true+    await nextTick()+    expect(serializeInner(root)).toBe('<div>content</div>')+    expect(onBeforeEnter).toHaveBeenCalledTimes(1)+  })++  test('should not error on component with empty Teleport root', () => {+    const root = nodeOps.createElement('div')+    const target = nodeOps.createElement('div')+    const Comp = () => h(Teleport, { to: target }, [])++    expect(() =>+      render(+        h(BaseTransition, null, () => h(Comp)),+        root,+      ),+    ).not.toThrow()+    expect(serializeInner(root)).toBe(+      '<!--teleport start--><!--teleport end-->',+    )+    expect(serializeInner(target)).toBe('')+    expect(+      'Component inside <Transition> renders non-element root node',+    ).toHaveBeenWarned()+  })++  test('should update transition hooks for component with Teleport root', async () => {+    const root = nodeOps.createElement('div')+    const target = nodeOps.createElement('div')+    const show = ref(true)+    const firstBeforeLeave = vi.fn()+    const nextBeforeLeave = vi.fn()+    const beforeLeave = ref(firstBeforeLeave)+    const Comp = () => h(Teleport, { to: target }, h('div', 'content'))+    const App = () =>+      h(BaseTransition, { onBeforeLeave: beforeLeave.value }, () =>+        show.value ? h(Comp) : null,+      )++    render(h(App), root)++    beforeLeave.value = nextBeforeLeave+    show.value = false+    await nextTick()++    expect(firstBeforeLeave).not.toHaveBeenCalled()+    expect(nextBeforeLeave).toHaveBeenCalledTimes(1)+  }) })packages/runtime-core/src/componentRenderUtils.tsindex 0b46130c0..be58e5b0a 100644@@ -34,7 +34,8 @@ import {   warnDeprecation, } from './compat/compatConfig' import { shallowReadonly } from '@vue/reactivity'-import { setTransitionHooks } from './components/BaseTransition'+import { getInnerChild, setTransitionHooks } from './components/BaseTransition'+import { isTeleport } from './components/Teleport'  /**  * dev only flag to track whether $attrs was used during render.@@ -255,13 +256,14 @@ export function renderComponentRoot(   }   // inherit transition data   if (vnode.transition) {-    if (__DEV__ && !isElementRoot(root)) {+    const child = isTeleport(root.type) ? getInnerChild(root) || root : root+    if (__DEV__ && !isElementRoot(child)) {       warn(         `Component inside <Transition> renders non-element root node ` +           `that cannot be animated.`,       )     }-    setTransitionHooks(root, vnode.transition)+    setTransitionHooks(child, vnode.transition)   }    if (__DEV__ && setRoot) {packages/runtime-core/src/components/BaseTransition.tsindex 4a9d5098e..a8cfe8b71 100644@@ -506,7 +506,7 @@ function emptyPlaceholder(vnode: VNode): VNode | undefined {   } } -function getInnerChild(vnode: VNode): VNode | undefined {+export function getInnerChild(vnode: VNode): VNode | undefined {   if (!isKeepAlive(vnode)) {     if (isTeleport(vnode.type) && vnode.children) {       return findNonCommentChild(vnode.children as VNode[])@@ -538,7 +538,11 @@ function getInnerChild(vnode: VNode): VNode | undefined { export function setTransitionHooks(vnode: VNode, hooks: TransitionHooks): void {   if (vnode.shapeFlag & ShapeFlags.COMPONENT && vnode.component) {     vnode.transition = hooks-    setTransitionHooks(vnode.component.subTree, hooks)+    const subTree = vnode.component.subTree+    setTransitionHooks(+      isTeleport(subTree.type) ? getInnerChild(subTree) || subTree : subTree,+      hooks,+    )   } else if (__FEATURE_SUSPENSE__ && vnode.shapeFlag & ShapeFlags.SUSPENSE) {     vnode.ssContent!.transition = hooks.clone(vnode.ssContent!)     vnode.ssFallback!.transition = hooks.clone(vnode.ssFallback!)packages/vue/__tests__/e2e/Transition.spec.tsindex 17519e832..025cc7c00 100644@@ -2782,6 +2782,87 @@ describe('e2e: Transition', () => {       },       E2E_TIMEOUT,     )++    // #11910+    test(+      'apply transition to teleport component child',+      async () => {+        await page().evaluate(() => {+          const { createApp, ref } = (window as any).Vue+          createApp({+            template: `+            <div id="target"></div>+            <div id="container">+              <transition>+                  <Comp v-if="toggle"></Comp>+              </transition>+            </div>+            <button id="toggleBtn" @click="click">button</button>+          `,+            components: {+              Comp: {+                template: `+                    <Teleport to="#target">+                      <div class="test">content</div>+                    </Teleport>+                  `,+              },+            },+            setup: () => {+              const toggle = ref(false)+              const click = () => (toggle.value = !toggle.value)+              return { toggle, click }+            },+          }).mount('#app')+        })++        expect(await html('#target')).toBe('')+        expect(await html('#container')).toBe('<!--v-if-->')++        const classWhenTransitionStart = () =>+          page().evaluate(() => {+            ;(document.querySelector('#toggleBtn') as any)!.click()+            return Promise.resolve().then(() => {+              // find the class of teleported node+              return document+                .querySelector('#target div')!+                .className.split(/\s+/g)+            })+          })++        // enter+        expect(await classWhenTransitionStart()).toStrictEqual([+          'test',+          'v-enter-from',+          'v-enter-active',+        ])+        await nextFrame()+        expect(await classList('.test')).toStrictEqual([+          'test',+          'v-enter-active',+          'v-enter-to',+        ])+        await transitionFinish()+        expect(await html('#target')).toBe('<div class="test">content</div>')++        // leave+        expect(await classWhenTransitionStart()).toStrictEqual([+          'test',+          'v-leave-from',+          'v-leave-active',+        ])+        await nextFrame()+        expect(await classList('.test')).toStrictEqual([+          'test',+          'v-leave-active',+          'v-leave-to',+        ])+        await transitionFinish()+        expect(await html('#target')).toBe('')+        expect(await html('#container')).toBe('<!--v-if-->')+      },+      E2E_TIMEOUT,+    )   })    describe('transition with v-show', () => {