@wagmi/vue 0.0.1 → 0.0.2

package/src/composables/useEnsAddress.ts

@@ -0,0 +1,65 @@
+import type {
+  Config,
+  GetEnsAddressErrorType,
+  ResolvedRegister,
+} from '@wagmi/core'
+import { type Evaluate } 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 { 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'
+
+export type UseEnsAddressParameters<
+  config extends Config = Config,
+  selectData = GetEnsAddressData,
+> = Evaluate<
+  DeepMaybeRef<
+    GetEnsAddressOptions<config> &
+      ConfigParameter<config> &
+      QueryParameter<
+        GetEnsAddressQueryFnData,
+        GetEnsAddressErrorType,
+        selectData,
+        GetEnsAddressQueryKey<config>
+      >
+  >
+>
+
+export type UseEnsAddressReturnType<selectData = GetEnsAddressData> =
+  UseQueryReturnType<selectData, GetEnsAddressErrorType>
+
+/** https://wagmi.sh/vue/api/composables/useEnsAddress */
+export function useEnsAddress<
+  config extends Config = ResolvedRegister['config'],
+  selectData = GetEnsAddressData,
+>(
+  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>
+}

package/src/composables/useEnsAvatar.ts

@@ -0,0 +1,65 @@
+import type {
+  Config,
+  GetEnsAvatarErrorType,
+  ResolvedRegister,
+} from '@wagmi/core'
+import { type Evaluate } 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 { 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'
+
+export type UseEnsAvatarParameters<
+  config extends Config = Config,
+  selectData = GetEnsAvatarData,
+> = Evaluate<
+  DeepMaybeRef<
+    GetEnsAvatarOptions<config> &
+      ConfigParameter<config> &
+      QueryParameter<
+        GetEnsAvatarQueryFnData,
+        GetEnsAvatarErrorType,
+        selectData,
+        GetEnsAvatarQueryKey<config>
+      >
+  >
+>
+
+export type UseEnsAvatarReturnType<selectData = GetEnsAvatarData> =
+  UseQueryReturnType<selectData, GetEnsAvatarErrorType>
+
+/** https://wagmi.sh/vue/api/composables/useEnsAvatar */
+export function useEnsAvatar<
+  config extends Config = ResolvedRegister['config'],
+  selectData = GetEnsAvatarData,
+>(
+  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>
+}

package/src/composables/useEnsName.ts

@@ -0,0 +1,65 @@
+import type { Config, GetEnsNameErrorType, ResolvedRegister } from '@wagmi/core'
+import { type Evaluate } 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 { 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'
+
+export type UseEnsNameParameters<
+  config extends Config = Config,
+  selectData = GetEnsNameData,
+> = Evaluate<
+  DeepMaybeRef<
+    GetEnsNameOptions<config> &
+      ConfigParameter<config> &
+      QueryParameter<
+        GetEnsNameQueryFnData,
+        GetEnsNameErrorType,
+        selectData,
+        GetEnsNameQueryKey<config>
+      >
+  >
+>
+
+export type UseEnsNameReturnType<selectData = GetEnsNameData> =
+  UseQueryReturnType<selectData, GetEnsNameErrorType>
+
+/** https://wagmi.sh/vue/api/composables/useEnsName */
+export function useEnsName<
+  config extends Config = ResolvedRegister['config'],
+  selectData = GetEnsNameData,
+>(
+  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>
+}

package/src/composables/useEstimateGas.ts

@@ -0,0 +1,83 @@
+import type {
+  Config,
+  EstimateGasErrorType,
+  ResolvedRegister,
+} from '@wagmi/core'
+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 { 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'
+
+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>
+    >
+>
+
+export type UseEstimateGasReturnType<selectData = EstimateGasData> =
+  UseQueryReturnType<selectData, EstimateGasErrorType>
+
+/** https://wagmi.sh/react/api/hooks/useEstimateGas */
+export function useEstimateGas<
+  config extends Config = ResolvedRegister['config'],
+  chainId extends config['chains'][number]['id'] | undefined = undefined,
+  selectData = EstimateGasData,
+>(
+  parameters?: UseEstimateGasParameters<config, chainId, selectData>,
+): UseEstimateGasReturnType<selectData>
+
+export function useEstimateGas(
+  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 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)
+}

package/src/composables/useReadContract.ts

@@ -0,0 +1,121 @@
+import {
+  type Config,
+  type ReadContractErrorType,
+  type ResolvedRegister,
+} from '@wagmi/core'
+import { type UnionEvaluate } from '@wagmi/core/internal'
+import {
+  type ReadContractData,
+  type ReadContractOptions,
+  type ReadContractQueryFnData,
+  type ReadContractQueryKey,
+  readContractQueryOptions,
+  structuralSharing,
+} from '@wagmi/core/query'
+import {
+  type Abi,
+  type ContractFunctionArgs,
+  type ContractFunctionName,
+} from 'viem'
+
+import { computed } from 'vue'
+import type { ConfigParameter, QueryParameter } 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'
+
+export type UseReadContractParameters<
+  abi extends Abi | readonly unknown[] = Abi,
+  functionName extends ContractFunctionName<
+    abi,
+    'pure' | 'view'
+  > = ContractFunctionName<abi, 'pure' | 'view'>,
+  args extends ContractFunctionArgs<
+    abi,
+    'pure' | 'view',
+    functionName
+  > = ContractFunctionArgs<abi, 'pure' | 'view', functionName>,
+  config extends Config = Config,
+  selectData = ReadContractData<abi, functionName, args>,
+> = UnionEvaluate<
+  DeepMaybeRef<
+    ReadContractOptions<abi, functionName, args, config> &
+      ConfigParameter<config> &
+      QueryParameter<
+        ReadContractQueryFnData<abi, functionName, args>,
+        ReadContractErrorType,
+        selectData,
+        ReadContractQueryKey<abi, functionName, args, config>
+      >
+  >
+>
+
+export type UseReadContractReturnType<
+  abi extends Abi | readonly unknown[] = Abi,
+  functionName extends ContractFunctionName<
+    abi,
+    'pure' | 'view'
+  > = ContractFunctionName<abi, 'pure' | 'view'>,
+  args extends ContractFunctionArgs<
+    abi,
+    'pure' | 'view',
+    functionName
+  > = ContractFunctionArgs<abi, 'pure' | 'view', functionName>,
+  selectData = ReadContractData<abi, functionName, args>,
+> = UseQueryReturnType<selectData, ReadContractErrorType>
+
+/** https://wagmi.sh/vue/api/hooks/useReadContract */
+export function useReadContract<
+  const abi extends Abi | readonly unknown[],
+  functionName extends ContractFunctionName<abi, 'pure' | 'view'>,
+  args extends ContractFunctionArgs<abi, 'pure' | 'view', functionName>,
+  config extends Config = ResolvedRegister['config'],
+  selectData = ReadContractData<abi, functionName, args>,
+>(
+  parameters_: UseReadContractParameters<
+    abi,
+    functionName,
+    args,
+    config,
+    selectData
+  > = {} as any,
+): UseReadContractReturnType<abi, functionName, args, selectData> {
+  const parameters = computed(() =>
+    deepUnref(parameters_),
+  ) as UseReadContractParameters
+
+  const config = useConfig(parameters)
+  const configChainId = useChainId({ config })
+
+  const queryOptions = computed(() => {
+    const {
+      abi,
+      address,
+      chainId = configChainId.value,
+      functionName,
+      query = {},
+    } = parameters.value as any
+    const options = readContractQueryOptions<config, abi, functionName, args>(
+      config as config,
+      { ...(parameters.value as any), chainId },
+    )
+    const enabled = Boolean(
+      address && abi && functionName && (query.enabled ?? true),
+    )
+    return {
+      ...query,
+      ...options,
+      enabled,
+      structuralSharing: query.structuralSharing ?? structuralSharing,
+    }
+  })
+
+  return useQuery(queryOptions) as UseReadContractReturnType<
+    abi,
+    functionName,
+    args,
+    selectData
+  >
+}

package/src/composables/useSendTransaction.ts

@@ -0,0 +1,76 @@
+import { useMutation } from '@tanstack/vue-query'
+import type {
+  Config,
+  ResolvedRegister,
+  SendTransactionErrorType,
+} from '@wagmi/core'
+import type { Evaluate } from '@wagmi/core/internal'
+import {
+  type SendTransactionData,
+  type SendTransactionMutate,
+  type SendTransactionMutateAsync,
+  type SendTransactionVariables,
+  sendTransactionMutationOptions,
+} from '@wagmi/core/query'
+
+import type { ConfigParameter } from '../types/properties.js'
+import type {
+  UseMutationParameters,
+  UseMutationReturnType,
+} from '../utils/query.js'
+import { useConfig } from './useConfig.js'
+
+export type UseSendTransactionParameters<
+  config extends Config = Config,
+  context = unknown,
+> = Evaluate<
+  ConfigParameter<config> & {
+    mutation?:
+      | UseMutationParameters<
+          SendTransactionData,
+          SendTransactionErrorType,
+          SendTransactionVariables<config, config['chains'][number]['id']>,
+          context
+        >
+      | undefined
+  }
+>
+
+export type UseSendTransactionReturnType<
+  config extends Config = Config,
+  context = unknown,
+> = Evaluate<
+  UseMutationReturnType<
+    SendTransactionData,
+    SendTransactionErrorType,
+    SendTransactionVariables<config, config['chains'][number]['id']>,
+    context
+  > & {
+    sendTransaction: SendTransactionMutate<config, context>
+    sendTransactionAsync: SendTransactionMutateAsync<config, context>
+  }
+>
+
+/** https://wagmi.sh/vue/api/composables/useSendTransaction */
+export function useSendTransaction<
+  config extends Config = ResolvedRegister['config'],
+  context = unknown,
+>(
+  parameters: UseSendTransactionParameters<config, context> = {},
+): UseSendTransactionReturnType<config, context> {
+  const { mutation } = parameters
+
+  const config = useConfig(parameters)
+
+  const mutationOptions = sendTransactionMutationOptions(config)
+  const { mutate, mutateAsync, ...result } = useMutation({
+    ...mutation,
+    ...mutationOptions,
+  })
+
+  return {
+    ...result,
+    sendTransaction: mutate,
+    sendTransactionAsync: mutateAsync,
+  } as UseSendTransactionReturnType<config, context>
+}

package/src/composables/useSignMessage.ts

@@ -0,0 +1,63 @@
+import { type SignMessageErrorType } from '@wagmi/core'
+import type { Evaluate } from '@wagmi/core/internal'
+import {
+  type SignMessageData,
+  type SignMessageMutate,
+  type SignMessageMutateAsync,
+  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 { useConfig } from './useConfig.js'
+
+export type UseSignMessageParameters<context = unknown> = Evaluate<
+  ConfigParameter & {
+    mutation?:
+      | UseMutationParameters<
+          SignMessageData,
+          SignMessageErrorType,
+          SignMessageVariables,
+          context
+        >
+      | undefined
+  }
+>
+
+export type UseSignMessageReturnType<context = unknown> = Evaluate<
+  UseMutationReturnType<
+    SignMessageData,
+    SignMessageErrorType,
+    SignMessageVariables,
+    context
+  > & {
+    signMessage: SignMessageMutate<context>
+    signMessageAsync: SignMessageMutateAsync<context>
+  }
+>
+
+/** https://wagmi.sh/vue/api/composables/useSignMessage */
+export function useSignMessage<context = unknown>(
+  parameters: UseSignMessageParameters<context> = {},
+): UseSignMessageReturnType<context> {
+  const { mutation } = parameters
+
+  const config = useConfig(parameters)
+
+  const mutationOptions = signMessageMutationOptions(config)
+  const { mutate, mutateAsync, ...result } = useMutation({
+    ...mutation,
+    ...mutationOptions,
+  })
+
+  return {
+    ...result,
+    signMessage: mutate,
+    signMessageAsync: mutateAsync,
+  }
+}

package/src/composables/useSignTypedData.ts

@@ -0,0 +1,64 @@
+import type { SignTypedDataErrorType } from '@wagmi/core'
+import type { Evaluate } from '@wagmi/core/internal'
+import {
+  type SignTypedDataData,
+  type SignTypedDataMutate,
+  type SignTypedDataMutateAsync,
+  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 { useConfig } from './useConfig.js'
+
+export type UseSignTypedDataParameters<context = unknown> = Evaluate<
+  ConfigParameter & {
+    mutation?:
+      | UseMutationParameters<
+          SignTypedDataData,
+          SignTypedDataErrorType,
+          SignTypedDataVariables,
+          context
+        >
+      | undefined
+  }
+>
+
+export type UseSignTypedDataReturnType<context = unknown> = Evaluate<
+  UseMutationReturnType<
+    SignTypedDataData,
+    SignTypedDataErrorType,
+    SignTypedDataVariables,
+    context
+  > & {
+    signTypedData: SignTypedDataMutate<context>
+    signTypedDataAsync: SignTypedDataMutateAsync<context>
+  }
+>
+
+/** https://wagmi.sh/vue/api/composables/useSignTypedData */
+export function useSignTypedData<context = unknown>(
+  parameters: UseSignTypedDataParameters<context> = {},
+): UseSignTypedDataReturnType<context> {
+  const { mutation } = parameters
+
+  const config = useConfig(parameters)
+
+  const mutationOptions = signTypedDataMutationOptions(config)
+  const { mutate, mutateAsync, ...result } = useMutation({
+    ...mutation,
+    ...mutationOptions,
+  })
+
+  type Return = UseSignTypedDataReturnType<context>
+  return {
+    ...result,
+    signTypedData: mutate as Return['signTypedData'],
+    signTypedDataAsync: mutateAsync as Return['signTypedDataAsync'],
+  }
+}