From 5b252e619e8a26af8c5190b4dbfcec3906bb7f91 Mon Sep 17 00:00:00 2001 From: Damian Osipiuk Date: Sun, 22 Jan 2023 17:25:22 +0100 Subject: [PATCH] fix(vue-query): simplify vue hooks, fix types (#4853) * refactor: drop unnecessary type assertions * fix: eslint errors about signal * fix: simplify vue hooks, fix types * test: remove unnecessary conditional --- .../src/__tests__/useInfiniteQuery.test.tsx | 39 +++--- .../src/__tests__/useQuery.test.tsx | 5 +- .../__tests__/createInfiniteQuery.test.tsx | 40 +++--- .../src/__tests__/createQueries.test.tsx | 2 +- .../src/__tests__/createQuery.test.tsx | 5 +- .../__tests__/useInfiniteQuery.types.test.tsx | 5 +- .../src/__tests__/useIsFetching.test.ts | 25 +--- .../src/__tests__/useIsMutating.test.ts | 25 +--- .../src/__tests__/useMutation.test.ts | 58 +------- .../src/__tests__/useMutation.types.test.tsx | 3 +- .../vue-query/src/__tests__/useQuery.test.ts | 19 +-- .../src/__tests__/useQuery.types.test.tsx | 3 +- packages/vue-query/src/mutationCache.ts | 4 +- packages/vue-query/src/queryCache.ts | 11 +- packages/vue-query/src/queryClient.ts | 130 +++++++----------- packages/vue-query/src/types.ts | 75 +--------- packages/vue-query/src/useBaseQuery.ts | 51 ++----- packages/vue-query/src/useInfiniteQuery.ts | 41 ++++-- packages/vue-query/src/useIsFetching.ts | 11 +- packages/vue-query/src/useIsMutating.ts | 11 +- packages/vue-query/src/useMutation.ts | 54 ++------ packages/vue-query/src/useQueries.ts | 14 +- packages/vue-query/src/useQuery.ts | 92 ++++++++----- packages/vue-query/src/utils.ts | 25 ++-- 24 files changed, 249 insertions(+), 499 deletions(-) diff --git a/packages/react-query/src/__tests__/useInfiniteQuery.test.tsx b/packages/react-query/src/__tests__/useInfiniteQuery.test.tsx index 31937fc3b8..1de959f3c8 100644 --- a/packages/react-query/src/__tests__/useInfiniteQuery.test.tsx +++ b/packages/react-query/src/__tests__/useInfiniteQuery.test.tsx @@ -846,14 +846,12 @@ describe('useInfiniteQuery', () => { Promise, [QueryFunctionContext] >(async ({ pageParam = start, signal }) => { - if (signal) { - const onAbort = jest.fn() - const abortListener = jest.fn() - onAborts.push(onAbort) - abortListeners.push(abortListener) - signal.onabort = onAbort - signal.addEventListener('abort', abortListener) - } + const onAbort = jest.fn() + const abortListener = jest.fn() + onAborts.push(onAbort) + abortListeners.push(abortListener) + signal.onabort = onAbort + signal.addEventListener('abort', abortListener) await sleep(50) return Number(pageParam) }) @@ -891,7 +889,7 @@ describe('useInfiniteQuery', () => { expect(firstCtx.pageParam).toBeUndefined() expect(firstCtx.queryKey).toEqual(key) expect(firstCtx.signal).toBeInstanceOf(AbortSignal) - expect(firstCtx.signal?.aborted).toBe(false) + expect(firstCtx.signal.aborted).toBe(false) expect(onAborts[callIndex]).not.toHaveBeenCalled() expect(abortListeners[callIndex]).not.toHaveBeenCalled() @@ -900,7 +898,7 @@ describe('useInfiniteQuery', () => { expect(secondCtx.pageParam).toBe(11) expect(secondCtx.queryKey).toEqual(key) expect(secondCtx.signal).toBeInstanceOf(AbortSignal) - expect(secondCtx.signal?.aborted).toBe(true) + expect(secondCtx.signal.aborted).toBe(true) expect(onAborts[callIndex]).toHaveBeenCalledTimes(1) expect(abortListeners[callIndex]).toHaveBeenCalledTimes(1) @@ -909,7 +907,7 @@ describe('useInfiniteQuery', () => { expect(thirdCtx.pageParam).toBe(11) expect(thirdCtx.queryKey).toEqual(key) expect(thirdCtx.signal).toBeInstanceOf(AbortSignal) - expect(thirdCtx.signal?.aborted).toBe(false) + expect(thirdCtx.signal.aborted).toBe(false) expect(onAborts[callIndex]).not.toHaveBeenCalled() expect(abortListeners[callIndex]).not.toHaveBeenCalled() }) @@ -923,14 +921,13 @@ describe('useInfiniteQuery', () => { Promise, [QueryFunctionContext] >(async ({ pageParam = start, signal }) => { - if (signal) { - const onAbort = jest.fn() - const abortListener = jest.fn() - onAborts.push(onAbort) - abortListeners.push(abortListener) - signal.onabort = onAbort - signal.addEventListener('abort', abortListener) - } + const onAbort = jest.fn() + const abortListener = jest.fn() + onAborts.push(onAbort) + abortListeners.push(abortListener) + signal.onabort = onAbort + signal.addEventListener('abort', abortListener) + await sleep(50) return Number(pageParam) }) @@ -968,7 +965,7 @@ describe('useInfiniteQuery', () => { expect(firstCtx.pageParam).toBeUndefined() expect(firstCtx.queryKey).toEqual(key) expect(firstCtx.signal).toBeInstanceOf(AbortSignal) - expect(firstCtx.signal?.aborted).toBe(false) + expect(firstCtx.signal.aborted).toBe(false) expect(onAborts[callIndex]).not.toHaveBeenCalled() expect(abortListeners[callIndex]).not.toHaveBeenCalled() @@ -977,7 +974,7 @@ describe('useInfiniteQuery', () => { expect(secondCtx.pageParam).toBe(11) expect(secondCtx.queryKey).toEqual(key) expect(secondCtx.signal).toBeInstanceOf(AbortSignal) - expect(secondCtx.signal?.aborted).toBe(false) + expect(secondCtx.signal.aborted).toBe(false) expect(onAborts[callIndex]).not.toHaveBeenCalled() expect(abortListeners[callIndex]).not.toHaveBeenCalled() }) diff --git a/packages/react-query/src/__tests__/useQuery.test.tsx b/packages/react-query/src/__tests__/useQuery.test.tsx index 458a5a06ad..2338b0a5b6 100644 --- a/packages/react-query/src/__tests__/useQuery.test.tsx +++ b/packages/react-query/src/__tests__/useQuery.test.tsx @@ -4664,6 +4664,7 @@ describe('useQuery', () => { ctx, ) => { const [, limit] = ctx.queryKey + // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition const value = limit % 2 && ctx.signal ? 'abort' : `data ${limit}` await sleep(25) return value @@ -5719,10 +5720,10 @@ describe('useQuery', () => { function Component() { const state = useQuery({ queryKey: key, - queryFn: async ({ signal }) => { + queryFn: async ({ signal: _signal }) => { count++ await sleep(10) - return `${signal ? 'signal' : 'data'}${count}` + return `signal${count}` }, }) diff --git a/packages/solid-query/src/__tests__/createInfiniteQuery.test.tsx b/packages/solid-query/src/__tests__/createInfiniteQuery.test.tsx index f1d6c90300..4b55e1b846 100644 --- a/packages/solid-query/src/__tests__/createInfiniteQuery.test.tsx +++ b/packages/solid-query/src/__tests__/createInfiniteQuery.test.tsx @@ -910,14 +910,13 @@ describe('useInfiniteQuery', () => { Promise, [QueryFunctionContext] >(async ({ pageParam = start, signal }) => { - if (signal) { - const onAbort = jest.fn() - const abortListener = jest.fn() - onAborts.push(onAbort) - abortListeners.push(abortListener) - signal.onabort = onAbort - signal.addEventListener('abort', abortListener) - } + const onAbort = jest.fn() + const abortListener = jest.fn() + onAborts.push(onAbort) + abortListeners.push(abortListener) + signal.onabort = onAbort + signal.addEventListener('abort', abortListener) + await sleep(50) return Number(pageParam) }) @@ -960,7 +959,7 @@ describe('useInfiniteQuery', () => { expect(firstCtx.pageParam).toBeUndefined() expect(firstCtx.queryKey).toEqual(key) expect(firstCtx.signal).toBeInstanceOf(AbortSignal) - expect(firstCtx.signal?.aborted).toBe(false) + expect(firstCtx.signal.aborted).toBe(false) expect(onAborts[callIndex]).not.toHaveBeenCalled() expect(abortListeners[callIndex]).not.toHaveBeenCalled() @@ -969,7 +968,7 @@ describe('useInfiniteQuery', () => { expect(secondCtx.pageParam).toBe(11) expect(secondCtx.queryKey).toEqual(key) expect(secondCtx.signal).toBeInstanceOf(AbortSignal) - expect(secondCtx.signal?.aborted).toBe(true) + expect(secondCtx.signal.aborted).toBe(true) expect(onAborts[callIndex]).toHaveBeenCalledTimes(1) expect(abortListeners[callIndex]).toHaveBeenCalledTimes(1) @@ -978,7 +977,7 @@ describe('useInfiniteQuery', () => { expect(thirdCtx.pageParam).toBe(11) expect(thirdCtx.queryKey).toEqual(key) expect(thirdCtx.signal).toBeInstanceOf(AbortSignal) - expect(thirdCtx.signal?.aborted).toBe(false) + expect(thirdCtx.signal.aborted).toBe(false) expect(onAborts[callIndex]).not.toHaveBeenCalled() expect(abortListeners[callIndex]).not.toHaveBeenCalled() }) @@ -992,14 +991,13 @@ describe('useInfiniteQuery', () => { Promise, [QueryFunctionContext] >(async ({ pageParam = start, signal }) => { - if (signal) { - const onAbort = jest.fn() - const abortListener = jest.fn() - onAborts.push(onAbort) - abortListeners.push(abortListener) - signal.onabort = onAbort - signal.addEventListener('abort', abortListener) - } + const onAbort = jest.fn() + const abortListener = jest.fn() + onAborts.push(onAbort) + abortListeners.push(abortListener) + signal.onabort = onAbort + signal.addEventListener('abort', abortListener) + await sleep(50) return Number(pageParam) }) @@ -1042,7 +1040,7 @@ describe('useInfiniteQuery', () => { expect(firstCtx.pageParam).toBeUndefined() expect(firstCtx.queryKey).toEqual(key) expect(firstCtx.signal).toBeInstanceOf(AbortSignal) - expect(firstCtx.signal?.aborted).toBe(false) + expect(firstCtx.signal.aborted).toBe(false) expect(onAborts[callIndex]).not.toHaveBeenCalled() expect(abortListeners[callIndex]).not.toHaveBeenCalled() @@ -1051,7 +1049,7 @@ describe('useInfiniteQuery', () => { expect(secondCtx.pageParam).toBe(11) expect(secondCtx.queryKey).toEqual(key) expect(secondCtx.signal).toBeInstanceOf(AbortSignal) - expect(secondCtx.signal?.aborted).toBe(false) + expect(secondCtx.signal.aborted).toBe(false) expect(onAborts[callIndex]).not.toHaveBeenCalled() expect(abortListeners[callIndex]).not.toHaveBeenCalled() }) diff --git a/packages/solid-query/src/__tests__/createQueries.test.tsx b/packages/solid-query/src/__tests__/createQueries.test.tsx index 676b8559b7..e895698e6d 100644 --- a/packages/solid-query/src/__tests__/createQueries.test.tsx +++ b/packages/solid-query/src/__tests__/createQueries.test.tsx @@ -803,7 +803,7 @@ describe('useQueries', () => { })) return (
-

Status: {state[0]?.data}

+

Status: {state[0].data}

) } diff --git a/packages/solid-query/src/__tests__/createQuery.test.tsx b/packages/solid-query/src/__tests__/createQuery.test.tsx index 3c1558cb38..2a2e39ae6c 100644 --- a/packages/solid-query/src/__tests__/createQuery.test.tsx +++ b/packages/solid-query/src/__tests__/createQuery.test.tsx @@ -4650,6 +4650,7 @@ describe('createQuery', () => { readonly [typeof key, number] > = async (ctx) => { const [, limit] = ctx.queryKey + // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition const value = limit % 2 && ctx.signal ? 'abort' : `data ${limit}` await sleep(25) return value @@ -5789,10 +5790,10 @@ describe('createQuery', () => { function Component() { const state = createQuery(() => ({ queryKey: key, - queryFn: async ({ signal }) => { + queryFn: async ({ signal: _signal }) => { count++ await sleep(10) - return `${signal ? 'signal' : 'data'}${count}` + return `signal${count}` }, })) diff --git a/packages/vue-query/src/__tests__/useInfiniteQuery.types.test.tsx b/packages/vue-query/src/__tests__/useInfiniteQuery.types.test.tsx index a965a6c334..3446bbc832 100644 --- a/packages/vue-query/src/__tests__/useInfiniteQuery.types.test.tsx +++ b/packages/vue-query/src/__tests__/useInfiniteQuery.types.test.tsx @@ -1,7 +1,8 @@ -import { InfiniteData } from '@tanstack/query-core' +import type { InfiniteData } from '@tanstack/query-core' import { reactive } from 'vue' import { useInfiniteQuery } from '../useInfiniteQuery' -import { doNotExecute, Equal, Expect, simpleFetcher } from './test-utils' +import type { Equal, Expect } from './test-utils' +import { doNotExecute, simpleFetcher } from './test-utils' describe('Discriminated union return type', () => { it('data should be possibly undefined by default', () => { diff --git a/packages/vue-query/src/__tests__/useIsFetching.test.ts b/packages/vue-query/src/__tests__/useIsFetching.test.ts index c1d15b67e4..1935d3de53 100644 --- a/packages/vue-query/src/__tests__/useIsFetching.test.ts +++ b/packages/vue-query/src/__tests__/useIsFetching.test.ts @@ -1,8 +1,8 @@ -import { onScopeDispose, reactive, ref } from 'vue-demi' +import { onScopeDispose, reactive } from 'vue-demi' import { flushPromises, simpleFetcher } from './test-utils' import { useQuery } from '../useQuery' -import { unrefFilterArgs, useIsFetching } from '../useIsFetching' +import { useIsFetching } from '../useIsFetching' jest.mock('../useQueryClient') @@ -74,25 +74,4 @@ describe('useIsFetching', () => { await flushPromises(100) }) - - describe('parseFilterArgs', () => { - test('should merge query key with filters', () => { - const filters = { queryKey: ['key'], stale: true } - - const result = unrefFilterArgs(filters) - const expected = { ...filters, queryKey: ['key'] } - - expect(result).toEqual(expected) - }) - - test('should unwrap refs arguments', () => { - const key = ref(['key']) - const filters = ref({ queryKey: key, stale: ref(true) }) - - const result = unrefFilterArgs(filters) - const expected = { queryKey: ['key'], stale: true } - - expect(result).toEqual(expected) - }) - }) }) diff --git a/packages/vue-query/src/__tests__/useIsMutating.test.ts b/packages/vue-query/src/__tests__/useIsMutating.test.ts index 21be6fbc81..4f006b7bec 100644 --- a/packages/vue-query/src/__tests__/useIsMutating.test.ts +++ b/packages/vue-query/src/__tests__/useIsMutating.test.ts @@ -1,8 +1,8 @@ -import { onScopeDispose, reactive, ref } from 'vue-demi' +import { onScopeDispose, reactive } from 'vue-demi' import { flushPromises, successMutator } from './test-utils' import { useMutation } from '../useMutation' -import { unrefFilterArgs, useIsMutating } from '../useIsMutating' +import { useIsMutating } from '../useIsMutating' jest.mock('../useQueryClient') @@ -78,25 +78,4 @@ describe('useIsMutating', () => { expect(isMutating.value).toStrictEqual(1) }) - - describe('parseMutationFilterArgs', () => { - test('should merge mutation key with filters', () => { - const filters = { mutationKey: ['key'], fetching: true } - - const result = unrefFilterArgs(filters) - const expected = { ...filters, mutationKey: ['key'] } - - expect(result).toEqual(expected) - }) - - test('should unwrap refs arguments', () => { - const key = ref(['key']) - const filters = ref({ mutationKey: key, fetching: ref(true) }) - - const result = unrefFilterArgs(filters) - const expected = { mutationKey: ['key'], fetching: true } - - expect(result).toEqual(expected) - }) - }) }) diff --git a/packages/vue-query/src/__tests__/useMutation.test.ts b/packages/vue-query/src/__tests__/useMutation.test.ts index 770bfbbe4f..a8fa10c083 100644 --- a/packages/vue-query/src/__tests__/useMutation.test.ts +++ b/packages/vue-query/src/__tests__/useMutation.test.ts @@ -1,6 +1,6 @@ import { reactive, ref } from 'vue-demi' import { errorMutator, flushPromises, successMutator } from './test-utils' -import { unrefMutationArgs, useMutation } from '../useMutation' +import { useMutation } from '../useMutation' import { useQueryClient } from '../useQueryClient' jest.mock('../useQueryClient') @@ -331,60 +331,4 @@ describe('useMutation', () => { }) }) }) - - describe('parseMutationArgs', () => { - test('should return the same instance of options', () => { - const options = { retry: false } - const result = unrefMutationArgs(options) - - expect(result).toEqual(options) - }) - - test('should merge query key with options', () => { - const options = { mutationKey: ['key'], retry: false } - const result = unrefMutationArgs(options) - const expected = { ...options, mutationKey: ['key'] } - - expect(result).toEqual(expected) - }) - - test('should merge query fn with options', () => { - const options = { mutationFn: successMutator, retry: false } - const result = unrefMutationArgs(options) - const expected = { ...options, mutationFn: successMutator } - - expect(result).toEqual(expected) - }) - - test('should merge query key and fn with options', () => { - const options = { - mutationKey: ['key'], - mutationFn: successMutator, - retry: false, - } - const result = unrefMutationArgs(options) - const expected = { - ...options, - mutationKey: ['key'], - mutationFn: successMutator, - } - - expect(result).toEqual(expected) - }) - - test('should unwrap refs arguments', () => { - const key = ref(['key']) - const mutationFn = ref(successMutator) - const options = ref({ mutationKey: key, mutationFn, retry: ref(12) }) - - const result = unrefMutationArgs(options) - const expected = { - mutationKey: ['key'], - mutationFn: successMutator, - retry: 12, - } - - expect(result).toEqual(expected) - }) - }) }) diff --git a/packages/vue-query/src/__tests__/useMutation.types.test.tsx b/packages/vue-query/src/__tests__/useMutation.types.test.tsx index 3d9ee11c80..ccfe84671e 100644 --- a/packages/vue-query/src/__tests__/useMutation.types.test.tsx +++ b/packages/vue-query/src/__tests__/useMutation.types.test.tsx @@ -1,6 +1,7 @@ import { reactive } from 'vue' import { useMutation } from '../useMutation' -import { doNotExecute, Equal, Expect, successMutator } from './test-utils' +import { doNotExecute, successMutator } from './test-utils' +import type { Equal, Expect } from './test-utils' describe('Discriminated union return type', () => { it('data should be possibly undefined by default', () => { diff --git a/packages/vue-query/src/__tests__/useQuery.test.ts b/packages/vue-query/src/__tests__/useQuery.test.ts index 343d4ae107..f3618bf443 100644 --- a/packages/vue-query/src/__tests__/useQuery.test.ts +++ b/packages/vue-query/src/__tests__/useQuery.test.ts @@ -14,7 +14,7 @@ import { getSimpleFetcherWithReturnData, } from './test-utils' import { useQuery } from '../useQuery' -import { unrefQueryArgs, useBaseQuery } from '../useBaseQuery' +import { useBaseQuery } from '../useBaseQuery' jest.mock('../useQueryClient') jest.mock('../useBaseQuery') @@ -254,23 +254,6 @@ describe('useQuery', () => { expect(status.value).toStrictEqual('loading') }) - describe('parseQueryArgs', () => { - test('should unwrap refs in options', () => { - const key = ref(['key']) - const fn = ref(simpleFetcher) - const options = ref({ queryKey: key, queryFn: fn, enabled: ref(true) }) - - const result = unrefQueryArgs(options) - const expected = { - queryKey: ['key'], - queryFn: simpleFetcher, - enabled: true, - } - - expect(result).toEqual(expected) - }) - }) - describe('suspense', () => { test('should return a Promise', () => { const getCurrentInstanceSpy = getCurrentInstance as jest.Mock diff --git a/packages/vue-query/src/__tests__/useQuery.types.test.tsx b/packages/vue-query/src/__tests__/useQuery.types.test.tsx index e77516a6df..879ca7f92a 100644 --- a/packages/vue-query/src/__tests__/useQuery.types.test.tsx +++ b/packages/vue-query/src/__tests__/useQuery.types.test.tsx @@ -1,6 +1,7 @@ import { reactive } from 'vue' import { useQuery } from '../useQuery' -import { doNotExecute, Equal, Expect, simpleFetcher } from './test-utils' +import { doNotExecute, simpleFetcher } from './test-utils' +import type { Equal, Expect } from './test-utils' describe('Discriminated union return type', () => { it('data should be possibly undefined by default', () => { diff --git a/packages/vue-query/src/mutationCache.ts b/packages/vue-query/src/mutationCache.ts index f0bce63b71..328526af53 100644 --- a/packages/vue-query/src/mutationCache.ts +++ b/packages/vue-query/src/mutationCache.ts @@ -7,10 +7,10 @@ export class MutationCache extends MC { find( filters: MaybeRefDeep, ): Mutation | undefined { - return super.find(cloneDeepUnref(filters) as MutationFilters) + return super.find(cloneDeepUnref(filters)) } findAll(filters: MaybeRefDeep): Mutation[] { - return super.findAll(cloneDeepUnref(filters) as MutationFilters) + return super.findAll(cloneDeepUnref(filters)) } } diff --git a/packages/vue-query/src/queryCache.ts b/packages/vue-query/src/queryCache.ts index 35e2c51427..7ba2db7e4f 100644 --- a/packages/vue-query/src/queryCache.ts +++ b/packages/vue-query/src/queryCache.ts @@ -7,15 +7,10 @@ export class QueryCache extends QC { find( filters: MaybeRefDeep>, ): Query | undefined { - const filtersUnreffed = cloneDeepUnref(filters) as WithRequired< - QueryFilters, - 'queryKey' - > - return super.find(filtersUnreffed) + return super.find(cloneDeepUnref(filters)) } - findAll(filters?: MaybeRefDeep): Query[] { - const filtersUnreffed = cloneDeepUnref(filters) as QueryFilters - return super.findAll(filtersUnreffed) + findAll(filters: MaybeRefDeep = {}): Query[] { + return super.findAll(cloneDeepUnref(filters)) } } diff --git a/packages/vue-query/src/queryClient.ts b/packages/vue-query/src/queryClient.ts index 80729c30b4..3e31f23899 100644 --- a/packages/vue-query/src/queryClient.ts +++ b/packages/vue-query/src/queryClient.ts @@ -30,10 +30,10 @@ import { MutationCache } from './mutationCache' export class QueryClient extends QC { constructor(config: MaybeRefDeep = {}) { - const unreffedConfig = cloneDeepUnref(config) as QueryClientConfig + const unreffedConfig = cloneDeepUnref(config) const vueQueryConfig: QueryClientConfig = { - logger: cloneDeepUnref(unreffedConfig.logger), - defaultOptions: cloneDeepUnref(unreffedConfig.defaultOptions), + logger: unreffedConfig.logger, + defaultOptions: unreffedConfig.defaultOptions, queryCache: unreffedConfig.queryCache || new QueryCache(), mutationCache: unreffedConfig.mutationCache || new MutationCache(), } @@ -42,103 +42,92 @@ export class QueryClient extends QC { isRestoring = ref(false) - isFetching(filters?: MaybeRefDeep): number { - const filtersUnreffed = cloneDeepUnref(filters) as QueryFilters - return super.isFetching(filtersUnreffed) + isFetching(filters: MaybeRefDeep = {}): number { + return super.isFetching(cloneDeepUnref(filters)) } - isMutating(filters?: MaybeRefDeep): number { - return super.isMutating(cloneDeepUnref(filters) as MutationFilters) + isMutating(filters: MaybeRefDeep = {}): number { + return super.isMutating(cloneDeepUnref(filters)) } getQueryData( queryKey: MaybeRefDeep, ): TData | undefined { - return super.getQueryData(cloneDeepUnref(queryKey) as QueryKey) + return super.getQueryData(cloneDeepUnref(queryKey)) } getQueriesData( filters: MaybeRefDeep, ): [QueryKey, TData | undefined][] { - const unreffed = cloneDeepUnref(filters) as QueryFilters - return super.getQueriesData(unreffed) + return super.getQueriesData(cloneDeepUnref(filters)) } setQueryData( queryKey: MaybeRefDeep, updater: Updater, - options?: MaybeRefDeep, + options: MaybeRefDeep = {}, ): TData | undefined { return super.setQueryData( - cloneDeepUnref(queryKey) as QueryKey, + cloneDeepUnref(queryKey), updater, - cloneDeepUnref(options) as SetDataOptions, + cloneDeepUnref(options), ) } setQueriesData( filters: MaybeRefDeep, updater: Updater, - options?: MaybeRefDeep, + options: MaybeRefDeep = {}, ): [QueryKey, TData | undefined][] { - const filtersUnreffed = cloneDeepUnref(filters) as QueryFilters - const optionsUnreffed = cloneDeepUnref(options) as SetDataOptions - - return super.setQueriesData(filtersUnreffed, updater, optionsUnreffed) + return super.setQueriesData( + cloneDeepUnref(filters), + updater, + cloneDeepUnref(options), + ) } getQueryState( queryKey: MaybeRefDeep, ): QueryState | undefined { - return super.getQueryState(cloneDeepUnref(queryKey) as QueryKey) + return super.getQueryState(cloneDeepUnref(queryKey)) } - removeQueries(filters?: MaybeRefDeep): void { - const filtersUnreffed = cloneDeepUnref(filters) as QueryFilters - return super.removeQueries(filtersUnreffed) + removeQueries(filters: MaybeRefDeep = {}): void { + return super.removeQueries(cloneDeepUnref(filters)) } resetQueries( - filters?: MaybeRefDeep>, - options?: MaybeRefDeep, + filters: MaybeRefDeep> = {}, + options: MaybeRefDeep = {}, ): Promise { - const filtersUnreffed = cloneDeepUnref(filters) as ResetQueryFilters - const optionsUnreffed = cloneDeepUnref(options) as ResetOptions - - return super.resetQueries(filtersUnreffed, optionsUnreffed) + return super.resetQueries(cloneDeepUnref(filters), cloneDeepUnref(options)) } cancelQueries( - filters?: MaybeRefDeep, - options?: MaybeRefDeep, + filters: MaybeRefDeep = {}, + options: MaybeRefDeep = {}, ): Promise { - const filtersUnreffed = cloneDeepUnref(filters) as QueryFilters - const optionsUnreffed = cloneDeepUnref(options) as CancelOptions - return super.cancelQueries(filtersUnreffed, optionsUnreffed) + return super.cancelQueries(cloneDeepUnref(filters), cloneDeepUnref(options)) } invalidateQueries( - filters?: MaybeRefDeep>, - options?: MaybeRefDeep, + filters: MaybeRefDeep> = {}, + options: MaybeRefDeep = {}, ): Promise { - const filtersUnreffed = cloneDeepUnref( - filters, - ) as InvalidateQueryFilters - const optionsUnreffed = cloneDeepUnref(options) as InvalidateOptions - - return super.invalidateQueries(filtersUnreffed, optionsUnreffed) + return super.invalidateQueries( + cloneDeepUnref(filters), + cloneDeepUnref(options), + ) } refetchQueries( - filters?: MaybeRefDeep>, - options?: MaybeRefDeep, + filters: MaybeRefDeep> = {}, + options: MaybeRefDeep = {}, ): Promise { - const filtersUnreffed = cloneDeepUnref( - filters, - ) as RefetchQueryFilters - const optionsUnreffed = cloneDeepUnref(options) as RefetchOptions - - return super.refetchQueries(filtersUnreffed, optionsUnreffed) + return super.refetchQueries( + cloneDeepUnref(filters), + cloneDeepUnref(options), + ) } fetchQuery< @@ -151,7 +140,7 @@ export class QueryClient extends QC { ): Promise fetchQuery< TQueryFnData, - TError, + TError = Error, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, >( @@ -159,14 +148,7 @@ export class QueryClient extends QC { FetchQueryOptions >, ): Promise { - const optionsUnreffed = cloneDeepUnref(options) as FetchQueryOptions< - TQueryFnData, - TError, - TData, - TQueryKey - > - - return super.fetchQuery(optionsUnreffed) + return super.fetchQuery(cloneDeepUnref(options)) } prefetchQuery< @@ -187,13 +169,7 @@ export class QueryClient extends QC { FetchQueryOptions >, ): Promise { - const optionsUnreffed = cloneDeepUnref(options) as FetchQueryOptions< - TQueryFnData, - TError, - TData, - TQueryKey - > - return super.prefetchQuery(optionsUnreffed) + return super.prefetchQuery(cloneDeepUnref(options)) } fetchInfiniteQuery< @@ -214,11 +190,7 @@ export class QueryClient extends QC { FetchInfiniteQueryOptions >, ): Promise> { - const optionsUnreffed = cloneDeepUnref( - options, - ) as FetchInfiniteQueryOptions - - return super.fetchInfiniteQuery(optionsUnreffed) + return super.fetchInfiniteQuery(cloneDeepUnref(options)) } prefetchInfiniteQuery< @@ -239,14 +211,11 @@ export class QueryClient extends QC { FetchInfiniteQueryOptions >, ): Promise { - const optionsUnreffed = cloneDeepUnref( - options, - ) as FetchInfiniteQueryOptions - return super.prefetchInfiniteQuery(optionsUnreffed) + return super.prefetchInfiniteQuery(cloneDeepUnref(options)) } setDefaultOptions(options: MaybeRefDeep): void { - super.setDefaultOptions(cloneDeepUnref(options) as DefaultOptions) + super.setDefaultOptions(cloneDeepUnref(options)) } setQueryDefaults( @@ -255,12 +224,7 @@ export class QueryClient extends QC { Omit, 'queryKey'> >, ): void { - const queryKeyUnreffed = cloneDeepUnref(queryKey) as QueryKey - const optionsUnreffed = cloneDeepUnref(options) as Omit< - QueryObserverOptions, - 'queryKey' - > - super.setQueryDefaults(queryKeyUnreffed, optionsUnreffed) + super.setQueryDefaults(cloneDeepUnref(queryKey), cloneDeepUnref(options)) } getQueryDefaults( @@ -275,7 +239,7 @@ export class QueryClient extends QC { ): void { super.setMutationDefaults( cloneDeepUnref(mutationKey), - cloneDeepUnref(options) as any, + cloneDeepUnref(options), ) } diff --git a/packages/vue-query/src/types.ts b/packages/vue-query/src/types.ts index 09a286828b..3fd37e1bd3 100644 --- a/packages/vue-query/src/types.ts +++ b/packages/vue-query/src/types.ts @@ -1,11 +1,6 @@ /* istanbul ignore file */ -import type { - QueryKey, - QueryObserverOptions, - InfiniteQueryObserverOptions, -} from '@tanstack/query-core' -import type { Ref, UnwrapRef } from 'vue-demi' +import type { Ref } from 'vue-demi' export type MaybeRef = Ref | T @@ -19,74 +14,6 @@ export type MaybeRefDeep = MaybeRef< : T > -// A Vue version of QueriesObserverOptions from "@tanstack/query-core" -// Accept refs as options -export type VueQueryObserverOptions< - TQueryFnData = unknown, - TError = Error, - TData = TQueryFnData, - TQueryData = TQueryFnData, - TQueryKey extends QueryKey = QueryKey, -> = { - [Property in keyof QueryObserverOptions< - TQueryFnData, - TError, - TData, - TQueryData, - TQueryKey - >]: Property extends 'queryFn' - ? QueryObserverOptions< - TQueryFnData, - TError, - TData, - TQueryData, - UnwrapRef - >[Property] - : MaybeRef< - QueryObserverOptions< - TQueryFnData, - TError, - TData, - TQueryData, - TQueryKey - >[Property] - > -} - -// A Vue version of InfiniteQueryObserverOptions from "@tanstack/query-core" -// Accept refs as options -export type VueInfiniteQueryObserverOptions< - TQueryFnData = unknown, - TError = Error, - TData = unknown, - TQueryData = unknown, - TQueryKey extends QueryKey = QueryKey, -> = { - [Property in keyof InfiniteQueryObserverOptions< - TQueryFnData, - TError, - TData, - TQueryData, - TQueryKey - >]: Property extends 'queryFn' - ? InfiniteQueryObserverOptions< - TQueryFnData, - TError, - TData, - TQueryData, - UnwrapRef - >[Property] - : MaybeRef< - InfiniteQueryObserverOptions< - TQueryFnData, - TError, - TData, - TQueryData, - TQueryKey - >[Property] - > -} - export type DistributiveOmit = T extends any ? Omit : never diff --git a/packages/vue-query/src/useBaseQuery.ts b/packages/vue-query/src/useBaseQuery.ts index 2ab1cf49f8..f03a206abe 100644 --- a/packages/vue-query/src/useBaseQuery.ts +++ b/packages/vue-query/src/useBaseQuery.ts @@ -6,23 +6,21 @@ import { watch, ref, computed, - unref, } from 'vue-demi' import type { ToRefs } from 'vue-demi' import type { QueryObserver, QueryKey, - QueryObserverOptions, QueryObserverResult, + DefaultedQueryObserverOptions, } from '@tanstack/query-core' import { useQueryClient } from './useQueryClient' import { updateState, cloneDeepUnref } from './utils' -import type { MaybeRef } from './types' +import type { QueryClient } from './queryClient' import type { UseQueryOptions } from './useQuery' import type { UseInfiniteQueryOptions } from './useInfiniteQuery' -import type { QueryClient } from './queryClient' -export type UseQueryReturnType< +export type UseBaseQueryReturnType< TData, TError, Result = QueryObserverResult, @@ -46,20 +44,22 @@ export function useBaseQuery< TQueryKey extends QueryKey, >( Observer: typeof QueryObserver, - genericOptions: UseQueryOptionsGeneric< - TQueryFnData, - TError, - TData, - TQueryKey - >, + options: UseQueryOptionsGeneric, queryClient?: QueryClient, -): UseQueryReturnType { - const options = computed(() => unrefQueryArgs(genericOptions)) - +): UseBaseQueryReturnType { const client = queryClient || useQueryClient() const defaultedOptions = computed(() => { - const defaulted = client.defaultQueryOptions(options.value) + const defaulted = client.defaultQueryOptions( + cloneDeepUnref(options as any), + ) as DefaultedQueryObserverOptions< + TQueryFnData, + TError, + TData, + TQueryFnData, + TQueryKey + > + defaulted._optimisticResults = client.isRestoring.value ? 'isRestoring' : 'optimistic' @@ -134,24 +134,3 @@ export function useBaseQuery< suspense, } } - -export function unrefQueryArgs< - TQueryFnData = unknown, - TError = Error, - TData = TQueryFnData, - TQueryData = TQueryFnData, - TQueryKey extends QueryKey = QueryKey, ->( - arg1: MaybeRef< - UseQueryOptionsGeneric - >, -): QueryObserverOptions { - const options = unref(arg1) - return cloneDeepUnref(options) as QueryObserverOptions< - TQueryFnData, - TError, - TData, - TQueryData, - TQueryKey - > -} diff --git a/packages/vue-query/src/useInfiniteQuery.ts b/packages/vue-query/src/useInfiniteQuery.ts index 531aa870dc..42830036ed 100644 --- a/packages/vue-query/src/useInfiniteQuery.ts +++ b/packages/vue-query/src/useInfiniteQuery.ts @@ -4,31 +4,52 @@ import type { WithRequired, QueryKey, InfiniteQueryObserverResult, + InfiniteQueryObserverOptions, } from '@tanstack/query-core' import { useBaseQuery } from './useBaseQuery' -import type { UseQueryReturnType } from './useBaseQuery' +import type { UseBaseQueryReturnType } from './useBaseQuery' -import type { VueInfiniteQueryObserverOptions, DistributiveOmit } from './types' +import type { DistributiveOmit, MaybeRefDeep } from './types' import type { QueryClient } from './queryClient' +import type { UnwrapRef } from 'vue-demi' export type UseInfiniteQueryOptions< TQueryFnData = unknown, TError = Error, - TData = TQueryFnData, + TData = unknown, + TQueryData = unknown, TQueryKey extends QueryKey = QueryKey, -> = WithRequired< - VueInfiniteQueryObserverOptions< +> = { + [Property in keyof InfiniteQueryObserverOptions< TQueryFnData, TError, TData, - TQueryFnData, + TQueryData, TQueryKey - >, - 'queryKey' -> + >]: Property extends 'queryFn' + ? InfiniteQueryObserverOptions< + TQueryFnData, + TError, + TData, + TQueryData, + UnwrapRef + >[Property] + : MaybeRefDeep< + WithRequired< + InfiniteQueryObserverOptions< + TQueryFnData, + TError, + TData, + TQueryData, + TQueryKey + >, + 'queryKey' + >[Property] + > +} -type InfiniteQueryReturnType = UseQueryReturnType< +type InfiniteQueryReturnType = UseBaseQueryReturnType< TData, TError, InfiniteQueryObserverResult diff --git a/packages/vue-query/src/useIsFetching.ts b/packages/vue-query/src/useIsFetching.ts index d226df2791..65874dc874 100644 --- a/packages/vue-query/src/useIsFetching.ts +++ b/packages/vue-query/src/useIsFetching.ts @@ -1,4 +1,4 @@ -import { computed, unref, onScopeDispose, ref, watch } from 'vue-demi' +import { computed, onScopeDispose, ref, watch } from 'vue-demi' import type { Ref } from 'vue-demi' import type { QueryFilters as QF } from '@tanstack/query-core' import { useQueryClient } from './useQueryClient' @@ -9,10 +9,10 @@ import type { QueryClient } from './queryClient' export type QueryFilters = MaybeRefDeep export function useIsFetching( - fetchingFilters: QueryFilters = {}, + fetchingFilters: MaybeRefDeep = {}, queryClient?: QueryClient, ): Ref { - const filters = computed(() => unrefFilterArgs(fetchingFilters)) + const filters = computed(() => cloneDeepUnref(fetchingFilters)) const client = queryClient || useQueryClient() const isFetching = ref(client.isFetching(filters)) @@ -35,8 +35,3 @@ export function useIsFetching( return isFetching } - -export function unrefFilterArgs(arg: QueryFilters) { - const options = unref(arg) - return cloneDeepUnref(options) as QF -} diff --git a/packages/vue-query/src/useIsMutating.ts b/packages/vue-query/src/useIsMutating.ts index ffff46d54f..3314b5a9d8 100644 --- a/packages/vue-query/src/useIsMutating.ts +++ b/packages/vue-query/src/useIsMutating.ts @@ -1,4 +1,4 @@ -import { computed, unref, onScopeDispose, ref, watch } from 'vue-demi' +import { computed, onScopeDispose, ref, watch } from 'vue-demi' import type { Ref } from 'vue-demi' import type { MutationFilters as MF } from '@tanstack/query-core' @@ -10,10 +10,10 @@ import type { QueryClient } from './queryClient' export type MutationFilters = MaybeRefDeep export function useIsMutating( - mutationFilters: MutationFilters = {}, + mutationFilters: MaybeRefDeep = {}, queryClient?: QueryClient, ): Ref { - const filters = computed(() => unrefFilterArgs(mutationFilters)) + const filters = computed(() => cloneDeepUnref(mutationFilters)) const client = queryClient || useQueryClient() const isMutating = ref(client.isMutating(filters)) @@ -36,8 +36,3 @@ export function useIsMutating( return isMutating } - -export function unrefFilterArgs(arg: MutationFilters) { - const options = unref(arg) - return cloneDeepUnref(options) as MF -} diff --git a/packages/vue-query/src/useMutation.ts b/packages/vue-query/src/useMutation.ts index 6148bfcd43..64ea5e5bfe 100644 --- a/packages/vue-query/src/useMutation.ts +++ b/packages/vue-query/src/useMutation.ts @@ -5,7 +5,6 @@ import { toRefs, watch, computed, - unref, } from 'vue-demi' import type { ToRefs } from 'vue-demi' import type { @@ -14,7 +13,7 @@ import type { MutationObserverResult, MutationObserverOptions, } from '@tanstack/query-core' -import type { MaybeRef, MaybeRefDeep, DistributiveOmit } from './types' +import type { MaybeRefDeep, DistributiveOmit } from './types' import { MutationObserver } from '@tanstack/query-core' import { cloneDeepUnref, updateState } from './utils' import { useQueryClient } from './useQueryClient' @@ -25,24 +24,12 @@ type MutationResult = DistributiveOmit< 'mutate' | 'reset' > -export type UseMutationOptions = - MutationObserverOptions - -export type VueMutationObserverOptions< +export type UseMutationOptions< TData = unknown, TError = Error, TVariables = void, TContext = unknown, -> = { - [Property in keyof UseMutationOptions< - TData, - TError, - TVariables, - TContext - >]: MaybeRefDeep< - UseMutationOptions[Property] - > -} +> = MaybeRefDeep> type MutateSyncFunction< TData = unknown, @@ -71,19 +58,16 @@ export function useMutation< TVariables = void, TContext = unknown, >( - mutationOptions: MaybeRef< - VueMutationObserverOptions + mutationOptions: MaybeRefDeep< + MutationObserverOptions >, queryClient?: QueryClient, ): UseMutationReturnType { + const client = queryClient || useQueryClient() const options = computed(() => { - return unrefMutationArgs(mutationOptions) + return client.defaultMutationOptions(cloneDeepUnref(mutationOptions)) }) - const client = queryClient || useQueryClient() - const observer = new MutationObserver( - client, - client.defaultMutationOptions(options.value), - ) + const observer = new MutationObserver(client, options.value) const state = reactive(observer.getCurrentResult()) const unsubscribe = observer.subscribe((result) => { @@ -102,7 +86,7 @@ export function useMutation< watch( options, () => { - observer.setOptions(client.defaultMutationOptions(options.value)) + observer.setOptions(options.value) }, { deep: true }, ) @@ -122,23 +106,3 @@ export function useMutation< reset: state.reset, } } - -export function unrefMutationArgs< - TData = unknown, - TError = Error, - TVariables = void, - TContext = unknown, ->( - arg: MaybeRef< - VueMutationObserverOptions - >, -): MutationObserverOptions { - const options = unref(arg) - - return cloneDeepUnref(options) as UseMutationOptions< - TData, - TError, - TVariables, - TContext - > -} diff --git a/packages/vue-query/src/useQueries.ts b/packages/vue-query/src/useQueries.ts index e8c85b93bc..d2c754c721 100644 --- a/packages/vue-query/src/useQueries.ts +++ b/packages/vue-query/src/useQueries.ts @@ -12,7 +12,6 @@ import { ref, watch, } from 'vue-demi' -import type { Ref } from 'vue-demi' import type { QueryFunction, QueryObserverResult } from '@tanstack/query-core' @@ -20,6 +19,7 @@ import { useQueryClient } from './useQueryClient' import { cloneDeepUnref } from './utils' import type { UseQueryOptions } from './useQuery' import type { QueryClient } from './queryClient' +import type { DistributiveOmit, MaybeRefDeep } from './types' // This defines the `UseQueryOptions` that are accepted in `QueriesOptions` & `GetOptions`. // `placeholderData` function does not have a parameter @@ -28,7 +28,7 @@ type UseQueryOptionsForUseQueries< TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, -> = Omit< +> = DistributiveOmit< UseQueryOptions, 'placeholderData' > & { @@ -155,17 +155,13 @@ export function useQueries({ queries, queryClient, }: { - queries: Ref> | UseQueriesOptionsArg + queries: MaybeRefDeep> queryClient?: QueryClient }): Readonly> { - const unreffedQueries = computed( - () => cloneDeepUnref(queries) as UseQueriesOptionsArg, - ) - const client = queryClient || useQueryClient() const defaultedQueries = computed(() => - unreffedQueries.value.map((options) => { + cloneDeepUnref(queries).map((options) => { const defaulted = client.defaultQueryOptions(options) defaulted._optimisticResults = client.isRestoring.value ? 'isRestoring' @@ -202,7 +198,7 @@ export function useQueries({ ) watch( - unreffedQueries, + defaultedQueries, () => { observer.setQueries(defaultedQueries.value) state.splice(0, state.length, ...observer.getCurrentResult()) diff --git a/packages/vue-query/src/useQuery.ts b/packages/vue-query/src/useQuery.ts index 633b15a8cc..fd02a2e819 100644 --- a/packages/vue-query/src/useQuery.ts +++ b/packages/vue-query/src/useQuery.ts @@ -1,18 +1,54 @@ -import type { ToRefs } from 'vue-demi' +import type { ToRefs, UnwrapRef } from 'vue-demi' import { QueryObserver } from '@tanstack/query-core' import type { QueryKey, QueryObserverResult, DefinedQueryObserverResult, WithRequired, + QueryObserverOptions, } from '@tanstack/query-core' import { useBaseQuery } from './useBaseQuery' -import type { UseQueryReturnType as UQRT } from './useBaseQuery' -import type { VueQueryObserverOptions, DistributiveOmit } from './types' +import type { UseBaseQueryReturnType } from './useBaseQuery' +import type { DistributiveOmit, MaybeRefDeep } from './types' import type { QueryClient } from './queryClient' +export type UseQueryOptions< + TQueryFnData = unknown, + TError = Error, + TData = TQueryFnData, + TQueryData = TQueryFnData, + TQueryKey extends QueryKey = QueryKey, +> = { + [Property in keyof QueryObserverOptions< + TQueryFnData, + TError, + TData, + TQueryData, + TQueryKey + >]: Property extends 'queryFn' + ? QueryObserverOptions< + TQueryFnData, + TError, + TData, + TQueryData, + UnwrapRef + >[Property] + : MaybeRefDeep< + WithRequired< + QueryObserverOptions< + TQueryFnData, + TError, + TData, + TQueryData, + TQueryKey + >, + 'queryKey' + >[Property] + > +} + export type UseQueryReturnType = DistributiveOmit< - UQRT, + UseBaseQueryReturnType, 'refetch' > & { refetch: QueryObserverResult['refetch'] @@ -26,41 +62,21 @@ export type UseQueryDefinedReturnType = DistributiveOmit< refetch: QueryObserverResult['refetch'] } -export type UseQueryOptions< - TQueryFnData = unknown, - TError = Error, - TData = TQueryFnData, - TQueryKey extends QueryKey = QueryKey, -> = WithRequired< - VueQueryObserverOptions, - 'queryKey' -> - -type UndefinedInitialDataOptions< - TQueryFnData = unknown, - TError = Error, - TData = TQueryFnData, - TQueryKey extends QueryKey = QueryKey, -> = UseQueryOptions & { - initialData?: undefined -} - -type DefinedInitialDataOptions< - TQueryFnData = unknown, - TError = Error, - TData = TQueryFnData, - TQueryKey extends QueryKey = QueryKey, -> = UseQueryOptions & { - initialData: TQueryFnData | (() => TQueryFnData) -} - export function useQuery< TQueryFnData = unknown, TError = Error, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, >( - options: UndefinedInitialDataOptions, + options: UseQueryOptions< + TQueryFnData, + TError, + TData, + TQueryFnData, + TQueryKey + > & { + initialData?: undefined + }, queryClient?: QueryClient, ): UseQueryReturnType @@ -70,7 +86,15 @@ export function useQuery< TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, >( - options: DefinedInitialDataOptions, + options: UseQueryOptions< + TQueryFnData, + TError, + TData, + TQueryFnData, + TQueryKey + > & { + initialData: TQueryFnData | (() => TQueryFnData) + }, queryClient?: QueryClient, ): UseQueryDefinedReturnType diff --git a/packages/vue-query/src/utils.ts b/packages/vue-query/src/utils.ts index fc50f1ff26..06b7c9bfcb 100644 --- a/packages/vue-query/src/utils.ts +++ b/packages/vue-query/src/utils.ts @@ -1,6 +1,5 @@ -/* eslint-disable @typescript-eslint/no-explicit-any */ import { isRef, unref } from 'vue-demi' -import type { UnwrapRef } from 'vue-demi' +import type { MaybeRefDeep } from './types' export const VUE_QUERY_CLIENT = 'VUE_QUERY_CLIENT' @@ -19,18 +18,22 @@ export function updateState( } export function cloneDeep( - value: T, - customizer?: (val: unknown) => unknown | void, + value: MaybeRefDeep, + customizer?: (val: MaybeRefDeep) => T | undefined, ): T { if (customizer) { const result = customizer(value) - if (result !== undefined || isRef(value)) { - return result as typeof value + // If it's a ref of undefined, return undefined + if (result === undefined && isRef(value)) { + return result as T + } + if (result !== undefined) { + return result } } if (Array.isArray(value)) { - return value.map((val) => cloneDeep(val, customizer)) as typeof value + return value.map((val) => cloneDeep(val, customizer)) as unknown as T } if (typeof value === 'object' && isPlainObject(value)) { @@ -41,15 +44,17 @@ export function cloneDeep( return Object.fromEntries(entries) } - return value + return value as T } -export function cloneDeepUnref(obj: T): UnwrapRef { +export function cloneDeepUnref(obj: MaybeRefDeep): T { return cloneDeep(obj, (val) => { if (isRef(val)) { return cloneDeepUnref(unref(val)) } - }) as UnwrapRef + + return undefined + }) } function isPlainObject(value: unknown): value is Object {