added callback argument

CHANGELOG.md

@@ -1,5 +1,9 @@
 # Change Log
 
+## 0.0.3
+
+- Added callback
+
 ## 0.0.2
 
 - Added cache control to useAsyncValidator hook

README.md

@@ -4,7 +4,7 @@ React hooks for [@yobta/validator](https://github.com/yobta/validator)
 
 ## Installation
 
-```
+```sh
 npm i @yobta/validator
 npm i @yobta/validator-react
 ```
@@ -25,13 +25,13 @@ const validator = createAsyncValidator(rule(async value => somePromise(value)))
 By default, the hook caches the validate function based on the validator provided. This means that unless the validator changes, the same validate function instance is used, optimizing performance by preventing unnecessary re-creations.
 
 ```ts
-const [validate, isValidating] = useAsyncValidator(validator)
+const [validate, isValidating] = useAsyncValidator(validator, conosle.log)
 ```
 
 #### Cache Control with Dependencies
 
 By providing a dependency list, you can control when the validate function is recreated. This is useful for optimizing performance and ensuring that the validator only updates when specific dependencies change.
 
 ```ts
-const [validate, isValidating] = useAsyncValidator(validator, [dep1, dep2])
+const [validate, isValidating] = useAsyncValidator(validator, conosle.log, [dep1, dep2])
 ```

package.json

@@ -78,14 +78,14 @@
       "import": {
         "lib/index.js": "{ useAsyncValidator }"
       },
-      "limit": "2644 B"
+      "limit": "2653 B"
     },
     {
       "name": "*",
       "import": {
         "lib/index.js": "*"
       },
-      "limit": "2691 B"
+      "limit": "2696 B"
     }
   ],
   "dependencies": {

src/useAsyncValidator/useAsyncValidator.test.ts

@@ -1,11 +1,13 @@
+import { jest } from '@jest/globals'
 import { act, renderHook } from '@testing-library/react'
 import { createAsyncValidator, rule } from '@yobta/validator'
 
 import { useAsyncValidator } from './useAsyncValidator.js'
 
 test('return value', () => {
   const validator = createAsyncValidator(rule(() => {}))
-  const { result } = renderHook(() => useAsyncValidator(validator))
+  const callback = jest.fn()
+  const { result } = renderHook(() => useAsyncValidator(validator, callback))
   const [validate, busy] = result.current
 
   expect(typeof validate).toBe('function')
@@ -14,6 +16,8 @@ test('return value', () => {
 
 test('promise resolve', async () => {
   let resolvePromise: (value: unknown) => void
+  const callback = jest.fn()
+
   const validator = createAsyncValidator(
     rule(
       () =>
@@ -23,7 +27,7 @@ test('promise resolve', async () => {
     ),
   )
 
-  const { result } = renderHook(() => useAsyncValidator(validator))
+  const { result } = renderHook(() => useAsyncValidator(validator, callback))
   const [validate] = result.current
 
   expect(result.current[1]).toBe(false)
@@ -37,14 +41,16 @@ test('promise resolve', async () => {
     resolvePromise({})
   })
   expect(result.current[1]).toBe(false)
+  expect(callback).toHaveBeenCalledWith({}, null)
 })
 
 test('deps', async () => {
   let deps = [1, 2, 3]
 
   let validator = createAsyncValidator(rule(() => null))
+  const callback = jest.fn()
 
-  const hook = renderHook(() => useAsyncValidator(validator, deps))
+  const hook = renderHook(() => useAsyncValidator(validator, callback, deps))
   const result1 = hook.result.current
 
   validator = createAsyncValidator(rule(() => null))

src/useAsyncValidator/useAsyncValidator.ts

@@ -12,19 +12,23 @@ type Validator<Data> = (event: unknown) => YobtaAsyncValidatorResult<Data>
  *
  * @template Data - The type of data returned by the validator.
  * @param {YobtaAsyncValidator<unknown, Data>} validator - The asynchronous validator function.
+ * @param {(...result: Awaited<YobtaAsyncValidatorResult<Data>>) => void} callback - The callback function to be called with the result of the validation.
  * @param {DependencyList} [deps=[validator]] - The dependency list for the validator function.
  * @returns {[Validator<Data>, boolean]} A tuple containing the validate function and a boolean indicating if validation is in progress.
  */
 export const useAsyncValidator = <Data>(
   validator: YobtaAsyncValidator<unknown, Data>,
+  callback: (...result: Awaited<YobtaAsyncValidatorResult<Data>>) => void,
   deps: DependencyList = [validator],
 ): [Validator<Data>, boolean] => {
   const [busy, setBusy] = useState(false)
 
   const validate: Validator<Data> = useCallback(async (event: unknown) => {
     setBusy(true)
     try {
-      return await validator(event)
+      const result = await validator(event)
+      callback(...result)
+      return result
     } finally {
       setBusy(false)
     }