@wagmi/solid 0.0.0-alpha → 0.0.1

package/src/primitives/useClient.ts

@@ -0,0 +1,67 @@
+import {
+  type Config,
+  type GetClientParameters,
+  type GetClientReturnType,
+  getClient,
+  type ResolvedRegister,
+  watchClient,
+} from '@wagmi/core'
+import type { Compute, ConfigParameter } from '@wagmi/core/internal'
+import type { Accessor } from 'solid-js'
+import { createEffect, createSignal, onCleanup } from 'solid-js'
+import { useConfig } from './useConfig.js'
+
+/** https://wagmi.sh/solid/api/primitives/useClient */
+export function useClient<
+  config extends Config = ResolvedRegister['config'],
+  chainId extends config['chains'][number]['id'] | number | undefined =
+    | config['chains'][number]['id']
+    | undefined,
+>(
+  parameters: useClient.Parameters<config, chainId> = () => ({}),
+): useClient.ReturnType<config, chainId> {
+  const config = useConfig(parameters)
+  const [client, setClient] = createSignal(getClient(config(), parameters()))
+  createEffect(() => {
+    const _config = config()
+    setClient(() => getClient(_config, parameters()))
+    const unsubscribe = watchClient(_config, {
+      onChange(data) {
+        if (client()?.uid === data?.uid) return
+        setClient(() => data)
+      },
+    })
+    onCleanup(() => unsubscribe())
+  })
+  return client as unknown as useClient.ReturnType<config, chainId>
+}
+
+export namespace useClient {
+  export type Parameters<
+    config extends Config = Config,
+    chainId extends config['chains'][number]['id'] | number | undefined =
+      | config['chains'][number]['id']
+      | undefined,
+  > = Accessor<SolidParameters<config, chainId>>
+
+  export type ReturnType<
+    config extends Config = Config,
+    chainId extends config['chains'][number]['id'] | number | undefined =
+      | config['chains'][number]['id']
+      | undefined,
+  > = Accessor<SolidReturnType<config, chainId>>
+
+  export type SolidParameters<
+    config extends Config = Config,
+    chainId extends config['chains'][number]['id'] | number | undefined =
+      | config['chains'][number]['id']
+      | undefined,
+  > = Compute<GetClientParameters<config, chainId> & ConfigParameter<config>>
+
+  export type SolidReturnType<
+    config extends Config = Config,
+    chainId extends config['chains'][number]['id'] | number | undefined =
+      | config['chains'][number]['id']
+      | undefined,
+  > = GetClientReturnType<config, chainId>
+}

package/src/primitives/useConfig.ts

@@ -0,0 +1,27 @@
+import type { Config, ResolvedRegister } from '@wagmi/core'
+import type { ConfigParameter } from '@wagmi/core/internal'
+import { type Accessor, createMemo, useContext } from 'solid-js'
+import { WagmiContext } from '../context.js'
+import { WagmiProviderNotFoundError } from '../errors/context.js'
+
+export function useConfig<config extends Config = ResolvedRegister['config']>(
+  parameters: useConfig.Parameters<config> = () => ({}),
+): useConfig.ReturnType<config> {
+  return createMemo(() => {
+    const config = parameters().config ?? useContext(WagmiContext)
+    if (!config) throw new WagmiProviderNotFoundError()
+    return config as config
+  })
+}
+
+export namespace useConfig {
+  export type Parameters<config extends Config = Config> = Accessor<
+    SolidParameters<config>
+  >
+  export type ReturnType<config extends Config = Config> = Accessor<
+    SolidReturnType<config>
+  >
+  export type SolidParameters<config extends Config = Config> =
+    ConfigParameter<config>
+  export type SolidReturnType<config extends Config = Config> = config
+}

package/src/primitives/useConnect.ts

@@ -0,0 +1,63 @@
+import type { Config, ConnectErrorType } from '@wagmi/core'
+import type { Compute, ConfigParameter } from '@wagmi/core/internal'
+import {
+  type ConnectData,
+  type ConnectMutate,
+  type ConnectMutateAsync,
+  type ConnectOptions,
+  type ConnectVariables,
+  connectMutationOptions,
+} from '@wagmi/core/query'
+import { type Accessor, createEffect, onCleanup } from 'solid-js'
+import type { UseMutationReturnType } from '../utils/query.js'
+import { useMutation } from '../utils/query.js'
+import { useConfig } from './useConfig.js'
+
+/** https://wagmi.sh/solid/api/hooks/useConnect */
+export function useConnect<config extends Config = Config, context = unknown>(
+  parameters: useConnect.Parameters<config, context> = () => ({}),
+): useConnect.ReturnType<config, context> {
+  const config = useConfig(parameters)
+  const mutation = useMutation(() =>
+    connectMutationOptions(config(), parameters()),
+  )
+  // Reset mutation back to an idle state when the connector disconnects.
+  createEffect(() => {
+    const unsubscribe = config().subscribe(
+      ({ status }) => status,
+      (status, previousStatus) => {
+        if (previousStatus === 'connected' && status === 'disconnected') {
+          mutation.reset()
+        }
+      },
+    )
+    onCleanup(() => unsubscribe())
+  })
+  return mutation as unknown as useConnect.ReturnType<config, context>
+}
+
+export namespace useConnect {
+  export type Parameters<
+    config extends Config = Config,
+    context = unknown,
+  > = Accessor<SolidParameters<config, context>>
+
+  export type ReturnType<
+    config extends Config = Config,
+    context = unknown,
+  > = Compute<
+    UseMutationReturnType<
+      ConnectData<config, config['connectors'][number], boolean>,
+      ConnectErrorType,
+      ConnectVariables<config, config['connectors'][number], boolean>,
+      context,
+      ConnectMutate<config, context>,
+      ConnectMutateAsync<config, context>
+    >
+  >
+
+  export type SolidParameters<
+    config extends Config = Config,
+    context = unknown,
+  > = Compute<ConfigParameter<config> & ConnectOptions<config, context>>
+}

package/src/primitives/useConnection.ts

@@ -0,0 +1,44 @@
+import {
+  type Config,
+  type GetConnectionReturnType,
+  getConnection,
+  type ResolvedRegister,
+  watchConnection,
+} from '@wagmi/core'
+import type { ConfigParameter } from '@wagmi/core/internal'
+import { type Accessor, createEffect, createSignal, onCleanup } from 'solid-js'
+import { useConfig } from './useConfig.js'
+
+/** https://wagmi.sh/solid/api/primitives/useConnection */
+export function useConnection<
+  config extends Config = ResolvedRegister['config'],
+>(
+  parameters: useConnection.Parameters<config> = () => ({}),
+): useConnection.ReturnType<config> {
+  const config = useConfig(parameters)
+  const [connection, setConnection] = createSignal(getConnection(config()))
+  createEffect(() => {
+    const _config = config()
+    setConnection(() => getConnection(_config))
+    const unsubscribe = watchConnection(_config, {
+      onChange(data) {
+        setConnection(() => data)
+      },
+    })
+    onCleanup(() => unsubscribe())
+  })
+  return connection
+}
+
+export namespace useConnection {
+  export type Parameters<config extends Config = Config> = Accessor<
+    SolidParameters<config>
+  >
+  export type ReturnType<config extends Config = Config> = Accessor<
+    SolidReturnType<config>
+  >
+  export type SolidParameters<config extends Config = Config> =
+    ConfigParameter<config>
+  export type SolidReturnType<config extends Config = Config> =
+    GetConnectionReturnType<config>
+}

package/src/primitives/useConnectionEffect.ts

@@ -0,0 +1,66 @@
+import { type GetConnectionReturnType, watchConnection } from '@wagmi/core'
+import type { Compute, ConfigParameter } from '@wagmi/core/internal'
+import type { Accessor } from 'solid-js'
+import { createEffect, onCleanup } from 'solid-js'
+import { useConfig } from './useConfig.js'
+
+/** https://wagmi.sh/solid/api/primitives/useConnectionEffect */
+export function useConnectionEffect(
+  parameters: useConnectionEffect.Parameters = () => ({}),
+) {
+  const config = useConfig(parameters)
+
+  createEffect(() => {
+    const { onConnect, onDisconnect } = parameters()
+
+    const unsubscribe = watchConnection(config(), {
+      onChange(data, prevData) {
+        if (
+          (prevData.status === 'reconnecting' ||
+            (prevData.status === 'connecting' &&
+              prevData.address === undefined)) &&
+          data.status === 'connected'
+        ) {
+          const { address, addresses, chain, chainId, connector } = data
+          const isReconnected =
+            prevData.status === 'reconnecting' ||
+            // if `previousAccount.status` is `undefined`, the connector connected immediately.
+            prevData.status === undefined
+          onConnect?.({
+            address,
+            addresses,
+            chain,
+            chainId,
+            connector,
+            isReconnected,
+          })
+        } else if (
+          prevData.status === 'connected' &&
+          data.status === 'disconnected'
+        )
+          onDisconnect?.()
+      },
+    })
+    onCleanup(() => unsubscribe())
+  })
+}
+
+export namespace useConnectionEffect {
+  export type Parameters = Accessor<SolidParameters>
+
+  export type SolidParameters = Compute<
+    {
+      onConnect?(
+        data: Compute<
+          Pick<
+            Extract<GetConnectionReturnType, { status: 'connected' }>,
+            'address' | 'addresses' | 'chain' | 'chainId' | 'connector'
+          > & {
+            isReconnected: boolean
+          }
+        >,
+      ): void
+      onDisconnect?(): void
+    } & ConfigParameter
+  >
+}

package/src/primitives/useConnections.ts

@@ -0,0 +1,34 @@
+import {
+  type GetConnectionsReturnType,
+  getConnections,
+  watchConnections,
+} from '@wagmi/core'
+import type { ConfigParameter } from '@wagmi/core/internal'
+import { type Accessor, createEffect, createSignal, onCleanup } from 'solid-js'
+import { useConfig } from './useConfig.js'
+
+/** https://wagmi.sh/solid/api/primitives/useConnections */
+export function useConnections(
+  parameters: useConnections.Parameters = () => ({}),
+): useConnections.ReturnType {
+  const config = useConfig(parameters)
+  const [connections, setConnections] = createSignal(getConnections(config()))
+  createEffect(() => {
+    const _config = config()
+    setConnections(() => getConnections(_config))
+    const unsubscribe = watchConnections(_config, {
+      onChange(data) {
+        setConnections(() => data)
+      },
+    })
+    onCleanup(() => unsubscribe())
+  })
+  return connections
+}
+
+export namespace useConnections {
+  export type Parameters = Accessor<SolidParameters>
+  export type ReturnType = Accessor<SolidReturnType>
+  export type SolidParameters = ConfigParameter
+  export type SolidReturnType = GetConnectionsReturnType
+}

package/src/primitives/useConnectorClient.ts

@@ -0,0 +1,86 @@
+import { useQueryClient } from '@tanstack/solid-query'
+import type {
+  Config,
+  GetConnectorClientErrorType,
+  ResolvedRegister,
+} from '@wagmi/core'
+import type { Compute, ConfigParameter } from '@wagmi/core/internal'
+import {
+  type GetConnectorClientData,
+  type GetConnectorClientOptions,
+  getConnectorClientQueryOptions,
+} from '@wagmi/core/query'
+import type { Accessor } from 'solid-js'
+import { createEffect, createMemo, on } from 'solid-js'
+import { type UseQueryReturnType, useQuery } from '../utils/query.js'
+import { useChainId } from './useChainId.js'
+import { useConfig } from './useConfig.js'
+import { useConnection } from './useConnection.js'
+
+/** https://wagmi.sh/solid/api/primitives/useConnectorClient */
+export function useConnectorClient<
+  config extends Config = ResolvedRegister['config'],
+  chainId extends
+    config['chains'][number]['id'] = config['chains'][number]['id'],
+  selectData = GetConnectorClientData<config, chainId>,
+>(
+  parameters: useConnectorClient.Parameters<
+    config,
+    chainId,
+    selectData
+  > = () => ({}),
+): useConnectorClient.ReturnType<config, chainId, selectData> {
+  const config = useConfig(parameters)
+  const chainId = useChainId(() => ({ config: config() }))
+  const connection = useConnection(() => ({ config: config() }))
+  const options = createMemo(() =>
+    getConnectorClientQueryOptions<config, chainId>(config(), {
+      ...(parameters() as any),
+      chainId: parameters().chainId ?? chainId(),
+      connector: parameters().connector ?? connection().connector,
+    }),
+  )
+  const queryClient = useQueryClient()
+  createEffect(
+    on(
+      () => connection().address,
+      (currentAddress, previousAddress) => {
+        if (!currentAddress && previousAddress) {
+          // remove when account is disconnected
+          queryClient.removeQueries({ queryKey: options().queryKey })
+        } else if (currentAddress !== previousAddress) {
+          // invalidate when address changes
+          queryClient.invalidateQueries({ queryKey: options().queryKey })
+        }
+      },
+      { defer: true },
+    ),
+  )
+  return useQuery(options) as any
+}
+
+export namespace useConnectorClient {
+  export type Parameters<
+    config extends Config = Config,
+    chainId extends
+      config['chains'][number]['id'] = config['chains'][number]['id'],
+    selectData = GetConnectorClientData<config, chainId>,
+  > = Accessor<SolidParameters<config, chainId, selectData>>
+
+  export type ReturnType<
+    config extends Config = Config,
+    chainId extends
+      config['chains'][number]['id'] = config['chains'][number]['id'],
+    selectData = GetConnectorClientData<config, chainId>,
+  > = UseQueryReturnType<selectData, GetConnectorClientErrorType>
+
+  export type SolidParameters<
+    config extends Config = Config,
+    chainId extends
+      config['chains'][number]['id'] = config['chains'][number]['id'],
+    selectData = GetConnectorClientData<config, chainId>,
+  > = Compute<
+    GetConnectorClientOptions<config, chainId, selectData> &
+      ConfigParameter<config>
+  >
+}

package/src/primitives/useConnectors.ts

@@ -0,0 +1,47 @@
+import {
+  type Config,
+  type GetConnectorsReturnType,
+  getConnectors,
+  type ResolvedRegister,
+  watchConnectors,
+} from '@wagmi/core'
+import { type Accessor, createEffect, createSignal, onCleanup } from 'solid-js'
+import { useConfig } from './useConfig.js'
+
+/** https://wagmi.sh/solid/api/primitives/useConnectors */
+export function useConnectors<
+  config extends Config = ResolvedRegister['config'],
+>(
+  parameters: useConnectors.Parameters<config> = () => ({}),
+): useConnectors.ReturnType<config> {
+  const config = useConfig(parameters)
+  const [connectors, setConnectors] = createSignal(getConnectors(config()))
+  createEffect(() => {
+    const _config = config()
+    setConnectors(() => getConnectors(_config))
+
+    const unsubscribe = watchConnectors(_config, {
+      onChange(data) {
+        setConnectors(() => data)
+      },
+    })
+    onCleanup(() => unsubscribe())
+  })
+  return connectors
+}
+
+export namespace useConnectors {
+  export type Parameters<config extends Config = Config> = Accessor<
+    SolidParameters<config>
+  >
+
+  export type ReturnType<config extends Config = Config> = Accessor<
+    SolidReturnType<config>
+  >
+
+  export type SolidParameters<config extends Config = Config> =
+    useConfig.SolidParameters<config>
+
+  export type SolidReturnType<config extends Config = Config> =
+    GetConnectorsReturnType<config>
+}

package/src/primitives/useDisconnect.ts

@@ -0,0 +1,44 @@
+import { createMutation as useMutation } from '@tanstack/solid-query'
+import type { DisconnectErrorType } from '@wagmi/core'
+import type { Compute, ConfigParameter } from '@wagmi/core/internal'
+import {
+  type DisconnectData,
+  type DisconnectMutate,
+  type DisconnectMutateAsync,
+  type DisconnectOptions,
+  type DisconnectVariables,
+  disconnectMutationOptions,
+} from '@wagmi/core/query'
+import type { Accessor } from 'solid-js'
+import type { UseMutationReturnType } from '../utils/query.js'
+import { useConfig } from './useConfig.js'
+
+/** https://wagmi.sh/solid/api/primitives/useDisconnect */
+export function useDisconnect<context = unknown>(
+  parameters: useDisconnect.Parameters<context> = () => ({}),
+): useDisconnect.ReturnType<context> {
+  const config = useConfig(parameters)
+  const mutation = useMutation(() =>
+    disconnectMutationOptions(config(), parameters()),
+  )
+  return mutation as useDisconnect.ReturnType<context>
+}
+
+export namespace useDisconnect {
+  export type Parameters<context = unknown> = Accessor<SolidParameters<context>>
+
+  export type ReturnType<context = unknown> = Compute<
+    UseMutationReturnType<
+      DisconnectData,
+      DisconnectErrorType,
+      DisconnectVariables,
+      context,
+      DisconnectMutate<context>,
+      DisconnectMutateAsync<context>
+    >
+  >
+
+  export type SolidParameters<context = unknown> = Compute<
+    ConfigParameter & DisconnectOptions<context>
+  >
+}

package/src/primitives/useReconnect.ts

@@ -0,0 +1,44 @@
+import { createMutation as useMutation } from '@tanstack/solid-query'
+import type { ReconnectErrorType } from '@wagmi/core'
+import type { Compute, ConfigParameter } from '@wagmi/core/internal'
+import {
+  type ReconnectData,
+  type ReconnectMutate,
+  type ReconnectMutateAsync,
+  type ReconnectOptions,
+  type ReconnectVariables,
+  reconnectMutationOptions,
+} from '@wagmi/core/query'
+import type { Accessor } from 'solid-js'
+import type { UseMutationReturnType } from '../utils/query.js'
+import { useConfig } from './useConfig.js'
+
+/** https://wagmi.sh/solid/api/primitives/useReconnect */
+export function useReconnect<context = unknown>(
+  parameters: useReconnect.Parameters<context> = () => ({}),
+): useReconnect.ReturnType<context> {
+  const config = useConfig(parameters)
+  const mutation = useMutation(() =>
+    reconnectMutationOptions(config(), parameters()),
+  )
+  return mutation as useReconnect.ReturnType<context>
+}
+
+export namespace useReconnect {
+  export type Parameters<context = unknown> = Accessor<SolidParameters<context>>
+
+  export type ReturnType<context = unknown> = Compute<
+    UseMutationReturnType<
+      ReconnectData,
+      ReconnectErrorType,
+      ReconnectVariables,
+      context,
+      ReconnectMutate<context>,
+      ReconnectMutateAsync<context>
+    >
+  >
+
+  export type SolidParameters<context = unknown> = Compute<
+    ConfigParameter & ReconnectOptions<context>
+  >
+}

package/src/primitives/useSwitchChain.ts

@@ -0,0 +1,58 @@
+import { createMutation as useMutation } from '@tanstack/solid-query'
+import type {
+  Config,
+  ResolvedRegister,
+  SwitchChainErrorType,
+} from '@wagmi/core'
+import type { Compute, ConfigParameter } from '@wagmi/core/internal'
+import {
+  type SwitchChainData,
+  type SwitchChainMutate,
+  type SwitchChainMutateAsync,
+  type SwitchChainOptions,
+  type SwitchChainVariables,
+  switchChainMutationOptions,
+} from '@wagmi/core/query'
+import type { Accessor } from 'solid-js'
+import type { UseMutationReturnType } from '../utils/query.js'
+import { useConfig } from './useConfig.js'
+
+/** https://wagmi.sh/solid/api/primitives/useSwitchChain */
+export function useSwitchChain<
+  config extends Config = ResolvedRegister['config'],
+  context = unknown,
+>(
+  parameters: useSwitchChain.Parameters<config, context> = () => ({}),
+): useSwitchChain.ReturnType<config, context> {
+  const config = useConfig(parameters)
+  const mutation = useMutation(() =>
+    switchChainMutationOptions(config(), parameters()),
+  )
+  return mutation as useSwitchChain.ReturnType<config, context>
+}
+
+export namespace useSwitchChain {
+  export type Parameters<
+    config extends Config = Config,
+    context = unknown,
+  > = Accessor<SolidParameters<config, context>>
+
+  export type ReturnType<
+    config extends Config = Config,
+    context = unknown,
+  > = Compute<
+    UseMutationReturnType<
+      SwitchChainData<config, config['chains'][number]['id']>,
+      SwitchChainErrorType,
+      SwitchChainVariables<config, config['chains'][number]['id']>,
+      context,
+      SwitchChainMutate<config, context>,
+      SwitchChainMutateAsync<config, context>
+    >
+  >
+
+  export type SolidParameters<
+    config extends Config = Config,
+    context = unknown,
+  > = Compute<ConfigParameter<config> & SwitchChainOptions<config, context>>
+}

package/src/primitives/useSwitchConnection.ts

@@ -0,0 +1,60 @@
+import { createMutation as useMutation } from '@tanstack/solid-query'
+import type {
+  Config,
+  ResolvedRegister,
+  SwitchConnectionErrorType,
+} from '@wagmi/core'
+import type { Compute, ConfigParameter } from '@wagmi/core/internal'
+import {
+  type SwitchConnectionData,
+  type SwitchConnectionMutate,
+  type SwitchConnectionMutateAsync,
+  type SwitchConnectionOptions,
+  type SwitchConnectionVariables,
+  switchConnectionMutationOptions,
+} from '@wagmi/core/query'
+import type { Accessor } from 'solid-js'
+import type { UseMutationReturnType } from '../utils/query.js'
+import { useConfig } from './useConfig.js'
+
+/** https://wagmi.sh/solid/api/primitives/useSwitchConnection */
+export function useSwitchConnection<
+  config extends Config = ResolvedRegister['config'],
+  context = unknown,
+>(
+  parameters: useSwitchConnection.Parameters<config, context> = () => ({}),
+): useSwitchConnection.ReturnType<config, context> {
+  const config = useConfig<config>(parameters)
+  const mutation = useMutation(() =>
+    switchConnectionMutationOptions(config(), parameters()),
+  )
+  return mutation as useSwitchConnection.ReturnType<config, context>
+}
+
+export namespace useSwitchConnection {
+  export type Parameters<
+    config extends Config = Config,
+    context = unknown,
+  > = Accessor<SolidParameters<config, context>>
+
+  export type ReturnType<
+    config extends Config = Config,
+    context = unknown,
+  > = Compute<
+    UseMutationReturnType<
+      SwitchConnectionData<config>,
+      SwitchConnectionErrorType,
+      SwitchConnectionVariables,
+      context,
+      SwitchConnectionMutate<config, context>,
+      SwitchConnectionMutateAsync<config, context>
+    >
+  >
+
+  export type SolidParameters<
+    config extends Config = Config,
+    context = unknown,
+  > = Compute<
+    ConfigParameter<config> & SwitchConnectionOptions<config, context>
+  >
+}