@growae/reactive-react 0.0.1 → 0.0.2

package/src/hooks/useMicroBlock.ts

@@ -0,0 +1,45 @@
+'use client'
+
+import {
+  type GetMicroBlockErrorType,
+  type GetMicroBlockParameters,
+  type GetMicroBlockReturnType,
+  getMicroBlock,
+} from '@growae/reactive'
+import type { Compute } from '@growae/reactive'
+import type { ConfigParameter } from '../types/properties'
+import { type UseQueryReturnType, useQuery } from '../utils/query'
+import { useConfig } from './useConfig'
+import { useNetworkId } from './useNetworkId'
+
+export type UseMicroBlockParameters = Compute<
+  GetMicroBlockParameters & ConfigParameter & { enabled?: boolean }
+>
+
+export type UseMicroBlockReturnType = UseQueryReturnType<
+  GetMicroBlockReturnType,
+  GetMicroBlockErrorType
+>
+
+export function useMicroBlock(
+  parameters: UseMicroBlockParameters = {} as UseMicroBlockParameters,
+): UseMicroBlockReturnType {
+  const config = useConfig(parameters)
+  const networkId = useNetworkId({ config })
+
+  return useQuery({
+    queryKey: [
+      'microBlock',
+      {
+        hash: parameters.hash,
+        networkId: parameters.networkId ?? networkId,
+      },
+    ],
+    queryFn: () =>
+      getMicroBlock(config, {
+        ...parameters,
+        networkId: parameters.networkId ?? networkId,
+      }),
+    enabled: Boolean(parameters.hash) && (parameters.enabled ?? true),
+  }) as UseMicroBlockReturnType
+}

package/src/hooks/useNameEntry.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 { useNameEntry } from './useNameEntry'
+
+describe('useNameEntry', () => {
+  it('should be a function', () => {
+    expect(typeof useNameEntry).toBe('function')
+  })
+
+  it('should be exported', () => {
+    expect(useNameEntry).toBeDefined()
+  })
+
+  it('should return query result shape', () => {
+    const result = useNameEntry({ name: 'test.chain' })
+    expect(result).toHaveProperty('data')
+    expect(result).toHaveProperty('error')
+    expect(result).toHaveProperty('isPending')
+    expect(result).toHaveProperty('isSuccess')
+  })
+})

package/src/hooks/useNameEntry.ts

@@ -0,0 +1,45 @@
+'use client'
+
+import {
+  type GetNameEntryErrorType,
+  type GetNameEntryParameters,
+  type GetNameEntryReturnType,
+  getNameEntry,
+} from '@growae/reactive'
+import type { Compute } from '@growae/reactive'
+import type { ConfigParameter } from '../types/properties'
+import { type UseQueryReturnType, useQuery } from '../utils/query'
+import { useConfig } from './useConfig'
+import { useNetworkId } from './useNetworkId'
+
+export type UseNameEntryParameters = Compute<
+  GetNameEntryParameters & ConfigParameter & { enabled?: boolean }
+>
+
+export type UseNameEntryReturnType = UseQueryReturnType<
+  GetNameEntryReturnType,
+  GetNameEntryErrorType
+>
+
+export function useNameEntry(
+  parameters: UseNameEntryParameters = {} as UseNameEntryParameters,
+): UseNameEntryReturnType {
+  const config = useConfig(parameters)
+  const networkId = useNetworkId({ config })
+
+  return useQuery({
+    queryKey: [
+      'nameEntry',
+      {
+        name: parameters.name,
+        networkId: parameters.networkId ?? networkId,
+      },
+    ],
+    queryFn: () =>
+      getNameEntry(config, {
+        ...parameters,
+        networkId: parameters.networkId ?? networkId,
+      }),
+    enabled: Boolean(parameters.name) && (parameters.enabled ?? true),
+  }) as UseNameEntryReturnType
+}

package/src/hooks/useNetworkId.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 { useNetworkId } from './useNetworkId.js'
-import { ReactiveProvider } from '../context.js'
 import { createConfig } from '@growae/reactive'
-import { testnet, mainnet } from '@growae/reactive'
+import { mainnet, testnet } from '@growae/reactive'
 import { mock } from '@growae/reactive'
+import { renderHook } from '@testing-library/react'
+import { createElement } from 'react'
+import { ReactiveProvider } from '../context'
+import { useNetworkId } from './useNetworkId'
 
 const TEST_ACCOUNTS = [
   'ak_2swhLkgBPeeADxVTABy7tt6d2HgBQFnGJELkBUMY4FUa8RVLM',

package/src/hooks/useNetworkId.ts

@@ -6,8 +6,8 @@ import {
   watchNetworkId,
 } 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 UseNetworkIdParameters = ConfigParameter
 

package/src/hooks/useNetworks.test.ts

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

package/src/hooks/useNetworks.ts

@@ -1,11 +1,8 @@
 'use client'
 
-import {
-  type GetNetworksReturnType,
-  getNetworks,
-} from '@growae/reactive'
-import type { ConfigParameter } from '../types/properties.js'
-import { useConfig } from './useConfig.js'
+import { type GetNetworksReturnType, getNetworks } from '@growae/reactive'
+import type { ConfigParameter } from '../types/properties'
+import { useConfig } from './useConfig'
 
 export type UseNetworksParameters = ConfigParameter
 

package/src/hooks/useNodeClient.test.ts

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

package/src/hooks/useNodeClient.ts

@@ -8,8 +8,8 @@ import {
 } from '@growae/reactive'
 import type { Compute } 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 UseNodeClientParameters = Compute<
   GetNodeClientParameters & ConfigParameter

package/src/hooks/useOpenChannel.test.ts

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

package/src/hooks/useOpenChannel.ts

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

package/src/hooks/useOracleQueries.test.ts

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

package/src/hooks/useOracleQueries.ts

@@ -6,10 +6,10 @@ import {
   getOracleQueries,
 } 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 UseOracleQueriesParameters = Compute<
   GetOracleQueriesParameters & ConfigParameter & { enabled?: boolean }
@@ -27,14 +27,18 @@ export function useOracleQueries(
   const networkId = useNetworkId({ config })
 
   return useQuery({
-    queryKey: ['oracleQueries', {
-      oracleId: parameters.oracleId,
-      networkId: parameters.networkId ?? networkId,
-    }],
-    queryFn: () => getOracleQueries(config, {
-      ...parameters,
-      networkId: parameters.networkId ?? networkId,
-    }),
+    queryKey: [
+      'oracleQueries',
+      {
+        oracleId: parameters.oracleId,
+        networkId: parameters.networkId ?? networkId,
+      },
+    ],
+    queryFn: () =>
+      getOracleQueries(config, {
+        ...parameters,
+        networkId: parameters.networkId ?? networkId,
+      }),
     enabled: Boolean(parameters.oracleId) && (parameters.enabled ?? true),
   }) as UseOracleQueriesReturnType
 }

package/src/hooks/useOracleState.test.ts

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

package/src/hooks/useOracleState.ts

@@ -6,10 +6,10 @@ import {
   getOracleState,
 } 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 UseOracleStateParameters = Compute<
   GetOracleStateParameters & ConfigParameter & { enabled?: boolean }
@@ -27,14 +27,18 @@ export function useOracleState(
   const networkId = useNetworkId({ config })
 
   return useQuery({
-    queryKey: ['oracleState', {
-      oracleId: parameters.oracleId,
-      networkId: parameters.networkId ?? networkId,
-    }],
-    queryFn: () => getOracleState(config, {
-      ...parameters,
-      networkId: parameters.networkId ?? networkId,
-    }),
+    queryKey: [
+      'oracleState',
+      {
+        oracleId: parameters.oracleId,
+        networkId: parameters.networkId ?? networkId,
+      },
+    ],
+    queryFn: () =>
+      getOracleState(config, {
+        ...parameters,
+        networkId: parameters.networkId ?? networkId,
+      }),
     enabled: Boolean(parameters.oracleId) && (parameters.enabled ?? true),
   }) as UseOracleStateReturnType
 }

package/src/hooks/usePayForTransaction.test.ts

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

package/src/hooks/usePayForTransaction.ts

@@ -1,22 +1,30 @@
 'use client'
 
-import { useMutation } from '@tanstack/react-query'
 import {
+  type PayForTransactionErrorType,
   type PayForTransactionParameters,
   type PayForTransactionReturnType,
-  type PayForTransactionErrorType,
   payForTransaction,
 } 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 UsePayForTransactionParameters<context = unknown> = Compute<
   ConfigParameter & {
     mutation?: {
-      onSuccess?: (data: PayForTransactionReturnType, variables: PayForTransactionParameters, context: context) => void
-      onError?: (error: PayForTransactionErrorType, variables: PayForTransactionParameters, context: context) => void
+      onSuccess?: (
+        data: PayForTransactionReturnType,
+        variables: PayForTransactionParameters,
+        context: context,
+      ) => void
+      onError?: (
+        error: PayForTransactionErrorType,
+        variables: PayForTransactionParameters,
+        context: context,
+      ) => void
     }
   }
 >
@@ -29,7 +37,9 @@ export type UsePayForTransactionReturnType<context = unknown> = Compute<
     context
   > & {
     payForTransaction: (variables: PayForTransactionParameters) => void
-    payForTransactionAsync: (variables: PayForTransactionParameters) => Promise<PayForTransactionReturnType>
+    payForTransactionAsync: (
+      variables: PayForTransactionParameters,
+    ) => Promise<PayForTransactionReturnType>
   }
 >
 
@@ -43,12 +53,14 @@ export function usePayForTransaction<context = unknown>(
     mutationFn: (variables: PayForTransactionParameters) =>
       payForTransaction(config, variables),
     ...parameters.mutation,
-  })
+  } as any)
 
   type Return = UsePayForTransactionReturnType<context>
   return {
     ...(mutation as unknown as Return),
-    payForTransaction: mutation.mutate as Return['payForTransaction'],
-    payForTransactionAsync: mutation.mutateAsync as Return['payForTransactionAsync'],
+    payForTransaction:
+      mutation.mutate as unknown as Return['payForTransaction'],
+    payForTransactionAsync:
+      mutation.mutateAsync as unknown as Return['payForTransactionAsync'],
   }
 }

package/src/hooks/usePreclaimName.test.ts

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

package/src/hooks/usePreclaimName.ts

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

package/src/hooks/useQueryOracle.test.ts

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

package/src/hooks/useQueryOracle.ts

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

package/src/hooks/useReadContract.test.ts

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