@growae/reactive-react 0.0.1 → 0.0.2

package/src/hooks/useBlock.ts

@@ -1,16 +1,16 @@
 'use client'
 
 import {
+  type GetBlockErrorType,
   type GetBlockParameters,
   type GetBlockReturnType,
-  type GetBlockErrorType,
   getBlock,
 } 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 UseBlockParameters = Compute<
   GetBlockParameters & ConfigParameter & { enabled?: boolean }
@@ -28,15 +28,19 @@ export function useBlock(
   const networkId = useNetworkId({ config })
 
   return useQuery({
-    queryKey: ['block', {
-      height: parameters.height,
-      hash: parameters.hash,
-      networkId: parameters.networkId ?? networkId,
-    }],
-    queryFn: () => getBlock(config, {
-      ...parameters,
-      networkId: parameters.networkId ?? networkId,
-    }),
+    queryKey: [
+      'block',
+      {
+        height: parameters.height,
+        hash: parameters.hash,
+        networkId: parameters.networkId ?? networkId,
+      },
+    ],
+    queryFn: () =>
+      getBlock(config, {
+        ...parameters,
+        networkId: parameters.networkId ?? networkId,
+      }),
     enabled: parameters.enabled ?? true,
   }) as UseBlockReturnType
 }

package/src/hooks/useBuildTransaction.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 { useBuildTransaction } from './useBuildTransaction'
+
+describe('useBuildTransaction', () => {
+  it('should be a function', () => {
+    expect(typeof useBuildTransaction).toBe('function')
+  })
+
+  it('should be exported', () => {
+    expect(useBuildTransaction).toBeDefined()
+  })
+
+  it('should return mutation with convenience aliases', () => {
+    const result = useBuildTransaction()
+    expect(result).toHaveProperty('buildTransaction')
+    expect(result).toHaveProperty('buildTransactionAsync')
+    expect(typeof result.buildTransaction).toBe('function')
+    expect(typeof result.buildTransactionAsync).toBe('function')
+  })
+})

package/src/hooks/useBuildTransaction.ts

@@ -0,0 +1,65 @@
+'use client'
+
+import {
+  type BuildTransactionErrorType,
+  type BuildTransactionParameters,
+  type BuildTransactionReturnType,
+  buildTransaction,
+} from '@growae/reactive'
+import type { Compute } from '@growae/reactive'
+import { useMutation } from '@tanstack/react-query'
+import type { ConfigParameter } from '../types/properties'
+import type { UseMutationReturnType } from '../utils/query'
+import { useConfig } from './useConfig'
+
+export type UseBuildTransactionParameters<context = unknown> = Compute<
+  ConfigParameter & {
+    mutation?: {
+      onSuccess?: (
+        data: BuildTransactionReturnType,
+        variables: BuildTransactionParameters,
+        context: context,
+      ) => void
+      onError?: (
+        error: BuildTransactionErrorType,
+        variables: BuildTransactionParameters,
+        context: context,
+      ) => void
+    }
+  }
+>
+
+export type UseBuildTransactionReturnType<context = unknown> = Compute<
+  UseMutationReturnType<
+    BuildTransactionReturnType,
+    BuildTransactionErrorType,
+    BuildTransactionParameters,
+    context
+  > & {
+    buildTransaction: (variables: BuildTransactionParameters) => void
+    buildTransactionAsync: (
+      variables: BuildTransactionParameters,
+    ) => Promise<BuildTransactionReturnType>
+  }
+>
+
+export function useBuildTransaction<context = unknown>(
+  parameters: UseBuildTransactionParameters<context> = {},
+): UseBuildTransactionReturnType<context> {
+  const config = useConfig(parameters)
+
+  const mutation = useMutation({
+    mutationKey: ['buildTransaction'],
+    mutationFn: (variables: BuildTransactionParameters) =>
+      buildTransaction(config, variables),
+    ...parameters.mutation,
+  } as any)
+
+  type Return = UseBuildTransactionReturnType<context>
+  return {
+    ...(mutation as unknown as Return),
+    buildTransaction: mutation.mutate as unknown as Return['buildTransaction'],
+    buildTransactionAsync:
+      mutation.mutateAsync as unknown as Return['buildTransactionAsync'],
+  }
+}

package/src/hooks/useCallContract.test.ts

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

package/src/hooks/useCallContract.ts

@@ -1,22 +1,30 @@
 'use client'
 
-import { useMutation } from '@tanstack/react-query'
 import {
+  type CallContractErrorType,
   type CallContractParameters,
   type CallContractReturnType,
-  type CallContractErrorType,
   callContract,
 } 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 UseCallContractParameters<context = unknown> = Compute<
   ConfigParameter & {
     mutation?: {
-      onSuccess?: (data: CallContractReturnType, variables: CallContractParameters, context: context) => void
-      onError?: (error: CallContractErrorType, variables: CallContractParameters, context: context) => void
+      onSuccess?: (
+        data: CallContractReturnType,
+        variables: CallContractParameters,
+        context: context,
+      ) => void
+      onError?: (
+        error: CallContractErrorType,
+        variables: CallContractParameters,
+        context: context,
+      ) => void
     }
   }
 >
@@ -29,7 +37,9 @@ export type UseCallContractReturnType<context = unknown> = Compute<
     context
   > & {
     callContract: (variables: CallContractParameters) => void
-    callContractAsync: (variables: CallContractParameters) => Promise<CallContractReturnType>
+    callContractAsync: (
+      variables: CallContractParameters,
+    ) => Promise<CallContractReturnType>
   }
 >
 
@@ -43,12 +53,13 @@ export function useCallContract<context = unknown>(
     mutationFn: (variables: CallContractParameters) =>
       callContract(config, variables),
     ...parameters.mutation,
-  })
+  } as any)
 
   type Return = UseCallContractReturnType<context>
   return {
     ...(mutation as unknown as Return),
-    callContract: mutation.mutate as Return['callContract'],
-    callContractAsync: mutation.mutateAsync as Return['callContractAsync'],
+    callContract: mutation.mutate as unknown as Return['callContract'],
+    callContractAsync:
+      mutation.mutateAsync as unknown as Return['callContractAsync'],
   }
 }

package/src/hooks/useChannelDeposit.test.ts

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

package/src/hooks/useChannelDeposit.ts

@@ -1,21 +1,29 @@
 'use client'
 
-import { useMutation } from '@tanstack/react-query'
 import {
   type ChannelDepositParameters,
   type ChannelDepositReturnType,
   channelDeposit,
 } 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 UseChannelDepositParameters<context = unknown> = Compute<
   ConfigParameter & {
     mutation?: {
-      onSuccess?: (data: ChannelDepositReturnType, variables: ChannelDepositParameters, context: context) => void
-      onError?: (error: Error, variables: ChannelDepositParameters, context: context) => void
+      onSuccess?: (
+        data: ChannelDepositReturnType,
+        variables: ChannelDepositParameters,
+        context: context,
+      ) => void
+      onError?: (
+        error: Error,
+        variables: ChannelDepositParameters,
+        context: context,
+      ) => void
     }
   }
 >
@@ -28,7 +36,9 @@ export type UseChannelDepositReturnType<context = unknown> = Compute<
     context
   > & {
     channelDeposit: (variables: ChannelDepositParameters) => void
-    channelDepositAsync: (variables: ChannelDepositParameters) => Promise<ChannelDepositReturnType>
+    channelDepositAsync: (
+      variables: ChannelDepositParameters,
+    ) => Promise<ChannelDepositReturnType>
   }
 >
 
@@ -42,12 +52,13 @@ export function useChannelDeposit<context = unknown>(
     mutationFn: (variables: ChannelDepositParameters) =>
       channelDeposit(config, variables),
     ...parameters.mutation,
-  })
+  } as any)
 
   type Return = UseChannelDepositReturnType<context>
   return {
     ...(mutation as unknown as Return),
-    channelDeposit: mutation.mutate as Return['channelDeposit'],
-    channelDepositAsync: mutation.mutateAsync as Return['channelDepositAsync'],
+    channelDeposit: mutation.mutate as unknown as Return['channelDeposit'],
+    channelDepositAsync:
+      mutation.mutateAsync as unknown as Return['channelDepositAsync'],
   }
 }

package/src/hooks/useClaimName.test.ts

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

package/src/hooks/useClaimName.ts

@@ -1,21 +1,29 @@
 'use client'
 
-import { useMutation } from '@tanstack/react-query'
 import {
   type ClaimNameParameters,
   type ClaimNameReturnType,
   claimName,
 } 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 UseClaimNameParameters<context = unknown> = Compute<
   ConfigParameter & {
     mutation?: {
-      onSuccess?: (data: ClaimNameReturnType, variables: ClaimNameParameters, context: context) => void
-      onError?: (error: Error, variables: ClaimNameParameters, context: context) => void
+      onSuccess?: (
+        data: ClaimNameReturnType,
+        variables: ClaimNameParameters,
+        context: context,
+      ) => void
+      onError?: (
+        error: Error,
+        variables: ClaimNameParameters,
+        context: context,
+      ) => void
     }
   }
 >
@@ -28,7 +36,9 @@ export type UseClaimNameReturnType<context = unknown> = Compute<
     context
   > & {
     claimName: (variables: ClaimNameParameters) => void
-    claimNameAsync: (variables: ClaimNameParameters) => Promise<ClaimNameReturnType>
+    claimNameAsync: (
+      variables: ClaimNameParameters,
+    ) => Promise<ClaimNameReturnType>
   }
 >
 
@@ -42,12 +52,12 @@ export function useClaimName<context = unknown>(
     mutationFn: (variables: ClaimNameParameters) =>
       claimName(config, variables),
     ...parameters.mutation,
-  })
+  } as any)
 
   type Return = UseClaimNameReturnType<context>
   return {
     ...(mutation as unknown as Return),
-    claimName: mutation.mutate as Return['claimName'],
-    claimNameAsync: mutation.mutateAsync as Return['claimNameAsync'],
+    claimName: mutation.mutate as unknown as Return['claimName'],
+    claimNameAsync: mutation.mutateAsync as unknown as Return['claimNameAsync'],
   }
 }

package/src/hooks/useCloseChannel.test.ts

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

package/src/hooks/useCloseChannel.ts

@@ -1,21 +1,29 @@
 'use client'
 
-import { useMutation } from '@tanstack/react-query'
 import {
   type CloseChannelParameters,
   type CloseChannelReturnType,
   closeChannel,
 } 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 UseCloseChannelParameters<context = unknown> = Compute<
   ConfigParameter & {
     mutation?: {
-      onSuccess?: (data: CloseChannelReturnType, variables: CloseChannelParameters, context: context) => void
-      onError?: (error: Error, variables: CloseChannelParameters, context: context) => void
+      onSuccess?: (
+        data: CloseChannelReturnType,
+        variables: CloseChannelParameters,
+        context: context,
+      ) => void
+      onError?: (
+        error: Error,
+        variables: CloseChannelParameters,
+        context: context,
+      ) => void
     }
   }
 >
@@ -28,7 +36,9 @@ export type UseCloseChannelReturnType<context = unknown> = Compute<
     context
   > & {
     closeChannel: (variables: CloseChannelParameters) => void
-    closeChannelAsync: (variables: CloseChannelParameters) => Promise<CloseChannelReturnType>
+    closeChannelAsync: (
+      variables: CloseChannelParameters,
+    ) => Promise<CloseChannelReturnType>
   }
 >
 
@@ -42,12 +52,13 @@ export function useCloseChannel<context = unknown>(
     mutationFn: (variables: CloseChannelParameters) =>
       closeChannel(config, variables),
     ...parameters.mutation,
-  })
+  } as any)
 
   type Return = UseCloseChannelReturnType<context>
   return {
     ...(mutation as unknown as Return),
-    closeChannel: mutation.mutate as Return['closeChannel'],
-    closeChannelAsync: mutation.mutateAsync as Return['closeChannelAsync'],
+    closeChannel: mutation.mutate as unknown as Return['closeChannel'],
+    closeChannelAsync:
+      mutation.mutateAsync as unknown as Return['closeChannelAsync'],
   }
 }

package/src/hooks/useCompileContract.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 { useCompileContract } from './useCompileContract'
+
+describe('useCompileContract', () => {
+  it('should be a function', () => {
+    expect(typeof useCompileContract).toBe('function')
+  })
+
+  it('should be exported', () => {
+    expect(useCompileContract).toBeDefined()
+  })
+
+  it('should return mutation with convenience aliases', () => {
+    const result = useCompileContract()
+    expect(result).toHaveProperty('compileContract')
+    expect(result).toHaveProperty('compileContractAsync')
+    expect(typeof result.compileContract).toBe('function')
+    expect(typeof result.compileContractAsync).toBe('function')
+  })
+})

package/src/hooks/useCompileContract.ts

@@ -0,0 +1,65 @@
+'use client'
+
+import {
+  type CompileContractErrorType,
+  type CompileContractParameters,
+  type CompileContractReturnType,
+  compileContract,
+} from '@growae/reactive'
+import type { Compute } from '@growae/reactive'
+import { useMutation } from '@tanstack/react-query'
+import type { ConfigParameter } from '../types/properties'
+import type { UseMutationReturnType } from '../utils/query'
+import { useConfig } from './useConfig'
+
+export type UseCompileContractParameters<context = unknown> = Compute<
+  ConfigParameter & {
+    mutation?: {
+      onSuccess?: (
+        data: CompileContractReturnType,
+        variables: CompileContractParameters,
+        context: context,
+      ) => void
+      onError?: (
+        error: CompileContractErrorType,
+        variables: CompileContractParameters,
+        context: context,
+      ) => void
+    }
+  }
+>
+
+export type UseCompileContractReturnType<context = unknown> = Compute<
+  UseMutationReturnType<
+    CompileContractReturnType,
+    CompileContractErrorType,
+    CompileContractParameters,
+    context
+  > & {
+    compileContract: (variables: CompileContractParameters) => void
+    compileContractAsync: (
+      variables: CompileContractParameters,
+    ) => Promise<CompileContractReturnType>
+  }
+>
+
+export function useCompileContract<context = unknown>(
+  parameters: UseCompileContractParameters<context> = {},
+): UseCompileContractReturnType<context> {
+  const config = useConfig(parameters)
+
+  const mutation = useMutation({
+    mutationKey: ['compileContract'],
+    mutationFn: (variables: CompileContractParameters) =>
+      compileContract(config, variables),
+    ...parameters.mutation,
+  } as any)
+
+  type Return = UseCompileContractReturnType<context>
+  return {
+    ...(mutation as unknown as Return),
+    compileContract: mutation.mutate as unknown as Return['compileContract'],
+    compileContractAsync:
+      mutation.mutateAsync as unknown as Return['compileContractAsync'],
+  }
+}

package/src/hooks/useConfig.test.ts

@@ -1,17 +1,17 @@
 // @vitest-environment jsdom
-import { describe, it, expect, vi } from 'vitest'
+import { describe, expect, it, vi } from 'vitest'
 
 vi.mock('@aeternity/aepp-sdk', () => ({
   Node: vi.fn().mockImplementation(() => ({})),
 }))
 
-import { createElement } from 'react'
-import { renderHook } from '@testing-library/react'
-import { useConfig } from './useConfig.js'
-import { ReactiveProvider } from '../context.js'
 import { createConfig } from '@growae/reactive'
 import { testnet } from '@growae/reactive'
 import { mock } from '@growae/reactive'
+import { renderHook } from '@testing-library/react'
+import { createElement } from 'react'
+import { ReactiveProvider } from '../context'
+import { useConfig } from './useConfig'
 
 const TEST_ACCOUNTS = [
   'ak_2swhLkgBPeeADxVTABy7tt6d2HgBQFnGJELkBUMY4FUa8RVLM',

package/src/hooks/useConfig.ts

@@ -2,9 +2,9 @@
 
 import type { Config } from '@growae/reactive'
 import { useContext } from 'react'
-import { ReactiveContext } from '../context.js'
-import { ReactiveProviderNotFoundError } from '../errors/context.js'
-import type { ConfigParameter } from '../types/properties.js'
+import { ReactiveContext } from '../context'
+import { ReactiveProviderNotFoundError } from '../errors/context'
+import type { ConfigParameter } from '../types/properties'
 
 export type UseConfigParameters<config extends Config = Config> =
   ConfigParameter<config>

package/src/hooks/useConnect.test.ts

@@ -1,18 +1,18 @@
 // @vitest-environment jsdom
-import { describe, it, expect, vi } from 'vitest'
+import { describe, expect, it, vi } from 'vitest'
 
 vi.mock('@aeternity/aepp-sdk', () => ({
   Node: vi.fn().mockImplementation(() => ({})),
 }))
 
-import { createElement } from 'react'
-import { renderHook } from '@testing-library/react'
-import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
-import { useConnect } from './useConnect.js'
-import { ReactiveProvider } from '../context.js'
 import { createConfig } from '@growae/reactive'
 import { testnet } from '@growae/reactive'
 import { mock } from '@growae/reactive'
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
+import { renderHook } from '@testing-library/react'
+import { createElement } from 'react'
+import { ReactiveProvider } from '../context'
+import { useConnect } from './useConnect'
 
 const TEST_ACCOUNTS = [
   'ak_2swhLkgBPeeADxVTABy7tt6d2HgBQFnGJELkBUMY4FUa8RVLM',