@growae/reactive-react 0.0.1 → 0.0.3

package/src/hooks/useTransferFunds.ts

@@ -0,0 +1,65 @@
+'use client'
+
+import {
+  type TransferFundsErrorType,
+  type TransferFundsParameters,
+  type TransferFundsReturnType,
+  transferFunds,
+} 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 UseTransferFundsParameters<context = unknown> = Compute<
+  ConfigParameter & {
+    mutation?: {
+      onSuccess?: (
+        data: TransferFundsReturnType,
+        variables: TransferFundsParameters,
+        context: context,
+      ) => void
+      onError?: (
+        error: TransferFundsErrorType,
+        variables: TransferFundsParameters,
+        context: context,
+      ) => void
+    }
+  }
+>
+
+export type UseTransferFundsReturnType<context = unknown> = Compute<
+  UseMutationReturnType<
+    TransferFundsReturnType,
+    TransferFundsErrorType,
+    TransferFundsParameters,
+    context
+  > & {
+    transferFunds: (variables: TransferFundsParameters) => void
+    transferFundsAsync: (
+      variables: TransferFundsParameters,
+    ) => Promise<TransferFundsReturnType>
+  }
+>
+
+export function useTransferFunds<context = unknown>(
+  parameters: UseTransferFundsParameters<context> = {},
+): UseTransferFundsReturnType<context> {
+  const config = useConfig(parameters)
+
+  const mutation = useMutation({
+    mutationKey: ['transferFunds'],
+    mutationFn: (variables: TransferFundsParameters) =>
+      transferFunds(config, variables),
+    ...parameters.mutation,
+  } as any)
+
+  type Return = UseTransferFundsReturnType<context>
+  return {
+    ...(mutation as unknown as Return),
+    transferFunds: mutation.mutate as unknown as Return['transferFunds'],
+    transferFundsAsync:
+      mutation.mutateAsync as unknown as Return['transferFundsAsync'],
+  }
+}

package/src/hooks/useTransferName.test.ts

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

package/src/hooks/useTransferName.ts

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

package/src/hooks/useUpdateName.test.ts

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

package/src/hooks/useUpdateName.ts

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

package/src/hooks/useVerifyMessage.test.ts

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

package/src/hooks/useVerifyMessage.ts

@@ -1,15 +1,15 @@
 'use client'
 
 import {
+  type VerifyMessageErrorType,
   type VerifyMessageParameters,
   type VerifyMessageReturnType,
-  type VerifyMessageErrorType,
   verifyMessage,
 } 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 UseVerifyMessageParameters = Compute<
   VerifyMessageParameters & ConfigParameter & { enabled?: boolean }
@@ -26,14 +26,19 @@ export function useVerifyMessage(
   const config = useConfig(parameters)
 
   return useQuery({
-    queryKey: ['verifyMessage', {
-      message: parameters.message,
-      signature: parameters.signature,
-      address: parameters.address,
-    }],
+    queryKey: [
+      'verifyMessage',
+      {
+        message: parameters.message,
+        signature: parameters.signature,
+        address: parameters.address,
+      },
+    ],
     queryFn: () => verifyMessage(config, parameters),
-    enabled: Boolean(
-      parameters.message && parameters.signature && parameters.address,
-    ) && (parameters.enabled ?? true),
+    enabled:
+      Boolean(
+        parameters.message && parameters.signature && parameters.address,
+      ) &&
+      (parameters.enabled ?? true),
   }) as UseVerifyMessageReturnType
 }

package/src/hooks/useVerifyTypedData.test.ts

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

package/src/hooks/useVerifyTypedData.ts

@@ -1,15 +1,15 @@
 'use client'
 
 import {
+  type VerifyTypedDataErrorType,
   type VerifyTypedDataParameters,
   type VerifyTypedDataReturnType,
-  type VerifyTypedDataErrorType,
   verifyTypedData,
 } 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 UseVerifyTypedDataParameters = Compute<
   VerifyTypedDataParameters & ConfigParameter & { enabled?: boolean }
@@ -26,14 +26,17 @@ export function useVerifyTypedData(
   const config = useConfig(parameters)
 
   return useQuery({
-    queryKey: ['verifyTypedData', {
-      data: parameters.data,
-      signature: parameters.signature,
-      address: parameters.address,
-    }],
+    queryKey: [
+      'verifyTypedData',
+      {
+        data: parameters.data,
+        signature: parameters.signature,
+        address: parameters.address,
+      },
+    ],
     queryFn: () => verifyTypedData(config, parameters),
-    enabled: Boolean(
-      parameters.data && parameters.signature && parameters.address,
-    ) && (parameters.enabled ?? true),
+    enabled:
+      Boolean(parameters.data && parameters.signature && parameters.address) &&
+      (parameters.enabled ?? true),
   }) as UseVerifyTypedDataReturnType
 }

package/src/hooks/useWaitForTransaction.test.ts

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

package/src/hooks/useWaitForTransaction.ts

@@ -1,16 +1,16 @@
 'use client'
 
 import {
+  type WaitForTransactionErrorType,
   type WaitForTransactionParameters,
   type WaitForTransactionReturnType,
-  type WaitForTransactionErrorType,
   waitForTransaction,
 } 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 UseWaitForTransactionParameters = Compute<
   WaitForTransactionParameters & ConfigParameter & { enabled?: boolean }
@@ -28,14 +28,18 @@ export function useWaitForTransaction(
   const networkId = useNetworkId({ config })
 
   return useQuery({
-    queryKey: ['waitForTransaction', {
-      hash: parameters.hash,
-      networkId: parameters.networkId ?? networkId,
-    }],
-    queryFn: () => waitForTransaction(config, {
-      ...parameters,
-      networkId: parameters.networkId ?? networkId,
-    }),
+    queryKey: [
+      'waitForTransaction',
+      {
+        hash: parameters.hash,
+        networkId: parameters.networkId ?? networkId,
+      },
+    ],
+    queryFn: () =>
+      waitForTransaction(config, {
+        ...parameters,
+        networkId: parameters.networkId ?? networkId,
+      }),
     enabled: Boolean(parameters.hash) && (parameters.enabled ?? true),
   }) as UseWaitForTransactionReturnType
 }

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

package/src/hooks/useWaitForTransactionConfirm.ts

@@ -0,0 +1,45 @@
+'use client'
+
+import {
+  type WaitForTransactionConfirmErrorType,
+  type WaitForTransactionConfirmParameters,
+  type WaitForTransactionConfirmReturnType,
+  waitForTransactionConfirm,
+} 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 UseWaitForTransactionConfirmParameters = Compute<
+  WaitForTransactionConfirmParameters & ConfigParameter & { enabled?: boolean }
+>
+
+export type UseWaitForTransactionConfirmReturnType = UseQueryReturnType<
+  WaitForTransactionConfirmReturnType,
+  WaitForTransactionConfirmErrorType
+>
+
+export function useWaitForTransactionConfirm(
+  parameters: UseWaitForTransactionConfirmParameters = {} as UseWaitForTransactionConfirmParameters,
+): UseWaitForTransactionConfirmReturnType {
+  const config = useConfig(parameters)
+  const networkId = useNetworkId({ config })
+
+  return useQuery({
+    queryKey: [
+      'waitForTransactionConfirm',
+      {
+        hash: parameters.hash,
+        networkId: parameters.networkId ?? networkId,
+      },
+    ],
+    queryFn: () =>
+      waitForTransactionConfirm(config, {
+        ...parameters,
+        networkId: parameters.networkId ?? networkId,
+      }),
+    enabled: Boolean(parameters.hash) && (parameters.enabled ?? true),
+  }) as UseWaitForTransactionConfirmReturnType
+}

package/src/hooks/useWatchConnection.test.ts

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

package/src/hooks/useWatchConnection.ts

@@ -1,10 +1,10 @@
 'use client'
 
 import { watchConnection } from '@growae/reactive'
-import type { Connection, Compute } from '@growae/reactive'
+import type { Compute, Connection } from '@growae/reactive'
 import { useEffect, useRef } 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 UseWatchConnectionParameters = Compute<
   ConfigParameter & {

package/src/hooks/useWatchConnectors.test.ts

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

package/src/hooks/useWatchConnectors.ts

@@ -1,10 +1,10 @@
 'use client'
 
 import { watchConnectors } from '@growae/reactive'
-import type { Connector, Compute } from '@growae/reactive'
+import type { Compute, Connector } from '@growae/reactive'
 import { useEffect, useRef } 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 UseWatchConnectorsParameters = Compute<
   ConfigParameter & {

package/src/hooks/useWatchHeight.test.ts

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

package/src/hooks/useWatchHeight.ts

@@ -3,14 +3,13 @@
 import { watchHeight } from '@growae/reactive'
 import type { Compute } from '@growae/reactive'
 import { useEffect, useRef } from 'react'
-import type { ConfigParameter } from '../types/properties.js'
-import { useConfig } from './useConfig.js'
-import { useNetworkId } from './useNetworkId.js'
+import type { ConfigParameter } from '../types/properties'
+import { useConfig } from './useConfig'
+import { useNetworkId } from './useNetworkId'
 
 export type UseWatchHeightParameters = Compute<
   ConfigParameter & {
     onHeight: (height: number) => void
-    onError?: (error: Error) => void
     enabled?: boolean
     interval?: number
     networkId?: string
@@ -28,17 +27,14 @@ export function useWatchHeight(
   const networkId = paramNetworkId ?? configNetworkId
 
   const onHeightRef = useRef(parameters.onHeight)
-  const onErrorRef = useRef(parameters.onError)
   onHeightRef.current = parameters.onHeight
-  onErrorRef.current = parameters.onError
 
   useEffect(() => {
     if (!enabled) return
     if (!onHeightRef.current) return
     return watchHeight(config, {
       onChange: (height) => onHeightRef.current?.(height),
-      onError: (error) => onErrorRef.current?.(error),
-      interval,
+      pollingInterval: interval,
       networkId,
     })
   }, [config, enabled, interval, networkId])

package/src/hydrate.ts

@@ -21,6 +21,7 @@ export function Hydrate(parameters: React.PropsWithChildren<HydrateProps>) {
   if (!config._internal.ssr) onMount()
 
   const active = useRef(true)
+  // biome-ignore lint/correctness/useExhaustiveDependencies: intentional mount-only effect
   useEffect(() => {
     if (!active.current) return
     if (!config._internal.ssr) return

package/src/utils/query.ts

@@ -1,18 +1,23 @@
 'use client'
 
+import type {
+  Compute,
+  ExactPartial,
+  LooseOmit,
+  UnionStrictOmit,
+} from '@growae/reactive'
+import { hashFn } from '@growae/reactive/query'
 import {
   type DefaultError,
   type MutateFunction,
   type QueryKey,
-  useQuery as tanstack_useQuery,
   type UseMutationOptions,
   type UseMutationResult,
   type UseQueryOptions,
   type UseQueryResult,
+  useQuery as tanstack_useQuery,
   useMutation,
 } from '@tanstack/react-query'
-import { hashFn } from '@growae/reactive/query'
-import type { Compute, ExactPartial, LooseOmit, UnionStrictOmit } from '@growae/reactive'
 
 export { useMutation }
 
@@ -65,7 +70,10 @@ export type UseQueryParameters<
   queryKey extends QueryKey = QueryKey,
 > = Compute<
   ExactPartial<
-    LooseOmit<UseQueryOptions<queryFnData, error, data, queryKey>, 'initialData'>
+    LooseOmit<
+      UseQueryOptions<queryFnData, error, data, queryKey>,
+      'initialData'
+    >
   > & {
     initialData?:
       | UseQueryOptions<queryFnData, error, data, queryKey>['initialData']

package/tsconfig.build.json

@@ -6,7 +6,8 @@
     "declarationDir": "dist/types",
     "declaration": true,
     "declarationMap": true,
-    "sourceMap": true
+    "sourceMap": true,
+    "paths": {}
   },
   "include": ["src/**/*.ts", "src/**/*.tsx"],
   "exclude": ["src/**/*.test.ts", "src/**/*.test-d.ts"]

package/tsconfig.json

@@ -1,7 +1,9 @@
 {
   "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "rootDir": "src"
-  },
-  "include": ["src/**/*.ts", "src/**/*.tsx", "src/**/*.test.ts", "src/**/*.test-d.ts"]
+  "include": [
+    "src/**/*.ts",
+    "src/**/*.tsx",
+    "src/**/*.test.ts",
+    "src/**/*.test-d.ts"
+  ]
 }