Backtestsvuerun-20261002-115633#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
The merged fix was judged better than our patch.
In this judgment, Patch B = our agent, Patch A = the merged fix.
**Root cause.** `buildProps` forces keyed elements, and elements with directives or hooks plus children, into blocks. Because blocks are always patched, it skips adding NEED_PATCH. A stable v-for (constant source such as `i in 3`) then converts the child back to a plain vnode without restoring the flag. The element is no longer tracked as a dynamic child, so its ref is never unset on unmount and `refDivArr` keeps growing. Both patches fix this by adding NEED_PATCH when vFor demotes the child to a plain vnode. **Patch A** computes `needsPatch` where the information already exists, in `buildProps`, from `hasRef`, `hasVnodeHook` and runtime directives. It records this on the VNodeCall, and vFor applies NEED_PATCH on demotion. It also adds `isBlockRequired`, which keeps elements with beforeUpdate semantics as blocks so the hook still runs before children update. That case covers runtime directives with children and `@vue:before-update` / `beforeUpdate` hooks, and it fixes a camelCase-variant miss in the original check. The extra block preservation does change codegen for that case, which is some added risk. It is principled, though: B degrades that case into a plain vnode. **Patch A tests** cover: - compiler flags for static ref, directives, vnode hooks and setup-const function refs; - preserved blocks; - runtime integration for ref-array clearing, function refs being called with null, directive/vnode unmounted hooks, and beforeUpdate ordering. **Patch B** works only inside vFor. It re-derives "needs patch" by scanning the props object for `ref` or reserved `onVnode*` keys, or for any directives. This is a heuristic reconstruction of state that `buildProps` already knew. It is more fragile and duplicates logic. It fixes the reported ref case and directive unmount, and its tests are solid: a repeated toggle test that exactly mirrors the issue, plus a directive update/unmount test. For directives with children in a stable v-for, it adds NEED_PATCH rather than keeping block semantics, so beforeUpdate may run after children update. **Verdict.** Both resolve the reported bug. A fixes it at the source with more robust analysis, preserves hook-ordering semantics, and has broader meaningful tests. B is smaller but relies on a less reliable re-inspection of the generated props.
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
17m 39s
Wall-clock time in the container
Full test suite
No new failures
3,664 passed · 6 skipped · 3,670 total
Contamination audit
Clean
No sign the agent saw the real fix
Patch size
186vs 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/vFor.spec.tsindex 839d9d358..132043948 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'@@ -1143,5 +1144,92 @@ describe('compiler: v-for', () => { }, }) })++ describe('element forced into block in stable fragment', () => {+ function getInnerVNodeCall(template: string) {+ const {+ node: { codegenNode },+ } = parseWithForTransform(template, { prefixIdentifiers: true })+ return assertSharedCodegen(+ codegenNode,+ false /* keyed */,+ false /* customReturn */,+ false /* disableTracking */,+ ).innerVNodeCall+ }++ test('keyed element with ref should have NEED_PATCH', () => {+ expect(+ getInnerVNodeCall(+ `<div v-for="i in 3" :key="i" ref="foo"><span/></div>`,+ ),+ ).toMatchObject({+ isBlock: false,+ patchFlag: PatchFlags.NEED_PATCH,+ })+ })++ test('keyed element with dynamic ref should have NEED_PATCH', () => {+ expect(+ getInnerVNodeCall(`<div v-for="i in 3" :key="i" :ref="foo"/>`),+ ).toMatchObject({+ isBlock: false,+ patchFlag: PatchFlags.NEED_PATCH,+ })+ })++ test('keyed element with cached vnode hook should have NEED_PATCH', () => {+ const {+ node: { codegenNode },+ } = parseWithForTransform(+ `<div v-for="i in 3" :key="i" @vue:mounted="foo"/>`,+ {+ prefixIdentifiers: true,+ cacheHandlers: true,+ directiveTransforms: { bind: transformBind, on: transformOn },+ },+ )+ expect(+ assertSharedCodegen(+ codegenNode,+ false /* keyed */,+ false /* customReturn */,+ false /* disableTracking */,+ ).innerVNodeCall,+ ).toMatchObject({+ isBlock: false,+ patchFlag: PatchFlags.NEED_PATCH,+ })+ })++ test('element with custom directive and children should have NEED_PATCH', () => {+ expect(+ getInnerVNodeCall(`<div v-for="i in 3" v-foo><span/></div>`),+ ).toMatchObject({+ isBlock: false,+ patchFlag: PatchFlags.NEED_PATCH,+ directives: { type: NodeTypes.JS_ARRAY_EXPRESSION },+ })+ })++ test('keyed element without ref, hooks or directives should not have NEED_PATCH', () => {+ expect(+ getInnerVNodeCall(`<div v-for="i in 3" :key="i"><span/></div>`),+ ).toMatchObject({+ isBlock: false,+ patchFlag: undefined,+ })+ })++ test('keyed component with ref should not be changed', () => {+ expect(+ getInnerVNodeCall(`<Comp v-for="i in 3" :key="i" ref="foo"/>`),+ ).toMatchObject({+ isBlock: false,+ isComponent: true,+ patchFlag: undefined,+ })+ })+ }) }) })packages/compiler-core/src/transforms/vFor.tsindex dcc31a9a9..f1fe1465c 100644@@ -37,6 +37,7 @@ import { findProp, injectProp, isSlotOutlet,+ isStaticExp, isTemplateNode, } from '../utils' import {@@ -47,7 +48,7 @@ import { } from '../runtimeHelpers' import { processExpression } from './transformExpression' import { validateBrowserExpression } from '../validateExpression'-import { PatchFlags } from '@vue/shared'+import { PatchFlags, isOn, isReservedProp } from '@vue/shared' export const transformFor: NodeTransform = createStructuralDirectiveTransform( 'for',@@ -201,6 +202,21 @@ export const transformFor: NodeTransform = createStructuralDirectiveTransform( } } childBlock.isBlock = !isStableFragment+ if (+ !childBlock.isBlock &&+ !childBlock.isComponent &&+ (childBlock.patchFlag === undefined ||+ childBlock.patchFlag === PatchFlags.NEED_HYDRATION) &&+ needsPatch(childBlock)+ ) {+ // elements forced into blocks (e.g. by :key or custom directives)+ // omit the NEED_PATCH flag since blocks are always patched. Once+ // switched to a plain vnode inside a stable fragment, the flag is+ // required so it is still tracked as a dynamic child, otherwise+ // its ref, vnode hooks and directives are never updated or unset.+ childBlock.patchFlag =+ (childBlock.patchFlag || 0) | PatchFlags.NEED_PATCH+ } if (childBlock.isBlock) { helper(OPEN_BLOCK) helper(getVNodeBlockHelper(context.inSSR, childBlock.isComponent))@@ -249,6 +265,25 @@ export const transformFor: NodeTransform = createStructuralDirectiveTransform( }, ) +// elements forced into blocks skip NEED_PATCH, check whether the element still+// needs to be patched (refs, vnode hooks or runtime directives)+function needsPatch(node: VNodeCall): boolean {+ if (node.directives) {+ return true+ }+ const { props } = node+ return (+ !!props &&+ props.type === NodeTypes.JS_OBJECT_EXPRESSION &&+ props.properties.some(+ ({ key }) =>+ isStaticExp(key) &&+ (key.content === 'ref' ||+ (isOn(key.content) && isReservedProp(key.content))),+ )+ )+}+ // target-agnostic transform used for both Client and SSR export function processFor( node: ElementNode,packages/vue/__tests__/index.spec.tsindex 79e48b775..6a6911c67 100644@@ -347,4 +347,65 @@ describe('compiler + runtime integration', () => { app.mount(root) expect(root.innerHTML).toBe('<div>60000000100000111</div>') })++ // keyed element with ref inside a v-for with constant source+ test('ref in keyed v-for should be unset on unmount', async () => {+ const visible = ref(true)+ const items = ref<HTMLElement[]>([])+ const App = {+ // prefixIdentifiers marks the v-for source as constant (stable fragment)+ // just like SFC compilation does+ compilerOptions: { prefixIdentifiers: true },+ setup: () => ({ visible, items }),+ template:+ `<div>{{ items.length }}</div>` ++ `<div v-if="visible">` ++ `<div v-for="i in 3" :key="i" ref="items"><span>{{ i }}</span></div>` ++ `</div>`,+ }+ const root = document.createElement('div')+ createApp(App).mount(root)+ await nextTick()+ expect(items.value.length).toBe(3)+ expect(root.firstElementChild!.textContent).toBe('3')++ for (let i = 0; i < 3; i++) {+ visible.value = false+ await nextTick()+ expect(items.value.length).toBe(0)+ expect(root.firstElementChild!.textContent).toBe('0')++ visible.value = true+ await nextTick()+ await nextTick()+ expect(items.value.length).toBe(3)+ expect(root.firstElementChild!.textContent).toBe('3')+ }+ })++ test('custom directive on keyed element in v-for should be updated and unmounted', async () => {+ const visible = ref(true)+ const msg = ref('a')+ const updated = vi.fn()+ const unmounted = vi.fn()+ const App = {+ compilerOptions: { prefixIdentifiers: true },+ directives: { foo: { updated, unmounted } },+ setup: () => ({ visible, msg }),+ template:+ `<div v-if="visible">` ++ `<div v-for="i in 2" :key="i" v-foo="msg"></div>` ++ `</div>`,+ }+ const root = document.createElement('div')+ createApp(App).mount(root)++ msg.value = 'b'+ await nextTick()+ expect(updated).toHaveBeenCalledTimes(2)++ visible.value = false+ await nextTick()+ expect(unmounted).toHaveBeenCalledTimes(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()+ })+ }) })