Backtestsvuerun-20261005-155915#12569
Custom directive's unmounted event is not triggered on v-for element
The merged fix was judged better than our patch.
In this judgment, Patch A = our agent, Patch B = the merged fix.
Both patches target the same root cause. When an element inside a stable (constant-source) v-for fragment is demoted from block to plain vnode, it never gets the NEED_PATCH flag. buildProps skipped that flag because the element was a block, so the fragment's dynamicChildren omits it and its directive, vnode-hook and ref lifecycle never runs on update or unmount. Both fix the reported `<h1 v-for="i in 3" :key="i" v-dir>text</h1>` case and add integration tests that would fail before the change. Patch A re-derives in vFor.ts whether NEED_PATCH is needed. It rescans the element's props with ad-hoc string matching (`ref`, `onVnode*`, `vue:*`, `vnode*`), which duplicates buildProps' logic in a second, fragile place. It also unconditionally demotes elements that buildProps forced into blocks because of an inline before-update hook with children. As a plain vnode in a stable fragment, the element's nested dynamic children are collected into the fragment's dynamicChildren before the element itself, so its onVnodeBeforeUpdate / directive beforeUpdate runs after children update. Patch A even codifies this with a test asserting `isBlock: false` for `@vue:before-update` with children. That defeats the documented reason for forcing the block. Patch B propagates the facts from buildProps (`needsPatch`, `isBlockRequired`) onto the VNodeCall and lets vFor consume them. This keeps the analysis in one place. It preserves the block when before-update ordering requires it, and adds a runtime test confirming beforeUpdate observes the old nested text. It also handles the camelized `@vue:beforeUpdate` form. It moves the `hasRef` detection before the early return for constant values, which covers setup-const function refs, and tests that path. The added AST fields are a modest scope increase but are well-commented and structurally sound. Patch B's tests are broader and more meaningful: refs cleared, function ref called with null, directive and vnode unmounted hooks, and before-update ordering. Overall Patch B is more correct and better engineered.
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
15m 2s
Wall-clock time in the container
Full test suite
No new failures
3,663 passed · 6 skipped · 3,669 total
Contamination audit
Clean
No sign the agent saw the real fix
Patch size
236vs 338 merged
Changed lines, ours vs merged
The issue
View on GitHubVue version
3.5.13
Link to minimal reproduction
Steps to reproduce
Press F12, Click the 'hide' button, console only logs Div's umounted event, H1's unmounted event is not logged
What is expected?
unmounted event in Directive should be triggered on elements with v-for
What is actually happening?
unmounted event in Directive is not triggered on elements with v-for
System Info
_No response_
Any additional comments?
_No response_
The two patches
packages/compiler-core/__tests__/transforms/vFor.spec.tsindex 839d9d358..780acb5cd 100644@@ -3,6 +3,7 @@ import { transform } from '../../src/transform' import { transformIf } from '../../src/transforms/vIf' import { transformFor } from '../../src/transforms/vFor' import { transformBind } from '../../src/transforms/vBind'+import { transformOn } from '../../src/transforms/vOn' import { transformElement } from '../../src/transforms/transformElement' import { transformSlotOutlet } from '../../src/transforms/transformSlotOutlet' import { transformExpression } from '../../src/transforms/transformExpression'@@ -1118,6 +1119,82 @@ describe('compiler: v-for', () => { expect(generate(root).code).toMatchSnapshot() }) + // #12569+ test('v-for with constant expression on element with custom directive and children', () => {+ const {+ node: { codegenNode },+ } = parseWithForTransform(+ '<h1 v-for="i in 3" :key="i" v-foo>hello</h1>',+ { prefixIdentifiers: true },+ )+ const { innerVNodeCall } = assertSharedCodegen(+ codegenNode,+ true /* keyed */,+ false /* customReturn */,+ false /* disableTracking */,+ )+ expect(innerVNodeCall).toMatchObject({+ tag: `"h1"`,+ isBlock: false,+ directives: { type: NodeTypes.JS_ARRAY_EXPRESSION },+ patchFlag: PatchFlags.NEED_PATCH,+ })+ })++ // #12569+ test('v-for with constant expression on element with vnode before-update hook and children', () => {+ const {+ node: { codegenNode },+ } = parseWithForTransform(+ '<h1 v-for="i in 3" :key="i" @vue:before-update="onUpdate">hello</h1>',+ {+ prefixIdentifiers: true,+ cacheHandlers: true,+ directiveTransforms: { bind: transformBind, on: transformOn },+ },+ )+ const { innerVNodeCall } = assertSharedCodegen(+ codegenNode,+ true /* keyed */,+ false /* customReturn */,+ false /* disableTracking */,+ )+ expect(innerVNodeCall).toMatchObject({+ tag: `"h1"`,+ isBlock: false,+ patchFlag: PatchFlags.NEED_PATCH,+ })+ })++ // #12569+ test.each([+ `ref="r"`,+ `:ref="r"`,+ `@vue:unmounted="onUnmounted"`,+ ])(+ 'v-for with constant expression on keyed element with %s',+ prop => {+ const {+ node: { codegenNode },+ } = parseWithForTransform(`<div v-for="i in 3" :key="i" ${prop}/>`, {+ prefixIdentifiers: true,+ cacheHandlers: true,+ directiveTransforms: { bind: transformBind, on: transformOn },+ })+ const { innerVNodeCall } = assertSharedCodegen(+ codegenNode,+ true /* keyed */,+ false /* customReturn */,+ false /* disableTracking */,+ )+ expect(innerVNodeCall).toMatchObject({+ tag: `"div"`,+ isBlock: false,+ patchFlag: PatchFlags.NEED_PATCH,+ })+ },+ )+ test('template v-for key w/ :key shorthand on div', () => { const { node: { codegenNode },packages/compiler-core/src/transforms/vFor.tsindex dcc31a9a9..27b51fbc4 100644@@ -37,6 +37,7 @@ import { findProp, injectProp, isSlotOutlet,+ isStaticExp, isTemplateNode, } from '../utils' import {@@ -193,6 +194,34 @@ export const transformFor: NodeTransform = createStructuralDirectiveTransform( removeHelper( getVNodeBlockHelper(context.inSSR, childBlock.isComponent), )+ // #12569 an element forced into a block (by :key, custom+ // directives or a vnode before-update hook) skipped NEED_PATCH+ // because blocks are always tracked by the parent. Once demoted+ // to a plain vnode it must be flagged so the stable fragment+ // still tracks it, otherwise its directives / vnode hooks / ref+ // are never invoked on update and unmount.+ if (+ !childBlock.isComponent &&+ (childBlock.patchFlag === undefined ||+ childBlock.patchFlag === PatchFlags.NEED_HYDRATION) &&+ (childBlock.directives ||+ (children[0] as PlainElementNode).props.some(+ p =>+ p.type === NodeTypes.ATTRIBUTE+ ? p.name === 'ref'+ : p.arg &&+ isStaticExp(p.arg) &&+ ((p.name === 'bind' &&+ (p.arg.content === 'ref' ||+ p.arg.content.startsWith('onVnode'))) ||+ (p.name === 'on' &&+ (p.arg.content.startsWith('vue:') ||+ p.arg.content.startsWith('vnode')))),+ ))+ ) {+ childBlock.patchFlag =+ (childBlock.patchFlag || 0) | PatchFlags.NEED_PATCH+ } } else { // switch from vnode to block removeHelper(packages/vue/__tests__/index.spec.tsindex 79e48b775..5ad9ba1da 100644@@ -1,5 +1,7 @@ import { EMPTY_ARR } from '@vue/shared'-import { createApp, nextTick, reactive, ref } from '../src'+import { compile } from '@vue/compiler-dom'+import * as runtimeDom from '@vue/runtime-dom'+import { type VNode, createApp, nextTick, reactive, ref } from '../src' describe('compiler + runtime integration', () => { it('should support runtime template compilation', () => {@@ -347,4 +349,130 @@ describe('compiler + runtime integration', () => { app.mount(root) expect(root.innerHTML).toBe('<div>60000000100000111</div>') })++ describe('v-for with constant source (#12569)', () => {+ // compile like SFCs do: with prefixIdentifiers the constant v-for source+ // produces a stable fragment, and cacheHandlers drops the PROPS patch flag+ // for vnode hooks.+ const compileRender = (template: string) =>+ new Function(+ 'Vue',+ compile(template, {+ mode: 'function',+ prefixIdentifiers: true,+ cacheHandlers: true,+ hoistStatic: true,+ }).code,+ )(runtimeDom)++ it('should invoke custom directive hooks on v-for elements', async () => {+ const calls: string[] = []+ const visible = ref(true)+ const msg = ref('a')+ const root = document.createElement('div')+ createApp({+ render: compileRender(`+ <template v-if="visible">+ <h1 v-for="i in 3" :key="i" v-log>{{ msg }}</h1>+ </template>+ <div v-if="visible" v-log>static</div>`),+ directives: {+ log: {+ mounted: (el: Element) => calls.push(`mounted ${el.tagName}`),+ updated: (el: Element) =>+ calls.push(`updated ${el.tagName} ${el.textContent}`),+ unmounted: (el: Element) => calls.push(`unmounted ${el.tagName}`),+ },+ },+ setup: () => ({ visible, msg }),+ }).mount(root)+ expect(calls).toEqual([+ 'mounted H1',+ 'mounted H1',+ 'mounted H1',+ 'mounted DIV',+ ])++ calls.length = 0+ msg.value = 'b'+ await nextTick()+ expect(root.querySelectorAll('h1')[0].textContent).toBe('b')+ expect(calls).toEqual([+ 'updated H1 b',+ 'updated H1 b',+ 'updated H1 b',+ 'updated DIV static',+ ])++ calls.length = 0+ visible.value = false+ await nextTick()+ expect(root.querySelector('h1')).toBeNull()+ expect(calls).toEqual([+ 'unmounted H1',+ 'unmounted H1',+ 'unmounted H1',+ 'unmounted DIV',+ ])+ })++ it('should invoke vnode hooks on v-for elements', async () => {+ const calls: string[] = []+ const visible = ref(true)+ const msg = ref('a')+ const root = document.createElement('div')+ createApp({+ render: compileRender(`+ <template v-if="visible">+ <h1+ v-for="i in 2"+ :key="i"+ @vue:before-update="onBeforeUpdate"+ @vue:unmounted="onUnmounted"+ >hello</h1>+ </template>+ <p>{{ msg }}</p>`),+ setup: () => ({+ visible,+ msg,+ onBeforeUpdate: (vnode: VNode) =>+ calls.push(`beforeUpdate ${String(vnode.key)}`),+ onUnmounted: (vnode: VNode) =>+ calls.push(`unmounted ${String(vnode.key)}`),+ }),+ }).mount(root)++ msg.value = 'b'+ await nextTick()+ expect(calls).toEqual(['beforeUpdate 1', 'beforeUpdate 2'])++ calls.length = 0+ visible.value = false+ await nextTick()+ expect(root.querySelector('h1')).toBeNull()+ expect(calls).toEqual(['unmounted 1', 'unmounted 2'])+ })++ it('should invoke vnode hooks on keyed v-for elements without children', async () => {+ const calls: string[] = []+ const visible = ref(true)+ const root = document.createElement('div')+ createApp({+ render: compileRender(`+ <template v-if="visible">+ <div v-for="i in 2" :key="i" @vue:unmounted="onUnmounted"/>+ </template>`),+ setup: () => ({+ visible,+ onUnmounted: (vnode: VNode) =>+ calls.push(`unmounted ${String(vnode.key)}`),+ }),+ }).mount(root)++ visible.value = false+ await nextTick()+ expect(root.querySelector('div')).toBeNull()+ expect(calls).toEqual(['unmounted 1', 'unmounted 2'])+ })+ }) })
packages/compiler-core/__tests__/transforms/transformElement.spec.tsindex bf3510a05..8215ceedb 100644@@ -74,6 +74,12 @@ function parseWithBind(template: string, options?: CompilerOptions) { }) } +function getVForChild(+ node: ReturnType<typeof parseWithForTransform>['node'],+): VNodeCall {+ return node.codegenNode.children.arguments[1].returns as VNodeCall+}+ describe('compiler: element transform', () => { test('import + resolve component', () => { const { root } = parseWithElementTransform(`<Foo/>`)@@ -1028,6 +1034,105 @@ describe('compiler: element transform', () => { expect(node.patchFlag).toBe(PatchFlags.NEED_PATCH) }) + test('NEED_PATCH (stable v-for + static ref)', () => {+ const { node } = parseWithForTransform(+ `<div v-for="i in 3" :key="i" ref="foo" />`,+ { prefixIdentifiers: true },+ )+ const child = getVForChild(node)+ expect(child.isBlock).toBe(false)+ expect(child.patchFlag).toBe(PatchFlags.NEED_PATCH)+ })++ test('NEED_PATCH (stable v-for + custom directives)', () => {+ const { node } = parseWithForTransform(+ `<div v-for="i in 3" :key="i" v-dir />`,+ { prefixIdentifiers: true },+ )+ const child = getVForChild(node)+ expect(child.isBlock).toBe(false)+ expect(child.patchFlag).toBe(PatchFlags.NEED_PATCH)+ })++ test('NEED_PATCH (stable v-for + vnode hooks)', () => {+ const { node } = parseWithForTransform(+ `<div v-for="i in 3" :key="i" @vue:unmounted="foo" />`,+ {+ prefixIdentifiers: true,+ cacheHandlers: true,+ directiveTransforms: {+ bind: transformBind,+ on: transformOn,+ },+ },+ )+ const child = getVForChild(node)+ expect(child.isBlock).toBe(false)+ expect(child.patchFlag).toBe(PatchFlags.NEED_PATCH)+ })++ test('NEED_PATCH (stable v-for + setup-const function ref)', () => {+ const { node } = parseWithForTransform(+ `<div v-for="i in 3" :key="i" :ref="setRefFn" />`,+ {+ prefixIdentifiers: true,+ bindingMetadata: {+ setRefFn: BindingTypes.SETUP_CONST,+ },+ },+ )+ const child = getVForChild(node)+ expect(child.isBlock).toBe(false)+ expect(child.patchFlag).toBe(PatchFlags.NEED_PATCH)+ })++ test('preserve block for stable v-for + custom directive with children', () => {+ const { node } = parseWithForTransform(+ `<div v-for="i in 3" v-dir>{{ i }}</div>`,+ { prefixIdentifiers: true },+ )+ const child = getVForChild(node)+ expect(child.isBlock).toBe(true)+ expect(child.patchFlag).toBe(PatchFlags.TEXT)+ })++ test.each(['before-update', 'beforeUpdate'])(+ 'preserve block for stable v-for + @vue:%s vnode hook',+ hook => {+ const { node } = parseWithForTransform(+ `<div v-for="i in 3" @vue:${hook}="foo"><span /></div>`,+ {+ prefixIdentifiers: true,+ cacheHandlers: true,+ directiveTransforms: {+ bind: transformBind,+ on: transformOn,+ },+ },+ )+ const child = getVForChild(node)+ expect(child.isBlock).toBe(true)+ expect(child.patchFlag).toBeUndefined()+ },+ )++ test('does not add NEED_PATCH when another patch flag tracks the vnode', () => {+ const { node } = parseWithForTransform(+ `<div v-for="i in 3" :key="i" @vue:unmounted="foo">{{ i }}</div>`,+ {+ prefixIdentifiers: true,+ cacheHandlers: true,+ directiveTransforms: {+ bind: transformBind,+ on: transformOn,+ },+ },+ )+ const child = getVForChild(node)+ expect(child.isBlock).toBe(false)+ expect(child.patchFlag).toBe(PatchFlags.TEXT)+ })+ test('script setup inline mode template ref (binding exists)', () => { const { node } = parseWithElementTransform(`<input ref="input"/>`, { inline: true,packages/compiler-core/src/ast.tsindex e6da01edb..f67231539 100644@@ -330,6 +330,10 @@ export interface VNodeCall extends Node { patchFlag: PatchFlags | undefined dynamicProps: string | SimpleExpressionNode | undefined directives: DirectiveArguments | undefined+ /** Whether this vnode must be patched if a later transform makes it non-block. */+ needsPatch?: boolean+ /** Whether a later transform must preserve this vnode as a block. */+ isBlockRequired?: boolean isBlock: boolean disableTracking: boolean isComponent: booleanpackages/compiler-core/src/transforms/transformElement.tsindex 40f08d45b..b2024b329 100644@@ -102,6 +102,8 @@ export const transformElement: NodeTransform = (node, context) => { let vnodeDynamicProps: VNodeCall['dynamicProps'] let dynamicPropNames: string[] | undefined let vnodeDirectives: VNodeCall['directives']+ let needsPatch = false+ let isBlockRequired = false let shouldUseBlock = // dynamic component may resolve to plain elements@@ -127,6 +129,8 @@ export const transformElement: NodeTransform = (node, context) => { vnodeProps = propsBuildResult.props patchFlag = propsBuildResult.patchFlag dynamicPropNames = propsBuildResult.dynamicPropNames+ needsPatch = propsBuildResult.needsPatch+ isBlockRequired = propsBuildResult.isBlockRequired const directives = propsBuildResult.directives vnodeDirectives = directives && directives.length@@ -206,7 +210,7 @@ export const transformElement: NodeTransform = (node, context) => { vnodeDynamicProps = stringifyDynamicPropNames(dynamicPropNames) } - node.codegenNode = createVNodeCall(+ const vnodeCall = (node.codegenNode = createVNodeCall( context, vnodeTag, vnodeProps,@@ -218,7 +222,15 @@ export const transformElement: NodeTransform = (node, context) => { false /* disableTracking */, isComponent, node.loc,- )+ ))+ needsPatch =+ needsPatch && (patchFlag === 0 || patchFlag === PatchFlags.NEED_HYDRATION)+ if (needsPatch) {+ vnodeCall.needsPatch = true+ }+ if (isBlockRequired) {+ vnodeCall.isBlockRequired = true+ } } } @@ -382,6 +394,8 @@ export function buildProps( patchFlag: number dynamicPropNames: string[] shouldUseBlock: boolean+ needsPatch: boolean+ isBlockRequired: boolean } { const { tag, loc: elementLoc, children } = node let properties: ObjectExpression['properties'] = []@@ -389,6 +403,7 @@ export function buildProps( const runtimeDirectives: DirectiveNode[] = [] const hasChildren = children.length > 0 let shouldUseBlock = false+ let isBlockRequired = false // patchFlag analysis let patchFlag = 0@@ -444,6 +459,10 @@ export function buildProps( hasVnodeHook = true } + if (name === 'ref') {+ hasRef = true+ }+ if (isEventHandler && value.type === NodeTypes.JS_CALL_EXPRESSION) { // handler wrapped with internal helper e.g. withModifiers(fn) // extract the actual expression@@ -460,13 +479,15 @@ export function buildProps( return } - if (name === 'ref') {- hasRef = true- } else if (name === 'class') {+ if (name === 'class') { hasClassBinding = true } else if (name === 'style') { hasStyleBinding = true- } else if (name !== 'key' && !dynamicPropNames.includes(name)) {+ } else if (+ name !== 'ref' &&+ name !== 'key' &&+ !dynamicPropNames.includes(name)+ ) { dynamicPropNames.push(name) } @@ -573,14 +594,21 @@ export function buildProps( continue } + // #938: elements with dynamic keys should be forced into blocks+ if (isVBind && isStaticArgOf(arg, 'key')) {+ shouldUseBlock = true+ }+ // inline before-update hooks need to remain blocks so that they are+ // invoked before children if (- // #938: elements with dynamic keys should be forced into blocks- (isVBind && isStaticArgOf(arg, 'key')) ||- // inline before-update hooks need to force block so that it is invoked- // before children- (isVOn && hasChildren && isStaticArgOf(arg, 'vue:before-update'))+ isVOn &&+ hasChildren &&+ arg &&+ isStaticExp(arg) &&+ camelize(arg.content) === 'vue:beforeUpdate' ) { shouldUseBlock = true+ isBlockRequired = true } if (isVBind && isStaticArgOf(arg, 'ref')) {@@ -691,6 +719,7 @@ export function buildProps( // to ensure before-update gets called before children update if (hasChildren) { shouldUseBlock = true+ isBlockRequired = true } } }@@ -736,11 +765,10 @@ export function buildProps( patchFlag |= PatchFlags.NEED_HYDRATION } }- if (- !shouldUseBlock &&+ const needsPatch = (patchFlag === 0 || patchFlag === PatchFlags.NEED_HYDRATION) && (hasRef || hasVnodeHook || runtimeDirectives.length > 0)- ) {+ if (!shouldUseBlock && needsPatch) { patchFlag |= PatchFlags.NEED_PATCH } @@ -825,6 +853,8 @@ export function buildProps( patchFlag, dynamicPropNames, shouldUseBlock,+ needsPatch,+ isBlockRequired, } } packages/compiler-core/src/transforms/vFor.tsindex dcc31a9a9..ebf67d3d7 100644@@ -186,7 +186,9 @@ export const transformFor: NodeTransform = createStructuralDirectiveTransform( if (isTemplate && keyProperty) { injectProp(childBlock, keyProperty, context) }- if (childBlock.isBlock !== !isStableFragment) {+ const shouldUseBlock =+ !isStableFragment || childBlock.isBlockRequired === true+ if (childBlock.isBlock !== shouldUseBlock) { if (childBlock.isBlock) { // switch from block to vnode removeHelper(OPEN_BLOCK)@@ -200,12 +202,16 @@ export const transformFor: NodeTransform = createStructuralDirectiveTransform( ) } }- childBlock.isBlock = !isStableFragment+ childBlock.isBlock = shouldUseBlock if (childBlock.isBlock) { helper(OPEN_BLOCK) helper(getVNodeBlockHelper(context.inSSR, childBlock.isComponent)) } else { helper(getVNodeHelper(context.inSSR, childBlock.isComponent))+ if (childBlock.needsPatch) {+ childBlock.patchFlag = ((childBlock.patchFlag ?? 0) |+ PatchFlags.NEED_PATCH) as PatchFlags+ } } } packages/vue/__tests__/index.spec.tsindex 79e48b775..98f00cf28 100644@@ -1,5 +1,19 @@+import { BindingTypes, type CompilerOptions } from '@vue/compiler-core'+import { compile } from '@vue/compiler-dom' import { EMPTY_ARR } from '@vue/shared'-import { createApp, nextTick, reactive, ref } from '../src'+import { type VNode, createApp, nextTick, reactive, ref } from '../src'+import * as Vue from '../src'+import type { InternalRenderFunction } from '../../runtime-core/src/component'++function compileToFunction(template: string, options?: CompilerOptions) {+ const { code } = compile(template, {+ hoistStatic: true,+ ...options,+ })+ const render = new Function('Vue', code)(Vue) as InternalRenderFunction+ render._rc = true+ return render+} describe('compiler + runtime integration', () => { it('should support runtime template compilation', () => {@@ -347,4 +361,149 @@ describe('compiler + runtime integration', () => { app.mount(root) expect(root.innerHTML).toBe('<div>60000000100000111</div>') })++ describe('stable v-for lifecycle', () => {+ test('clears static ref arrays on branch removal', async () => {+ const show = ref(true)+ const items = ref<HTMLElement[]>([])+ const app = createApp({+ setup: () => ({ items, show }),+ render: compileToFunction(+ `<template v-if="show"><div v-for="i in 3" :key="i" ref="items" /></template>`,+ { prefixIdentifiers: true },+ ),+ })+ const container = document.createElement('div')++ app.mount(container)+ expect(items.value).toHaveLength(3)++ show.value = false+ await nextTick()+ expect(items.value).toHaveLength(0)++ app.unmount()+ })++ test('calls setup-const function refs with null on branch removal', async () => {+ const show = ref(true)+ const values: (Element | null)[] = []+ const setRef = (value: Element | null) => values.push(value)+ const app = createApp({+ setup: () => ({ setRef, show }),+ render: compileToFunction(+ `<template v-if="show"><div v-for="i in 1" :ref="setRef" /></template>`,+ {+ prefixIdentifiers: true,+ bindingMetadata: {+ setRef: BindingTypes.SETUP_CONST,+ },+ },+ ),+ })+ const container = document.createElement('div')++ app.mount(container)+ expect(values).toHaveLength(1)+ expect(values[0]).toBeInstanceOf(HTMLDivElement)++ show.value = false+ await nextTick()+ expect(values).toHaveLength(2)+ expect(values[1]).toBeNull()++ app.unmount()+ })++ test('calls directive unmounted hooks on branch removal', async () => {+ const show = ref(true)+ const unmounted = vi.fn()+ const app = createApp({+ directives: { dir: { unmounted } },+ setup: () => ({ show }),+ render: compileToFunction(+ `<template v-if="show"><div v-for="i in 1" v-dir /></template>`,+ { prefixIdentifiers: true },+ ),+ })+ const container = document.createElement('div')++ app.mount(container)+ show.value = false+ await nextTick()+ expect(unmounted).toHaveBeenCalledOnce()++ app.unmount()+ })++ test('calls vnode unmounted hooks on branch removal', async () => {+ const show = ref(true)+ const onVnodeUnmounted = vi.fn()+ const app = createApp({+ setup: () => ({ onVnodeUnmounted, show }),+ render: compileToFunction(+ `<template v-if="show"><div v-for="i in 1" @vue:unmounted="onVnodeUnmounted" /></template>`,+ { prefixIdentifiers: true },+ ),+ })+ const container = document.createElement('div')++ app.mount(container)+ show.value = false+ await nextTick()+ expect(onVnodeUnmounted).toHaveBeenCalledOnce()++ app.unmount()+ })++ test('runs directive beforeUpdate before child updates', async () => {+ const value = ref('old')+ const observed: string[] = []+ const app = createApp({+ directives: {+ dir: {+ beforeUpdate(el: HTMLElement) {+ observed.push(el.textContent!)+ },+ },+ },+ setup: () => ({ value }),+ render: compileToFunction(+ `<div v-for="i in 1" v-dir>{{ value }}</div>`,+ { prefixIdentifiers: true },+ ),+ })+ const container = document.createElement('div')++ app.mount(container)+ value.value = 'new'+ await nextTick()+ expect(observed).toEqual(['old'])++ app.unmount()+ })++ test('runs vnode beforeUpdate before nested child updates', async () => {+ const value = ref('old')+ const observed: string[] = []+ const onVnodeBeforeUpdate = (vnode: VNode) => {+ observed.push((vnode.el as HTMLElement).textContent!)+ }+ const app = createApp({+ setup: () => ({ onVnodeBeforeUpdate, value }),+ render: compileToFunction(+ `<div v-for="i in 1" @vue:beforeUpdate="onVnodeBeforeUpdate"><span>{{ value }}</span></div>`,+ { prefixIdentifiers: true },+ ),+ })+ const container = document.createElement('div')++ app.mount(container)+ value.value = 'new'+ await nextTick()+ expect(observed).toEqual(['old'])++ app.unmount()+ })+ }) })