@growae/reactive-react 0.0.1 → 0.0.3

package/src/hooks/useConnect.ts

@@ -1,26 +1,38 @@
 'use client'
 
-import { useMutation } from '@tanstack/react-query'
 import {
-  type Config,
+  type ConnectErrorType,
   type ConnectParameters,
   type ConnectReturnType,
-  type ConnectErrorType,
   connect,
 } from '@growae/reactive'
 import type { Compute } from '@growae/reactive'
+import { useMutation } from '@tanstack/react-query'
 import { useEffect } from 'react'
-import type { ConfigParameter } from '../types/properties.js'
-import type { UseMutationReturnType } from '../utils/query.js'
-import { useConfig } from './useConfig.js'
-import { useConnectors } from './useConnectors.js'
+import type { ConfigParameter } from '../types/properties'
+import type { UseMutationReturnType } from '../utils/query'
+import { useConfig } from './useConfig'
+import { useConnectors } from './useConnectors'
 
 export type UseConnectParameters<context = unknown> = Compute<
   ConfigParameter & {
     mutation?: {
-      onSuccess?: (data: ConnectReturnType, variables: ConnectParameters, context: context) => void
-      onError?: (error: ConnectErrorType, variables: ConnectParameters, context: context) => void
-      onSettled?: (data: ConnectReturnType | undefined, error: ConnectErrorType | null, variables: ConnectParameters, context: context) => void
+      onSuccess?: (
+        data: ConnectReturnType,
+        variables: ConnectParameters,
+        context: context,
+      ) => void
+      onError?: (
+        error: ConnectErrorType,
+        variables: ConnectParameters,
+        context: context,
+      ) => void
+      onSettled?: (
+        data: ConnectReturnType | undefined,
+        error: ConnectErrorType | null,
+        variables: ConnectParameters,
+        context: context,
+      ) => void
     }
   }
 >
@@ -47,7 +59,7 @@ export function useConnect<context = unknown>(
     mutationKey: ['connect'],
     mutationFn: (variables: ConnectParameters) => connect(config, variables),
     ...parameters.mutation,
-  })
+  } as any)
 
   useEffect(() => {
     return config.subscribe(
@@ -62,8 +74,8 @@ export function useConnect<context = unknown>(
   type Return = UseConnectReturnType<context>
   return {
     ...(mutation as unknown as Return),
-    connect: mutation.mutate as Return['connect'],
-    connectAsync: mutation.mutateAsync as Return['connectAsync'],
+    connect: mutation.mutate as unknown as Return['connect'],
+    connectAsync: mutation.mutateAsync as unknown as Return['connectAsync'],
     connectors: useConnectors({ config }),
   }
 }

package/src/hooks/useConnection.test.ts

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

package/src/hooks/useConnection.ts

@@ -6,8 +6,8 @@ import {
   watchConnection,
 } from '@growae/reactive'
 import { useSyncExternalStore } from 'react'
-import type { ConfigParameter } from '../types/properties.js'
-import { useConfig } from './useConfig.js'
+import type { ConfigParameter } from '../types/properties'
+import { useConfig } from './useConfig'
 
 export type UseConnectionParameters = ConfigParameter
 

package/src/hooks/useConnections.test.ts

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

package/src/hooks/useConnections.ts

@@ -6,8 +6,8 @@ import {
   watchConnections,
 } from '@growae/reactive'
 import { useSyncExternalStore } from 'react'
-import type { ConfigParameter } from '../types/properties.js'
-import { useConfig } from './useConfig.js'
+import type { ConfigParameter } from '../types/properties'
+import { useConfig } from './useConfig'
 
 export type UseConnectionsParameters = ConfigParameter
 

package/src/hooks/useConnectorClient.test.ts

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

package/src/hooks/useConnectorClient.ts

@@ -1,24 +1,24 @@
 'use client'
 
 import {
-  type GetConnectorClientParameters,
-  type GetConnectorClientReturnType,
-  getConnectorClient,
+  type GetConnectionReturnType,
+  type GetNodeClientParameters,
+  getConnection,
 } from '@growae/reactive'
 import type { Compute } from '@growae/reactive'
-import { useQuery } from '../utils/query.js'
-import type { UseQueryReturnType } from '../utils/query.js'
-import type { ConfigParameter } from '../types/properties.js'
-import { useConfig } from './useConfig.js'
-import { useConnection } from './useConnection.js'
-import { useNetworkId } from './useNetworkId.js'
+import type { ConfigParameter } from '../types/properties'
+import { useQuery } from '../utils/query'
+import type { UseQueryReturnType } from '../utils/query'
+import { useConfig } from './useConfig'
+import { useConnection } from './useConnection'
+import { useNetworkId } from './useNetworkId'
 
 export type UseConnectorClientParameters = Compute<
-  GetConnectorClientParameters & ConfigParameter
+  GetNodeClientParameters & ConfigParameter
 >
 
 export type UseConnectorClientReturnType = UseQueryReturnType<
-  GetConnectorClientReturnType,
+  GetConnectionReturnType,
   Error
 >
 
@@ -30,15 +30,14 @@ export function useConnectorClient(
   const connection = useConnection({ config })
 
   return useQuery({
-    queryKey: ['connectorClient', {
-      networkId: parameters.networkId ?? networkId,
-      connector: connection?.connector?.uid,
-    }],
-    queryFn: () => getConnectorClient(config, {
-      ...parameters,
-      networkId: parameters.networkId ?? networkId,
-      connector: parameters.connector ?? connection?.connector,
-    }),
+    queryKey: [
+      'connectorClient',
+      {
+        networkId: parameters.networkId ?? networkId,
+        connector: connection?.connector?.uid,
+      },
+    ],
+    queryFn: () => getConnection(config),
     enabled: !!connection?.connector,
   }) as UseConnectorClientReturnType
 }

package/src/hooks/useConnectors.test.ts

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

package/src/hooks/useConnectors.ts

@@ -6,8 +6,8 @@ import {
   watchConnectors,
 } from '@growae/reactive'
 import { useSyncExternalStore } from 'react'
-import type { ConfigParameter } from '../types/properties.js'
-import { useConfig } from './useConfig.js'
+import type { ConfigParameter } from '../types/properties'
+import { useConfig } from './useConfig'
 
 export type UseConnectorsParameters = ConfigParameter
 

package/src/hooks/useContractBytecode.test.ts

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

package/src/hooks/useContractBytecode.ts

@@ -1,16 +1,16 @@
 'use client'
 
 import {
+  type GetContractBytecodeErrorType,
   type GetContractBytecodeParameters,
   type GetContractBytecodeReturnType,
-  type GetContractBytecodeErrorType,
   getContractBytecode,
 } 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 UseContractBytecodeParameters = Compute<
   GetContractBytecodeParameters & ConfigParameter & { enabled?: boolean }
@@ -28,14 +28,18 @@ export function useContractBytecode(
   const networkId = useNetworkId({ config })
 
   return useQuery({
-    queryKey: ['contractBytecode', {
-      contractId: parameters.contractId,
-      networkId: parameters.networkId ?? networkId,
-    }],
-    queryFn: () => getContractBytecode(config, {
-      ...parameters,
-      networkId: parameters.networkId ?? networkId,
-    }),
-    enabled: Boolean(parameters.contractId) && (parameters.enabled ?? true),
+    queryKey: [
+      'contractBytecode',
+      {
+        address: parameters.address,
+        networkId: parameters.networkId ?? networkId,
+      },
+    ],
+    queryFn: () =>
+      getContractBytecode(config, {
+        ...parameters,
+        networkId: parameters.networkId ?? networkId,
+      }),
+    enabled: Boolean(parameters.address) && (parameters.enabled ?? true),
   }) as UseContractBytecodeReturnType
 }

package/src/hooks/useContractEvents.test.ts

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

package/src/hooks/useContractEvents.ts

@@ -6,10 +6,10 @@ import {
   getContractEvents,
 } 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 UseContractEventsParameters = Compute<
   GetContractEventsParameters & ConfigParameter & { enabled?: boolean }
@@ -27,16 +27,20 @@ export function useContractEvents(
   const networkId = useNetworkId({ config })
 
   return useQuery({
-    queryKey: ['contractEvents', {
-      address: parameters.address,
-      fromHeight: parameters.fromHeight,
-      toHeight: parameters.toHeight,
-      networkId: parameters.networkId ?? networkId,
-    }],
-    queryFn: () => getContractEvents(config, {
-      ...parameters,
-      networkId: parameters.networkId ?? networkId,
-    }),
+    queryKey: [
+      'contractEvents',
+      {
+        address: parameters.address,
+        fromHeight: parameters.fromHeight,
+        toHeight: parameters.toHeight,
+        networkId: parameters.networkId ?? networkId,
+      },
+    ],
+    queryFn: () =>
+      getContractEvents(config, {
+        ...parameters,
+        networkId: parameters.networkId ?? networkId,
+      }),
     enabled: Boolean(parameters.address) && (parameters.enabled ?? true),
   }) as UseContractEventsReturnType
 }

package/src/hooks/useDeployContract.test.ts

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

package/src/hooks/useDeployContract.ts

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

package/src/hooks/useDisconnect.test.ts

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

package/src/hooks/useDisconnect.ts

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

package/src/hooks/useEstimateGas.test.ts

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

package/src/hooks/useEstimateGas.ts

@@ -1,16 +1,16 @@
 'use client'
 
 import {
+  type EstimateGasErrorType,
   type EstimateGasParameters,
   type EstimateGasReturnType,
-  type EstimateGasErrorType,
   estimateGas,
 } 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 UseEstimateGasParameters = Compute<
   EstimateGasParameters & ConfigParameter & { enabled?: boolean }
@@ -28,15 +28,21 @@ export function useEstimateGas(
   const networkId = useNetworkId({ config })
 
   return useQuery({
-    queryKey: ['estimateGas', {
-      tx: parameters.tx,
-      accountAddress: parameters.accountAddress,
-      networkId: parameters.networkId ?? networkId,
-    }],
-    queryFn: () => estimateGas(config, {
-      ...parameters,
-      networkId: parameters.networkId ?? networkId,
-    }),
-    enabled: Boolean(parameters.tx && parameters.accountAddress) && (parameters.enabled ?? true),
+    queryKey: [
+      'estimateGas',
+      {
+        tx: parameters.tx,
+        accountAddress: parameters.accountAddress,
+        networkId: parameters.networkId ?? networkId,
+      },
+    ],
+    queryFn: () =>
+      estimateGas(config, {
+        ...parameters,
+        networkId: parameters.networkId ?? networkId,
+      }),
+    enabled:
+      Boolean(parameters.tx && parameters.accountAddress) &&
+      (parameters.enabled ?? true),
   }) as UseEstimateGasReturnType
 }

package/src/hooks/useHeight.test.ts

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

package/src/hooks/useHeight.ts

@@ -1,16 +1,16 @@
 'use client'
 
 import {
+  type GetHeightErrorType,
   type GetHeightParameters,
   type GetHeightReturnType,
-  type GetHeightErrorType,
   getHeight,
 } 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 UseHeightParameters = Compute<
   GetHeightParameters & ConfigParameter & { enabled?: boolean }
@@ -28,12 +28,16 @@ export function useHeight(
   const networkId = useNetworkId({ config })
 
   return useQuery({
-    queryKey: ['height', {
-      networkId: parameters.networkId ?? networkId,
-    }],
-    queryFn: () => getHeight(config, {
-      networkId: parameters.networkId ?? networkId,
-    }),
+    queryKey: [
+      'height',
+      {
+        networkId: parameters.networkId ?? networkId,
+      },
+    ],
+    queryFn: () =>
+      getHeight(config, {
+        networkId: parameters.networkId ?? networkId,
+      }),
     enabled: parameters.enabled ?? true,
   }) as UseHeightReturnType
 }

package/src/hooks/useMicroBlock.test.ts

@@ -0,0 +1,45 @@
+import { describe, expect, it, vi } from 'vitest'
+
+vi.mock('../utils/query.js', () => ({
+  useQuery: vi.fn(() => ({
+    data: undefined,
+    error: null,
+    isPending: true,
+    isSuccess: false,
+    isError: false,
+    isLoading: true,
+    status: 'pending',
+    refetch: vi.fn(),
+  })),
+}))
+
+vi.mock('./useConfig.js', () => ({
+  useConfig: vi.fn(() => ({
+    state: { networkId: 'ae_uat' },
+    getNodeClient: vi.fn(),
+  })),
+}))
+
+vi.mock('./useNetworkId.js', () => ({
+  useNetworkId: vi.fn(() => 'ae_uat'),
+}))
+
+import { useMicroBlock } from './useMicroBlock'
+
+describe('useMicroBlock', () => {
+  it('should be a function', () => {
+    expect(typeof useMicroBlock).toBe('function')
+  })
+
+  it('should be exported', () => {
+    expect(useMicroBlock).toBeDefined()
+  })
+
+  it('should return query result shape', () => {
+    const result = useMicroBlock({ hash: 'mh_test' })
+    expect(result).toHaveProperty('data')
+    expect(result).toHaveProperty('error')
+    expect(result).toHaveProperty('isPending')
+    expect(result).toHaveProperty('isSuccess')
+  })
+})