@wagmi/vue 0.4.12 → 0.4.13

package/src/composables/useReconnect.ts

@@ -1,32 +1,19 @@
-import { useMutation } from '@tanstack/vue-query'
 import type { Connector, ReconnectErrorType } from '@wagmi/core'
 import type { Compute } from '@wagmi/core/internal'
 import {
   type ReconnectData,
   type ReconnectMutate,
   type ReconnectMutateAsync,
+  type ReconnectOptions,
   type ReconnectVariables,
   reconnectMutationOptions,
 } from '@wagmi/core/query'
-
 import type { ConfigParameter } from '../types/properties.js'
-import type {
-  UseMutationParameters,
-  UseMutationReturnType,
-} from '../utils/query.js'
+import { type UseMutationReturnType, useMutation } from '../utils/query.js'
 import { useConfig } from './useConfig.js'
 
 export type UseReconnectParameters<context = unknown> = Compute<
-  ConfigParameter & {
-    mutation?:
-      | UseMutationParameters<
-          ReconnectData,
-          ReconnectErrorType,
-          ReconnectVariables,
-          context
-        >
-      | undefined
-  }
+  ConfigParameter & ReconnectOptions<context>
 >
 
 export type UseReconnectReturnType<context = unknown> = Compute<
@@ -51,12 +38,13 @@ export function useReconnect<context = unknown>(
   parameters: UseReconnectParameters<context> = {},
 ): UseReconnectReturnType<context> {
   const config = useConfig(parameters)
-  const mutationOptions = reconnectMutationOptions(config)
-  const mutation = useMutation({ ...parameters.mutation, ...mutationOptions })
+  const options = reconnectMutationOptions(config, parameters as any)
+  const mutation = useMutation(options)
+  type Return = UseReconnectReturnType<context>
   return {
-    ...mutation,
+    ...(mutation as Return),
     connectors: config.connectors,
-    reconnect: mutation.mutate,
-    reconnectAsync: mutation.mutateAsync,
+    reconnect: mutation.mutate as Return['mutate'],
+    reconnectAsync: mutation.mutateAsync as Return['mutateAsync'],
   }
 }

package/src/composables/useSendTransaction.ts

@@ -9,32 +9,18 @@ import {
   type SendTransactionData,
   type SendTransactionMutate,
   type SendTransactionMutateAsync,
+  type SendTransactionOptions,
   type SendTransactionVariables,
   sendTransactionMutationOptions,
 } from '@wagmi/core/query'
-
 import type { ConfigParameter } from '../types/properties.js'
-import type {
-  UseMutationParameters,
-  UseMutationReturnType,
-} from '../utils/query.js'
+import type { UseMutationReturnType } from '../utils/query.js'
 import { useConfig } from './useConfig.js'
 
 export type UseSendTransactionParameters<
   config extends Config = Config,
   context = unknown,
-> = Compute<
-  ConfigParameter<config> & {
-    mutation?:
-      | UseMutationParameters<
-          SendTransactionData,
-          SendTransactionErrorType,
-          SendTransactionVariables<config, config['chains'][number]['id']>,
-          context
-        >
-      | undefined
-  }
->
+> = Compute<ConfigParameter<config> & SendTransactionOptions<config, context>>
 
 export type UseSendTransactionReturnType<
   config extends Config = Config,
@@ -44,10 +30,10 @@ export type UseSendTransactionReturnType<
     SendTransactionData,
     SendTransactionErrorType,
     SendTransactionVariables<config, config['chains'][number]['id']>,
-    context
+    context,
+    SendTransactionMutate<config, context>,
+    SendTransactionMutateAsync<config, context>
   > & {
-    mutate: SendTransactionMutate<config, context>
-    mutateAsync: SendTransactionMutateAsync<config, context>
     /** @deprecated use `mutate` instead */
     sendTransaction: SendTransactionMutate<config, context>
     /** @deprecated use `mutateAsync` instead */
@@ -63,11 +49,11 @@ export function useSendTransaction<
   parameters: UseSendTransactionParameters<config, context> = {},
 ): UseSendTransactionReturnType<config, context> {
   const config = useConfig(parameters)
-  const mutationOptions = sendTransactionMutationOptions(config)
-  const mutation = useMutation({ ...parameters.mutation, ...mutationOptions })
+  const options = sendTransactionMutationOptions(config, parameters)
+  const mutation = useMutation(options)
   type Return = UseSendTransactionReturnType<config, context>
   return {
-    ...mutation,
+    ...(mutation as Return),
     sendTransaction: mutation.mutate as Return['mutate'],
     sendTransactionAsync: mutation.mutateAsync as Return['mutateAsync'],
   }

package/src/composables/useSignMessage.ts

@@ -4,29 +4,16 @@ import {
   type SignMessageData,
   type SignMessageMutate,
   type SignMessageMutateAsync,
+  type SignMessageOptions,
   type SignMessageVariables,
   signMessageMutationOptions,
 } from '@wagmi/core/query'
-
 import type { ConfigParameter } from '../types/properties.js'
-import {
-  type UseMutationParameters,
-  type UseMutationReturnType,
-  useMutation,
-} from '../utils/query.js'
+import { type UseMutationReturnType, useMutation } from '../utils/query.js'
 import { useConfig } from './useConfig.js'
 
 export type UseSignMessageParameters<context = unknown> = Compute<
-  ConfigParameter & {
-    mutation?:
-      | UseMutationParameters<
-          SignMessageData,
-          SignMessageErrorType,
-          SignMessageVariables,
-          context
-        >
-      | undefined
-  }
+  ConfigParameter & SignMessageOptions<context>
 >
 
 export type UseSignMessageReturnType<context = unknown> = Compute<
@@ -34,10 +21,10 @@ export type UseSignMessageReturnType<context = unknown> = Compute<
     SignMessageData,
     SignMessageErrorType,
     SignMessageVariables,
-    context
+    context,
+    SignMessageMutate<context>,
+    SignMessageMutateAsync<context>
   > & {
-    mutate: SignMessageMutate<context>
-    mutateAsync: SignMessageMutateAsync<context>
     /** @deprecated use `mutate` instead */
     signMessage: SignMessageMutate<context>
     /** @deprecated use `mutateAsync` instead */
@@ -50,11 +37,12 @@ export function useSignMessage<context = unknown>(
   parameters: UseSignMessageParameters<context> = {},
 ): UseSignMessageReturnType<context> {
   const config = useConfig(parameters)
-  const mutationOptions = signMessageMutationOptions(config)
-  const mutation = useMutation({ ...parameters.mutation, ...mutationOptions })
+  const options = signMessageMutationOptions(config, parameters)
+  const mutation = useMutation(options)
+  type Return = UseSignMessageReturnType<context>
   return {
-    ...mutation,
-    signMessage: mutation.mutate,
-    signMessageAsync: mutation.mutateAsync,
+    ...(mutation as Return),
+    signMessage: mutation.mutate as Return['mutate'],
+    signMessageAsync: mutation.mutateAsync as Return['mutateAsync'],
   }
 }

package/src/composables/useSignTypedData.ts

@@ -4,29 +4,16 @@ import {
   type SignTypedDataData,
   type SignTypedDataMutate,
   type SignTypedDataMutateAsync,
+  type SignTypedDataOptions,
   type SignTypedDataVariables,
   signTypedDataMutationOptions,
 } from '@wagmi/core/query'
-
 import type { ConfigParameter } from '../types/properties.js'
-import {
-  type UseMutationParameters,
-  type UseMutationReturnType,
-  useMutation,
-} from '../utils/query.js'
+import { type UseMutationReturnType, useMutation } from '../utils/query.js'
 import { useConfig } from './useConfig.js'
 
 export type UseSignTypedDataParameters<context = unknown> = Compute<
-  ConfigParameter & {
-    mutation?:
-      | UseMutationParameters<
-          SignTypedDataData,
-          SignTypedDataErrorType,
-          SignTypedDataVariables,
-          context
-        >
-      | undefined
-  }
+  ConfigParameter & SignTypedDataOptions<context>
 >
 
 export type UseSignTypedDataReturnType<context = unknown> = Compute<
@@ -34,10 +21,10 @@ export type UseSignTypedDataReturnType<context = unknown> = Compute<
     SignTypedDataData,
     SignTypedDataErrorType,
     SignTypedDataVariables,
-    context
+    context,
+    SignTypedDataMutate<context>,
+    SignTypedDataMutateAsync<context>
   > & {
-    mutate: SignTypedDataMutate<context>
-    mutateAsync: SignTypedDataMutateAsync<context>
     /** @deprecated use `mutate` instead */
     signTypedData: SignTypedDataMutate<context>
     /** @deprecated use `mutateAsync` instead */
@@ -50,13 +37,11 @@ export function useSignTypedData<context = unknown>(
   parameters: UseSignTypedDataParameters<context> = {},
 ): UseSignTypedDataReturnType<context> {
   const config = useConfig(parameters)
-  const mutationOptions = signTypedDataMutationOptions(config)
-  const mutation = useMutation({ ...parameters.mutation, ...mutationOptions })
+  const options = signTypedDataMutationOptions(config, parameters)
+  const mutation = useMutation(options)
   type Return = UseSignTypedDataReturnType<context>
   return {
-    ...mutation,
-    mutate: mutation.mutate as Return['mutate'],
-    mutateAsync: mutation.mutateAsync as Return['mutateAsync'],
+    ...(mutation as Return),
     signTypedData: mutation.mutate as Return['mutate'],
     signTypedDataAsync: mutation.mutateAsync as Return['mutateAsync'],
   }

package/src/composables/useSwitchChain.ts

@@ -1,4 +1,3 @@
-import { useMutation } from '@tanstack/vue-query'
 import type {
   Config,
   ResolvedRegister,
@@ -9,34 +8,20 @@ import {
   type SwitchChainData,
   type SwitchChainMutate,
   type SwitchChainMutateAsync,
+  type SwitchChainOptions,
   type SwitchChainVariables,
   switchChainMutationOptions,
 } from '@wagmi/core/query'
 import type { Ref } from 'vue'
-
 import type { ConfigParameter } from '../types/properties.js'
-import type {
-  UseMutationParameters,
-  UseMutationReturnType,
-} from '../utils/query.js'
+import { type UseMutationReturnType, useMutation } from '../utils/query.js'
 import { useChains } from './useChains.js'
 import { useConfig } from './useConfig.js'
 
 export type UseSwitchChainParameters<
   config extends Config = Config,
   context = unknown,
-> = Compute<
-  ConfigParameter<config> & {
-    mutation?:
-      | UseMutationParameters<
-          SwitchChainData<config, config['chains'][number]['id']>,
-          SwitchChainErrorType,
-          SwitchChainVariables<config, config['chains'][number]['id']>,
-          context
-        >
-      | undefined
-  }
->
+> = Compute<ConfigParameter<config> & SwitchChainOptions<config, context>>
 
 export type UseSwitchChainReturnType<
   config extends Config = Config,
@@ -67,14 +52,12 @@ export function useSwitchChain<
   parameters: UseSwitchChainParameters<config, context> = {},
 ): UseSwitchChainReturnType<config, context> {
   const config = useConfig(parameters)
-  const mutationOptions = switchChainMutationOptions(config)
-  const mutation = useMutation({ ...parameters.mutation, ...mutationOptions })
+  const options = switchChainMutationOptions(config, parameters as any)
+  const mutation = useMutation(options)
   type Return = UseSwitchChainReturnType<config, context>
   return {
     ...(mutation as unknown as Return),
     chains: useChains({ config }) as unknown as Ref<config['chains']>,
-    mutate: mutation.mutate as Return['mutate'],
-    mutateAsync: mutation.mutateAsync as Return['mutateAsync'],
     switchChain: mutation.mutate as Return['mutate'],
     switchChainAsync: mutation.mutateAsync as Return['mutateAsync'],
   }

package/src/composables/useSwitchConnection.ts

@@ -1,4 +1,3 @@
-import { useMutation } from '@tanstack/vue-query'
 import type {
   Config,
   Connector,
@@ -10,34 +9,21 @@ import {
   type SwitchConnectionData,
   type SwitchConnectionMutate,
   type SwitchConnectionMutateAsync,
+  type SwitchConnectionOptions,
   type SwitchConnectionVariables,
   switchConnectionMutationOptions,
 } from '@wagmi/core/query'
 import { computed, type Ref } from 'vue'
 
 import type { ConfigParameter } from '../types/properties.js'
-import type {
-  UseMutationParameters,
-  UseMutationReturnType,
-} from '../utils/query.js'
+import { type UseMutationReturnType, useMutation } from '../utils/query.js'
 import { useConfig } from './useConfig.js'
 import { useConnections } from './useConnections.js'
 
 export type UseSwitchConnectionParameters<
   config extends Config = Config,
   context = unknown,
-> = Compute<
-  ConfigParameter<config> & {
-    mutation?:
-      | UseMutationParameters<
-          SwitchConnectionData<config>,
-          SwitchConnectionErrorType,
-          SwitchConnectionVariables,
-          context
-        >
-      | undefined
-  }
->
+> = Compute<ConfigParameter<config> & SwitchConnectionOptions<config, context>>
 
 export type UseSwitchConnectionReturnType<
   config extends Config = Config,
@@ -73,18 +59,17 @@ export function useSwitchConnection<
 ): UseSwitchConnectionReturnType<config, context> {
   const config = useConfig(parameters)
   const connections = useConnections({ config })
-  const mutationOptions = switchConnectionMutationOptions(config)
-  const mutation = useMutation({ ...parameters.mutation, ...mutationOptions })
+  const options = switchConnectionMutationOptions(config, parameters as any)
+  const mutation = useMutation(options)
+  type Return = UseSwitchConnectionReturnType<config, context>
   return {
-    ...mutation,
+    ...(mutation as Return),
     connectors: computed(() =>
       connections.value.map((connection) => connection.connector),
     ),
-    mutate: mutation.mutate,
-    mutateAsync: mutation.mutateAsync,
-    switchAccount: mutation.mutate,
-    switchAccountAsync: mutation.mutateAsync,
-    switchConnection: mutation.mutate,
-    switchConnectionAsync: mutation.mutateAsync,
+    switchAccount: mutation.mutate as Return['mutate'],
+    switchAccountAsync: mutation.mutateAsync as Return['mutateAsync'],
+    switchConnection: mutation.mutate as Return['mutate'],
+    switchConnectionAsync: mutation.mutateAsync as Return['mutateAsync'],
   }
 }

package/src/composables/useWriteContract.ts

@@ -8,37 +8,19 @@ import {
   type WriteContractData,
   type WriteContractMutate,
   type WriteContractMutateAsync,
+  type WriteContractOptions,
   type WriteContractVariables,
   writeContractMutationOptions,
 } from '@wagmi/core/query'
 import type { Abi } from 'viem'
-
 import type { ConfigParameter } from '../types/properties.js'
-import type {
-  UseMutationParameters,
-  UseMutationReturnType,
-} from '../utils/query.js'
+import type { UseMutationReturnType } from '../utils/query.js'
 import { useConfig } from './useConfig.js'
 
 export type UseWriteContractParameters<
   config extends Config = Config,
   context = unknown,
-> = ConfigParameter<config> & {
-  mutation?:
-    | UseMutationParameters<
-        WriteContractData,
-        WriteContractErrorType,
-        WriteContractVariables<
-          Abi,
-          string,
-          readonly unknown[],
-          config,
-          config['chains'][number]['id']
-        >,
-        context
-      >
-    | undefined
-}
+> = ConfigParameter<config> & WriteContractOptions<config, context>
 
 export type UseWriteContractReturnType<
   config extends Config = Config,
@@ -53,10 +35,10 @@ export type UseWriteContractReturnType<
     config,
     config['chains'][number]['id']
   >,
-  context
+  context,
+  WriteContractMutate<config, context>,
+  WriteContractMutateAsync<config, context>
 > & {
-  mutate: WriteContractMutate<config, context>
-  mutateAsync: WriteContractMutateAsync<config, context>
   /** @deprecated use `mutate` instead */
   writeContract: WriteContractMutate<config, context>
   /** @deprecated use `mutateAsync` instead */
@@ -71,13 +53,11 @@ export function useWriteContract<
   parameters: UseWriteContractParameters<config, context> = {},
 ): UseWriteContractReturnType<config, context> {
   const config = useConfig(parameters)
-  const mutationOptions = writeContractMutationOptions(config)
-  const mutation = useMutation({ ...parameters.mutation, ...mutationOptions })
+  const options = writeContractMutationOptions(config, parameters)
+  const mutation = useMutation(options)
   type Return = UseWriteContractReturnType<config, context>
   return {
     ...(mutation as Return),
-    mutate: mutation.mutate as Return['mutate'],
-    mutateAsync: mutation.mutateAsync as Return['mutateAsync'],
     writeContract: mutation.mutate as Return['mutate'],
     writeContractAsync: mutation.mutateAsync as Return['mutateAsync'],
   }

package/src/errors/plugin.ts

@@ -9,7 +9,7 @@ export class WagmiPluginNotFoundError extends BaseError {
     super(
       'No `config` found in Vue context, use `WagmiPlugin` to properly initialize the library.',
       {
-        docsPath: '/api/TODO',
+        docsPath: '/api/Nuxt',
       },
     )
   }
@@ -24,7 +24,7 @@ export class WagmiInjectionContextError extends BaseError {
     super(
       'Wagmi composables can only be used inside `setup()` function or functions that support injection context.',
       {
-        docsPath: '/api/TODO',
+        docsPath: '/api/Nuxt',
       },
     )
   }

package/src/utils/query.ts

@@ -1,5 +1,6 @@
 import {
   type DefaultError,
+  type MutateFunction,
   type MutationObserverOptions,
   type QueryKey,
   type UseMutationReturnType as tanstack_UseMutationReturnType,
@@ -19,6 +20,8 @@ import { computed, type MaybeRef, unref } from 'vue'
 
 import type { DeepMaybeRef, DeepUnwrapRef } from '../types/ref.js'
 
+export { useMutation }
+
 export type UseMutationParameters<
   data = unknown,
   error = Error,
@@ -40,17 +43,39 @@ export type UseMutationReturnType<
   error = Error,
   variables = void,
   context = unknown,
+  mutate = MutateFunction,
+  mutateAsync = MutateFunction,
 > = Compute<
   UnionStrictOmit<
     tanstack_UseMutationReturnType<data, error, variables, context>,
     'mutate' | 'mutateAsync'
-  >
+  > & {
+    mutate: mutate
+    mutateAsync: mutateAsync
+  }
 >
 
-export { useMutation }
-
 ////////////////////////////////////////////////////////////////////////////////
 
+// Adding some basic customization.
+// Ideally we don't have this function, but `import('@tanstack/vue-query').useQuery` currently has some quirks where it is super hard to
+// pass down the inferred `initialData` type because of it's discriminated overload in the on `useQuery`.
+export function useQuery<queryFnData, error, data, queryKey extends QueryKey>(
+  parameters: MaybeRef<
+    UseQueryParameters<queryFnData, error, data, queryKey> & {
+      queryKey: QueryKey
+    }
+  >,
+): UseQueryReturnType<data, error> {
+  const options = computed(() => ({
+    ...(unref(parameters) as any),
+    queryKeyHashFn: hashFn,
+  }))
+  const result = tanstack_useQuery(options) as UseQueryReturnType<data, error>
+  result.queryKey = unref(options).queryKey as QueryKey
+  return result
+}
+
 export type UseQueryParameters<
   queryFnData = unknown,
   error = DefaultError,
@@ -81,81 +106,3 @@ export type UseQueryReturnType<data = unknown, error = DefaultError> = Compute<
     queryKey: QueryKey
   }
 >
-
-// Adding some basic customization.
-// Ideally we don't have this function, but `import('@tanstack/vue-query').useQuery` currently has some quirks where it is super hard to
-// pass down the inferred `initialData` type because of it's discriminated overload in the on `useQuery`.
-export function useQuery<queryFnData, error, data, queryKey extends QueryKey>(
-  parameters: MaybeRef<
-    UseQueryParameters<queryFnData, error, data, queryKey> & {
-      queryKey: QueryKey
-    }
-  >,
-): UseQueryReturnType<data, error> {
-  const options = computed(() => ({
-    ...(unref(parameters) as any),
-    queryKeyHashFn: hashFn,
-  }))
-  const result = tanstack_useQuery(options) as UseQueryReturnType<data, error>
-  result.queryKey = unref(options).queryKey as QueryKey
-  return result
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-// export type UseInfiniteQueryParameters<
-//   queryFnData = unknown,
-//   error = DefaultError,
-//   data = queryFnData,
-//   queryData = queryFnData,
-//   queryKey extends QueryKey = QueryKey,
-//   pageParam = unknown,
-// > = Compute<
-//   Omit<
-//     UseInfiniteQueryOptions<
-//       queryFnData,
-//       error,
-//       data,
-//       queryData,
-//       queryKey,
-//       pageParam
-//     >,
-//     'initialData'
-//   > & {
-//     // Fix `initialData` type
-//     initialData?:
-//       | UseInfiniteQueryOptions<
-//           queryFnData,
-//           error,
-//           data,
-//           queryKey
-//         >['initialData']
-//       | undefined
-//   }
-// >
-
-// export type UseInfiniteQueryReturnType<
-//   data = unknown,
-//   error = DefaultError,
-// > = import('@tanstack/vue-query').UseInfiniteQueryReturnType<data, error> & {
-//   queryKey: QueryKey
-// }
-
-// // Adding some basic customization.
-// export function useInfiniteQuery<
-//   queryFnData,
-//   error,
-//   data,
-//   queryKey extends QueryKey,
-// >(
-//   parameters: UseInfiniteQueryParameters<queryFnData, error, data, queryKey> & {
-//     queryKey: QueryKey
-//   },
-// ): UseInfiniteQueryReturnType<data, error> {
-//   const result = tanstack_useInfiniteQuery({
-//     ...(parameters as any),
-//     queryKeyHashFn: hashFn, // for bigint support
-//   }) as UseInfiniteQueryReturnType<data, error>
-//   result.queryKey = parameters.queryKey
-//   return result
-// }

package/src/version.ts

@@ -1 +1 @@
-export const version = '0.4.12'
+export const version = '0.4.13'