Backtestsvuerun-20261021-133314#11910

Issue #11910 Merged fix PR #11959 Run 21 Oct 2026 · run-20261021-133314 vuejs/core

Transition should sniff for teleport in custom components

Better

Our patch was judged better than the merged fix.

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

Both patches fix the root cause the same way: make a Teleport root transparent so transition hooks land on the teleported element, and both pass all six independent tests. The differences are robustness and generality. Patch B adds a dedicated TELEPORT branch to setTransitionHooks, so any Teleport vnode reached through component propagation (including nested components and re-render updates) gets unwrapped, and it guards with isVNode because raw render-function children (e.g. `[cond ? h('div') : null]`) are not normalized at renderComponentRoot time. Patch A instead special-cases only the component subTree path and reuses getInnerChild/findNonCommentChild, which dereferences `c.type` on each child and will throw a TypeError on a null child; A's test only covers the empty-array case, not the null case that B explicitly tests. B's warning helper also correctly treats an empty or single-element Teleport as transitionable and surfaces the existing multi-child warning. On tests, B's unit suite is considerably more thorough (toggle on/off with hook/element assertions, out-in mode, KeepAlive, null children, multi-root warning, and asserts no spurious warning), whereas A's unit tests are thinner (its KeepAlive test exercises existing behavior unrelated to the change), though A does add a useful e2e DOM test. Scope is comparable. Overall B is the more correct and better-tested fix.

Four judges ruled on this ticket in parallel, and the verdict comes from counting their votes. Each saw the issue and the two patches, labelled A and B in random order (two of them saw ours as A), with issue links and version numbers removed. Where tests could check the fix, they also saw the results of tests a separate agent wrote for the issue, run on both patches. None was told which patch was ours. The reasoning above is one judge's, shown verbatim.

Solve

10m 20s

Wall-clock time in the container

Full test suite

No new failures

1,749 passed · 1 skipped · 1,750 total

Contamination audit

Clean

No sign the agent saw the real fix

Patch size

173vs 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+172 −1
packages/runtime-core/__tests__/components/BaseTransition.spec.tsindex c541d5fc4..1bcbee63d 100644@@ -2,6 +2,7 @@ import {   BaseTransition,   type BaseTransitionProps,   KeepAlive,+  Teleport,   type TestElement,   type VNodeProps,   h,@@ -1242,6 +1243,146 @@ describe('BaseTransition', () => {     })   }) +  describe('w/ component rendering a Teleport root', () => {+    const target = nodeOps.createElement('div')+    const CompA = () => h(Teleport, { to: target }, [h('div', 'foo')])+    const CompB = () => h(Teleport, { to: target }, [h('span', 'bar')])++    beforeEach(() => {+      target.children.length = 0+    })++    test('toggle on-off', async () => {+      const toggle = ref(false)+      const { props, cbs } = mockProps()+      const { root } = mount(props, () => (toggle.value ? h(CompA) : null))+      expect(serializeInner(target)).toBe(``)++      // enter+      toggle.value = true+      await nextTick()+      expect(serializeInner(target)).toBe(`<div>foo</div>`)+      expect(serializeInner(root)).toBe(+        `<!--teleport start--><!--teleport end-->`,+      )+      expect(props.onBeforeEnter).toHaveBeenCalledTimes(1)+      assertCalledWithEl(props.onBeforeEnter, `<div>foo</div>`)+      expect(props.onEnter).toHaveBeenCalledTimes(1)+      assertCalledWithEl(props.onEnter, `<div>foo</div>`)+      expect(props.onAfterEnter).not.toHaveBeenCalled()+      cbs.doneEnter[`<div>foo</div>`]()+      expect(props.onAfterEnter).toHaveBeenCalledTimes(1)+      assertCalledWithEl(props.onAfterEnter, `<div>foo</div>`)++      // leave: teleported element stays until the leave transition is done+      toggle.value = false+      await nextTick()+      expect(serializeInner(target)).toBe(`<div>foo</div>`)+      expect(serializeInner(root)).toBe(`<!---->`)+      expect(props.onBeforeLeave).toHaveBeenCalledTimes(1)+      assertCalledWithEl(props.onBeforeLeave, `<div>foo</div>`)+      expect(props.onLeave).toHaveBeenCalledTimes(1)+      assertCalledWithEl(props.onLeave, `<div>foo</div>`)+      expect(props.onAfterLeave).not.toHaveBeenCalled()+      cbs.doneLeave[`<div>foo</div>`]()+      expect(serializeInner(target)).toBe(``)+      expect(props.onAfterLeave).toHaveBeenCalledTimes(1)+      assertCalledWithEl(props.onAfterLeave, `<div>foo</div>`)++      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('mode: "out-in"', async () => {+      const toggle = ref(true)+      const { props, cbs } = mockProps({ mode: 'out-in' })+      mount(props, () => (toggle.value ? h(CompA) : h(CompB)))+      expect(serializeInner(target)).toBe(`<div>foo</div>`)++      toggle.value = false+      await nextTick()+      expect(serializeInner(target)).toBe(`<div>foo</div>`)+      assertCalledWithEl(props.onLeave, `<div>foo</div>`)+      expect(props.onBeforeEnter).not.toHaveBeenCalled()++      cbs.doneLeave[`<div>foo</div>`]()+      assertCalledWithEl(props.onAfterLeave, `<div>foo</div>`)+      await nextTick()+      expect(serializeInner(target)).toBe(`<span>bar</span>`)+      assertCalledWithEl(props.onBeforeEnter, `<span>bar</span>`)+      assertCalledWithEl(props.onEnter, `<span>bar</span>`)+      cbs.doneEnter[`<span>bar</span>`]()+      assertCalledWithEl(props.onAfterEnter, `<span>bar</span>`)++      assertCalls(props, {+        onBeforeEnter: 1,+        onEnter: 1,+        onAfterEnter: 1,+        onBeforeLeave: 1,+        onLeave: 1,+        onAfterLeave: 1,+      })+      expect(+        'renders non-element root node that cannot be animated',+      ).not.toHaveBeenWarned()+    })++    test('w/ KeepAlive', async () => {+      const toggle = ref(true)+      const { props, cbs } = mockProps({ mode: 'out-in' }, true)+      mount(props, () => (toggle.value ? h(CompA) : h(CompB)), true)+      expect(serializeInner(target)).toBe(`<div>foo</div>`)++      toggle.value = false+      await nextTick()+      assertCalledWithEl(props.onLeave, `<div>foo</div>`)+      cbs.doneLeave[`<div>foo</div>`]()+      await nextTick()+      expect(serializeInner(target)).toBe(`<span>bar</span>`)+      assertCalledWithEl(props.onEnter, `<span>bar</span>`)+      expect(+        'renders non-element root node that cannot be animated',+      ).not.toHaveBeenWarned()+    })++    test('should not throw on non-vnode teleport children', async () => {+      const toggle = ref(false)+      const Comp = () =>+        h(Teleport, { to: target }, [toggle.value ? h('div', 'foo') : null])+      const { props } = mockProps()+      mount(props, () => h(Comp))+      expect(serializeInner(target)).toBe(`<!---->`)++      toggle.value = true+      await nextTick()+      expect(serializeInner(target)).toBe(`<div>foo</div>`)+    })++    test('warn when teleporting multiple root nodes', async () => {+      const Comp = () =>+        h(Teleport, { to: target }, [h('div', 'foo'), h('span', 'bar')])+      const { props } = mockProps()+      mount(props, () => h(Comp))+      expect(+        'renders non-element root node that cannot be animated',+      ).toHaveBeenWarned()+      expect(+        '<transition> can only be used on a single element or component',+      ).toHaveBeenWarned()+    })+  })+   // #10719   test('should not error on KeepAlive w/ function children', () => {     expect(() => mount({}, () => () => h('div'), true)).not.toThrow()packages/runtime-core/src/componentRenderUtils.tsindex 0b46130c0..0b477afd7 100644@@ -255,7 +255,7 @@ export function renderComponentRoot(   }   // inherit transition data   if (vnode.transition) {-    if (__DEV__ && !isElementRoot(root)) {+    if (__DEV__ && !isTransitionableRoot(root)) {       warn(         `Component inside <Transition> renders non-element root node ` +           `that cannot be animated.`,@@ -368,6 +368,25 @@ const isElementRoot = (vnode: VNode) => {   ) } +// a teleport root is transparent to transitions as long as it teleports a+// single element root (see setTransitionHooks)+const isTransitionableRoot = (vnode: VNode): boolean => {+  if (vnode.shapeFlag & ShapeFlags.TELEPORT) {+    const children = ((vnode.children as VNode[] | null) || []).filter(+      // null/boolean children are normalized to comments+      c =>+        isVNode(c) ? c.type !== Comment : c != null && typeof c !== 'boolean',+    )+    return (+      children.length === 0 ||+      (children.length === 1 &&+        isVNode(children[0]) &&+        !!isElementRoot(children[0]))+    )+  }+  return !!isElementRoot(vnode)+}+ export function shouldUpdateComponent(   prevVNode: VNode,   nextVNode: VNode,packages/runtime-core/src/components/BaseTransition.tsindex 4a9d5098e..808f78e80 100644@@ -12,6 +12,7 @@ import {   cloneVNode,   createCommentVNode,   isSameVNodeType,+  isVNode, } from '../vnode' import { warn } from '../warning' import { isKeepAlive } from './KeepAlive'@@ -542,6 +543,16 @@ 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) {+    // teleport is transparent to transitions (e.g. a component whose root is+    // a <Teleport>): apply the hooks to the teleported content instead.+    const children = vnode.children as VNode[] | null+    const child =+      children && children.length ? findNonCommentChild(children) : null+    // raw render function children may not be normalized yet (e.g. null)+    if (isVNode(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', () => {