Backtestsvuerun-20261005-124535#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.
Root cause: in `buildProps`, an element is forced into a block when it has a dynamic `:key`, or a custom directive or before-update hook plus children. Because `shouldUseBlock` is set, NEED_PATCH is skipped. The stable-fragment branch of the v-for transform then demotes the block to a plain vnode. The result is an untracked vnode whose directive unmounted hooks, refs and vnode hooks never run, which is the reported bug. Patch A fixes the symptom inside vFor. When demoting, it re-derives a NEED_PATCH condition with a separate `needsPatch` helper that duplicates `buildProps` logic (refs, runtime directives, onVnode* props and `@vue:` handlers). This fixes unmount and update for the issue's case. However, it still demotes elements that were forced into blocks *because* of directives or before-update hooks with children. Those blocks exist so that `beforeUpdate` runs before the children update. Once demoted, the children are tracked in the parent block and patched first, so hook ordering stays broken. Patch A's own test `custom directive with children` asserts `isBlock: false`, which locks in that behaviour. The duplicated detection logic can also drift from `buildProps`. Patch B computes `needsPatch` and `isBlockRequired` at the source in `buildProps` / `transformElement` and records them on the VNodeCall. vFor then adds NEED_PATCH on demotion and keeps the block when it is truly required, for directives or before-update hooks with children. That fixes the unmount bug and also preserves `beforeUpdate` ordering. It also normalizes the before-update arg check via camelize and tracks setup-const function refs, which were previously skipped by the early return. Tests: both add compiler and runtime tests that fail before the fix. Patch B's runtime tests are broader. They cover static ref array cleanup, function ref null calls, directive and vnode unmounted hooks, and `beforeUpdate` ordering relative to children. Patch B touches more code, but the changes are coherent and keep a single source of truth. Patch B is the more correct root-cause fix.
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
16m 24s
Wall-clock time in the container
Full test suite
No new failures
3,665 passed · 6 skipped · 3,671 total
Contamination audit
Clean
No sign the agent saw the real fix
Patch size
189vs 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..53bc10d65 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'@@ -17,7 +18,7 @@ import { type SimpleExpressionNode, } from '../../src/ast' import { ErrorCodes } from '../../src/errors'-import { type CompilerOptions, generate } from '../../src'+import { BindingTypes, type CompilerOptions, generate } from '../../src' import { FRAGMENT, RENDER_LIST, RENDER_SLOT } from '../../src/runtimeHelpers' import { PatchFlags } from '@vue/shared' import { createObjectMatcher } from '../testUtils'@@ -874,6 +875,103 @@ describe('compiler: v-for', () => { expect(generate(root).code).toMatchSnapshot() }) + // elements forced into blocks are demoted to plain vnodes inside a+ // stable fragment, they must keep NEED_PATCH so the parent block tracks+ // them and directive hooks / refs / vnode hooks run on update & unmount+ describe('v-for with constant expression on element forced into block', () => {+ function getInnerVNodeCall(+ template: string,+ options: CompilerOptions = {},+ ) {+ const {+ node: { codegenNode },+ } = parseWithForTransform(template, {+ ...options,+ prefixIdentifiers: true,+ directiveTransforms: { bind: transformBind, on: transformOn },+ })+ return assertSharedCodegen(+ codegenNode,+ false /* keyed */,+ false /* customReturn */,+ false /* disableTracking */,+ ).innerVNodeCall+ }++ test('custom directive with children', () => {+ expect(+ getInnerVNodeCall('<p v-for="item in 10" v-foo>hello</p>'),+ ).toMatchObject({+ tag: `"p"`,+ isBlock: false,+ directives: { type: NodeTypes.JS_ARRAY_EXPRESSION },+ patchFlag: PatchFlags.NEED_PATCH,+ })+ })++ test('custom directive with dynamic key', () => {+ expect(+ getInnerVNodeCall('<p v-for="item in 10" :key="item" v-foo/>'),+ ).toMatchObject({+ isBlock: false,+ patchFlag: PatchFlags.NEED_PATCH,+ })+ })++ test('custom directive keeps existing patch flag', () => {+ expect(+ getInnerVNodeCall(+ '<p v-for="item in 10" :key="item" v-foo>{{ item }}</p>',+ ),+ ).toMatchObject({+ isBlock: false,+ patchFlag: PatchFlags.TEXT,+ })+ })++ test('ref with dynamic key', () => {+ expect(+ getInnerVNodeCall('<p v-for="item in 10" :key="item" ref="foo"/>'),+ ).toMatchObject({+ isBlock: false,+ patchFlag: PatchFlags.NEED_PATCH,+ })+ })++ test('vnode hook with children', () => {+ expect(+ getInnerVNodeCall(+ '<p v-for="item in 10" @vue:before-update="foo">hello</p>',+ { cacheHandlers: true },+ ),+ ).toMatchObject({+ isBlock: false,+ patchFlag: PatchFlags.NEED_PATCH,+ })+ })++ test('vnode hook bound as prop with dynamic key', () => {+ expect(+ getInnerVNodeCall(+ '<p v-for="item in 10" :key="item" :onVnodeUnmounted="foo"/>',+ { bindingMetadata: { foo: BindingTypes.SETUP_CONST } },+ ),+ ).toMatchObject({+ isBlock: false,+ patchFlag: PatchFlags.NEED_PATCH,+ })+ })++ test('dynamic key only does not need patch', () => {+ expect(+ getInnerVNodeCall('<p v-for="item in 10" :key="item"/>'),+ ).toMatchObject({+ isBlock: false,+ patchFlag: undefined,+ })+ })+ })+ test('template v-for', () => { const { root,packages/compiler-core/src/transforms/vFor.tsindex dcc31a9a9..5a53f6761 100644@@ -37,6 +37,7 @@ import { findProp, injectProp, isSlotOutlet,+ isStaticExp, isTemplateNode, } from '../utils' import {@@ -47,7 +48,12 @@ import { } from '../runtimeHelpers' import { processExpression } from './transformExpression' import { validateBrowserExpression } from '../validateExpression'-import { PatchFlags } from '@vue/shared'+import {+ PatchFlags,+ camelize,+ isReservedProp,+ toHandlerKey,+} from '@vue/shared' export const transformFor: NodeTransform = createStructuralDirectiveTransform( 'for',@@ -193,6 +199,19 @@ export const transformFor: NodeTransform = createStructuralDirectiveTransform( removeHelper( getVNodeBlockHelper(context.inSSR, childBlock.isComponent), )+ // the element was forced into a block (e.g. dynamic key or custom+ // directive with children), so transformElement skipped the+ // NEED_PATCH flag. As a plain vnode in a stable fragment it must+ // still be tracked as a dynamic child, otherwise directive hooks,+ // vnode hooks and refs are skipped on update / unmount.+ if (+ (!childBlock.patchFlag ||+ childBlock.patchFlag === PatchFlags.NEED_HYDRATION) &&+ needsPatch(children[0] as ElementNode, childBlock)+ ) {+ childBlock.patchFlag =+ (childBlock.patchFlag || 0) | PatchFlags.NEED_PATCH+ } } else { // switch from vnode to block removeHelper(@@ -249,6 +268,32 @@ export const transformFor: NodeTransform = createStructuralDirectiveTransform( }, ) +// mirrors the NEED_PATCH condition in transformElement's buildProps: elements+// with runtime directives, a ref or vnode hooks must be patched even when they+// have no other dynamic bindings.+function needsPatch(node: ElementNode, codegenNode: VNodeCall): boolean {+ return (+ !!codegenNode.directives ||+ !!findProp(node, 'ref', false, true) ||+ node.props.some(p => {+ if (p.type !== NodeTypes.DIRECTIVE || !p.arg || !isStaticExp(p.arg)) {+ return false+ }+ let name = p.arg.content+ if (p.name === 'on') {+ // @vue:xxx / @vnode-xxx -> onVnodeXxx+ name = toHandlerKey(+ camelize(name.startsWith('vue:') ? `vnode-${name.slice(4)}` : name),+ )+ } else if (p.name !== 'bind') {+ return false+ }+ // :onVnodeXxx+ return name.startsWith('onVnode') && isReservedProp(name)+ })+ )+}+ // target-agnostic transform used for both Client and SSR export function processFor( node: ElementNode,packages/vue/__tests__/index.spec.tsindex 79e48b775..ebad3db37 100644@@ -1,5 +1,5 @@ import { EMPTY_ARR } from '@vue/shared'-import { createApp, nextTick, reactive, ref } from '../src'+import { compile, createApp, nextTick, reactive, ref } from '../src' describe('compiler + runtime integration', () => { it('should support runtime template compilation', () => {@@ -347,4 +347,44 @@ describe('compiler + runtime integration', () => { app.mount(root) expect(root.innerHTML).toBe('<div>60000000100000111</div>') })++ test('directive hooks on v-for element with constant source', async () => {+ const log: string[] = []+ const visible = ref(true)+ const count = ref(0)+ const container = document.createElement('div')+ createApp({+ setup: () => ({ visible, count }),+ directives: {+ foo: {+ mounted: (el: Element, { value }: any) =>+ log.push(`mounted ${el.tagName} ${value}`),+ updated: (el: Element, { value }: any) =>+ log.push(`updated ${el.tagName} ${value}`),+ unmounted: (el: Element) => log.push(`unmounted ${el.tagName}`),+ },+ },+ // the v-for source is only treated as constant with prefixIdentifiers,+ // which is how SFC templates are compiled+ render: compile(+ `<template v-if="visible">` ++ `<h1 v-for="i in 2" :key="i" v-foo="count">hello</h1>` ++ `</template>` ++ `<div v-if="visible" v-foo="count">tag</div>`,+ { prefixIdentifiers: true },+ ),+ }).mount(container)+ expect(log).toEqual(['mounted H1 0', 'mounted H1 0', 'mounted DIV 0'])++ log.length = 0+ count.value+++ await nextTick()+ expect(log).toEqual(['updated H1 1', 'updated H1 1', 'updated DIV 1'])++ log.length = 0+ visible.value = false+ await nextTick()+ expect(container.innerHTML).toBe(`<!--v-if--><!--v-if-->`)+ expect(log).toEqual(['unmounted H1', 'unmounted H1', 'unmounted DIV'])+ }) })
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()+ })+ }) })