@wagmi/vue 0.4.10 → 0.4.11

package/src/composables/useBlockNumber.ts

@@ -12,13 +12,11 @@ import type {
 import {
   type GetBlockNumberData,
   type GetBlockNumberOptions,
-  type GetBlockNumberQueryFnData,
-  type GetBlockNumberQueryKey,
   getBlockNumberQueryOptions,
 } from '@wagmi/core/query'
 import { computed } from 'vue'
 
-import type { ConfigParameter, QueryParameter } from '../types/properties.js'
+import type { ConfigParameter } from '../types/properties.js'
 import type { DeepMaybeRef, DeepUnwrapRef } from '../types/ref.js'
 import { deepUnref } from '../utils/cloneDeep.js'
 import { type UseQueryReturnType, useQuery } from '../utils/query.js'
@@ -36,14 +34,8 @@ export type UseBlockNumberParameters<
   selectData = GetBlockNumberData,
 > = Compute<
   DeepMaybeRef<
-    GetBlockNumberOptions<config, chainId> &
-      ConfigParameter<config> &
-      QueryParameter<
-        GetBlockNumberQueryFnData,
-        GetBlockNumberErrorType,
-        selectData,
-        GetBlockNumberQueryKey<config, chainId>
-      > & {
+    GetBlockNumberOptions<config, chainId, selectData> &
+      ConfigParameter<config> & {
         watch?:
           | boolean
           | UnionCompute<
@@ -67,54 +59,38 @@ export function useBlockNumber<
     config['chains'][number]['id'] = config['chains'][number]['id'],
   selectData = GetBlockNumberData,
 >(
-  parameters_: UseBlockNumberParameters<config, chainId, selectData> = {},
+  parameters: UseBlockNumberParameters<config, chainId, selectData> = {},
 ): UseBlockNumberReturnType<selectData> {
-  const parameters = computed(() => deepUnref(parameters_))
+  const params = computed(() => deepUnref(parameters))
+  const config = useConfig(params)
+  const chainId = useChainId({ config })
+  const options = computed(() =>
+    getBlockNumberQueryOptions(config as any, {
+      ...params.value,
+      chainId: params.value.chainId ?? chainId.value,
+      query: params.value.query,
+    }),
+  )
 
-  const config = useConfig(parameters)
   const queryClient = useQueryClient()
-  const configChainId = useChainId({ config })
-
-  const queryOptions = computed(() => {
-    const {
-      chainId = configChainId.value,
-      query = {},
-      watch: _,
-      ...rest
-    } = parameters.value
-    const options = getBlockNumberQueryOptions(config, {
-      ...deepUnref(rest),
-      chainId,
-    })
-    return {
-      ...query,
-      ...options,
-    }
-  })
-
   const watchBlockNumberArgs = computed(() => {
-    const {
-      config,
-      chainId = configChainId.value,
-      query,
-      watch,
-    } = parameters.value
     return {
       ...({
         config,
-        chainId,
-        ...(typeof watch === 'object' ? watch : {}),
+        chainId: params.value.chainId ?? chainId.value,
+        ...(typeof params.value.watch === 'object' ? params.value.watch : {}),
       } as UseWatchBlockNumberParameters),
       enabled:
-        (query?.enabled ?? true) &&
-        (typeof watch === 'object' ? watch.enabled : watch),
+        (params.value.query?.enabled ?? true) &&
+        (typeof params.value.watch === 'object'
+          ? params.value.watch.enabled
+          : params.value.watch),
       onBlockNumber(blockNumber) {
-        queryClient.setQueryData(queryOptions.value.queryKey, blockNumber)
+        queryClient.setQueryData(options.value.queryKey, blockNumber)
       },
     } satisfies UseWatchBlockNumberParameters
   })
-
   useWatchBlockNumber(watchBlockNumberArgs)
 
-  return useQuery(queryOptions as any) as UseBlockNumberReturnType<selectData>
+  return useQuery(options as any) as any
 }

package/src/composables/useBytecode.ts

@@ -4,15 +4,13 @@ import type {
   ResolvedRegister,
 } from '@wagmi/core'
 import type { Compute } from '@wagmi/core/internal'
-import type { GetBytecodeQueryFnData } from '@wagmi/core/query'
 import {
   type GetBytecodeData,
   type GetBytecodeOptions,
-  type GetBytecodeQueryKey,
   getBytecodeQueryOptions,
 } from '@wagmi/core/query'
 import { computed } from 'vue'
-import type { ConfigParameter, QueryParameter } from '../types/properties.js'
+import type { ConfigParameter } from '../types/properties.js'
 import type { DeepMaybeRef } from '../types/ref.js'
 import { deepUnref } from '../utils/cloneDeep.js'
 import { type UseQueryReturnType, useQuery } from '../utils/query.js'
@@ -23,16 +21,7 @@ export type UseBytecodeParameters<
   config extends Config = Config,
   selectData = GetBytecodeData,
 > = Compute<
-  DeepMaybeRef<
-    GetBytecodeOptions<config> &
-      ConfigParameter<config> &
-      QueryParameter<
-        GetBytecodeQueryFnData,
-        GetBytecodeErrorType,
-        selectData,
-        GetBytecodeQueryKey<config>
-      >
-  >
+  DeepMaybeRef<GetBytecodeOptions<config, selectData> & ConfigParameter<config>>
 >
 
 export type UseBytecodeReturnType<selectData = GetBytecodeData> =
@@ -43,28 +32,18 @@ export function useBytecode<
   config extends Config = ResolvedRegister['config'],
   selectData = GetBytecodeData,
 >(
-  parameters_: UseBytecodeParameters<config, selectData> = {},
+  parameters: UseBytecodeParameters<config, selectData> = {},
 ): UseBytecodeReturnType<selectData> {
-  const parameters = computed(() => deepUnref(parameters_))
-
-  const config = useConfig(parameters)
+  const params = computed(() => deepUnref(parameters))
+  const config = useConfig(params)
   const chainId = useChainId({ config })
-
-  const queryOptions = computed(() => {
-    const {
-      address: contractAddress,
-      chainId: parametersChainId,
-      query = {},
-    } = parameters.value
-
-    const options = getBytecodeQueryOptions(config, {
-      ...parameters.value,
-      address: contractAddress,
-      chainId: parametersChainId ?? chainId.value,
-    })
-    const enabled = Boolean(contractAddress && (query.enabled ?? true))
-    return { ...query, ...options, enabled }
-  })
-
-  return useQuery(queryOptions as any) as UseBytecodeReturnType<selectData>
+  const options = computed(() =>
+    getBytecodeQueryOptions(config as any, {
+      ...params.value,
+      address: params.value.address,
+      chainId: params.value.chainId ?? chainId.value,
+      query: params.value.query,
+    }),
+  )
+  return useQuery(options as any) as any
 }

package/src/composables/useConnectorClient.ts

@@ -5,24 +5,17 @@ import type {
   GetConnectorClientErrorType,
   ResolvedRegister,
 } from '@wagmi/core'
-import type { Compute, Omit } from '@wagmi/core/internal'
+import type { Compute } from '@wagmi/core/internal'
 import {
   type GetConnectorClientData,
   type GetConnectorClientOptions,
-  type GetConnectorClientQueryFnData,
-  type GetConnectorClientQueryKey,
   getConnectorClientQueryOptions,
 } from '@wagmi/core/query'
 import { computed, ref, watchEffect } from 'vue'
-
 import type { ConfigParameter } from '../types/properties.js'
-import type { DeepMaybeRef, DeepUnwrapRef } from '../types/ref.js'
+import type { DeepMaybeRef } from '../types/ref.js'
 import { deepUnref } from '../utils/cloneDeep.js'
-import {
-  type UseQueryParameters,
-  type UseQueryReturnType,
-  useQuery,
-} from '../utils/query.js'
+import { type UseQueryReturnType, useQuery } from '../utils/query.js'
 import { useChainId } from './useChainId.js'
 import { useConfig } from './useConfig.js'
 import { useConnection } from './useConnection.js'
@@ -34,24 +27,8 @@ export type UseConnectorClientParameters<
   selectData = GetConnectorClientData<config, chainId>,
 > = Compute<
   DeepMaybeRef<
-    GetConnectorClientOptions<config, chainId> &
-      ConfigParameter<config> & {
-        query?:
-          | Compute<
-              Omit<
-                DeepUnwrapRef<
-                  UseQueryParameters<
-                    GetConnectorClientQueryFnData<config, chainId>,
-                    GetConnectorClientErrorType,
-                    selectData,
-                    GetConnectorClientQueryKey<config, chainId>
-                  >
-                >,
-                'gcTime' | 'staleTime'
-              >
-            >
-          | undefined
-      }
+    GetConnectorClientOptions<config, chainId, selectData> &
+      ConfigParameter<config>
   >
 >
 
@@ -69,64 +46,33 @@ export function useConnectorClient<
     config['chains'][number]['id'] = config['chains'][number]['id'],
   selectData = GetConnectorClientData<config, chainId>,
 >(
-  parameters_: UseConnectorClientParameters<config, chainId, selectData> = {},
+  parameters: UseConnectorClientParameters<config, chainId, selectData> = {},
 ): UseConnectorClientReturnType<config, chainId, selectData> {
-  const parameters = computed(() => deepUnref(parameters_))
-
-  const config = useConfig(parameters)
-  const queryClient = useQueryClient()
-  const {
-    address,
-    connector: accountConnector,
-    status,
-  } = useConnection({ config })
-  const configChainId = useChainId({ config })
-
-  const queryOptions = computed(() => {
-    const {
-      chainId = configChainId.value,
-      connector = accountConnector.value,
-      query = {},
-    } = parameters.value
-    const { queryKey, ...options } = getConnectorClientQueryOptions<
-      config,
-      chainId
-    >(config as config, {
-      ...deepUnref(parameters),
-      chainId: chainId as chainId,
-      connector: connector as Connector,
-    })
-    const enabled = Boolean(
-      (status.value === 'connected' ||
-        (status.value === 'reconnecting' && connector?.getProvider)) &&
-        (query.enabled ?? true),
-    )
-    return {
-      ...query,
-      ...options,
-      queryKey,
-      enabled,
-      staleTime: Number.POSITIVE_INFINITY,
-    }
-  })
+  const params = computed(() => deepUnref(parameters))
+  const config = useConfig(params)
+  const chainId = useChainId({ config })
+  const { address, connector } = useConnection({ config })
+  const options = computed(() =>
+    getConnectorClientQueryOptions(config as any, {
+      ...params.value,
+      chainId: params.value.chainId ?? chainId.value,
+      connector: (params.value.connector ?? connector.value) as Connector,
+      query: params.value.query as any,
+    }),
+  )
 
   const addressRef = ref(address)
+  const queryClient = useQueryClient()
   watchEffect(() => {
     const previousAddress = addressRef.value
     if (!address && previousAddress) {
-      // remove when account is disconnected
-      queryClient.removeQueries({ queryKey: queryOptions.value.queryKey })
+      queryClient.removeQueries({ queryKey: options.value.queryKey })
       addressRef.value = undefined
     } else if (address.value !== previousAddress) {
-      // invalidate when address changes
-      queryClient.invalidateQueries({ queryKey: queryOptions.value.queryKey })
+      queryClient.invalidateQueries({ queryKey: options.value.queryKey })
       addressRef.value = address.value
     }
   })
 
-  return useQuery(queryOptions as any) as UseConnectorClientReturnType<
-    config,
-    chainId,
-    selectData
-  >
+  return useQuery(options as any) as any
 }

package/src/composables/useEnsAddress.ts

@@ -7,13 +7,10 @@ import type { Compute } from '@wagmi/core/internal'
 import {
   type GetEnsAddressData,
   type GetEnsAddressOptions,
-  type GetEnsAddressQueryFnData,
-  type GetEnsAddressQueryKey,
   getEnsAddressQueryOptions,
 } from '@wagmi/core/query'
 import { computed } from 'vue'
-
-import type { ConfigParameter, QueryParameter } from '../types/properties.js'
+import type { ConfigParameter } from '../types/properties.js'
 import type { DeepMaybeRef } from '../types/ref.js'
 import { deepUnref } from '../utils/cloneDeep.js'
 import { type UseQueryReturnType, useQuery } from '../utils/query.js'
@@ -25,14 +22,7 @@ export type UseEnsAddressParameters<
   selectData = GetEnsAddressData,
 > = Compute<
   DeepMaybeRef<
-    GetEnsAddressOptions<config> &
-      ConfigParameter<config> &
-      QueryParameter<
-        GetEnsAddressQueryFnData,
-        GetEnsAddressErrorType,
-        selectData,
-        GetEnsAddressQueryKey<config>
-      >
+    GetEnsAddressOptions<config, selectData> & ConfigParameter<config>
   >
 >
 
@@ -44,22 +34,17 @@ export function useEnsAddress<
   config extends Config = ResolvedRegister['config'],
   selectData = GetEnsAddressData,
 >(
-  parameters_: UseEnsAddressParameters<config, selectData> = {},
+  parameters: UseEnsAddressParameters<config, selectData> = {},
 ): UseEnsAddressReturnType<selectData> {
-  const parameters = computed(() => deepUnref(parameters_))
-
-  const config = useConfig(parameters)
-  const configChainId = useChainId({ config })
-
-  const queryOptions = computed(() => {
-    const { chainId = configChainId.value, name, query = {} } = parameters.value
-    const options = getEnsAddressQueryOptions(config, {
-      ...parameters.value,
-      chainId,
-    })
-    const enabled = Boolean(name && (query.enabled ?? true))
-    return { ...query, ...options, enabled }
-  })
-
-  return useQuery(queryOptions as any) as UseEnsAddressReturnType<selectData>
+  const params = computed(() => deepUnref(parameters))
+  const config = useConfig(params)
+  const chainId = useChainId({ config })
+  const options = computed(() =>
+    getEnsAddressQueryOptions(config as any, {
+      ...params.value,
+      chainId: params.value.chainId ?? chainId.value,
+      query: params.value.query,
+    }),
+  )
+  return useQuery(options as any) as any
 }

package/src/composables/useEnsAvatar.ts

@@ -7,13 +7,10 @@ import type { Compute } from '@wagmi/core/internal'
 import {
   type GetEnsAvatarData,
   type GetEnsAvatarOptions,
-  type GetEnsAvatarQueryFnData,
-  type GetEnsAvatarQueryKey,
   getEnsAvatarQueryOptions,
 } from '@wagmi/core/query'
 import { computed } from 'vue'
-
-import type { ConfigParameter, QueryParameter } from '../types/properties.js'
+import type { ConfigParameter } from '../types/properties.js'
 import type { DeepMaybeRef } from '../types/ref.js'
 import { deepUnref } from '../utils/cloneDeep.js'
 import { type UseQueryReturnType, useQuery } from '../utils/query.js'
@@ -25,14 +22,7 @@ export type UseEnsAvatarParameters<
   selectData = GetEnsAvatarData,
 > = Compute<
   DeepMaybeRef<
-    GetEnsAvatarOptions<config> &
-      ConfigParameter<config> &
-      QueryParameter<
-        GetEnsAvatarQueryFnData,
-        GetEnsAvatarErrorType,
-        selectData,
-        GetEnsAvatarQueryKey<config>
-      >
+    GetEnsAvatarOptions<config, selectData> & ConfigParameter<config>
   >
 >
 
@@ -44,22 +34,17 @@ export function useEnsAvatar<
   config extends Config = ResolvedRegister['config'],
   selectData = GetEnsAvatarData,
 >(
-  parameters_: UseEnsAvatarParameters<config, selectData> = {},
+  parameters: UseEnsAvatarParameters<config, selectData> = {},
 ): UseEnsAvatarReturnType<selectData> {
-  const parameters = computed(() => deepUnref(parameters_))
-
-  const config = useConfig(parameters)
-  const configChainId = useChainId({ config })
-
-  const queryOptions = computed(() => {
-    const { chainId = configChainId.value, name, query = {} } = parameters.value
-    const options = getEnsAvatarQueryOptions(config, {
-      ...parameters.value,
-      chainId,
-    })
-    const enabled = Boolean(name && (query.enabled ?? true))
-    return { ...query, ...options, enabled }
-  })
-
-  return useQuery(queryOptions as any) as UseEnsAvatarReturnType<selectData>
+  const params = computed(() => deepUnref(parameters))
+  const config = useConfig(params)
+  const chainId = useChainId({ config })
+  const options = computed(() =>
+    getEnsAvatarQueryOptions(config as any, {
+      ...params.value,
+      chainId: params.value.chainId ?? chainId.value,
+      query: params.value.query,
+    }),
+  )
+  return useQuery(options as any) as any
 }

package/src/composables/useEnsName.ts

@@ -3,13 +3,10 @@ import type { Compute } from '@wagmi/core/internal'
 import {
   type GetEnsNameData,
   type GetEnsNameOptions,
-  type GetEnsNameQueryFnData,
-  type GetEnsNameQueryKey,
   getEnsNameQueryOptions,
 } from '@wagmi/core/query'
-
 import { computed } from 'vue'
-import type { ConfigParameter, QueryParameter } from '../types/properties.js'
+import type { ConfigParameter } from '../types/properties.js'
 import type { DeepMaybeRef } from '../types/ref.js'
 import { deepUnref } from '../utils/cloneDeep.js'
 import { type UseQueryReturnType, useQuery } from '../utils/query.js'
@@ -20,16 +17,7 @@ export type UseEnsNameParameters<
   config extends Config = Config,
   selectData = GetEnsNameData,
 > = Compute<
-  DeepMaybeRef<
-    GetEnsNameOptions<config> &
-      ConfigParameter<config> &
-      QueryParameter<
-        GetEnsNameQueryFnData,
-        GetEnsNameErrorType,
-        selectData,
-        GetEnsNameQueryKey<config>
-      >
-  >
+  DeepMaybeRef<GetEnsNameOptions<config, selectData> & ConfigParameter<config>>
 >
 
 export type UseEnsNameReturnType<selectData = GetEnsNameData> =
@@ -40,26 +28,18 @@ export function useEnsName<
   config extends Config = ResolvedRegister['config'],
   selectData = GetEnsNameData,
 >(
-  parameters_: UseEnsNameParameters<config, selectData> = {},
+  parameters: UseEnsNameParameters<config, selectData> = {},
 ): UseEnsNameReturnType<selectData> {
-  const parameters = computed(() => deepUnref(parameters_))
-
-  const config = useConfig(parameters)
-  const configChainId = useChainId({ config })
-
-  const queryOptions = computed(() => {
-    const {
-      address,
-      chainId = configChainId.value,
-      query = {},
-    } = parameters.value
-    const options = getEnsNameQueryOptions(config, {
-      ...parameters.value,
-      chainId,
-    })
-    const enabled = Boolean(address && (query.enabled ?? true))
-    return { ...query, ...options, enabled }
-  })
-
-  return useQuery(queryOptions as any) as UseEnsNameReturnType<selectData>
+  const params = computed(() => deepUnref(parameters))
+  const config = useConfig(params)
+  const chainId = useChainId({ config })
+  const options = computed(() =>
+    getEnsNameQueryOptions(config as any, {
+      ...params.value,
+      address: params.value.address,
+      chainId: params.value.chainId ?? chainId.value,
+      query: params.value.query,
+    }),
+  )
+  return useQuery(options as any) as any
 }

package/src/composables/useEstimateGas.ts

@@ -6,33 +6,23 @@ import type {
 import {
   type EstimateGasData,
   type EstimateGasOptions,
-  type EstimateGasQueryFnData,
-  type EstimateGasQueryKey,
   estimateGasQueryOptions,
 } from '@wagmi/core/query'
 import { computed } from 'vue'
-
-import type { ConfigParameter, QueryParameter } from '../types/properties.js'
+import type { ConfigParameter } from '../types/properties.js'
 import type { DeepMaybeRef } from '../types/ref.js'
 import { deepUnref } from '../utils/cloneDeep.js'
 import { type UseQueryReturnType, useQuery } from '../utils/query.js'
 import { useChainId } from './useChainId.js'
 import { useConfig } from './useConfig.js'
-import { useConnectorClient } from './useConnectorClient.js'
+import { useConnection } from './useConnection.js'
 
 export type UseEstimateGasParameters<
   config extends Config = Config,
   chainId extends config['chains'][number]['id'] | undefined = undefined,
   selectData = EstimateGasData,
 > = DeepMaybeRef<
-  EstimateGasOptions<config, chainId> &
-    ConfigParameter<config> &
-    QueryParameter<
-      EstimateGasQueryFnData,
-      EstimateGasErrorType,
-      selectData,
-      EstimateGasQueryKey<config, chainId>
-    >
+  EstimateGasOptions<config, chainId, selectData> & ConfigParameter<config>
 >
 
 export type UseEstimateGasReturnType<selectData = EstimateGasData> =
@@ -48,36 +38,20 @@ export function useEstimateGas<
 ): UseEstimateGasReturnType<selectData>
 
 export function useEstimateGas(
-  parameters_: UseEstimateGasParameters = {},
+  parameters: UseEstimateGasParameters = {},
 ): UseEstimateGasReturnType {
-  const parameters = computed(() => deepUnref(parameters_))
-
-  const config = useConfig(parameters)
-  const { data: connectorClient } = useConnectorClient(
-    computed(() => ({
-      connector: parameters.value.connector,
-      query: { enabled: parameters.value.account === undefined },
-    })),
+  const params = computed(() => deepUnref(parameters))
+  const config = useConfig(params)
+  const { address, connector } = useConnection({ config })
+  const chainId = useChainId({ config })
+  const options = computed(() =>
+    estimateGasQueryOptions(config as any, {
+      ...params.value,
+      account: params.value.account ?? address.value,
+      chainId: params.value.chainId ?? chainId.value,
+      connector: params.value.connector ?? connector.value,
+      query: params.value.query,
+    }),
   )
-
-  const configChainId = useChainId({ config })
-
-  const queryOptions = computed(() => {
-    const {
-      account = connectorClient?.value?.account,
-      chainId = configChainId.value,
-      connector,
-      query = {},
-    } = parameters.value
-    const options = estimateGasQueryOptions(config, {
-      ...parameters.value,
-      account,
-      chainId,
-      connector,
-    })
-    const enabled = Boolean((account || connector) && (query.enabled ?? true))
-    return { ...query, ...options, enabled }
-  })
-
-  return useQuery(queryOptions)
+  return useQuery(options as any) as any
 }