@growae/reactive-react 0.0.1 → 0.0.2

package/src/hooks/useReadContract.ts

@@ -6,10 +6,10 @@ import {
   readContract,
 } 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 UseReadContractParameters = Compute<
   ReadContractParameters & ConfigParameter & { enabled?: boolean }
@@ -27,17 +27,22 @@ export function useReadContract(
   const networkId = useNetworkId({ config })
 
   return useQuery({
-    queryKey: ['readContract', {
-      address: parameters.address,
-      method: parameters.method,
-      args: parameters.args,
-      networkId: parameters.networkId ?? networkId,
-    }],
-    queryFn: () => readContract(config, {
-      ...parameters,
-      networkId: parameters.networkId ?? networkId,
-    }),
-    enabled: Boolean(parameters.address && parameters.aci && parameters.method) &&
+    queryKey: [
+      'readContract',
+      {
+        address: parameters.address,
+        method: parameters.method,
+        args: parameters.args,
+        networkId: parameters.networkId ?? networkId,
+      },
+    ],
+    queryFn: () =>
+      readContract(config, {
+        ...parameters,
+        networkId: parameters.networkId ?? networkId,
+      }),
+    enabled:
+      Boolean(parameters.address && parameters.aci && parameters.method) &&
       (parameters.enabled ?? true),
   }) as UseReadContractReturnType
 }

package/src/hooks/useReadContracts.test.ts

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

package/src/hooks/useReadContracts.ts

@@ -6,9 +6,9 @@ import {
   readContracts,
 } 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 type { ConfigParameter } from '../types/properties'
+import { type UseQueryReturnType, useQuery } from '../utils/query'
+import { useConfig } from './useConfig'
 
 export type UseReadContractsParameters = Compute<
   ReadContractsParameters & ConfigParameter & { enabled?: boolean }
@@ -25,14 +25,18 @@ export function useReadContracts(
   const config = useConfig(parameters)
 
   return useQuery({
-    queryKey: ['readContracts', {
-      contracts: parameters.contracts?.map((c) => ({
-        address: c.address,
-        method: c.method,
-        args: c.args,
-      })),
-    }],
+    queryKey: [
+      'readContracts',
+      {
+        contracts: parameters.contracts?.map((c) => ({
+          address: c.address,
+          method: c.method,
+          args: c.args,
+        })),
+      },
+    ],
     queryFn: () => readContracts(config, parameters),
-    enabled: Boolean(parameters.contracts?.length) && (parameters.enabled ?? true),
+    enabled:
+      Boolean(parameters.contracts?.length) && (parameters.enabled ?? true),
   }) as UseReadContractsReturnType
 }

package/src/hooks/useReconnect.test.ts

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

package/src/hooks/useReconnect.ts

@@ -1,22 +1,30 @@
 'use client'
 
-import { useMutation } from '@tanstack/react-query'
 import {
+  type ReconnectErrorType,
   type ReconnectParameters,
   type ReconnectReturnType,
-  type ReconnectErrorType,
   reconnect,
 } 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 UseReconnectParameters<context = unknown> = Compute<
   ConfigParameter & {
     mutation?: {
-      onSuccess?: (data: ReconnectReturnType, variables: ReconnectParameters, context: context) => void
-      onError?: (error: ReconnectErrorType, variables: ReconnectParameters, context: context) => void
+      onSuccess?: (
+        data: ReconnectReturnType,
+        variables: ReconnectParameters,
+        context: context,
+      ) => void
+      onError?: (
+        error: ReconnectErrorType,
+        variables: ReconnectParameters,
+        context: context,
+      ) => void
     }
   }
 >
@@ -29,7 +37,9 @@ export type UseReconnectReturnType<context = unknown> = Compute<
     context
   > & {
     reconnect: (variables?: ReconnectParameters) => void
-    reconnectAsync: (variables?: ReconnectParameters) => Promise<ReconnectReturnType>
+    reconnectAsync: (
+      variables?: ReconnectParameters,
+    ) => Promise<ReconnectReturnType>
   }
 >
 
@@ -43,12 +53,12 @@ export function useReconnect<context = unknown>(
     mutationFn: (variables: ReconnectParameters = {}) =>
       reconnect(config, variables),
     ...parameters.mutation,
-  })
+  } as any)
 
   type Return = UseReconnectReturnType<context>
   return {
     ...(mutation as unknown as Return),
-    reconnect: mutation.mutate as Return['reconnect'],
-    reconnectAsync: mutation.mutateAsync as Return['reconnectAsync'],
+    reconnect: mutation.mutate as unknown as Return['reconnect'],
+    reconnectAsync: mutation.mutateAsync as unknown as Return['reconnectAsync'],
   }
 }

package/src/hooks/useRegisterOracle.test.ts

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

package/src/hooks/useRegisterOracle.ts

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

package/src/hooks/useResolveName.test.ts

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

package/src/hooks/useResolveName.ts

@@ -6,10 +6,10 @@ import {
   resolveName,
 } 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 UseResolveNameParameters = Compute<
   ResolveNameParameters & ConfigParameter & { enabled?: boolean }
@@ -27,15 +27,19 @@ export function useResolveName(
   const networkId = useNetworkId({ config })
 
   return useQuery({
-    queryKey: ['resolveName', {
-      name: parameters.name,
-      key: parameters.key,
-      networkId: parameters.networkId ?? networkId,
-    }],
-    queryFn: () => resolveName(config, {
-      ...parameters,
-      networkId: parameters.networkId ?? networkId,
-    }),
+    queryKey: [
+      'resolveName',
+      {
+        name: parameters.name,
+        key: parameters.key,
+        networkId: parameters.networkId ?? networkId,
+      },
+    ],
+    queryFn: () =>
+      resolveName(config, {
+        ...parameters,
+        networkId: parameters.networkId ?? networkId,
+      }),
     enabled: Boolean(parameters.name) && (parameters.enabled ?? true),
   }) as UseResolveNameReturnType
 }

package/src/hooks/useRespondToQuery.test.ts

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

package/src/hooks/useRespondToQuery.ts

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

package/src/hooks/useRevokeName.test.ts

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

package/src/hooks/useRevokeName.ts

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

package/src/hooks/useSendTransaction.test.ts

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

package/src/hooks/useSendTransaction.ts

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

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

package/src/hooks/useSignDelegation.ts

@@ -0,0 +1,65 @@
+'use client'
+
+import {
+  type SignDelegationErrorType,
+  type SignDelegationParameters,
+  type SignDelegationReturnType,
+  signDelegation,
+} 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 UseSignDelegationParameters<context = unknown> = Compute<
+  ConfigParameter & {
+    mutation?: {
+      onSuccess?: (
+        data: SignDelegationReturnType,
+        variables: SignDelegationParameters,
+        context: context,
+      ) => void
+      onError?: (
+        error: SignDelegationErrorType,
+        variables: SignDelegationParameters,
+        context: context,
+      ) => void
+    }
+  }
+>
+
+export type UseSignDelegationReturnType<context = unknown> = Compute<
+  UseMutationReturnType<
+    SignDelegationReturnType,
+    SignDelegationErrorType,
+    SignDelegationParameters,
+    context
+  > & {
+    signDelegation: (variables: SignDelegationParameters) => void
+    signDelegationAsync: (
+      variables: SignDelegationParameters,
+    ) => Promise<SignDelegationReturnType>
+  }
+>
+
+export function useSignDelegation<context = unknown>(
+  parameters: UseSignDelegationParameters<context> = {},
+): UseSignDelegationReturnType<context> {
+  const config = useConfig(parameters)
+
+  const mutation = useMutation({
+    mutationKey: ['signDelegation'],
+    mutationFn: (variables: SignDelegationParameters) =>
+      signDelegation(config, variables),
+    ...parameters.mutation,
+  } as any)
+
+  type Return = UseSignDelegationReturnType<context>
+  return {
+    ...(mutation as unknown as Return),
+    signDelegation: mutation.mutate as unknown as Return['signDelegation'],
+    signDelegationAsync:
+      mutation.mutateAsync as unknown as Return['signDelegationAsync'],
+  }
+}

package/src/hooks/useSignMessage.test.ts

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