From deeaf9a2050a3a17bfa2a57453c6682cfec1bdf1 Mon Sep 17 00:00:00 2001 From: linzhe141 <1572213544@qq.com> Date: Fri, 19 Jul 2024 11:35:28 +0800 Subject: [PATCH 1/8] feat(reactivity): set supurts intersection --- packages/reactivity/src/collectionHandlers.ts | 20 +++++++++++++++++++ packages/reactivity/src/constants.ts | 1 + 2 files changed, 21 insertions(+) diff --git a/packages/reactivity/src/collectionHandlers.ts b/packages/reactivity/src/collectionHandlers.ts index c39e3ed48..f1de4476e 100644 --- a/packages/reactivity/src/collectionHandlers.ts +++ b/packages/reactivity/src/collectionHandlers.ts @@ -137,6 +137,22 @@ function deleteEntry(this: CollectionTypes, key: unknown) { return result } +function intersection(this: SetTypes, value: unknown, _isShallow = false) { + if (!_isShallow && !isShallow(value) && !isReadonly(value)) { + value = toRaw(value) + } + const target = toRaw(this) + const proto = getProto(target) + const hadKey = proto.has.call(target, value) + let result + if (!hadKey) { + // @ts-expect-error + result = target.intersection(value) + trigger(target, TriggerOpTypes.INTERSECTION, value, value) + } + return result +} + function clear(this: IterableCollections) { const target = toRaw(this) const hadItems = target.size !== 0 @@ -263,6 +279,7 @@ function createInstrumentations() { delete: deleteEntry, clear, forEach: createForEach(false, false), + intersection, } const shallowInstrumentations: Instrumentations = { @@ -282,6 +299,7 @@ function createInstrumentations() { delete: deleteEntry, clear, forEach: createForEach(false, true), + intersection, } const readonlyInstrumentations: Instrumentations = { @@ -299,6 +317,7 @@ function createInstrumentations() { delete: createReadonlyMethod(TriggerOpTypes.DELETE), clear: createReadonlyMethod(TriggerOpTypes.CLEAR), forEach: createForEach(true, false), + intersection, } const shallowReadonlyInstrumentations: Instrumentations = { @@ -316,6 +335,7 @@ function createInstrumentations() { delete: createReadonlyMethod(TriggerOpTypes.DELETE), clear: createReadonlyMethod(TriggerOpTypes.CLEAR), forEach: createForEach(true, true), + intersection, } const iteratorMethods = [ diff --git a/packages/reactivity/src/constants.ts b/packages/reactivity/src/constants.ts index baa75d616..9da7103a8 100644 --- a/packages/reactivity/src/constants.ts +++ b/packages/reactivity/src/constants.ts @@ -12,6 +12,7 @@ export enum TriggerOpTypes { ADD = 'add', DELETE = 'delete', CLEAR = 'clear', + INTERSECTION = 'intersection', } export enum ReactiveFlags { From df070bfc1fb85d0944e57d4770c903fcbea07107 Mon Sep 17 00:00:00 2001 From: linzhe141 <1572213544@qq.com> Date: Fri, 19 Jul 2024 14:12:37 +0800 Subject: [PATCH 2/8] feat: the `set` supports the new `difference, intersection, isDisjointFrom, isSubsetOf, isSupersetOf, and symmetricDifference` methods --- packages/reactivity/src/collectionHandlers.ts | 78 ++++++++++++++----- packages/reactivity/src/constants.ts | 7 ++ 2 files changed, 65 insertions(+), 20 deletions(-) diff --git a/packages/reactivity/src/collectionHandlers.ts b/packages/reactivity/src/collectionHandlers.ts index f1de4476e..417755074 100644 --- a/packages/reactivity/src/collectionHandlers.ts +++ b/packages/reactivity/src/collectionHandlers.ts @@ -137,22 +137,6 @@ function deleteEntry(this: CollectionTypes, key: unknown) { return result } -function intersection(this: SetTypes, value: unknown, _isShallow = false) { - if (!_isShallow && !isShallow(value) && !isReadonly(value)) { - value = toRaw(value) - } - const target = toRaw(this) - const proto = getProto(target) - const hadKey = proto.has.call(target, value) - let result - if (!hadKey) { - // @ts-expect-error - result = target.intersection(value) - trigger(target, TriggerOpTypes.INTERSECTION, value, value) - } - return result -} - function clear(this: IterableCollections) { const target = toRaw(this) const hadItems = target.size !== 0 @@ -189,6 +173,24 @@ function createForEach(isReadonly: boolean, isShallow: boolean) { } } +function createSetProtoMethod(method: TriggerOpTypes) { + return function (this: SetTypes, value: unknown, _isShallow = false) { + if (!_isShallow && !isShallow(value) && !isReadonly(value)) { + value = toRaw(value) + } + const target = toRaw(this) + const proto = getProto(target) + const hadKey = proto.has.call(target, value) + let result + if (!hadKey) { + // @ts-expect-error + result = target[method](value) + trigger(target, method, value, value) + } + return result + } +} + interface Iterable { [Symbol.iterator](): Iterator } @@ -279,7 +281,16 @@ function createInstrumentations() { delete: deleteEntry, clear, forEach: createForEach(false, false), - intersection, + + // set + difference: createSetProtoMethod(TriggerOpTypes.DIFFERENCE), + intersection: createSetProtoMethod(TriggerOpTypes.INTERSECTION), + isDisjointFrom: createSetProtoMethod(TriggerOpTypes.IS_DISJOINT_FROM), + isSubsetOf: createSetProtoMethod(TriggerOpTypes.IS_SUBSET_OF), + isSupersetOf: createSetProtoMethod(TriggerOpTypes.IS_SUPERSET_OF), + symmetricDifference: createSetProtoMethod( + TriggerOpTypes.SYMMETRIC_DIFFERENCE, + ), } const shallowInstrumentations: Instrumentations = { @@ -299,7 +310,16 @@ function createInstrumentations() { delete: deleteEntry, clear, forEach: createForEach(false, true), - intersection, + + // set + difference: createSetProtoMethod(TriggerOpTypes.DIFFERENCE), + intersection: createSetProtoMethod(TriggerOpTypes.INTERSECTION), + isDisjointFrom: createSetProtoMethod(TriggerOpTypes.IS_DISJOINT_FROM), + isSubsetOf: createSetProtoMethod(TriggerOpTypes.IS_SUBSET_OF), + isSupersetOf: createSetProtoMethod(TriggerOpTypes.IS_SUPERSET_OF), + symmetricDifference: createSetProtoMethod( + TriggerOpTypes.SYMMETRIC_DIFFERENCE, + ), } const readonlyInstrumentations: Instrumentations = { @@ -317,7 +337,16 @@ function createInstrumentations() { delete: createReadonlyMethod(TriggerOpTypes.DELETE), clear: createReadonlyMethod(TriggerOpTypes.CLEAR), forEach: createForEach(true, false), - intersection, + + // set + difference: createSetProtoMethod(TriggerOpTypes.DIFFERENCE), + intersection: createSetProtoMethod(TriggerOpTypes.INTERSECTION), + isDisjointFrom: createSetProtoMethod(TriggerOpTypes.IS_DISJOINT_FROM), + isSubsetOf: createSetProtoMethod(TriggerOpTypes.IS_SUBSET_OF), + isSupersetOf: createSetProtoMethod(TriggerOpTypes.IS_SUPERSET_OF), + symmetricDifference: createSetProtoMethod( + TriggerOpTypes.SYMMETRIC_DIFFERENCE, + ), } const shallowReadonlyInstrumentations: Instrumentations = { @@ -335,7 +364,16 @@ function createInstrumentations() { delete: createReadonlyMethod(TriggerOpTypes.DELETE), clear: createReadonlyMethod(TriggerOpTypes.CLEAR), forEach: createForEach(true, true), - intersection, + + // set + difference: createSetProtoMethod(TriggerOpTypes.DIFFERENCE), + intersection: createSetProtoMethod(TriggerOpTypes.INTERSECTION), + isDisjointFrom: createSetProtoMethod(TriggerOpTypes.IS_DISJOINT_FROM), + isSubsetOf: createSetProtoMethod(TriggerOpTypes.IS_SUBSET_OF), + isSupersetOf: createSetProtoMethod(TriggerOpTypes.IS_SUPERSET_OF), + symmetricDifference: createSetProtoMethod( + TriggerOpTypes.SYMMETRIC_DIFFERENCE, + ), } const iteratorMethods = [ diff --git a/packages/reactivity/src/constants.ts b/packages/reactivity/src/constants.ts index 9da7103a8..2a98c90f0 100644 --- a/packages/reactivity/src/constants.ts +++ b/packages/reactivity/src/constants.ts @@ -12,7 +12,14 @@ export enum TriggerOpTypes { ADD = 'add', DELETE = 'delete', CLEAR = 'clear', + + // set + DIFFERENCE = 'difference', INTERSECTION = 'intersection', + IS_DISJOINT_FROM = 'isDisjointFrom', + IS_SUBSET_OF = 'isSubsetOf', + IS_SUPERSET_OF = 'isSupersetOf', + SYMMETRIC_DIFFERENCE = 'symmetricDifference', } export enum ReactiveFlags { From bc0a11f94f1c408f011a7a347ed55b7002affbe8 Mon Sep 17 00:00:00 2001 From: linzhe141 <1572213544@qq.com> Date: Fri, 19 Jul 2024 14:46:24 +0800 Subject: [PATCH 3/8] chore: update test --- .../__tests__/collections/Set.spec.ts | 68 ++++++++++++++++++- 1 file changed, 67 insertions(+), 1 deletion(-) diff --git a/packages/reactivity/__tests__/collections/Set.spec.ts b/packages/reactivity/__tests__/collections/Set.spec.ts index 2aeef1982..b854f7385 100644 --- a/packages/reactivity/__tests__/collections/Set.spec.ts +++ b/packages/reactivity/__tests__/collections/Set.spec.ts @@ -1,4 +1,4 @@ -import { effect, isReactive, reactive, toRaw } from '../../src' +import { effect, isReactive, reactive, ref, toRaw } from '../../src' describe('reactivity/collections', () => { function coverCollectionFn(collection: Set, fnName: string) { @@ -459,5 +459,71 @@ describe('reactivity/collections', () => { const result = set.add('a') expect(result).toBe(set) }) + + it('set with difference', () => { + const result = ref('') + const set1 = ref(new Set([1, 2, 3])) + const set2 = ref(new Set([2, 3, 4])) + const setSpy = vi.fn(() => result.value) + effect(setSpy) + // @ts-expect-error + set1.value.difference(set2.value) + expect(setSpy).toHaveBeenCalledTimes(1) + }) + + it('set with intersection', () => { + const result = ref('') + const set1 = ref(new Set([1, 2, 3])) + const set2 = ref(new Set([2, 3, 4])) + const setSpy = vi.fn(() => result.value) + effect(setSpy) + // @ts-expect-error + set1.value.intersection(set2.value) + expect(setSpy).toHaveBeenCalledTimes(1) + }) + + it('set with isDisjointFrom', () => { + const result = ref('') + const set1 = ref(new Set([1, 2, 3])) + const set2 = ref(new Set([2, 3, 4])) + const setSpy = vi.fn(() => result.value) + effect(setSpy) + // @ts-expect-error + set1.value.isDisjointFrom(set2.value) + expect(setSpy).toHaveBeenCalledTimes(1) + }) + + it('set with isSubsetOf', () => { + const result = ref('') + const set1 = ref(new Set([1, 2, 3])) + const set2 = ref(new Set([2, 3, 4])) + const setSpy = vi.fn(() => result.value) + effect(setSpy) + // @ts-expect-error + set1.value.isSubsetOf(set2.value) + expect(setSpy).toHaveBeenCalledTimes(1) + }) + + it('set with isSupersetOf', () => { + const result = ref('') + const set1 = ref(new Set([1, 2, 3])) + const set2 = ref(new Set([2, 3, 4])) + const setSpy = vi.fn(() => result.value) + effect(setSpy) + // @ts-expect-error + set1.value.isSupersetOf(set2.value) + expect(setSpy).toHaveBeenCalledTimes(1) + }) + + it('set with symmetricDifference', () => { + const result = ref('') + const set1 = ref(new Set([1, 2, 3])) + const set2 = ref(new Set([2, 3, 4])) + const setSpy = vi.fn(() => result.value) + effect(setSpy) + // @ts-expect-error + set1.value.symmetricDifference(set2.value) + expect(setSpy).toHaveBeenCalledTimes(1) + }) }) }) From 7e028ea1e74736e940dde46c58ac0127c9e9f462 Mon Sep 17 00:00:00 2001 From: linzhe141 <1572213544@qq.com> Date: Fri, 19 Jul 2024 15:19:05 +0800 Subject: [PATCH 4/8] chore: update --- .../__tests__/collections/Set.spec.ts | 35 ++++++++++++------- packages/reactivity/src/collectionHandlers.ts | 4 +++ packages/reactivity/src/constants.ts | 1 + 3 files changed, 28 insertions(+), 12 deletions(-) diff --git a/packages/reactivity/__tests__/collections/Set.spec.ts b/packages/reactivity/__tests__/collections/Set.spec.ts index b854f7385..0cbfb4c87 100644 --- a/packages/reactivity/__tests__/collections/Set.spec.ts +++ b/packages/reactivity/__tests__/collections/Set.spec.ts @@ -467,8 +467,8 @@ describe('reactivity/collections', () => { const setSpy = vi.fn(() => result.value) effect(setSpy) // @ts-expect-error - set1.value.difference(set2.value) - expect(setSpy).toHaveBeenCalledTimes(1) + result.value = set1.value.difference(set2.value) + expect(setSpy).toHaveBeenCalledTimes(2) }) it('set with intersection', () => { @@ -478,8 +478,8 @@ describe('reactivity/collections', () => { const setSpy = vi.fn(() => result.value) effect(setSpy) // @ts-expect-error - set1.value.intersection(set2.value) - expect(setSpy).toHaveBeenCalledTimes(1) + result.value = set1.value.intersection(set2.value) + expect(setSpy).toHaveBeenCalledTimes(2) }) it('set with isDisjointFrom', () => { @@ -489,8 +489,8 @@ describe('reactivity/collections', () => { const setSpy = vi.fn(() => result.value) effect(setSpy) // @ts-expect-error - set1.value.isDisjointFrom(set2.value) - expect(setSpy).toHaveBeenCalledTimes(1) + result.value = set1.value.isDisjointFrom(set2.value) + expect(setSpy).toHaveBeenCalledTimes(2) }) it('set with isSubsetOf', () => { @@ -500,8 +500,8 @@ describe('reactivity/collections', () => { const setSpy = vi.fn(() => result.value) effect(setSpy) // @ts-expect-error - set1.value.isSubsetOf(set2.value) - expect(setSpy).toHaveBeenCalledTimes(1) + result.value = set1.value.isSubsetOf(set2.value) + expect(setSpy).toHaveBeenCalledTimes(2) }) it('set with isSupersetOf', () => { @@ -511,8 +511,8 @@ describe('reactivity/collections', () => { const setSpy = vi.fn(() => result.value) effect(setSpy) // @ts-expect-error - set1.value.isSupersetOf(set2.value) - expect(setSpy).toHaveBeenCalledTimes(1) + result.value = set1.value.isSupersetOf(set2.value) + expect(setSpy).toHaveBeenCalledTimes(2) }) it('set with symmetricDifference', () => { @@ -522,8 +522,19 @@ describe('reactivity/collections', () => { const setSpy = vi.fn(() => result.value) effect(setSpy) // @ts-expect-error - set1.value.symmetricDifference(set2.value) - expect(setSpy).toHaveBeenCalledTimes(1) + result.value = set1.value.symmetricDifference(set2.value) + expect(setSpy).toHaveBeenCalledTimes(2) + }) + + it('set with union', () => { + const result = ref('') + const set1 = ref(new Set([1, 2, 3])) + const set2 = ref(new Set([2, 3, 4])) + const setSpy = vi.fn(() => result.value) + effect(setSpy) + // @ts-expect-error + result.value = set1.value.union(set2.value) + expect(setSpy).toHaveBeenCalledTimes(2) }) }) }) diff --git a/packages/reactivity/src/collectionHandlers.ts b/packages/reactivity/src/collectionHandlers.ts index 417755074..a0df178b5 100644 --- a/packages/reactivity/src/collectionHandlers.ts +++ b/packages/reactivity/src/collectionHandlers.ts @@ -291,6 +291,7 @@ function createInstrumentations() { symmetricDifference: createSetProtoMethod( TriggerOpTypes.SYMMETRIC_DIFFERENCE, ), + union: createSetProtoMethod(TriggerOpTypes.UNION), } const shallowInstrumentations: Instrumentations = { @@ -320,6 +321,7 @@ function createInstrumentations() { symmetricDifference: createSetProtoMethod( TriggerOpTypes.SYMMETRIC_DIFFERENCE, ), + union: createSetProtoMethod(TriggerOpTypes.UNION), } const readonlyInstrumentations: Instrumentations = { @@ -347,6 +349,7 @@ function createInstrumentations() { symmetricDifference: createSetProtoMethod( TriggerOpTypes.SYMMETRIC_DIFFERENCE, ), + union: createSetProtoMethod(TriggerOpTypes.UNION), } const shallowReadonlyInstrumentations: Instrumentations = { @@ -374,6 +377,7 @@ function createInstrumentations() { symmetricDifference: createSetProtoMethod( TriggerOpTypes.SYMMETRIC_DIFFERENCE, ), + union: createSetProtoMethod(TriggerOpTypes.UNION), } const iteratorMethods = [ diff --git a/packages/reactivity/src/constants.ts b/packages/reactivity/src/constants.ts index 2a98c90f0..583faea5f 100644 --- a/packages/reactivity/src/constants.ts +++ b/packages/reactivity/src/constants.ts @@ -20,6 +20,7 @@ export enum TriggerOpTypes { IS_SUBSET_OF = 'isSubsetOf', IS_SUPERSET_OF = 'isSupersetOf', SYMMETRIC_DIFFERENCE = 'symmetricDifference', + UNION = 'union', } export enum ReactiveFlags { From 1383006144f3c95e5d3f00254c6e356c092ed776 Mon Sep 17 00:00:00 2001 From: linzhe Date: Sun, 21 Jul 2024 23:21:50 +0800 Subject: [PATCH 5/8] chore: update --- .../__tests__/collections/Set.spec.ts | 21 ++++++++++- packages/reactivity/src/collectionHandlers.ts | 35 +++++++++++++------ 2 files changed, 44 insertions(+), 12 deletions(-) diff --git a/packages/reactivity/__tests__/collections/Set.spec.ts b/packages/reactivity/__tests__/collections/Set.spec.ts index 0cbfb4c87..2c62698be 100644 --- a/packages/reactivity/__tests__/collections/Set.spec.ts +++ b/packages/reactivity/__tests__/collections/Set.spec.ts @@ -1,4 +1,4 @@ -import { effect, isReactive, reactive, ref, toRaw } from '../../src' +import { computed, effect, isReactive, reactive, ref, toRaw } from '../../src' describe('reactivity/collections', () => { function coverCollectionFn(collection: Set, fnName: string) { @@ -536,5 +536,24 @@ describe('reactivity/collections', () => { result.value = set1.value.union(set2.value) expect(setSpy).toHaveBeenCalledTimes(2) }) + + it('set with computed', () => { + const set1 = ref(new Set([1, 2, 3])) + const set2 = ref(new Set([2, 3, 4])) + // @ts-expect-error + const c = computed(() => set1.value.union(set2.value)) + let ret: any + const setSpy = vi.fn(() => { + ret = c + console.log(c.value) + }) + effect(setSpy) + set1.value.add(6) + expect(setSpy).toHaveBeenCalledTimes(2) + expect(ret.value).toEqual(new Set([1, 2, 3, 4, 6])) + set2.value.add(7) + expect(setSpy).toHaveBeenCalledTimes(3) + expect(ret.value).toEqual(new Set([1, 2, 3, 4, 6, 7])) + }) }) }) diff --git a/packages/reactivity/src/collectionHandlers.ts b/packages/reactivity/src/collectionHandlers.ts index a0df178b5..9c5092f0e 100644 --- a/packages/reactivity/src/collectionHandlers.ts +++ b/packages/reactivity/src/collectionHandlers.ts @@ -174,22 +174,35 @@ function createForEach(isReadonly: boolean, isShallow: boolean) { } function createSetProtoMethod(method: TriggerOpTypes) { - return function (this: SetTypes, value: unknown, _isShallow = false) { - if (!_isShallow && !isShallow(value) && !isReadonly(value)) { + return function (this: SetTypes, value: unknown) { + if (!isShallow(value) && !isReadonly(value)) { value = toRaw(value) } - const target = toRaw(this) - const proto = getProto(target) - const hadKey = proto.has.call(target, value) - let result - if (!hadKey) { - // @ts-expect-error - result = target[method](value) - trigger(target, method, value, value) - } + const target = (this as any)[ReactiveFlags.RAW] + const rawTarget = toRaw(target) + const result = target[method](value) + track(rawTarget, TrackOpTypes.ITERATE, ITERATE_KEY) + track(value as any, TrackOpTypes.ITERATE, ITERATE_KEY) return result } } +// function createSetProtoMethod(method: TriggerOpTypes) { +// return function (this: SetTypes, value: unknown, _isShallow = false) { +// if (!_isShallow && !isShallow(value) && !isReadonly(value)) { +// value = toRaw(value) +// } +// const target = toRaw(this) +// const proto = getProto(target) +// const hadKey = proto.has.call(target, value) +// let result +// if (!hadKey) { +// // @ts-expect-error +// result = target[method](value) +// trigger(target, method, value, value) +// } +// return result +// } +// } interface Iterable { [Symbol.iterator](): Iterator From ba93ebfc459ad6ecf5416b98a5a43389ae68c42c Mon Sep 17 00:00:00 2001 From: linzhe Date: Mon, 22 Jul 2024 19:55:06 +0800 Subject: [PATCH 6/8] chore: update comment --- packages/reactivity/src/collectionHandlers.ts | 17 ----------------- 1 file changed, 17 deletions(-) diff --git a/packages/reactivity/src/collectionHandlers.ts b/packages/reactivity/src/collectionHandlers.ts index 9c5092f0e..3de789afa 100644 --- a/packages/reactivity/src/collectionHandlers.ts +++ b/packages/reactivity/src/collectionHandlers.ts @@ -186,23 +186,6 @@ function createSetProtoMethod(method: TriggerOpTypes) { return result } } -// function createSetProtoMethod(method: TriggerOpTypes) { -// return function (this: SetTypes, value: unknown, _isShallow = false) { -// if (!_isShallow && !isShallow(value) && !isReadonly(value)) { -// value = toRaw(value) -// } -// const target = toRaw(this) -// const proto = getProto(target) -// const hadKey = proto.has.call(target, value) -// let result -// if (!hadKey) { -// // @ts-expect-error -// result = target[method](value) -// trigger(target, method, value, value) -// } -// return result -// } -// } interface Iterable { [Symbol.iterator](): Iterator From 15bd0ee9e3eccd0897d0d1cb6de52eec61a9ec9a Mon Sep 17 00:00:00 2001 From: linzhe141 <1572213544@qq.com> Date: Sat, 12 Oct 2024 17:20:32 +0800 Subject: [PATCH 7/8] chore: update test --- packages/reactivity/__tests__/collections/Set.spec.ts | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/packages/reactivity/__tests__/collections/Set.spec.ts b/packages/reactivity/__tests__/collections/Set.spec.ts index 25a02ffed..c614c9fd7 100644 --- a/packages/reactivity/__tests__/collections/Set.spec.ts +++ b/packages/reactivity/__tests__/collections/Set.spec.ts @@ -546,11 +546,10 @@ describe('reactivity/collections', () => { const setSpy = vi.fn(() => (ret = c)) effect(setSpy) set1.value.add(6) - expect(setSpy).toHaveBeenCalledTimes(2) expect(ret.value).toEqual(new Set([1, 2, 3, 4, 6])) set2.value.add(7) - expect(setSpy).toHaveBeenCalledTimes(3) expect(ret.value).toEqual(new Set([1, 2, 3, 4, 6, 7])) + expect(setSpy).toHaveBeenCalledTimes(1) }) }) }) From 63d5d8f506be28b2d7248f1ae95ffd8a0af71e40 Mon Sep 17 00:00:00 2001 From: linzhe141 <1572213544@qq.com> Date: Sat, 12 Oct 2024 17:57:33 +0800 Subject: [PATCH 8/8] chore: update --- .../__tests__/collections/Set.spec.ts | 96 ++----------------- packages/reactivity/src/collectionHandlers.ts | 4 +- 2 files changed, 11 insertions(+), 89 deletions(-) diff --git a/packages/reactivity/__tests__/collections/Set.spec.ts b/packages/reactivity/__tests__/collections/Set.spec.ts index c614c9fd7..926212f08 100644 --- a/packages/reactivity/__tests__/collections/Set.spec.ts +++ b/packages/reactivity/__tests__/collections/Set.spec.ts @@ -460,96 +460,20 @@ describe('reactivity/collections', () => { expect(result).toBe(set) }) - it('set with difference', () => { - const result = ref('') - const set1 = ref(new Set([1, 2, 3])) - const set2 = ref(new Set([2, 3, 4])) - const setSpy = vi.fn(() => result.value) - effect(setSpy) - // @ts-expect-error - result.value = set1.value.difference(set2.value) - expect(setSpy).toHaveBeenCalledTimes(2) - }) - - it('set with intersection', () => { - const result = ref('') - const set1 = ref(new Set([1, 2, 3])) - const set2 = ref(new Set([2, 3, 4])) - const setSpy = vi.fn(() => result.value) - effect(setSpy) - // @ts-expect-error - result.value = set1.value.intersection(set2.value) - expect(setSpy).toHaveBeenCalledTimes(2) - }) - - it('set with isDisjointFrom', () => { - const result = ref('') - const set1 = ref(new Set([1, 2, 3])) - const set2 = ref(new Set([2, 3, 4])) - const setSpy = vi.fn(() => result.value) - effect(setSpy) - // @ts-expect-error - result.value = set1.value.isDisjointFrom(set2.value) - expect(setSpy).toHaveBeenCalledTimes(2) - }) - - it('set with isSubsetOf', () => { - const result = ref('') - const set1 = ref(new Set([1, 2, 3])) - const set2 = ref(new Set([2, 3, 4])) - const setSpy = vi.fn(() => result.value) - effect(setSpy) - // @ts-expect-error - result.value = set1.value.isSubsetOf(set2.value) - expect(setSpy).toHaveBeenCalledTimes(2) - }) - - it('set with isSupersetOf', () => { - const result = ref('') - const set1 = ref(new Set([1, 2, 3])) - const set2 = ref(new Set([2, 3, 4])) - const setSpy = vi.fn(() => result.value) - effect(setSpy) - // @ts-expect-error - result.value = set1.value.isSupersetOf(set2.value) - expect(setSpy).toHaveBeenCalledTimes(2) - }) - - it('set with symmetricDifference', () => { - const result = ref('') - const set1 = ref(new Set([1, 2, 3])) - const set2 = ref(new Set([2, 3, 4])) - const setSpy = vi.fn(() => result.value) - effect(setSpy) - // @ts-expect-error - result.value = set1.value.symmetricDifference(set2.value) - expect(setSpy).toHaveBeenCalledTimes(2) - }) - - it('set with union', () => { - const result = ref('') - const set1 = ref(new Set([1, 2, 3])) - const set2 = ref(new Set([2, 3, 4])) - const setSpy = vi.fn(() => result.value) - effect(setSpy) - // @ts-expect-error - result.value = set1.value.union(set2.value) - expect(setSpy).toHaveBeenCalledTimes(2) - }) - - it('set with computed', () => { + it('set with union in computed', () => { const set1 = ref(new Set([1, 2, 3])) const set2 = ref(new Set([2, 3, 4])) // @ts-expect-error - const c = computed(() => set1.value.union(set2.value)) - let ret: any - const setSpy = vi.fn(() => (ret = c)) - effect(setSpy) - set1.value.add(6) - expect(ret.value).toEqual(new Set([1, 2, 3, 4, 6])) - set2.value.add(7) - expect(ret.value).toEqual(new Set([1, 2, 3, 4, 6, 7])) + const setSpy = vi.fn(() => set1.value.union(set2.value)) + const c = computed(setSpy) + effect(() => c.value) expect(setSpy).toHaveBeenCalledTimes(1) + set1.value.add(6) + expect(setSpy).toHaveBeenCalledTimes(2) + expect(c.value).toEqual(new Set([1, 2, 3, 4, 6])) + set2.value.add(7) + expect(setSpy).toHaveBeenCalledTimes(3) + expect(c.value).toEqual(new Set([1, 2, 3, 4, 6, 7])) }) }) }) diff --git a/packages/reactivity/src/collectionHandlers.ts b/packages/reactivity/src/collectionHandlers.ts index 020e3e7bf..4cb8157d2 100644 --- a/packages/reactivity/src/collectionHandlers.ts +++ b/packages/reactivity/src/collectionHandlers.ts @@ -93,9 +93,7 @@ function createReadonlyMethod(type: TriggerOpTypes): Function { function createSetProtoMethod(method: string) { return function (this: SetTypes, value: unknown) { - if (!isShallow(value) && !isReadonly(value)) { - value = toRaw(value) - } + value = toRaw(value) const target = (this as any)[ReactiveFlags.RAW] const rawTarget = toRaw(target) const result = target[method](value)