@wagmi/vue 0.0.0-vue-20240513033839

package/src/composables/useConnect.ts

@@ -0,0 +1,91 @@
+import { useMutation } from '@tanstack/vue-query'
+import {
+  type Config,
+  type ConnectErrorType,
+  type GetConnectorsReturnType,
+  type ResolvedRegister,
+} from '@wagmi/core'
+import type { Evaluate } from '@wagmi/core/internal'
+import {
+  type ConnectData,
+  type ConnectMutate,
+  type ConnectMutateAsync,
+  type ConnectVariables,
+  connectMutationOptions,
+} from '@wagmi/core/query'
+import { onScopeDispose } from 'vue'
+
+import type { ConfigParameter } from '../types/properties.js'
+import type {
+  UseMutationParameters,
+  UseMutationReturnType,
+} from '../utils/query.js'
+import { useConfig } from './useConfig.js'
+import { useConnectors } from './useConnectors.js'
+
+export type UseConnectParameters<
+  config extends Config = Config,
+  context = unknown,
+> = Evaluate<
+  ConfigParameter<config> & {
+    mutation?:
+      | UseMutationParameters<
+          ConnectData<config>,
+          ConnectErrorType,
+          ConnectVariables<config>,
+          context
+        >
+      | undefined
+  }
+>
+
+export type UseConnectReturnType<
+  config extends Config = Config,
+  context = unknown,
+> = Evaluate<
+  UseMutationReturnType<
+    ConnectData<config>,
+    ConnectErrorType,
+    ConnectVariables<config>,
+    context
+  > & {
+    connect: ConnectMutate<config, context>
+    connectAsync: ConnectMutateAsync<config, context>
+    connectors: Evaluate<GetConnectorsReturnType>
+  }
+>
+
+/** https://wagmi.sh/vue/api/composables/useConnect */
+export function useConnect<
+  config extends Config = ResolvedRegister['config'],
+  context = unknown,
+>(
+  parameters: UseConnectParameters<config, context> = {},
+): UseConnectReturnType<config, context> {
+  const { mutation } = parameters
+
+  const config = useConfig(parameters)
+
+  const mutationOptions = connectMutationOptions(config)
+  const { mutate, mutateAsync, ...result } = useMutation({
+    ...mutation,
+    ...mutationOptions,
+  })
+
+  // Reset mutation back to an idle state when the connector disconnects.
+  const unsubscribe = config.subscribe(
+    ({ status }) => status,
+    (status, previousStatus) => {
+      if (previousStatus === 'connected' && status === 'disconnected')
+        result.reset()
+    },
+  )
+  onScopeDispose(() => unsubscribe())
+
+  return {
+    ...result,
+    connect: mutate,
+    connectAsync: mutateAsync,
+    connectors: useConnectors({ config }).value,
+  }
+}

package/src/composables/useConnections.ts

@@ -0,0 +1,30 @@
+import {
+  type GetConnectionsReturnType,
+  getConnections,
+  watchConnections,
+} from '@wagmi/core'
+import { type Ref, onScopeDispose, readonly, ref } from 'vue'
+
+import type { ConfigParameter } from '../types/properties.js'
+import { useConfig } from './useConfig.js'
+
+export type UseConnectionsParameters = ConfigParameter
+
+export type UseConnectionsReturnType = Ref<GetConnectionsReturnType>
+
+/** https://wagmi.sh/vue/api/composables/useConnections */
+export function useConnections(
+  parameters: UseConnectionsParameters = {},
+): UseConnectionsReturnType {
+  const config = useConfig(parameters)
+
+  const connections = ref(getConnections(config))
+  const unsubscribe = watchConnections(config, {
+    onChange(data) {
+      connections.value = data
+    },
+  })
+  onScopeDispose(() => unsubscribe())
+
+  return readonly(connections) as UseConnectionsReturnType
+}

package/src/composables/useConnectorClient.ts

@@ -0,0 +1,127 @@
+import { useQueryClient } from '@tanstack/vue-query'
+import type {
+  Config,
+  Connector,
+  GetConnectorClientErrorType,
+  ResolvedRegister,
+} from '@wagmi/core'
+import { type Evaluate, type Omit } 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 { deepUnref } from '../utils/cloneDeep.js'
+import {
+  type UseQueryParameters,
+  type UseQueryReturnType,
+  useQuery,
+} from '../utils/query.js'
+import { useAccount } from './useAccount.js'
+import { useChainId } from './useChainId.js'
+import { useConfig } from './useConfig.js'
+
+export type UseConnectorClientParameters<
+  config extends Config = Config,
+  chainId extends config['chains'][number]['id'] = config['chains'][number]['id'],
+  selectData = GetConnectorClientData<config, chainId>,
+> = Evaluate<
+  DeepMaybeRef<
+    GetConnectorClientOptions<config, chainId> &
+      ConfigParameter<config> & {
+        query?:
+          | Evaluate<
+              Omit<
+                DeepUnwrapRef<
+                  UseQueryParameters<
+                    GetConnectorClientQueryFnData<config, chainId>,
+                    GetConnectorClientErrorType,
+                    selectData,
+                    GetConnectorClientQueryKey<config, chainId>
+                  >
+                >,
+                'gcTime' | 'staleTime'
+              >
+            >
+          | undefined
+      }
+  >
+>
+
+export type UseConnectorClientReturnType<
+  config extends Config = Config,
+  chainId extends config['chains'][number]['id'] = config['chains'][number]['id'],
+  selectData = GetConnectorClientData<config, chainId>,
+> = UseQueryReturnType<selectData, GetConnectorClientErrorType>
+
+/** https://wagmi.sh/vue/api/composables/useConnectorClient */
+export function useConnectorClient<
+  config extends Config = ResolvedRegister['config'],
+  chainId extends config['chains'][number]['id'] = config['chains'][number]['id'],
+  selectData = GetConnectorClientData<config, chainId>,
+>(
+  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,
+  } = useAccount({ 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 !== 'disconnected' && (query.enabled ?? true),
+    )
+    return {
+      ...query,
+      ...options,
+      queryKey,
+      enabled,
+      staleTime: Infinity,
+    }
+  })
+
+  const addressRef = ref(address)
+  watchEffect(() => {
+    const previousAddress = addressRef.value
+    if (!address && previousAddress) {
+      // remove when account is disconnected
+      queryClient.removeQueries({ queryKey: queryOptions.value.queryKey })
+      addressRef.value = undefined
+    } else if (address.value !== previousAddress) {
+      // invalidate when address changes
+      queryClient.invalidateQueries({ queryKey: queryOptions.value.queryKey })
+      addressRef.value = address.value
+    }
+  })
+
+  return useQuery(queryOptions as any) as UseConnectorClientReturnType<
+    config,
+    chainId,
+    selectData
+  >
+}

package/src/composables/useConnectors.ts

@@ -0,0 +1,30 @@
+import {
+  type GetConnectorsReturnType,
+  getConnectors,
+  watchConnectors,
+} from '@wagmi/core'
+import { type Ref, onScopeDispose, ref } from 'vue'
+
+import type { ConfigParameter } from '../types/properties.js'
+import { useConfig } from './useConfig.js'
+
+export type UseConnectorsParameters = ConfigParameter
+
+export type UseConnectorsReturnType = Ref<GetConnectorsReturnType>
+
+/** https://wagmi.sh/vue/api/composables/useConnectors */
+export function useConnectors(
+  parameters: UseConnectorsParameters = {},
+): UseConnectorsReturnType {
+  const config = useConfig(parameters)
+
+  const connectors = ref(getConnectors(config))
+  const unsubscribe = watchConnectors(config, {
+    onChange(data) {
+      connectors.value = data
+    },
+  })
+  onScopeDispose(() => unsubscribe())
+
+  return connectors
+}

package/src/composables/useDisconnect.ts

@@ -0,0 +1,70 @@
+import { useMutation } from '@tanstack/vue-query'
+import { type Connector, type DisconnectErrorType } from '@wagmi/core'
+import type { Evaluate } from '@wagmi/core/internal'
+import {
+  type DisconnectData,
+  type DisconnectMutate,
+  type DisconnectMutateAsync,
+  type DisconnectVariables,
+  disconnectMutationOptions,
+} from '@wagmi/core/query'
+import { type Ref, computed } from 'vue'
+
+import type { ConfigParameter } from '../types/properties.js'
+import type {
+  UseMutationParameters,
+  UseMutationReturnType,
+} from '../utils/query.js'
+import { useConfig } from './useConfig.js'
+import { useConnections } from './useConnections.js'
+
+export type UseDisconnectParameters<context = unknown> = Evaluate<
+  ConfigParameter & {
+    mutation?:
+      | UseMutationParameters<
+          DisconnectData,
+          DisconnectErrorType,
+          DisconnectVariables,
+          context
+        >
+      | undefined
+  }
+>
+
+export type UseDisconnectReturnType<context = unknown> = Evaluate<
+  UseMutationReturnType<
+    DisconnectData,
+    DisconnectErrorType,
+    DisconnectVariables,
+    context
+  > & {
+    connectors: Ref<readonly Connector[]>
+    disconnect: DisconnectMutate<context>
+    disconnectAsync: DisconnectMutateAsync<context>
+  }
+>
+
+/** https://wagmi.sh/vue/api/composables/useDisconnect */
+export function useDisconnect<context = unknown>(
+  parameters: UseDisconnectParameters<context> = {},
+): UseDisconnectReturnType<context> {
+  const { mutation } = parameters
+
+  const config = useConfig(parameters)
+  const connections = useConnections({ config })
+
+  const mutationOptions = disconnectMutationOptions(config)
+  const { mutate, mutateAsync, ...result } = useMutation({
+    ...mutation,
+    ...mutationOptions,
+  })
+
+  return {
+    ...result,
+    connectors: computed(() =>
+      connections.value.map((connection) => connection.connector),
+    ),
+    disconnect: mutate,
+    disconnectAsync: mutateAsync,
+  }
+}

package/src/composables/useReconnect.ts

@@ -0,0 +1,65 @@
+import { useMutation } from '@tanstack/vue-query'
+import { type Connector, type ReconnectErrorType } from '@wagmi/core'
+import type { Evaluate } from '@wagmi/core/internal'
+import {
+  type ReconnectData,
+  type ReconnectMutate,
+  type ReconnectMutateAsync,
+  type ReconnectVariables,
+  reconnectMutationOptions,
+} 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 UseReconnectParameters<context = unknown> = Evaluate<
+  ConfigParameter & {
+    mutation?:
+      | UseMutationParameters<
+          ReconnectData,
+          ReconnectErrorType,
+          ReconnectVariables,
+          context
+        >
+      | undefined
+  }
+>
+
+export type UseReconnectReturnType<context = unknown> = Evaluate<
+  UseMutationReturnType<
+    ReconnectData,
+    ReconnectErrorType,
+    ReconnectVariables,
+    context
+  > & {
+    connectors: readonly Connector[]
+    reconnect: ReconnectMutate<context>
+    reconnectAsync: ReconnectMutateAsync<context>
+  }
+>
+
+/** https://wagmi.sh/vue/api/composables/useReconnect */
+export function useReconnect<context = unknown>(
+  parameters: UseReconnectParameters<context> = {},
+): UseReconnectReturnType<context> {
+  const { mutation } = parameters
+
+  const config = useConfig(parameters)
+
+  const mutationOptions = reconnectMutationOptions(config)
+  const { mutate, mutateAsync, ...result } = useMutation({
+    ...mutation,
+    ...mutationOptions,
+  })
+
+  return {
+    ...result,
+    connectors: config.connectors,
+    reconnect: mutate,
+    reconnectAsync: mutateAsync,
+  }
+}

package/src/composables/useSwitchAccount.ts

@@ -0,0 +1,84 @@
+import { useMutation } from '@tanstack/vue-query'
+import type {
+  Config,
+  Connector,
+  ResolvedRegister,
+  SwitchAccountErrorType,
+} from '@wagmi/core'
+import type { Evaluate } from '@wagmi/core/internal'
+import {
+  type SwitchAccountData,
+  type SwitchAccountMutate,
+  type SwitchAccountMutateAsync,
+  type SwitchAccountVariables,
+  switchAccountMutationOptions,
+} from '@wagmi/core/query'
+import { type Ref, computed } from 'vue'
+
+import type { ConfigParameter } from '../types/properties.js'
+import type {
+  UseMutationParameters,
+  UseMutationReturnType,
+} from '../utils/query.js'
+import { useConfig } from './useConfig.js'
+import { useConnections } from './useConnections.js'
+
+export type UseSwitchAccountParameters<
+  config extends Config = Config,
+  context = unknown,
+> = Evaluate<
+  ConfigParameter<config> & {
+    mutation?:
+      | UseMutationParameters<
+          SwitchAccountData<config>,
+          SwitchAccountErrorType,
+          SwitchAccountVariables,
+          context
+        >
+      | undefined
+  }
+>
+
+export type UseSwitchAccountReturnType<
+  config extends Config = Config,
+  context = unknown,
+> = Evaluate<
+  UseMutationReturnType<
+    SwitchAccountData<config>,
+    SwitchAccountErrorType,
+    SwitchAccountVariables,
+    context
+  > & {
+    connectors: Ref<readonly Connector[]>
+    switchAccount: SwitchAccountMutate<config, context>
+    switchAccountAsync: SwitchAccountMutateAsync<config, context>
+  }
+>
+
+/** https://wagmi.sh/vue/api/composables/useSwitchAccount */
+export function useSwitchAccount<
+  config extends Config = ResolvedRegister['config'],
+  context = unknown,
+>(
+  parameters: UseSwitchAccountParameters<config, context> = {},
+): UseSwitchAccountReturnType<config, context> {
+  const { mutation } = parameters
+
+  const config = useConfig(parameters)
+  const connections = useConnections({ config })
+
+  const mutationOptions = switchAccountMutationOptions(config)
+  const { mutate, mutateAsync, ...result } = useMutation({
+    ...mutation,
+    ...mutationOptions,
+  })
+
+  return {
+    ...result,
+    connectors: computed(() =>
+      connections.value.map((connection) => connection.connector),
+    ),
+    switchAccount: mutate,
+    switchAccountAsync: mutateAsync,
+  }
+}

package/src/composables/useSwitchChain.ts

@@ -0,0 +1,80 @@
+import { useMutation } from '@tanstack/vue-query'
+import {
+  type Config,
+  type ResolvedRegister,
+  type SwitchChainErrorType,
+} from '@wagmi/core'
+import { type Evaluate } from '@wagmi/core/internal'
+import {
+  type SwitchChainData,
+  type SwitchChainMutate,
+  type SwitchChainMutateAsync,
+  type SwitchChainVariables,
+  switchChainMutationOptions,
+} from '@wagmi/core/query'
+
+import { type ConfigParameter } from '../types/properties.js'
+import {
+  type UseMutationParameters,
+  type UseMutationReturnType,
+} from '../utils/query.js'
+import { type UseChainsReturnType, useChains } from './useChains.js'
+import { useConfig } from './useConfig.js'
+
+export type UseSwitchChainParameters<
+  config extends Config = Config,
+  context = unknown,
+> = Evaluate<
+  ConfigParameter<config> & {
+    mutation?:
+      | UseMutationParameters<
+          SwitchChainData<config, config['chains'][number]['id']>,
+          SwitchChainErrorType,
+          SwitchChainVariables<config, config['chains'][number]['id']>,
+          context
+        >
+      | undefined
+  }
+>
+
+export type UseSwitchChainReturnType<
+  config extends Config = Config,
+  context = unknown,
+> = Evaluate<
+  UseMutationReturnType<
+    SwitchChainData<config, config['chains'][number]['id']>,
+    SwitchChainErrorType,
+    SwitchChainVariables<config, config['chains'][number]['id']>,
+    context
+  > & {
+    chains: Evaluate<UseChainsReturnType<config>>
+    switchChain: SwitchChainMutate<config, context>
+    switchChainAsync: SwitchChainMutateAsync<config, context>
+  }
+>
+
+/** https://wagmi.sh/vue/api/composables/useSwitchChain */
+export function useSwitchChain<
+  config extends Config = ResolvedRegister['config'],
+  context = unknown,
+>(
+  parameters: UseSwitchChainParameters<config, context> = {},
+): UseSwitchChainReturnType<config, context> {
+  const { mutation } = parameters
+
+  const config = useConfig(parameters)
+
+  const mutationOptions = switchChainMutationOptions(config)
+  const { mutate, mutateAsync, ...result } = useMutation({
+    ...mutation,
+    ...mutationOptions,
+  })
+
+  type Return = UseSwitchChainReturnType<config, context>
+  return {
+    ...result,
+    chains: useChains({ config }),
+    switchChain: mutate as Return['switchChain'],
+    switchChainAsync: mutateAsync as Return['switchChainAsync'],
+  } as Return
+}

package/src/composables/useWatchBlockNumber.ts

@@ -0,0 +1,61 @@
+import {
+  type Config,
+  type ResolvedRegister,
+  type WatchBlockNumberParameters,
+  watchBlockNumber,
+} from '@wagmi/core'
+import { type UnionEvaluate, type UnionPartial } from '@wagmi/core/internal'
+import { computed, watchEffect } from 'vue'
+
+import type { ConfigParameter, EnabledParameter } from '../types/properties.js'
+import type { DeepMaybeRef } from '../types/ref.js'
+import { deepUnref } from '../utils/cloneDeep.js'
+import { useChainId } from './useChainId.js'
+import { useConfig } from './useConfig.js'
+
+export type UseWatchBlockNumberParameters<
+  config extends Config = Config,
+  chainId extends config['chains'][number]['id'] = config['chains'][number]['id'],
+> = DeepMaybeRef<
+  UnionEvaluate<
+    UnionPartial<WatchBlockNumberParameters<config, chainId>> &
+      ConfigParameter<config> &
+      EnabledParameter
+  >
+>
+
+export type UseWatchBlockNumberReturnType = void
+
+/** https://wagmi.sh/vue/api/composables/useWatchBlockNumber */
+export function useWatchBlockNumber<
+  config extends Config = ResolvedRegister['config'],
+  chainId extends config['chains'][number]['id'] = config['chains'][number]['id'],
+>(
+  parameters_: UseWatchBlockNumberParameters<config, chainId> = {} as any,
+): UseWatchBlockNumberReturnType {
+  const parameters = computed(() => deepUnref(parameters_))
+
+  const config = useConfig(parameters)
+  const configChainId = useChainId({ config })
+
+  watchEffect((onCleanup) => {
+    const {
+      chainId = configChainId.value,
+      enabled = true,
+      onBlockNumber,
+      config: _,
+      ...rest
+    } = parameters.value
+
+    if (!enabled) return
+    if (!onBlockNumber) return
+
+    const unwatch = watchBlockNumber(config, {
+      ...(rest as any),
+      chainId,
+      onBlockNumber,
+      emitOnBegin: true,
+    })
+    onCleanup(unwatch)
+  })
+}

package/src/errors/base.ts

@@ -0,0 +1,14 @@
+import { BaseError as CoreError } from '@wagmi/core'
+
+import { getVersion } from '../utils/getVersion.js'
+
+export type BaseErrorType = BaseError & { name: 'WagmiError' }
+export class BaseError extends CoreError {
+  override name = 'WagmiError'
+  override get docsBaseUrl() {
+    return 'https://wagmi.sh/vue'
+  }
+  override get version() {
+    return getVersion()
+  }
+}

package/src/errors/plugin.ts

@@ -0,0 +1,31 @@
+import { BaseError } from './base.js'
+
+export type WagmiPluginNotFoundErrorType = WagmiPluginNotFoundError & {
+  name: 'WagmiPluginNotFoundError'
+}
+export class WagmiPluginNotFoundError extends BaseError {
+  override name = 'WagmiPluginNotFoundError'
+  constructor() {
+    super(
+      'No `config` found in Vue context, use `WagmiPlugin` to properly initialize the library.',
+      {
+        docsPath: '/api/TODO',
+      },
+    )
+  }
+}
+
+export type WagmiInjectionContextErrorType = WagmiInjectionContextError & {
+  name: 'WagmiInjectionContextError'
+}
+export class WagmiInjectionContextError extends BaseError {
+  override name = 'WagmiInjectionContextError'
+  constructor() {
+    super(
+      'Wagmi composables can only be used inside `setup()` function or functions that support injection context.',
+      {
+        docsPath: '/api/TODO',
+      },
+    )
+  }
+}

package/src/exports/actions.ts

@@ -0,0 +1,5 @@
+////////////////////////////////////////////////////////////////////////////////
+// @wagmi/core/actions
+////////////////////////////////////////////////////////////////////////////////
+
+export * from '@wagmi/core/actions'