@growae/reactive-react 0.0.1 → 0.0.2

package/src/hooks/useSignMessage.ts

@@ -1,22 +1,30 @@
 'use client'
 
-import { useMutation } from '@tanstack/react-query'
 import {
+  type SignMessageErrorType,
   type SignMessageParameters,
   type SignMessageReturnType,
-  type SignMessageErrorType,
   signMessage,
 } from '@growae/reactive'
 import type { Compute } from '@growae/reactive'
-import type { ConfigParameter } from '../types/properties.js'
-import type { UseMutationReturnType } from '../utils/query.js'
-import { useConfig } from './useConfig.js'
+import { useMutation } from '@tanstack/react-query'
+import type { ConfigParameter } from '../types/properties'
+import type { UseMutationReturnType } from '../utils/query'
+import { useConfig } from './useConfig'
 
 export type UseSignMessageParameters<context = unknown> = Compute<
   ConfigParameter & {
     mutation?: {
-      onSuccess?: (data: SignMessageReturnType, variables: SignMessageParameters, context: context) => void
-      onError?: (error: SignMessageErrorType, variables: SignMessageParameters, context: context) => void
+      onSuccess?: (
+        data: SignMessageReturnType,
+        variables: SignMessageParameters,
+        context: context,
+      ) => void
+      onError?: (
+        error: SignMessageErrorType,
+        variables: SignMessageParameters,
+        context: context,
+      ) => void
     }
   }
 >
@@ -29,7 +37,9 @@ export type UseSignMessageReturnType<context = unknown> = Compute<
     context
   > & {
     signMessage: (variables: SignMessageParameters) => void
-    signMessageAsync: (variables: SignMessageParameters) => Promise<SignMessageReturnType>
+    signMessageAsync: (
+      variables: SignMessageParameters,
+    ) => Promise<SignMessageReturnType>
   }
 >
 
@@ -43,12 +53,13 @@ export function useSignMessage<context = unknown>(
     mutationFn: (variables: SignMessageParameters) =>
       signMessage(config, variables),
     ...parameters.mutation,
-  })
+  } as any)
 
   type Return = UseSignMessageReturnType<context>
   return {
     ...(mutation as unknown as Return),
-    signMessage: mutation.mutate as Return['signMessage'],
-    signMessageAsync: mutation.mutateAsync as Return['signMessageAsync'],
+    signMessage: mutation.mutate as unknown as Return['signMessage'],
+    signMessageAsync:
+      mutation.mutateAsync as unknown as Return['signMessageAsync'],
   }
 }

package/src/hooks/useSignTransaction.test.ts

@@ -1,5 +1,5 @@
-import { describe, it, expect } from 'vitest'
-import { useSignTransaction } from './useSignTransaction.js'
+import { describe, expect, it } from 'vitest'
+import { useSignTransaction } from './useSignTransaction'
 
 describe('useSignTransaction', () => {
   it('should be a function', () => {

package/src/hooks/useSignTransaction.ts

@@ -1,22 +1,30 @@
 'use client'
 
-import { useMutation } from '@tanstack/react-query'
 import {
+  type SignTransactionErrorType,
   type SignTransactionParameters,
   type SignTransactionReturnType,
-  type SignTransactionErrorType,
   signTransaction,
 } from '@growae/reactive'
 import type { Compute } from '@growae/reactive'
-import type { ConfigParameter } from '../types/properties.js'
-import type { UseMutationReturnType } from '../utils/query.js'
-import { useConfig } from './useConfig.js'
+import { useMutation } from '@tanstack/react-query'
+import type { ConfigParameter } from '../types/properties'
+import type { UseMutationReturnType } from '../utils/query'
+import { useConfig } from './useConfig'
 
 export type UseSignTransactionParameters<context = unknown> = Compute<
   ConfigParameter & {
     mutation?: {
-      onSuccess?: (data: SignTransactionReturnType, variables: SignTransactionParameters, context: context) => void
-      onError?: (error: SignTransactionErrorType, variables: SignTransactionParameters, context: context) => void
+      onSuccess?: (
+        data: SignTransactionReturnType,
+        variables: SignTransactionParameters,
+        context: context,
+      ) => void
+      onError?: (
+        error: SignTransactionErrorType,
+        variables: SignTransactionParameters,
+        context: context,
+      ) => void
     }
   }
 >
@@ -29,7 +37,9 @@ export type UseSignTransactionReturnType<context = unknown> = Compute<
     context
   > & {
     signTransaction: (variables: SignTransactionParameters) => void
-    signTransactionAsync: (variables: SignTransactionParameters) => Promise<SignTransactionReturnType>
+    signTransactionAsync: (
+      variables: SignTransactionParameters,
+    ) => Promise<SignTransactionReturnType>
   }
 >
 
@@ -43,12 +53,13 @@ export function useSignTransaction<context = unknown>(
     mutationFn: (variables: SignTransactionParameters) =>
       signTransaction(config, variables),
     ...parameters.mutation,
-  })
+  } as any)
 
   type Return = UseSignTransactionReturnType<context>
   return {
     ...(mutation as unknown as Return),
-    signTransaction: mutation.mutate as Return['signTransaction'],
-    signTransactionAsync: mutation.mutateAsync as Return['signTransactionAsync'],
+    signTransaction: mutation.mutate as unknown as Return['signTransaction'],
+    signTransactionAsync:
+      mutation.mutateAsync as unknown as Return['signTransactionAsync'],
   }
 }

package/src/hooks/useSignTypedData.test.ts

@@ -1,5 +1,5 @@
-import { describe, it, expect } from 'vitest'
-import { useSignTypedData } from './useSignTypedData.js'
+import { describe, expect, it } from 'vitest'
+import { useSignTypedData } from './useSignTypedData'
 
 describe('useSignTypedData', () => {
   it('should be a function', () => {

package/src/hooks/useSignTypedData.ts

@@ -1,22 +1,30 @@
 'use client'
 
-import { useMutation } from '@tanstack/react-query'
 import {
+  type SignTypedDataErrorType,
   type SignTypedDataParameters,
   type SignTypedDataReturnType,
-  type SignTypedDataErrorType,
   signTypedData,
 } from '@growae/reactive'
 import type { Compute } from '@growae/reactive'
-import type { ConfigParameter } from '../types/properties.js'
-import type { UseMutationReturnType } from '../utils/query.js'
-import { useConfig } from './useConfig.js'
+import { useMutation } from '@tanstack/react-query'
+import type { ConfigParameter } from '../types/properties'
+import type { UseMutationReturnType } from '../utils/query'
+import { useConfig } from './useConfig'
 
 export type UseSignTypedDataParameters<context = unknown> = Compute<
   ConfigParameter & {
     mutation?: {
-      onSuccess?: (data: SignTypedDataReturnType, variables: SignTypedDataParameters, context: context) => void
-      onError?: (error: SignTypedDataErrorType, variables: SignTypedDataParameters, context: context) => void
+      onSuccess?: (
+        data: SignTypedDataReturnType,
+        variables: SignTypedDataParameters,
+        context: context,
+      ) => void
+      onError?: (
+        error: SignTypedDataErrorType,
+        variables: SignTypedDataParameters,
+        context: context,
+      ) => void
     }
   }
 >
@@ -29,7 +37,9 @@ export type UseSignTypedDataReturnType<context = unknown> = Compute<
     context
   > & {
     signTypedData: (variables: SignTypedDataParameters) => void
-    signTypedDataAsync: (variables: SignTypedDataParameters) => Promise<SignTypedDataReturnType>
+    signTypedDataAsync: (
+      variables: SignTypedDataParameters,
+    ) => Promise<SignTypedDataReturnType>
   }
 >
 
@@ -43,12 +53,13 @@ export function useSignTypedData<context = unknown>(
     mutationFn: (variables: SignTypedDataParameters) =>
       signTypedData(config, variables),
     ...parameters.mutation,
-  })
+  } as any)
 
   type Return = UseSignTypedDataReturnType<context>
   return {
     ...(mutation as unknown as Return),
-    signTypedData: mutation.mutate as Return['signTypedData'],
-    signTypedDataAsync: mutation.mutateAsync as Return['signTypedDataAsync'],
+    signTypedData: mutation.mutate as unknown as Return['signTypedData'],
+    signTypedDataAsync:
+      mutation.mutateAsync as unknown as Return['signTypedDataAsync'],
   }
 }

package/src/hooks/useSimulateContract.test.ts

@@ -1,5 +1,5 @@
-import { describe, it, expect } from 'vitest'
-import { useSimulateContract } from './useSimulateContract.js'
+import { describe, expect, it } from 'vitest'
+import { useSimulateContract } from './useSimulateContract'
 
 describe('useSimulateContract', () => {
   it('should be a function', () => {

package/src/hooks/useSimulateContract.ts

@@ -6,10 +6,10 @@ import {
   simulateContract,
 } from '@growae/reactive'
 import type { Compute } from '@growae/reactive'
-import { type UseQueryReturnType, useQuery } from '../utils/query.js'
-import type { ConfigParameter } from '../types/properties.js'
-import { useConfig } from './useConfig.js'
-import { useNetworkId } from './useNetworkId.js'
+import type { ConfigParameter } from '../types/properties'
+import { type UseQueryReturnType, useQuery } from '../utils/query'
+import { useConfig } from './useConfig'
+import { useNetworkId } from './useNetworkId'
 
 export type UseSimulateContractParameters = Compute<
   SimulateContractParameters & ConfigParameter & { enabled?: boolean }
@@ -27,17 +27,22 @@ export function useSimulateContract(
   const networkId = useNetworkId({ config })
 
   return useQuery({
-    queryKey: ['simulateContract', {
-      address: parameters.address,
-      method: parameters.method,
-      args: parameters.args,
-      networkId: parameters.networkId ?? networkId,
-    }],
-    queryFn: () => simulateContract(config, {
-      ...parameters,
-      networkId: parameters.networkId ?? networkId,
-    }),
-    enabled: Boolean(parameters.address && parameters.aci && parameters.method) &&
+    queryKey: [
+      'simulateContract',
+      {
+        address: parameters.address,
+        method: parameters.method,
+        args: parameters.args,
+        networkId: parameters.networkId ?? networkId,
+      },
+    ],
+    queryFn: () =>
+      simulateContract(config, {
+        ...parameters,
+        networkId: parameters.networkId ?? networkId,
+      }),
+    enabled:
+      Boolean(parameters.address && parameters.aci && parameters.method) &&
       (parameters.enabled ?? true),
   }) as UseSimulateContractReturnType
 }

package/src/hooks/useSpend.test.ts

@@ -1,5 +1,5 @@
-import { describe, it, expect } from 'vitest'
-import { useSpend } from './useSpend.js'
+import { describe, expect, it } from 'vitest'
+import { useSpend } from './useSpend'
 
 describe('useSpend', () => {
   it('should be a function', () => {

package/src/hooks/useSpend.ts

@@ -1,22 +1,30 @@
 'use client'
 
-import { useMutation } from '@tanstack/react-query'
 import {
+  type SpendErrorType,
   type SpendParameters,
   type SpendReturnType,
-  type SpendErrorType,
   spend,
 } from '@growae/reactive'
 import type { Compute } from '@growae/reactive'
-import type { ConfigParameter } from '../types/properties.js'
-import type { UseMutationReturnType } from '../utils/query.js'
-import { useConfig } from './useConfig.js'
+import { useMutation } from '@tanstack/react-query'
+import type { ConfigParameter } from '../types/properties'
+import type { UseMutationReturnType } from '../utils/query'
+import { useConfig } from './useConfig'
 
 export type UseSpendParameters<context = unknown> = Compute<
   ConfigParameter & {
     mutation?: {
-      onSuccess?: (data: SpendReturnType, variables: SpendParameters, context: context) => void
-      onError?: (error: SpendErrorType, variables: SpendParameters, context: context) => void
+      onSuccess?: (
+        data: SpendReturnType,
+        variables: SpendParameters,
+        context: context,
+      ) => void
+      onError?: (
+        error: SpendErrorType,
+        variables: SpendParameters,
+        context: context,
+      ) => void
     }
   }
 >
@@ -42,12 +50,12 @@ export function useSpend<context = unknown>(
     mutationKey: ['spend'],
     mutationFn: (variables: SpendParameters) => spend(config, variables),
     ...parameters.mutation,
-  })
+  } as any)
 
   type Return = UseSpendReturnType<context>
   return {
     ...(mutation as unknown as Return),
-    spend: mutation.mutate as Return['spend'],
-    spendAsync: mutation.mutateAsync as Return['spendAsync'],
+    spend: mutation.mutate as unknown as Return['spend'],
+    spendAsync: mutation.mutateAsync as unknown as Return['spendAsync'],
   }
 }

package/src/hooks/useSwitchActiveAccount.ts

@@ -0,0 +1,38 @@
+'use client'
+
+import {
+  type SwitchActiveAccountParameters,
+  switchActiveAccount,
+} from '@growae/reactive'
+import { useMutation } from '@tanstack/react-query'
+import type { ConfigParameter } from '../types/properties'
+import { useConfig } from './useConfig'
+
+export type UseSwitchActiveAccountParameters = ConfigParameter
+
+export type UseSwitchActiveAccountReturnType = {
+  switchActiveAccount: (params: SwitchActiveAccountParameters) => void
+  isPending: boolean
+  error: Error | null
+}
+
+export function useSwitchActiveAccount(
+  parameters: UseSwitchActiveAccountParameters = {},
+): UseSwitchActiveAccountReturnType {
+  const config = useConfig(parameters)
+
+  const mutation = useMutation({
+    mutationKey: ['switchActiveAccount'],
+    mutationFn: (params: SwitchActiveAccountParameters) => {
+      switchActiveAccount(config, params)
+      return Promise.resolve()
+    },
+  } as any)
+
+  return {
+    switchActiveAccount:
+      mutation.mutate as unknown as UseSwitchActiveAccountReturnType['switchActiveAccount'],
+    isPending: mutation.isPending,
+    error: mutation.error,
+  }
+}

package/src/hooks/useSwitchNetwork.test.ts

@@ -1,5 +1,5 @@
-import { describe, it, expect } from 'vitest'
-import { useSwitchNetwork } from './useSwitchNetwork.js'
+import { describe, expect, it } from 'vitest'
+import { useSwitchNetwork } from './useSwitchNetwork'
 
 describe('useSwitchNetwork', () => {
   it('should be a function', () => {

package/src/hooks/useSwitchNetwork.ts

@@ -1,23 +1,31 @@
 'use client'
 
-import { useMutation } from '@tanstack/react-query'
 import {
+  type SwitchNetworkErrorType,
   type SwitchNetworkParameters,
   type SwitchNetworkReturnType,
-  type SwitchNetworkErrorType,
   switchNetwork,
 } from '@growae/reactive'
 import type { Compute } from '@growae/reactive'
-import type { ConfigParameter } from '../types/properties.js'
-import type { UseMutationReturnType } from '../utils/query.js'
-import { useConfig } from './useConfig.js'
-import { useNetworks } from './useNetworks.js'
+import { useMutation } from '@tanstack/react-query'
+import type { ConfigParameter } from '../types/properties'
+import type { UseMutationReturnType } from '../utils/query'
+import { useConfig } from './useConfig'
+import { useNetworks } from './useNetworks'
 
 export type UseSwitchNetworkParameters<context = unknown> = Compute<
   ConfigParameter & {
     mutation?: {
-      onSuccess?: (data: SwitchNetworkReturnType, variables: SwitchNetworkParameters, context: context) => void
-      onError?: (error: SwitchNetworkErrorType, variables: SwitchNetworkParameters, context: context) => void
+      onSuccess?: (
+        data: SwitchNetworkReturnType,
+        variables: SwitchNetworkParameters,
+        context: context,
+      ) => void
+      onError?: (
+        error: SwitchNetworkErrorType,
+        variables: SwitchNetworkParameters,
+        context: context,
+      ) => void
     }
   }
 >
@@ -30,7 +38,9 @@ export type UseSwitchNetworkReturnType<context = unknown> = Compute<
     context
   > & {
     switchNetwork: (variables: SwitchNetworkParameters) => void
-    switchNetworkAsync: (variables: SwitchNetworkParameters) => Promise<SwitchNetworkReturnType>
+    switchNetworkAsync: (
+      variables: SwitchNetworkParameters,
+    ) => Promise<SwitchNetworkReturnType>
     networks: ReturnType<typeof useNetworks>
   }
 >
@@ -45,13 +55,14 @@ export function useSwitchNetwork<context = unknown>(
     mutationFn: (variables: SwitchNetworkParameters) =>
       switchNetwork(config, variables),
     ...parameters.mutation,
-  })
+  } as any)
 
   type Return = UseSwitchNetworkReturnType<context>
   return {
     ...(mutation as unknown as Return),
-    switchNetwork: mutation.mutate as Return['switchNetwork'],
-    switchNetworkAsync: mutation.mutateAsync as Return['switchNetworkAsync'],
+    switchNetwork: mutation.mutate as unknown as Return['switchNetwork'],
+    switchNetworkAsync:
+      mutation.mutateAsync as unknown as Return['switchNetworkAsync'],
     networks: useNetworks({ config }),
   }
 }

package/src/hooks/useTransaction.test.ts

@@ -1,5 +1,5 @@
-import { describe, it, expect } from 'vitest'
-import { useTransaction } from './useTransaction.js'
+import { describe, expect, it } from 'vitest'
+import { useTransaction } from './useTransaction'
 
 describe('useTransaction', () => {
   it('should be a function', () => {

package/src/hooks/useTransaction.ts

@@ -1,16 +1,16 @@
 'use client'
 
 import {
+  type GetTransactionErrorType,
   type GetTransactionParameters,
   type GetTransactionReturnType,
-  type GetTransactionErrorType,
   getTransaction,
 } from '@growae/reactive'
 import type { Compute } from '@growae/reactive'
-import { type UseQueryReturnType, useQuery } from '../utils/query.js'
-import type { ConfigParameter } from '../types/properties.js'
-import { useConfig } from './useConfig.js'
-import { useNetworkId } from './useNetworkId.js'
+import type { ConfigParameter } from '../types/properties'
+import { type UseQueryReturnType, useQuery } from '../utils/query'
+import { useConfig } from './useConfig'
+import { useNetworkId } from './useNetworkId'
 
 export type UseTransactionParameters = Compute<
   GetTransactionParameters & ConfigParameter & { enabled?: boolean }
@@ -28,14 +28,18 @@ export function useTransaction(
   const networkId = useNetworkId({ config })
 
   return useQuery({
-    queryKey: ['transaction', {
-      hash: parameters.hash,
-      networkId: parameters.networkId ?? networkId,
-    }],
-    queryFn: () => getTransaction(config, {
-      ...parameters,
-      networkId: parameters.networkId ?? networkId,
-    }),
+    queryKey: [
+      'transaction',
+      {
+        hash: parameters.hash,
+        networkId: parameters.networkId ?? networkId,
+      },
+    ],
+    queryFn: () =>
+      getTransaction(config, {
+        ...parameters,
+        networkId: parameters.networkId ?? networkId,
+      }),
     enabled: Boolean(parameters.hash) && (parameters.enabled ?? true),
   }) as UseTransactionReturnType
 }

package/src/hooks/useTransactionCount.test.ts

@@ -1,5 +1,5 @@
-import { describe, it, expect } from 'vitest'
-import { useTransactionCount } from './useTransactionCount.js'
+import { describe, expect, it } from 'vitest'
+import { useTransactionCount } from './useTransactionCount'
 
 describe('useTransactionCount', () => {
   it('should be a function', () => {

package/src/hooks/useTransactionCount.ts

@@ -1,16 +1,16 @@
 'use client'
 
 import {
+  type GetTransactionCountErrorType,
   type GetTransactionCountParameters,
   type GetTransactionCountReturnType,
-  type GetTransactionCountErrorType,
   getTransactionCount,
 } from '@growae/reactive'
 import type { Compute } from '@growae/reactive'
-import { type UseQueryReturnType, useQuery } from '../utils/query.js'
-import type { ConfigParameter } from '../types/properties.js'
-import { useConfig } from './useConfig.js'
-import { useNetworkId } from './useNetworkId.js'
+import type { ConfigParameter } from '../types/properties'
+import { type UseQueryReturnType, useQuery } from '../utils/query'
+import { useConfig } from './useConfig'
+import { useNetworkId } from './useNetworkId'
 
 export type UseTransactionCountParameters = Compute<
   GetTransactionCountParameters & ConfigParameter & { enabled?: boolean }
@@ -28,14 +28,18 @@ export function useTransactionCount(
   const networkId = useNetworkId({ config })
 
   return useQuery({
-    queryKey: ['transactionCount', {
-      address: parameters.address,
-      networkId: parameters.networkId ?? networkId,
-    }],
-    queryFn: () => getTransactionCount(config, {
-      ...parameters,
-      networkId: parameters.networkId ?? networkId,
-    }),
+    queryKey: [
+      'transactionCount',
+      {
+        address: parameters.address,
+        networkId: parameters.networkId ?? networkId,
+      },
+    ],
+    queryFn: () =>
+      getTransactionCount(config, {
+        ...parameters,
+        networkId: parameters.networkId ?? networkId,
+      }),
     enabled: Boolean(parameters.address) && (parameters.enabled ?? true),
   }) as UseTransactionCountReturnType
 }

package/src/hooks/useTransferFunds.test.ts

@@ -0,0 +1,42 @@
+import { describe, expect, it, vi } from 'vitest'
+
+vi.mock('@tanstack/react-query', () => ({
+  useMutation: vi.fn(() => {
+    const state = {
+      data: undefined,
+      error: null,
+      isPending: false,
+      isSuccess: false,
+      isError: false,
+      status: 'idle' as const,
+      mutate: vi.fn(),
+      mutateAsync: vi.fn(),
+      reset: vi.fn(),
+    }
+    return state
+  }),
+}))
+
+vi.mock('./useConfig.js', () => ({
+  useConfig: vi.fn(() => ({})),
+}))
+
+import { useTransferFunds } from './useTransferFunds'
+
+describe('useTransferFunds', () => {
+  it('should be a function', () => {
+    expect(typeof useTransferFunds).toBe('function')
+  })
+
+  it('should be exported', () => {
+    expect(useTransferFunds).toBeDefined()
+  })
+
+  it('should return mutation with convenience aliases', () => {
+    const result = useTransferFunds()
+    expect(result).toHaveProperty('transferFunds')
+    expect(result).toHaveProperty('transferFundsAsync')
+    expect(typeof result.transferFunds).toBe('function')
+    expect(typeof result.transferFundsAsync).toBe('function')
+  })
+})