@alextewpin/use-promise - npm Package Compare versions

Comparing version 1.0.1 to 2.0.0

lib/index.d.ts

@@ -1,16 +0,16 @@
-export interface PromiseConfig<T, U> {
-    promiseThunk(payload: U): Promise<T>;
-    onResolve?(data: T, payload: U): void;
-    onReject?(error: Error, payload: U): void;
+export interface PromiseConfig<Data, Payload extends unknown[]> {
+    promiseThunk(...payload: Payload): Promise<Data>;
+    onResolve?(data: Data, ...payload: Payload): void;
+    onReject?(error: Error, ...payload: Payload): void;
 }
-interface InternalState<T, U> {
-    data?: T;
+interface InternalState<Data, Payload> {
+    data?: Data;
     error?: Error;
-    payload?: U;
+    payload?: Payload;
     isPending: boolean;
 }
-export interface PromiseState<T, U> extends InternalState<T, U> {
-    run: (payload: U) => void;
+export interface PromiseState<Data, Payload extends unknown[]> extends InternalState<Data, Payload> {
+    run: (...payload: Payload) => void;
 }
-declare const usePromise: <T, U>({ promiseThunk, onResolve, onReject, }: PromiseConfig<T, U>) => PromiseState<T, U>;
+declare const usePromise: <Data, Payload extends unknown[]>({ promiseThunk, onResolve, onReject, }: PromiseConfig<Data, Payload>) => PromiseState<Data, Payload>;
 export default usePromise;

lib/index.js

@@ -74,3 +74,7 @@ "use strict";
   }, [dispatch]);
-  var run = (0, _react.useCallback)(function (payload) {
+  var run = (0, _react.useCallback)(function () {
+    for (var _len = arguments.length, payload = new Array(_len), _key = 0; _key < _len; _key++) {
+      payload[_key] = arguments[_key];
+    }
+
     dispatch({
@@ -80,3 +84,3 @@ type: actionTypes.run,
     });
-    var pendingPromise = promiseThunk(payload).then(function (data) {
+    var pendingPromise = promiseThunk.apply(void 0, payload).then(function (data) {
       if (pendingPromise === pendingPromiseRef.current) {
@@ -89,3 +93,3 @@ dispatch({
         if (onResolve) {
-          onResolve(data, payload);
+          onResolve.apply(void 0, [data].concat(payload));
         }
@@ -101,3 +105,3 @@ }
         if (onReject) {
-          onReject(error, payload);
+          onReject.apply(void 0, [error].concat(payload));
         }
@@ -104,0 +108,0 @@ }

package.json

 {
   "name": "@alextewpin/use-promise",
-  "version": "1.0.1",
+  "version": "2.0.0",
   "author": "Alexander Tewpin <[e-mail]> (https://github.com/alextewpin)",
@@ -5,0 +5,0 @@ "repository": {

README.md

@@ -95,22 +95,22 @@ # use-promise
 
-`<Data, Payload = undefined>(config: PromiseConfig<Data, Payload>) => PromiseState<Data, Payload>`
+`<Data, Payload extends unknown[]>(config: PromiseConfig<Data, Payload>) => PromiseState<Data, Payload>`
 
 Default export, hook that accepts `PromiseConfig` and returns `PromiseState`. In most cases there is not need to pass types manually.
 
-### interface PromiseConfig<Data, Payload>
+### interface PromiseConfig<Data, Payload extends unknown[]>
 
-| Parameter      | Type                                       | Desrciption                                                      |
-| -------------- | ------------------------------------------ | ---------------------------------------------------------------- |
-| `promiseThunk` | `(payload: Payload) => Promise<Data>`      | Function that returns promise, can be called manually with `run` |
-| `onResolve?`   | `(data: Data, payload: Payload) => void`   | Function that will be called on promise resolution.              |
-| `onReject?`    | `(error: Error, payload: Payload) => void` | Function that will be called on promise rejection.               |
+| Parameter      | Type                                          | Desrciption                                                      |
+| -------------- | --------------------------------------------- | ---------------------------------------------------------------- |
+| `promiseThunk` | `(...payload: Payload) => Promise<Data>`      | Function that returns promise, can be called manually with `run` |
+| `onResolve?`   | `(data: Data, ...payload: Payload) => void`   | Function that will be called on promise resolution.              |
+| `onReject?`    | `(error: Error, ...payload: Payload) => void` | Function that will be called on promise rejection.               |
 
-### interface PromiseState<Data, Payload>
+### interface PromiseState<Data, Payload extends unknown[]>
 
-| Parameter   | Type                         | Desrciption                              |
-| ----------- | ---------------------------- | ---------------------------------------- |
-| `data?`     | `Data`                       | Result of the resolved promise.          |
-| `error?`    | `Error`                      | Error of the rejected promise.           |
-| `payload?`  | `Payload`                    | Last started promise payload.            |
-| `isPending` | `boolean`                    | Promise pending status.                  |
-| `run`       | `(payload: Payload) => void` | Run `promiseThunk` with given `Payload`. |
+| Parameter   | Type                            | Desrciption                                                                               |
+| ----------- | ------------------------------- | ----------------------------------------------------------------------------------------- |
+| `data?`     | `Data`                          | Result of the resolved promise.                                                           |
+| `error?`    | `Error`                         | Error of the rejected promise.                                                            |
+| `payload?`  | `Payload`                       | Last started promise payload. Returned as array, as thunk may include multiple argumnets. |
+| `isPending` | `boolean`                       | Promise pending status.                                                                   |
+| `run`       | `(...payload: Payload) => void` | Run `promiseThunk` with given `Payload`.                                                  |

src/index.ts

 import { useCallback, useEffect, useReducer, useRef, Reducer } from 'react';
 
-export interface PromiseConfig<T, U> {
-  promiseThunk(payload: U): Promise<T>;
-  onResolve?(data: T, payload: U): void;
-  onReject?(error: Error, payload: U): void;
+export interface PromiseConfig<Data, Payload extends unknown[]> {
+  promiseThunk(...payload: Payload): Promise<Data>;
+  onResolve?(data: Data, ...payload: Payload): void;
+  onReject?(error: Error, ...payload: Payload): void;
 }
 
-interface InternalState<T, U> {
-  data?: T;
+interface InternalState<Data, Payload> {
+  data?: Data;
   error?: Error;
-  payload?: U;
+  payload?: Payload;
   isPending: boolean;
 }
 
-export interface PromiseState<T, U> extends InternalState<T, U> {
-  run: (payload: U) => void;
+export interface PromiseState<Data, Payload extends unknown[]>
+  extends InternalState<Data, Payload> {
+  run: (...payload: Payload) => void;
 }
@@ -27,9 +28,9 @@
 
-interface RunAction<U> {
-  payload: U;
+interface RunAction<Payload> {
+  payload: Payload;
   type: actionTypes.run;
 }
 
-interface ResolveAction<T> {
-  payload: T;
+interface ResolveAction<Data> {
+  payload: Data;
   type: actionTypes.resolve;
@@ -47,5 +48,5 @@ }
 
-type Action<T, U> =
-  | RunAction<U>
-  | ResolveAction<T>
+type Action<Data, Payload> =
+  | RunAction<Payload>
+  | ResolveAction<Data>
   | RejectAction
@@ -61,6 +62,6 @@ | CancelAction;
 
-const reducer = <T, U>(
-  state: InternalState<T, U>,
-  action: Action<T, U>,
-): InternalState<T, U> => {
+const reducer = <Data, Payload>(
+  state: InternalState<Data, Payload>,
+  action: Action<Data, Payload>,
+): InternalState<Data, Payload> => {
   switch (action.type) {
@@ -93,12 +94,11 @@ case actionTypes.run:
 
-const usePromise = <T, U>({
+const usePromise = <Data, Payload extends unknown[]>({
   promiseThunk,
   onResolve,
   onReject,
-}: PromiseConfig<T, U>): PromiseState<T, U> => {
+}: PromiseConfig<Data, Payload>): PromiseState<Data, Payload> => {
   const pendingPromiseRef = useRef<Promise<void> | null>(null);
-  const usedReducer = useReducer<Reducer<InternalState<T, U>, Action<T, U>>>(
-    reducer,
-    defaultState,
-  );
+  const usedReducer = useReducer<
+    Reducer<InternalState<Data, Payload>, Action<Data, Payload>>
+  >(reducer, defaultState);
 
@@ -120,6 +120,6 @@ const state = usedReducer[0];
   const run = useCallback(
-    (payload: U) => {
+    (...payload: Payload) => {
       dispatch({ type: actionTypes.run, payload });
 
-      const pendingPromise = promiseThunk(payload)
+      const pendingPromise = promiseThunk(...payload)
         .then((data) => {
@@ -133,3 +133,3 @@ if (pendingPromise === pendingPromiseRef.current) {
             if (onResolve) {
-              onResolve(data, payload);
+              onResolve(data, ...payload);
             }
@@ -146,3 +146,3 @@ }
             if (onReject) {
-              onReject(error, payload);
+              onReject(error, ...payload);
             }
@@ -149,0 +149,0 @@ }

No alert changes

Improved metrics

Total package byte prevSize

14665

increased by7.78%

Lines of code

247

increased by1.23%

No dependency changes