Backtestsvuerun-20261003-231210#9239
the div which has the ref attribute inside the v-for, when I v-if toggle them, the ref value.length increase more and more
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, and both have solid regression tests. B wins on scope: it fixes the same thing with a far smaller, lower-risk change. **Root cause.** In a constant-source v-for, an element with a ref, vnode hook or custom directive can be forced into a block by a dynamic key (or by before-update, or by directives with children). Because `buildProps` skipped NEED_PATCH when `shouldUseBlock` was true, the element never got that flag. vFor's stable-fragment handling then turns the block back into a plain vnode. The result has no patch flag and is not tracked in the parent block's `dynamicChildren`. On optimized unmount its ref is never unset, so the ref array keeps growing. **Patch B** removes the `!shouldUseBlock` guard, so NEED_PATCH is always added when needed. That fixes the issue at its source. For blocks that stay blocks, the extra 512 flag has no effect at runtime: `patchElement` does nothing extra for NEED_PATCH alone. That is why the only fallout is two snapshot updates. B's runtime tests compile real templates: - A keyed ref in `v-for="i in 3"` inside a v-if, toggled repeatedly. It asserts the length goes back to 0 and 3 each cycle, which reproduces the issue exactly. - Directive `updated`/`unmounted` counts. Both would fail before the change. **Patch A** fixes the same bug differently. It adds `needsPatch` and `isBlockRequired` fields to `VNodeCall`, threads them through `transformElement`, and has vFor apply NEED_PATCH when it demotes a block. It also goes further: it keeps elements as blocks in stable fragments when they have before-update hooks or directives with children. That fixes a separate hook-ordering problem the issue doesn't ask about. It also changes block structure in stable fragments and adds AST surface area. A's tests are thorough and also cover the issue scenario. However, the extra mechanism adds complexity and risk that this fix doesn't need. Both are correct for the reported bug with good tests, so the smaller and more direct root-cause fix tips the balance to B.
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 41s
Wall-clock time in the container
Full test suite
No new failures
3,658 passed · 6 skipped · 3,664 total
Contamination audit
Clean
No sign the agent saw the real fix
Patch size
167vs 338 merged
Changed lines, ours vs merged
The issue
View on GitHubVue version
3.2.47
Link to minimal reproduction
Steps to reproduce
if I click toggleVisible many times,
- the
refDivSingletoggle between null and div - the
refCompSingletoggle between null and {} - the
refDivArr.lengthincrease more and more <-- error here - the
refCompArr.lengthtoggle between 3 and 0
if I use ref function, it don't get null
<img width="532" alt="image" src="https://github.com/vuejs/core/assets/417448/b1a09a97-2c9f-4310-9430-27aa04b79863">
What is expected?
the refDivArr.length should toggle between 3 and 0, same as the refCompArr.length
What is actually happening?
the refDivArr.length increase more and more
System Info
_No response_
Any additional comments?
_No response_
The two patches
packages/compiler-core/__tests__/transforms/__snapshots__/cacheStatic.spec.ts.snapindex 7d5e47719..ea966a937 100644@@ -217,7 +217,7 @@ return function render(_ctx, _cache) { return (_openBlock(), _createElementBlock("div", null, [ _withDirectives((_openBlock(), _createElementBlock("svg", null, [...(_cache[0] || (_cache[0] = [ _createElementVNode("path", { d: "M2,3H5.5L12" }, null, -1 /* CACHED */)- ]))])), [+ ]))], 512 /* NEED_PATCH */)), [ [_directive_foo] ]) ]))packages/compiler-core/__tests__/transforms/__snapshots__/transformText.spec.ts.snapindex 7fb49ea78..55a7d7143 100644@@ -73,7 +73,7 @@ return function render(_ctx, _cache) { return _withDirectives((_openBlock(), _createElementBlock("p", null, [ _createTextVNode(_toDisplayString(foo), 1 /* TEXT */)- ])), [+ ], 512 /* NEED_PATCH */)), [ [_directive_foo] ]) }packages/compiler-core/__tests__/transforms/vFor.spec.tsindex 839d9d358..b8cbdbe65 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'@@ -874,6 +875,76 @@ describe('compiler: v-for', () => { expect(generate(root).code).toMatchSnapshot() }) + // elements forced into blocks (e.g. by a dynamic key) are converted back+ // to plain vnodes inside a stable fragment, so they must keep NEED_PATCH+ // to be tracked as dynamic children (otherwise refs / directives are+ // never unset on unmount)+ test('v-for with constant expression + key + ref', () => {+ const {+ node: { codegenNode },+ } = parseWithForTransform(+ '<div v-for="item in 3" :key="item" ref="foo"><span/></div>',+ { prefixIdentifiers: true },+ )+ expect(+ assertSharedCodegen(+ codegenNode,+ false /* keyed */,+ false /* customReturn */,+ false /* disableTracking */,+ ).innerVNodeCall,+ ).toMatchObject({+ tag: `"div"`,+ isBlock: false,+ patchFlag: PatchFlags.NEED_PATCH,+ })+ })++ test('v-for with constant expression + custom directive', () => {+ const {+ node: { codegenNode },+ } = parseWithForTransform('<div v-for="item in 3" v-foo><span/></div>', {+ prefixIdentifiers: true,+ })+ expect(+ assertSharedCodegen(+ codegenNode,+ false /* keyed */,+ false /* customReturn */,+ false /* disableTracking */,+ ).innerVNodeCall,+ ).toMatchObject({+ tag: `"div"`,+ isBlock: false,+ patchFlag: PatchFlags.NEED_PATCH,+ })+ })++ test('v-for with constant expression + inline before-update hook', () => {+ const {+ node: { codegenNode },+ } = parseWithForTransform(+ '<div v-for="item in 3" @vue:before-update="onUpdate"><span/></div>',+ {+ prefixIdentifiers: true,+ cacheHandlers: true,+ directiveTransforms: { bind: transformBind, on: transformOn },+ },+ )+ expect(+ assertSharedCodegen(+ codegenNode,+ false /* keyed */,+ false /* customReturn */,+ false /* disableTracking */,+ ).innerVNodeCall,+ ).toMatchObject({+ tag: `"div"`,+ isBlock: false,+ patchFlag: PatchFlags.NEED_PATCH,+ })+ })+ test('template v-for', () => { const { root,packages/compiler-core/src/transforms/transformElement.tsindex 40f08d45b..c640f02fb 100644@@ -737,7 +737,6 @@ export function buildProps( } } if (- !shouldUseBlock && (patchFlag === 0 || patchFlag === PatchFlags.NEED_HYDRATION) && (hasRef || hasVnodeHook || runtimeDirectives.length > 0) ) {packages/runtime-core/__tests__/directives.spec.tsindex 8d9982548..7d5c268d4 100644@@ -10,11 +10,22 @@ import { render, withDirectives, } from '@vue/runtime-test'+import * as runtimeTest from '@vue/runtime-test'+import { baseCompile } from '@vue/compiler-core' import { type ComponentInternalInstance,+ type InternalRenderFunction, currentInstance, } from '../src/component' +function compileToFunction(template: string) {+ const { code } = baseCompile(template, {+ hoistStatic: true,+ prefixIdentifiers: true,+ })+ return new Function('Vue', code)(runtimeTest) as InternalRenderFunction+}+ describe('directives', () => { it('should work', async () => { const count = ref(0)@@ -441,4 +452,35 @@ describe('directives', () => { render(h(App), root) expect(d1.mounted).toHaveBeenCalled() })++ // elements with custom directives and children are compiled as blocks,+ // which are then converted back to plain vnodes inside a stable+ // (constant source) v-for fragment+ test('directive in v-for with constant source should be updated and unmounted', async () => {+ const visible = ref(true)+ const count = ref(0)+ const updated = vi.fn()+ const unmounted = vi.fn()+ const App = {+ setup() {+ return { visible, count }+ },+ directives: { foo: { updated, unmounted } },+ render: compileToFunction(+ `<div v-if="visible">` ++ `<div v-for="i in 3" v-foo><span>{{ count }}</span></div>` ++ `</div>`,+ ),+ }+ const root = nodeOps.createElement('div')+ render(h(App), root)++ count.value+++ await nextTick()+ expect(updated).toHaveBeenCalledTimes(3)++ visible.value = false+ await nextTick()+ expect(unmounted).toHaveBeenCalledTimes(3)+ }) })packages/runtime-core/__tests__/rendererTemplateRef.spec.tsindex 53e03c827..5c154f712 100644@@ -12,6 +12,17 @@ import { shallowRef, watch, } from '@vue/runtime-test'+import * as runtimeTest from '@vue/runtime-test'+import { baseCompile } from '@vue/compiler-core'+import type { InternalRenderFunction } from '../src/component'++function compileToFunction(template: string) {+ const { code } = baseCompile(template, {+ hoistStatic: true,+ prefixIdentifiers: true,+ })+ return new Function('Vue', code)(runtimeTest) as InternalRenderFunction+} describe('api: template refs', () => { it('string ref mount', () => {@@ -610,6 +621,44 @@ describe('api: template refs', () => { expect(mapRefs()).toMatchObject(['2', '3', '4']) }) + // keyed elements are compiled as blocks, which are then converted back to+ // plain vnodes inside a stable (constant source) v-for fragment+ test('keyed ref in v-for with constant source should be unset on unmount', async () => {+ const visible = ref(true)+ const listRefs = ref<any[]>([])+ const App = {+ setup() {+ return { visible, listRefs }+ },+ render: compileToFunction(+ `<div>{{ listRefs.length }}</div>` ++ `<div v-if="visible">` ++ `<div v-for="i in 3" :key="i" ref="listRefs"><span>item</span></div>` ++ `</div>`,+ ),+ }+ const root = nodeOps.createElement('div')+ render(h(App), root)+ await nextTick()+ expect(listRefs.value.length).toBe(3)++ for (let i = 0; i < 3; i++) {+ visible.value = false+ await nextTick()+ expect(listRefs.value.length).toBe(0)+ expect(serializeInner(root)).toBe(`<div>0</div><!--v-if-->`)++ visible.value = true+ await nextTick()+ expect(listRefs.value.length).toBe(3)+ expect(serializeInner(root)).toBe(+ `<div>3</div><div>` ++ `<div><span>item</span></div>`.repeat(3) ++ `</div>`,+ )+ }+ })+ // #6697 v-for ref behaves differently under production and development test('named ref in v-for , should be responsive when rendering', async () => { const list = ref([1, 2, 3])
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()+ })+ }) })