fixes: v0.1.3 - changes signature and exports

Author: svaraborut

README.md

@@ -14,7 +14,7 @@ A repository of `React` components
 
 # Hooks
 
-## Async
+### Async hooks
 
 | Name                  | Behaviour                                                            | todo |
 |-----------------------|----------------------------------------------------------------------|------|
@@ -28,3 +28,19 @@ A repository of `React` components
 | `useSharedAsync2`     | Last call is the only one effective, all resolve with the last value |      |
 |                       |                                                                      |      |
 | `useQuery`            | Similar to task, but runs when dependencies changes                  |      |
+
+### Browser hooks
+
+
+### Dom hooks
+
+
+### Generic hooks
+
+
+### Navigation hooks
+
+
+### State hooks
+
+

package.json

@@ -3,7 +3,7 @@
   "description": "Hook collection for React",
   "author": "Borut Svara <[email protected]>",
   "license": "ISC",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {

src/async/useAsync.ts

@@ -20,14 +20,14 @@ export interface UseAsyncState<Res, Err> {
     error?: Err
 }
 
-export interface UseAsyncReturn<Args extends any[] = [], Res = void, Err = any> extends UseAsyncState<Res, Err>{
+export interface UseAsyncReturn<Res = void, Args extends any[] = [], Err = any> extends UseAsyncState<Res, Err>{
     run: (...args: Args) => void
     runAsync: PromiseFn<Args, Res>
 }
 
-export function useAsync<Args extends any[] = [], Res = void, Err = any>(
+export function useAsync<Res = void, Args extends any[] = [], Err = any>(
     fn: PromiseFn<Args, Res>,
-): UseAsyncReturn<Args, Res, Err> {
+): UseAsyncReturn<Res, Args, Err> {
 
     // Unique call id to handle concurrency
     const callIdRef = useRef(0)

src/async/useExclusivePromise.ts

@@ -15,12 +15,12 @@ import { useLatest } from '../generic/useLatest';
  *
  * /B 2022-10-19
  */
-export function useExclusivePromise<R, A extends any[] = []>(fn: PromiseFn<A, R>): PromiseFn<A, R> {
+export function useExclusivePromise<Res, Args extends any[] = []>(fn: PromiseFn<Args, Res>): PromiseFn<Args, Res> {
 
     const lastFn = useLatest(fn)
     const isExecuting = useRef<boolean>(false)
 
-    return useCallback(async (...args: A): Promise<R> => {
+    return useCallback(async (...args: Args): Promise<Res> => {
         if (isExecuting.current) {
             throw new ConcurrencyError(`Promise is already running`)
         } else {

src/async/usePromise.ts

@@ -13,11 +13,11 @@ import { useLatest } from '../generic/useLatest';
  *
  * /B 2022-10-19
  */
-export function usePromise<R, A extends any[] = []>(fn: PromiseFn<A, R>): DispatchFn<A> {
+export function usePromise<Res, Args extends any[] = []>(fn: PromiseFn<Args, Res>): DispatchFn<Args> {
 
     const lastFn = useLatest(fn)
 
-    return useCallback((...args: A) => {
+    return useCallback((...args: Args) => {
         lastFn.current.apply(undefined, ...args).catch((error: any) => {
             console.debug(`usePromise collected an error ${fn.name}`, error)
         })

src/async/useSharedAsync.ts

@@ -9,9 +9,9 @@ import { usePromise } from './usePromise';
  * same or will throw if arguments have changed.
  */
 
-export function useSharedAsync<Args extends any[] = [], Res = void, Err = any>(
+export function useSharedAsync<Res = void, Args extends any[] = [], Err = any>(
     fn: PromiseFn<Args, Res>,
-): UseAsyncReturn<Args, Res, Err> {
+): UseAsyncReturn<Res, Args, Err> {
 
     const { runAsync: oldRunAsync, run: oldRun, ...rest } = useAsync(fn);
     const runAsync = useSharedPromise(oldRunAsync)

src/async/useSharedPromise.ts

@@ -21,19 +21,19 @@ import { areArgsEqual } from '../utils';
  *
  * /B 2022-10-19
  */
-export function useSharedPromise<R, A extends any[] = []>(fn: PromiseFn<A, R>): PromiseFn<A, R> {
+export function useSharedPromise<Res, Args extends any[] = []>(fn: PromiseFn<Args, Res>): PromiseFn<Args, Res> {
 
     const lastFn = useLatest(fn)
-    const stack = useRef<{ args: A, res: ((v: R) => void)[], rej: ((e: any) => void)[] } | undefined>()
+    const stack = useRef<{ args: Args, res: ((v: Res) => void)[], rej: ((e: any) => void)[] } | undefined>()
 
-    return useCallback(async (...args: A): Promise<R> => {
-        return new Promise<R>((res, rej) => {
+    return useCallback(async (...args: Args): Promise<Res> => {
+        return new Promise<Res>((res, rej) => {
             if (!stack.current) {
                 // First execution
                 stack.current = { args, res: [res], rej: [rej] }
 
                 lastFn.current.apply(undefined, args)
-                    .then((r: R) => {
+                    .then((r: Res) => {
                         stack.current?.res.forEach(f => f(r))
                         stack.current = undefined
                     })

src/index.ts

@@ -1,5 +1,25 @@
-export { useLatest } from './generic/useLatest';
-export { usePrevious } from './generic/usePrevious';
-export { useDefault } from './state/useDefault';
-export { usePatch } from './state/usePatch';
-export { useReset } from './state/useReset';
+
+export * from './async/types';
+export * from './async/useAsync';
+export * from './async/useExclusivePromise';
+export * from './async/usePromise';
+export * from './async/useQuery';
+export * from './async/useSharedAsync';
+export * from './async/useSharedPromise';
+
+export * from './browser/useIsMobile';
+
+export * from './dom/useEvent';
+
+export * from './generic/useLatest';
+export * from './generic/usePrevious';
+
+export * from './navigation/useHref';
+export * from './navigation/useLocation';
+export * from './navigation/useSearchParam';
+
+export * from './state/useDefault';
+export * from './state/usePatch';
+export * from './state/useReset';
+
+export * from './utils';