nebius/SWE-rebench-V2-PRs huggingface dataset:
Repository: vuejs/composition-api
Pull request #689 (2021-04-29 03:48:10)

fix(reactive): align behavior with vue-next
Keep consistent with `vue-next`:

https://github.com/vuejs/vue-next/blob/d3d9355c5a75675ab99ff8bb381e34d02e322e88/packages/reactivity/src/reactive.ts#L180-L185


Patch:
diff --git a/src/reactivity/reactive.ts b/src/reactivity/reactive.ts
index 6cdaa82..fec1cea 100644
--- a/src/reactivity/reactive.ts
+++ b/src/reactivity/reactive.ts
@@ -1,6 +1,14 @@
 import { AnyObject } from '../types/basic'
 import { getRegisteredVueOrDefault } from '../runtimeContext'
-import { isPlainObject, def, warn, isArray, hasOwn, noopFn } from '../utils'
+import {
+  isPlainObject,
+  def,
+  warn,
+  isArray,
+  hasOwn,
+  noopFn,
+  isObject,
+} from '../utils'
 import { isComponentInstance, defineComponentInstance } from '../utils/helper'
 import { RefKey } from '../utils/symbols'
 import { isRef, UnwrapRef } from './ref'
@@ -190,10 +198,11 @@ export function shallowReactive(obj: any): any {
  * Make obj reactivity
  */
 export function reactive<T extends object>(obj: T): UnwrapRef<T> {
-  if (__DEV__ && !obj) {
-    warn('"reactive()" is called without provide an "object".')
-    // @ts-ignore
-    return
+  if (!isObject(obj)) {
+    if (__DEV__) {
+      warn('"reactive()" is called without provide an "object".')
+    }
+    return obj as any
   }
 
   if (
diff --git a/src/utils/utils.ts b/src/utils/utils.ts
index 32d0961..dff6823 100644
--- a/src/utils/utils.ts
+++ b/src/utils/utils.ts
@@ -14,21 +14,17 @@ export const hasSymbol =
 
 export const noopFn: any = (_: any) => _
 
-const sharedPropertyDefinition = {
-  enumerable: true,
-  configurable: true,
-  get: noopFn,
-  set: noopFn,
-}
-
 export function proxy(
   target: any,
   key: string,
   { get, set }: { get?: Function; set?: Function }
 ) {
-  sharedPropertyDefinition.get = get || noopFn
-  sharedPropertyDefinition.set = set || noopFn
-  Object.defineProperty(target, key, sharedPropertyDefinition)
+  Object.defineProperty(target, key, {
+    enumerable: true,
+    configurable: true,
+    get: get || noopFn,
+    set: set || noopFn,
+  })
 }
 
 export function def(obj: Object, key: string, val: any, enumerable?: boolean) {


Test patch:
diff --git a/test/v3/reactivity/reactive.spec.ts b/test/v3/reactivity/reactive.spec.ts
index 04034ba..5576836 100644
--- a/test/v3/reactivity/reactive.spec.ts
+++ b/test/v3/reactivity/reactive.spec.ts
@@ -142,6 +142,7 @@ describe('reactivity/reactive', () => {
   test('non-observable values', () => {
     const assertValue = (value: any) => {
       expect(isReactive(reactive(value))).toBe(false)
+      expect(reactive(value)).toBe(value)
       // expect(warnSpy).toHaveBeenLastCalledWith(`value cannot be made reactive: ${String(value)}`);
     }
 
@@ -167,7 +168,7 @@ describe('reactivity/reactive', () => {
     const d = new Date()
     expect(reactive(d)).toBe(d)
 
-    expect(warn).toBeCalledTimes(3)
+    expect(warn).toBeCalledTimes(12)
     expect(
       warn.mock.calls.map((call) => {
         expect(call[0]).toBe(
Repository: vuejs/composition-api
Pull request #694 (2021-05-12 01:33:49)

fix: The behavior of development and production merge should be consistent.
fix: #679 


Patch:
diff --git a/src/utils/instance.ts b/src/utils/instance.ts
index 5fa4e4b..5abfa75 100644
--- a/src/utils/instance.ts
+++ b/src/utils/instance.ts
@@ -47,7 +47,12 @@ export function asVmProperty(
             },
           })
         } else {
-          vm._data[propName] = propValue
+          proxy(vm._data, propName, {
+            get: () => propValue,
+            set: (val: any) => {
+              propValue = val
+            },
+          })
         }
       })
     }


Test patch:
diff --git a/test/setup.spec.js b/test/setup.spec.js
index 2bcbe44..e1ac9a6 100644
--- a/test/setup.spec.js
+++ b/test/setup.spec.js
@@ -898,6 +898,50 @@ describe('setup', () => {
     expect(vm.$el.textContent).toBe('2')
   })
 
+  // #679
+  it('should work merge with object in development', async () => {
+    global.__DEV__ = true
+    const vm = new Vue({
+      template: '<div>{{ data.id }}</div>',
+      setup() {
+        const data = reactive({
+          id: 42,
+        })
+        return { data }
+      },
+      data() {
+        return {
+          data: { id: 1 },
+        }
+      },
+    }).$mount()
+
+    await nextTick()
+    expect(vm.$el.textContent).toBe('1')
+  })
+
+  // #679
+  it('should work merge with object in production', async () => {
+    global.__DEV__ = false
+    const vm = new Vue({
+      template: '<div>{{ data.id }}</div>',
+      setup() {
+        const data = reactive({
+          id: 42,
+        })
+        return { data }
+      },
+      data() {
+        return {
+          data: { id: 1 },
+        }
+      },
+    }).$mount()
+
+    await nextTick()
+    expect(vm.$el.textContent).toBe('1')
+  })
+
   // #683 #603 #580
   it('should update directly when adding attributes to a reactive object', async () => {
     const vm = new Vue({
Repository: vuejs/composition-api
Pull request #696 (2021-05-19 07:25:35)

fix(shallowReactive): align behavior with vue-next
Keep consistent with vue-next:

https://github.com/vuejs/vue-next/blob/d3d9355c5a75675ab99ff8bb381e34d02e322e88/packages/reactivity/src/reactive.ts#L180-L185


Patch:
diff --git a/src/reactivity/reactive.ts b/src/reactivity/reactive.ts
index fec1cea..3777958 100644
--- a/src/reactivity/reactive.ts
+++ b/src/reactivity/reactive.ts
@@ -141,9 +141,11 @@ function mockObserver(value: any = {}): any {
 
 export function shallowReactive<T extends object = any>(obj: T): T
 export function shallowReactive(obj: any): any {
-  if (__DEV__ && !obj) {
-    warn('"shallowReactive()" is called without provide an "object".')
-    return
+  if (!isObject(obj)) {
+    if (__DEV__) {
+      warn('"shallowReactive()" is called without provide an "object".')
+    }
+    return obj as any
   }
 
   if (


Test patch:
diff --git a/test/v3/reactivity/reactive.spec.ts b/test/v3/reactivity/reactive.spec.ts
index 5576836..75f9e82 100644
--- a/test/v3/reactivity/reactive.spec.ts
+++ b/test/v3/reactivity/reactive.spec.ts
@@ -207,4 +207,34 @@ describe('reactivity/reactive', () => {
       expect(isReactive(props.n)).toBe(true)
     })
   })
+
+  test('should shallowReactive non-observable values', () => {
+    const assertValue = (value: any) => {
+      expect(shallowReactive(value)).toBe(value)
+    }
+
+    // number
+    assertValue(1)
+    // string
+    assertValue('foo')
+    // boolean
+    assertValue(false)
+    // null
+    assertValue(null)
+    // undefined
+    assertValue(undefined)
+    // symbol
+    const s = Symbol()
+    assertValue(s)
+
+    expect(warn).toBeCalledTimes(6)
+    expect(
+      warn.mock.calls.map((call) => {
+        expect(call[0]).toBe(
+          '[Vue warn]: "shallowReactive()" is called without provide an "object".'
+        )
+      })
+    )
+    warn.mockReset()
+  })
 })
Repository: vuejs/composition-api
Pull request #720 (2021-06-01 14:26:37)

fix(reactivity): should trigger watchEffect when using set to change value of array length


Patch:
diff --git a/src/reactivity/set.ts b/src/reactivity/set.ts
index f2a733c..669487c 100644
--- a/src/reactivity/set.ts
+++ b/src/reactivity/set.ts
@@ -15,10 +15,16 @@ export function set<T>(target: any, key: any, val: T): T {
       `Cannot set reactive property on undefined, null, or primitive value: ${target}`
     )
   }
-  if (isArray(target) && isValidArrayIndex(key)) {
-    target.length = Math.max(target.length, key)
-    target.splice(key, 1, val)
-    return val
+  if (isArray(target)) {
+    if (isValidArrayIndex(key)) {
+      target.length = Math.max(target.length, key)
+      target.splice(key, 1, val)
+      return val
+    } else if (key === 'length' && (val as any) !== target.length) {
+      target.length = val as any
+      ;(target as any).__ob__?.dep.notify()
+      return val
+    }
   }
   if (key in target && !(key in Object.prototype)) {
     target[key] = val
@@ -34,7 +40,8 @@ export function set<T>(target: any, key: any, val: T): T {
     return val
   }
   if (!ob) {
-    target[key] = val
+    // If we are using `set` we can assume that the unwrapping is intended
+    defineAccessControl(target, key, val)
     return val
   }
   defineReactive(ob.value, key, val)


Test patch:
diff --git a/test/ssr/ssrReactive.spec.ts b/test/ssr/ssrReactive.spec.ts
index 5c8510c..b4325fa 100644
--- a/test/ssr/ssrReactive.spec.ts
+++ b/test/ssr/ssrReactive.spec.ts
@@ -90,4 +90,16 @@ describe('SSR Reactive', () => {
 
     done()
   })
+
+  // #721
+  it('should behave correctly', () => {
+    const state = ref({ old: ref(false) })
+    set(state.value, 'new', ref(true))
+    // console.log(process.server, 'state.value', JSON.stringify(state.value))
+
+    expect(state.value).toMatchObject({
+      old: false,
+      new: true,
+    })
+  })
 })
diff --git a/test/v3/reactivity/set.spec.ts b/test/v3/reactivity/set.spec.ts
new file mode 100644
index 0000000..24fb1b4
--- /dev/null
+++ b/test/v3/reactivity/set.spec.ts
@@ -0,0 +1,19 @@
+import { set, ref, watchEffect } from '../../../src'
+
+describe('reactivity/set', () => {
+  it('should trigger watchEffect when using set to change value of array length', () => {
+    const arr = ref([1, 2, 3])
+    const spy = jest.fn()
+    watchEffect(
+      () => {
+        spy(arr.value)
+      },
+      { flush: 'sync' }
+    )
+
+    expect(spy).toHaveBeenCalledTimes(1)
+    set(arr.value, 'length', 1)
+    expect(arr.value.length).toBe(1)
+    expect(spy).toHaveBeenCalledTimes(2)
+  })
+})
Repository: vuejs/composition-api
Pull request #741 (2021-07-02 03:19:31)

fix(shallowReadonly): align behavior with vue-next


Patch:
diff --git a/src/reactivity/del.ts b/src/reactivity/del.ts
index d7a9607..aceb324 100644
--- a/src/reactivity/del.ts
+++ b/src/reactivity/del.ts
@@ -1,10 +1,11 @@
+import { AnyObject } from '../types/basic'
 import { getVueConstructor } from '../runtimeContext'
 import { hasOwn, isPrimitive, isUndef, isValidArrayIndex } from '../utils'
 
 /**
  * Delete a property and trigger change if necessary.
  */
-export function del(target: any, key: any) {
+export function del(target: AnyObject, key: any) {
   const Vue = getVueConstructor()
   const { warn } = Vue.util
 
diff --git a/src/reactivity/readonly.ts b/src/reactivity/readonly.ts
index e223c91..552054b 100644
--- a/src/reactivity/readonly.ts
+++ b/src/reactivity/readonly.ts
@@ -1,5 +1,5 @@
 import { reactive, Ref, UnwrapRef } from '.'
-import { isArray, isPlainObject, warn } from '../utils'
+import { isArray, isPlainObject, isObject, warn } from '../utils'
 import { readonlySet } from '../utils/sets'
 import { isReactive, observe } from './reactive'
 import { isRef, RefImpl } from './ref'
@@ -49,6 +49,13 @@ export function readonly<T extends object>(
 
 export function shallowReadonly<T extends object>(obj: T): Readonly<T>
 export function shallowReadonly(obj: any): any {
+  if (!isObject(obj)) {
+    if (__DEV__) {
+      warn(`value cannot be made reactive: ${String(obj)}`)
+    }
+    return obj
+  }
+
   if (
     !(isPlainObject(obj) || isArray(obj)) ||
     (!Object.isExtensible(obj) && !isRef(obj))
diff --git a/src/reactivity/set.ts b/src/reactivity/set.ts
index 669487c..d1baecf 100644
--- a/src/reactivity/set.ts
+++ b/src/reactivity/set.ts
@@ -1,3 +1,4 @@
+import { AnyObject } from '../types/basic'
 import { getVueConstructor } from '../runtimeContext'
 import { isArray, isPrimitive, isUndef, isValidArrayIndex } from '../utils'
 import { defineAccessControl } from './reactive'
@@ -7,7 +8,7 @@ import { defineAccessControl } from './reactive'
  * notification and intercept it's subsequent access if the property doesn't
  * already exist.
  */
-export function set<T>(target: any, key: any, val: T): T {
+export function set<T>(target: AnyObject, key: any, val: T): T {
   const Vue = getVueConstructor()
   const { warn, defineReactive } = Vue.util
   if (__DEV__ && (isUndef(target) || isPrimitive(target))) {


Test patch:
diff --git a/test/v3/reactivity/readonly.spec.ts b/test/v3/reactivity/readonly.spec.ts
index 5272f48..a645715 100644
--- a/test/v3/reactivity/readonly.spec.ts
+++ b/test/v3/reactivity/readonly.spec.ts
@@ -382,6 +382,12 @@ describe('reactivity/readonly', () => {
       ).not.toHaveBeenWarned()
     })
 
+    test('should not process non-object data', () => {
+      // @ts-ignore
+      shallowReadonly(25)
+      expect(`value cannot be made reactive: 25`).toHaveBeenWarned()
+    })
+
     // #669
     test('shallowReadonly should work for refs', () => {
       const vm = new Vue({
Repository: vuejs/composition-api
Pull request #759 (2021-07-14 07:12:40)

fix(mockReactivityDeep): add parameter seen for mockReactivityDeep.
modify: ```mockReactivityDeep(value)----> mockReactivityDeep(value, seen)```


Patch:
diff --git a/src/reactivity/reactive.ts b/src/reactivity/reactive.ts
index 86f3e06..2914d1e 100644
--- a/src/reactivity/reactive.ts
+++ b/src/reactivity/reactive.ts
@@ -150,7 +150,7 @@ function mockReactivityDeep(obj: any, seen = new Set()) {
     ) {
       continue
     }
-    mockReactivityDeep(value)
+    mockReactivityDeep(value, seen)
   }
 }
 


Test patch:
diff --git a/test/ssr/ssrReactive.spec.ts b/test/ssr/ssrReactive.spec.ts
index fd32982..90ec277 100644
--- a/test/ssr/ssrReactive.spec.ts
+++ b/test/ssr/ssrReactive.spec.ts
@@ -11,10 +11,14 @@ import {
   isRef,
   set,
   shallowRef,
+  getCurrentInstance,
+  nextTick,
 } from '../../src'
 import { createRenderer } from 'vue-server-renderer'
+import { mockWarn } from '../helpers'
 
 describe('SSR Reactive', () => {
+  mockWarn(true)
   beforeEach(() => {
     process.env.VUE_ENV = 'server'
   })
@@ -118,4 +122,27 @@ describe('SSR Reactive', () => {
     set(state.value, 'new', ref(true))
     expect(JSON.stringify(state.value)).toBe('{"old":false,"new":true}')
   })
+
+  // test the input parameter of mockReactivityDeep
+  it('ssr should not RangeError: Maximum call stack size exceeded', async () => {
+    new Vue({
+      setup() {
+        // @ts-expect-error
+        const app = getCurrentInstance().proxy
+        let mockNt: any = []
+        mockNt.__ob__ = {}
+        const test = reactive({
+          app,
+          mockNt,
+        })
+        return {
+          test,
+        }
+      },
+    })
+    await nextTick()
+    expect(
+      `"RangeError: Maximum call stack size exceeded"`
+    ).not.toHaveBeenWarned()
+  })
 })
Repository: vuejs/composition-api
Pull request #764 (2021-07-16 02:28:31)

fix: should dynamically update refs in context
fix: #296


Patch:
diff --git a/src/mixin.ts b/src/mixin.ts
index 9bdc197..b0c3ae5 100644
--- a/src/mixin.ts
+++ b/src/mixin.ts
@@ -35,6 +35,9 @@ export function mixin(Vue: VueConstructor) {
     },
     updated(this: ComponentInstance) {
       updateTemplateRef(this)
+      if (this.$vnode?.context) {
+        updateTemplateRef(this.$vnode.context)
+      }
     },
   })
 


Test patch:
diff --git a/test/templateRefs.spec.js b/test/templateRefs.spec.js
index 10bbc56..f41ec84 100644
--- a/test/templateRefs.spec.js
+++ b/test/templateRefs.spec.js
@@ -1,5 +1,5 @@
 const Vue = require('vue/dist/vue.common.js')
-const { ref, watchEffect } = require('../src')
+const { ref, watchEffect, nextTick } = require('../src')
 
 describe('ref', () => {
   it('should work', (done) => {
@@ -69,6 +69,50 @@ describe('ref', () => {
       .then(done)
   })
 
+  // #296
+  it('should dynamically update refs in context', async () => {
+    const vm = new Vue({
+      setup() {
+        const barRef = ref(null)
+        return {
+          barRef,
+        }
+      },
+      template: `<div>
+        <foo><bar ref="barRef"/></foo>
+      </div>`,
+      components: {
+        bar: {
+          setup() {
+            const name = ref('bar')
+            return {
+              name,
+            }
+          },
+          template: '<div> {{name}} </div>',
+        },
+        foo: {
+          setup() {
+            const showSlot = ref(false)
+            const setShow = () => {
+              showSlot.value = true
+            }
+            return {
+              setShow,
+              showSlot,
+            }
+          },
+          template: `<div> <slot v-if="showSlot"></slot> </div>`,
+        },
+      },
+    }).$mount()
+    await nextTick()
+    //@ts-ignore
+    vm.$children[0].setShow()
+    await nextTick()
+    //@ts-ignore
+    expect(vm.$refs.barRef).toBe(vm.barRef)
+  })
   // TODO: how ?
   // it('work with createElement', () => {
   //   let root;
Repository: vuejs/composition-api
Pull request #784 (2021-08-11 15:54:23)

test(effectScope): add test case for effectScope
add test case for effectScope


Patch:
diff --git a/src/apis/effectScope.ts b/src/apis/effectScope.ts
index e2aac9d..657276f 100644
--- a/src/apis/effectScope.ts
+++ b/src/apis/effectScope.ts
@@ -102,7 +102,7 @@ export function onScopeDispose(fn: () => void) {
     activeEffectScope.cleanups.push(fn)
   } else if (__DEV__) {
     warn(
-      `onDispose() is called when there is no active effect scope ` +
+      `onDispose() is called when there is no active effect scope` +
         ` to be associated with.`
     )
   }


Test patch:
diff --git a/test/v3/reactivity/effectScope.spec.ts b/test/v3/reactivity/effectScope.spec.ts
index 77d0582..ec5a5e8 100644
--- a/test/v3/reactivity/effectScope.spec.ts
+++ b/test/v3/reactivity/effectScope.spec.ts
@@ -209,6 +209,25 @@ describe('reactivity/effect/scope', () => {
     expect(dummy).toBe(7)
   })
 
+  it('should warn onDispose() is called when there is no active effect scope', () => {
+    const spy = jest.fn()
+    const scope = new EffectScope()
+    scope.run(() => {
+      onScopeDispose(spy)
+    })
+
+    expect(spy).toHaveBeenCalledTimes(0)
+
+    onScopeDispose(spy)
+
+    expect(
+      '[Vue warn]: onDispose() is called when there is no active effect scope to be associated with.'
+    ).toHaveBeenWarned()
+
+    scope.stop()
+    expect(spy).toHaveBeenCalledTimes(1)
+  })
+
   it('test with higher level APIs', async () => {
     const r = ref(1)
Repository: vuejs/composition-api
Pull request #788 (2021-08-17 02:11:45)

fix: typos
onDispose => onScopeDispose


Patch:
diff --git a/src/apis/effectScope.ts b/src/apis/effectScope.ts
index 657276f..cde52c5 100644
--- a/src/apis/effectScope.ts
+++ b/src/apis/effectScope.ts
@@ -102,7 +102,7 @@ export function onScopeDispose(fn: () => void) {
     activeEffectScope.cleanups.push(fn)
   } else if (__DEV__) {
     warn(
-      `onDispose() is called when there is no active effect scope` +
+      `onScopeDispose() is called when there is no active effect scope` +
         ` to be associated with.`
     )
   }


Test patch:
diff --git a/test/v3/reactivity/effectScope.spec.ts b/test/v3/reactivity/effectScope.spec.ts
index ec5a5e8..f50a4b3 100644
--- a/test/v3/reactivity/effectScope.spec.ts
+++ b/test/v3/reactivity/effectScope.spec.ts
@@ -190,7 +190,7 @@ describe('reactivity/effect/scope', () => {
     expect(doubled).toBe(undefined)
   })
 
-  it('should fire onDispose hook', () => {
+  it('should fire onScopeDispose hook', () => {
     let dummy = 0
 
     const scope = new EffectScope()
@@ -209,7 +209,7 @@ describe('reactivity/effect/scope', () => {
     expect(dummy).toBe(7)
   })
 
-  it('should warn onDispose() is called when there is no active effect scope', () => {
+  it('should warn onScopeDispose() is called when there is no active effect scope', () => {
     const spy = jest.fn()
     const scope = new EffectScope()
     scope.run(() => {
@@ -221,7 +221,7 @@ describe('reactivity/effect/scope', () => {
     onScopeDispose(spy)
 
     expect(
-      '[Vue warn]: onDispose() is called when there is no active effect scope to be associated with.'
+      '[Vue warn]: onScopeDispose() is called when there is no active effect scope to be associated with.'
     ).toHaveBeenWarned()
 
     scope.stop()
Repository: vuejs/composition-api
Pull request #796 (2021-08-19 15:24:32)

fix(set): reactive in SSR w/ set
fix #795 


Patch:
diff --git a/src/reactivity/reactive.ts b/src/reactivity/reactive.ts
index d08b7c5..f7ddc8f 100644
--- a/src/reactivity/reactive.ts
+++ b/src/reactivity/reactive.ts
@@ -135,7 +135,7 @@ export function observe<T>(obj: T): T {
 /**
  * Mock __ob__ for object recursively
  */
-function mockReactivityDeep(obj: any, seen = new Set()) {
+export function mockReactivityDeep(obj: any, seen = new Set()) {
   if (seen.has(obj)) return
 
   def(obj, '__ob__', mockObserver(obj))
diff --git a/src/reactivity/set.ts b/src/reactivity/set.ts
index dfbd40f..2270c9e 100644
--- a/src/reactivity/set.ts
+++ b/src/reactivity/set.ts
@@ -1,7 +1,14 @@
 import { AnyObject } from '../types/basic'
 import { getVueConstructor } from '../runtimeContext'
-import { isArray, isPrimitive, isUndef, isValidArrayIndex } from '../utils'
-import { defineAccessControl } from './reactive'
+import {
+  isArray,
+  isPrimitive,
+  isUndef,
+  isValidArrayIndex,
+  isObject,
+  hasOwn,
+} from '../utils'
+import { defineAccessControl, mockReactivityDeep } from './reactive'
 
 /**
  * Set a property on an object. Adds the new property, triggers change
@@ -49,6 +56,11 @@ export function set<T>(target: AnyObject, key: any, val: T): T {
   // IMPORTANT: define access control before trigger watcher
   defineAccessControl(target, key, val)
 
+  // in SSR, there is no __ob__. Mock for reactivity check
+  if (isObject(target[key]) && !hasOwn(target[key], '__ob__')) {
+    mockReactivityDeep(target[key])
+  }
+
   ob.dep.notify()
   return val
 }


Test patch:
diff --git a/test/ssr/ssrReactive.spec.ts b/test/ssr/ssrReactive.spec.ts
index 90ec277..432244b 100644
--- a/test/ssr/ssrReactive.spec.ts
+++ b/test/ssr/ssrReactive.spec.ts
@@ -145,4 +145,11 @@ describe('SSR Reactive', () => {
       `"RangeError: Maximum call stack size exceeded"`
     ).not.toHaveBeenWarned()
   })
+
+  it('should work on objects sets with set()', () => {
+    const state = ref<any>({})
+    set(state.value, 'a', {})
+
+    expect(isReactive(state.value.a)).toBe(true)
+  })
 })