Backtestsvuerun-20261013-093701#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 the issue, the `<h1>` has a custom directive and children, so `transformElement` forces it into a block. Because it is a block, it skips the `NEED_PATCH` flag. When the `v-for` source is constant, the stable-fragment path in `transformFor` then turns it back into a plain vnode. The result is a vnode with no patch flag, which never enters the parent's `dynamicChildren`, so its directive unmount hook never runs. Both patches fix the reported symptom.
**Patch A** adds a post-hoc check in `vFor.ts`. When a child becomes a plain vnode, it adds `NEED_PATCH` if the vnode has directives or a static `ref`/`onVnode*` prop key. This is targeted and works for unmount and update hooks. However, it accepts that the element is no longer a block. That defeats the reason the block was forced in the first place: making directive and vnode `beforeUpdate` hooks run before children update. With Patch A, a stable `v-for` element with a custom directive or an inline `@vue:before-update` will call `beforeUpdate` after its children have patched. A's own test only checks that an `updated` call happens, not the ordering. A also re-derives the flag by pattern-matching the props object (`startsWith('onVnode')`), which is somewhat ad hoc.
**Patch B** has `buildProps` record two facts on the `VNodeCall`:
- `needsPatch`: the element would have needed `NEED_PATCH` had it not been forced into a block.
- `isBlockRequired`: the block exists for `beforeUpdate` ordering (a custom directive with children, or an inline before-update hook).
`transformFor` then keeps such children as blocks inside the stable fragment, which keeps them tracked and preserves hook ordering. It adds `NEED_PATCH` only when the child really becomes a plain vnode. For the issue's exact case (`h1` with `v-focus` and children), B keeps the block, so unmount is tracked and `beforeUpdate` ordering is correct.
B also:
- handles the camelized `vue:beforeUpdate` spelling;
- moves `hasRef` detection ahead of the constant-prop early return, so setup-const function refs are tracked and get called with `null` on removal.
B's tests cover the compiler flags and runtime behaviour, including `beforeUpdate` running before child updates, which A cannot satisfy.
**Risk.** B is more invasive. The `hasRef` move could change patch flags in other compiler output. Still, the design carries the information from the right place rather than guessing it later, and it addresses the full semantics.
**Verdict.** On correctness, B is the more complete root-cause fix, so B wins.
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
12m 59s
Wall-clock time in the container
Full test suite
No new failures
1,861 passed · 1 skipped · 1,862 total
Contamination audit
Clean
No sign the agent saw the real fix
Patch size
206vs 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..26ad67561 100644@@ -10,11 +10,13 @@ import { ConstantTypes, type ElementNode, type ForCodegenNode,+ type ForIteratorExpression, type ForNode, type InterpolationNode, NodeTypes, type RootNode, type SimpleExpressionNode,+ type VNodeCall, } from '../../src/ast' import { ErrorCodes } from '../../src/errors' import { type CompilerOptions, generate } from '../../src'@@ -1144,4 +1146,43 @@ describe('compiler: v-for', () => { }) }) })++ // #12569+ describe('stable fragment children forced into blocks', () => {+ function getChildVNodeCall(template: string) {+ const {+ node: { codegenNode },+ } = parseWithForTransform(template, { prefixIdentifiers: true })+ expect(codegenNode.patchFlag).toBe(PatchFlags.STABLE_FRAGMENT)+ return (codegenNode.children.arguments[1] as ForIteratorExpression)+ .returns as VNodeCall+ }++ test('element with custom directive and children', () => {+ const child = getChildVNodeCall(+ `<h1 v-for="i in 3" :key="i" v-foo>hello</h1>`,+ )+ expect(child.isBlock).toBe(false)+ expect(child.directives).toBeDefined()+ expect(child.patchFlag).toBe(PatchFlags.NEED_PATCH)+ })++ test('element with dynamic key and ref', () => {+ const child = getChildVNodeCall(`<div v-for="i in 3" :key="i" ref="el"/>`)+ expect(child.isBlock).toBe(false)+ expect(child.patchFlag).toBe(PatchFlags.NEED_PATCH)+ })++ test('element with dynamic key and custom directive', () => {+ const child = getChildVNodeCall(`<div v-for="i in 3" :key="i" v-foo/>`)+ expect(child.isBlock).toBe(false)+ expect(child.patchFlag).toBe(PatchFlags.NEED_PATCH)+ })++ test('element with dynamic key and nothing to patch', () => {+ const child = getChildVNodeCall(`<div v-for="i in 3" :key="i"/>`)+ expect(child.isBlock).toBe(false)+ expect(child.patchFlag).toBeUndefined()+ })+ }) })packages/compiler-core/src/transforms/vFor.tsindex dcc31a9a9..5908e2f20 100644@@ -37,6 +37,7 @@ import { findProp, injectProp, isSlotOutlet,+ isStaticExp, isTemplateNode, } from '../utils' import {@@ -206,6 +207,20 @@ export const transformFor: NodeTransform = createStructuralDirectiveTransform( helper(getVNodeBlockHelper(context.inSSR, childBlock.isComponent)) } else { helper(getVNodeHelper(context.inSSR, childBlock.isComponent))+ // #12569 the element may have been forced into a block (custom+ // directive with children, dynamic key, inline before-update hook)+ // and thus skipped NEED_PATCH. Now that it is a plain vnode inside+ // the stable fragment's block, it must be tracked as a dynamic+ // child so that its directive hooks, vnode hooks and ref are+ // handled on update / unmount.+ if (+ (childBlock.patchFlag === undefined ||+ childBlock.patchFlag === PatchFlags.NEED_HYDRATION) &&+ needsPatch(childBlock)+ ) {+ childBlock.patchFlag =+ (childBlock.patchFlag || 0) | PatchFlags.NEED_PATCH+ } } } @@ -249,6 +264,22 @@ export const transformFor: NodeTransform = createStructuralDirectiveTransform( }, ) +function needsPatch(node: VNodeCall): boolean {+ if (node.directives) {+ return true+ }+ const props = node.props+ return (+ !!props &&+ props.type === NodeTypes.JS_OBJECT_EXPRESSION &&+ props.properties.some(+ ({ key }) =>+ isStaticExp(key) &&+ (key.content === 'ref' || key.content.startsWith('onVnode')),+ )+ )+}+ // target-agnostic transform used for both Client and SSR export function processFor( node: ElementNode,packages/vue/__tests__/index.spec.tsindex 79e48b775..f57d6156d 100644@@ -1,5 +1,13 @@ import { EMPTY_ARR } from '@vue/shared'-import { createApp, nextTick, reactive, ref } from '../src'+import { compile } from '@vue/compiler-dom'+import * as Vue from '../src'+import {+ type RenderFunction,+ createApp,+ nextTick,+ reactive,+ ref,+} from '../src' describe('compiler + runtime integration', () => { it('should support runtime template compilation', () => {@@ -347,4 +355,128 @@ describe('compiler + runtime integration', () => { app.mount(root) expect(root.innerHTML).toBe('<div>60000000100000111</div>') })+ // #12569+ describe('v-for with constant source on elements forced into blocks', () => {+ // compile like SFCs do (prefixIdentifiers), so that a constant v-for+ // source produces a STABLE_FRAGMENT+ const compileTemplate = (template: string): RenderFunction =>+ new Function(+ 'Vue',+ compile(template, {+ prefixIdentifiers: true,+ hoistStatic: true,+ cacheHandlers: true,+ }).code,+ )(Vue)++ test('custom directive hooks', async () => {+ const container = document.createElement('div')+ const visible = ref(true)+ const msg = ref('hi')+ const calls: string[] = []+ const App = {+ directives: {+ focus: {+ mounted: (el: Element) => calls.push(`mounted ${el.tagName}`),+ updated: (el: Element) => calls.push(`updated ${el.tagName}`),+ unmounted: (el: Element) => calls.push(`unmounted ${el.tagName}`),+ },+ },+ setup() {+ return { visible, msg }+ },+ render: compileTemplate(`+ <template v-if="visible">+ <h1 v-for="i in 2" v-focus>hello</h1>+ <span>{{ msg }}</span>+ </template>+ <div v-focus v-if="visible">my tag</div>+ `),+ }+ createApp(App).mount(container)+ expect(calls).toEqual(['mounted H1', 'mounted H1', 'mounted DIV'])++ calls.length = 0+ msg.value = 'changed'+ await nextTick()+ expect(container.innerHTML).toContain('<span>changed</span>')+ expect(calls).toEqual(['updated H1', 'updated H1', 'updated DIV'])++ calls.length = 0+ visible.value = false+ await nextTick()+ expect(container.innerHTML).toBe('<!--v-if--><!--v-if-->')+ expect(calls).toEqual(['unmounted H1', 'unmounted H1', 'unmounted DIV'])+ })++ test('vnode hooks', async () => {+ const container = document.createElement('div')+ const visible = ref(true)+ const onUnmounted = vi.fn()+ const App = {+ setup() {+ return { visible, onUnmounted }+ },+ render: compileTemplate(`+ <div v-if="visible">+ <p v-for="i in 2" :key="i" @vue:unmounted="onUnmounted"></p>+ </div>+ `),+ }+ createApp(App).mount(container)+ expect(container.innerHTML).toBe('<div><p></p><p></p></div>')++ visible.value = false+ await nextTick()+ expect(container.innerHTML).toBe('<!--v-if-->')+ expect(onUnmounted).toHaveBeenCalledTimes(2)+ })++ test('inline before-update vnode hook', async () => {+ const container = document.createElement('div')+ const msg = ref('a')+ const onBeforeUpdate = vi.fn()+ const App = {+ setup() {+ return { msg, onBeforeUpdate }+ },+ render: compileTemplate(`+ <div>+ <p v-for="i in 2" @vue:before-update="onBeforeUpdate">static</p>+ <span>{{ msg }}</span>+ </div>+ `),+ }+ createApp(App).mount(container)+ msg.value = 'b'+ await nextTick()+ expect(container.innerHTML).toBe(+ '<div><p>static</p><p>static</p><span>b</span></div>',+ )+ expect(onBeforeUpdate).toHaveBeenCalledTimes(2)+ })++ test('template ref', async () => {+ const container = document.createElement('div')+ const visible = ref(true)+ const els = ref<Element[]>([])+ const App = {+ setup() {+ return { visible, els }+ },+ render: compileTemplate(`+ <div v-if="visible">+ <p v-for="i in 2" :key="i" ref="els"></p>+ </div>+ `),+ }+ createApp(App).mount(container)+ expect(els.value.length).toBe(2)++ visible.value = false+ await nextTick()+ expect(container.innerHTML).toBe('<!--v-if-->')+ expect(els.value.length).toBe(0)+ })+ }) })
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()+ })+ }) })