redux-unfold-saga-toolkit 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Hung Nguyen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,460 @@
+# redux-unfold-saga-toolkit
+
+A more user-friendly, headache-free redux-saga middleware.
+
+> This library is inspired by [redux-unfold-saga](https://github.com/manhhailua/redux-unfold-saga).
+
+## Getting started
+
+#### Install
+
+```bash
+npm install --save redux-unfold-saga-toolkit
+```
+
+or
+
+```bash
+yarn add redux-unfold-saga-toolkit
+```
+
+> This library is required [redux-saga](https://redux-saga.js.org/docs/introduction/GettingStarted) and [immer](https://immerjs.github.io/immer/installation)
+
+#### Usage example
+
+- action
+
+```typescript
+import { createAction } from 'redux-unfold-saga-toolkit';
+
+const fetchPosts = createAction('FETCH_POSTS');
+
+dispatch(
+  fetchPosts(
+    { category: 'HOT' },
+    {
+      onBegin: () => {
+        // Do something before the query
+        setLoading(true);
+      },
+      onFailure: (error: Error) => {
+        // Do something in case of caught error
+      },
+      onSuccess: (posts: IPost[]) => {
+        // Do something after the query succeeded
+      },
+      onFinish: () => {
+        // Do something after everything is done
+        setLoading(false);
+      },
+    },
+  ),
+);
+```
+
+- saga
+
+```typescript
+import { call, takeLatest } from 'redux-saga/effects';
+import { unfoldSaga } from 'redux-unfold-saga-toolkit';
+
+function* takeQueryPosts(action: UnfoldSagaActionType): Iterable<SagaIterator> {
+  yield unfoldSaga({
+    action: action,
+    handler: function* () {
+      const data = yield call(ApiPost.listPost);
+      return data;
+    },
+  });
+}
+
+function* defaultSaga() {
+  yield takeLatest('QUERY_POSTS', takeQueryPosts);
+  // yield takeLatest(fetchPosts, takeQueryPosts);
+  // yield takeLatest(fetchPosts.type, takeQueryPosts);
+}
+```
+
+- reducer
+
+```typescript
+import { createReducer, createStoreAction } from 'redux-unfold-saga-toolkit';
+
+const fetchPosts = createStoreAction('FETCH_POSTS');
+
+const initState = {
+  posts: [],
+  error: null,
+  loading: true,
+};
+
+const postReducer = createReducer(initState, (builder) => {
+  builder.addCase<void>(fetchPosts.begin, (state, action) => {
+    state.loading = true;
+  });
+  builder.addCase<void>(fetchPosts.finish, (state, action) => {
+    state.loading = false;
+  });
+  builder.addCase<IPost[]>(fetchPosts.success, (state, action) => {
+    state.posts = action.payload;
+  });
+  builder.addCase<Error>(fetchPosts.failure, (state, action) => {
+    state.error = action.payload;
+  });
+});
+```
+
+## API
+
+<!-- Generated by documentation.js. Update this documentation by updating the source code. -->
+
+### Table of Contents
+
+- [createActionTypeOnBegin][1]
+  - [Parameters][2]
+  - [Examples][3]
+- [createActionTypeOnFinish][4]
+  - [Parameters][5]
+  - [Examples][6]
+- [createActionTypeOnSuccess][7]
+  - [Parameters][8]
+  - [Examples][9]
+- [createActionTypeOnFailure][10]
+  - [Parameters][11]
+  - [Examples][12]
+- [createAction][13]
+  - [Parameters][14]
+  - [Examples][15]
+- [createStoreAction][16]
+  - [Parameters][17]
+  - [Examples][18]
+- [createReducer][19]
+  - [Parameters][20]
+  - [Examples][21]
+- [unfoldSaga][22]
+  - [Parameters][23]
+  - [Examples][24]
+
+## createActionTypeOnBegin
+
+Create onBegin action type
+
+### Parameters
+
+- `key` &#x20;
+
+### Examples
+
+```javascript
+import { createActionTypeOnBegin } from 'redux-unfold-saga-toolkit';
+
+createActionTypeOnBegin('DO_SOMETHING'); // DO_SOMETHING_BEGAN
+```
+
+Returns **[string][25]** `${key}_BEGAN`
+
+## createActionTypeOnFinish
+
+Create onFinish action type
+
+### Parameters
+
+- `key` &#x20;
+
+### Examples
+
+```javascript
+import { createActionTypeOnFinish } from 'redux-unfold-saga-toolkit';
+
+createActionTypeOnFinish('DO_SOMETHING'); // DO_SOMETHING_FINISHED
+```
+
+Returns **[string][25]** `${key}_FINISHED`
+
+## createActionTypeOnSuccess
+
+Create onSuccess action type
+
+### Parameters
+
+- `key` &#x20;
+
+### Examples
+
+```javascript
+import { createActionTypeOnSuccess } from 'redux-unfold-saga-toolkit';
+
+createActionTypeOnSuccess('DO_SOMETHING'); // DO_SOMETHING_SUCCEEDED
+```
+
+Returns **[string][25]** `${key}_SUCCEEDED`
+
+## createActionTypeOnFailure
+
+Create onFailure action type
+
+### Parameters
+
+- `key` &#x20;
+
+### Examples
+
+```javascript
+import { createActionTypeOnFailure } from 'redux-unfold-saga-toolkit';
+
+createActionTypeOnFailure('DO_SOMETHING'); // DO_SOMETHING_FAILED
+```
+
+Returns **[string][25]** `${key}_FAILED`
+
+## createAction
+
+Create an action for real life usage inside or even outside of a component, no dispatch to reducer
+
+### Parameters
+
+- `type` &#x20;
+
+### Examples
+
+```javascript
+import {createAction} from 'redux-unfold-saga-toolkit';
+
+const fetchPosts = createAction<IPostPayload>('FETCH_POSTS');
+
+dispatch(
+  fetchPosts(
+    {category: 'HOT'},
+    {
+      onBegin: () => {
+        // Do something before the query
+        setLoading(true);
+      },
+      onFailure: (error: Error) => {
+        // Do something in case of caught error
+      },
+      onSuccess: (posts: IPost[]) => {
+        // Do something after the query succeeded
+      },
+      onFinish: () => {
+        // Do something after everything is done
+        setLoading(false);
+      },
+    },
+  ),
+);
+```
+
+Returns **UnfoldSagaActionCreator** action
+
+## createStoreAction
+
+Create an action for real life usage inside or even outside of a component, dispatch to reducer with automatic create action type
+
+### Parameters
+
+- `type` &#x20;
+
+### Examples
+
+```javascript
+// Action
+import {createStoreAction, createReducer} from 'redux-unfold-saga-toolkit';
+
+const fetchPosts = createStoreAction<IPostPayload>('FETCH_POSTS');
+
+dispatch(
+  fetchPosts(
+    {category: 'HOT'},
+    {
+      onBegin: () => {
+        // Do something before the query
+        setLoading(true);
+      },
+      onFailure: (error:Error) => {
+        // Do something in case of caught error
+      },
+      onSuccess: (posts:IPost) => {
+        // Do something after the query succeeded
+      },
+      onFinish: () => {
+        // Do something after everything is done
+        setLoading(false);
+      },
+    },
+  ),
+);
+
+// Reducer
+const initState = {
+        posts: [],
+        error: null,
+        loading: true,
+};
+
+const postReducer = createReducer(initState, (builder) => {
+  builder.addCase<void>(fetchPosts.begin, (state, action) => {
+    state.loading = true;
+  });
+  builder.addCase<void>(fetchPosts.finish, (state, action) => {
+    state.loading = false;
+  });
+  builder.addCase<IPost[]>(fetchPosts.success, (state, action) => {
+    state.posts = action.payload;
+  });
+  builder.addCase<Error>(fetchPosts.failure, (state, action) => {
+    state.error = action.payload;
+  });
+})
+```
+
+Returns **UnfoldSagaActionCreator** action
+
+## createReducer
+
+A utility function that allows defining a reducer as a mapping from action
+type to _case reducer_ functions that handle these action types. The
+reducer's initial state is passed as the first argument.
+
+### Parameters
+
+- `initialState` &#x20;
+- `builderCallback` &#x20;
+
+### Examples
+
+```javascript
+// Action
+
+import {createStoreAction, createReducer} from 'redux-unfold-saga-toolkit';
+
+const fetchPosts = createStoreAction<IPostPayload>('FETCH_POSTS');
+
+dispatch(
+  fetchPosts(
+    {category: 'HOT'},
+    {
+      onBegin: () => {
+        // Do something before the query
+        setLoading(true);
+      },
+      onFailure: (error:Error) => {
+        // Do something in case of caught error
+      },
+      onSuccess: (posts:IPost) => {
+        // Do something after the query succeeded
+      },
+      onFinish: () => {
+        // Do something after everything is done
+        setLoading(false);
+      },
+    },
+  ),
+);
+
+// Reducer
+const initState = {
+        posts: [],
+        error: null,
+        loading: true,
+};
+
+const postReducer = createReducer(initState, (builder) => {
+  builder.addCase<void>(fetchPosts.begin, (state, action) => {
+    state.loading = true;
+  });
+  builder.addCase<void>(fetchPosts.finish, (state, action) => {
+    state.loading = false;
+  });
+  builder.addCase<IPost[]>(fetchPosts.success, (state, action) => {
+    state.posts = action.payload;
+  });
+  builder.addCase<Error>(fetchPosts.failure, (state, action) => {
+    state.error = action.payload;
+  });
+})
+```
+
+Returns **any** State of reducer has immer
+
+## unfoldSaga
+
+Common saga helper that unifies handling side effects into only one standard form
+
+### Parameters
+
+- `body` **UnfoldSagaHandlerType**&#x20;
+  - `body.action` **UnfoldSagaActionType** Action
+  - `body.handler` **[Function][26]** Main handler function. Its returned value will become onSuccess callback param
+
+### Examples
+
+```javascript
+import {SagaIterator} from 'redux-saga';
+import {call, takeLatest} from 'redux-saga/effects';
+import {unfoldSaga} from 'redux-unfold-saga-toolkit';
+import {fetchPosts} from './action';
+
+// Saga function
+function* takeQueryPosts(action: UnfoldSagaActionType): Iterable<SagaIterator> {
+  yield unfoldSaga({
+  action: action,
+  handler: function* () {
+    const data = yield call(ApiPost.listPost);
+    return data;
+  },
+ });
+}
+
+or
+
+// Async function
+function* takeQueryPosts(action: UnfoldSagaActionType): Iterable<SagaIterator> {
+  yield unfoldSaga({
+  action: action,
+  handler: async function () {
+    const data = await ApiPost.listPost();
+    return data;
+  },
+ });
+}
+
+function* defaultSaga() {
+  yield takeLatest('FETCH_POSTS', takeQueryPosts);
+  // yield takeLatest(fetchPosts, takeQueryPosts);
+  // yield takeLatest(fetchPosts.type, takeQueryPosts);
+}
+```
+
+Returns **SagaIterator** SagaIterator
+
+[1]: #createactiontypeonbegin
+[2]: #parameters
+[3]: #examples
+[4]: #createactiontypeonfinish
+[5]: #parameters-1
+[6]: #examples-1
+[7]: #createactiontypeonsuccess
+[8]: #parameters-2
+[9]: #examples-2
+[10]: #createactiontypeonfailure
+[11]: #parameters-3
+[12]: #examples-3
+[13]: #createaction
+[14]: #parameters-4
+[15]: #examples-4
+[16]: #createstoreaction
+[17]: #parameters-5
+[18]: #examples-5
+[19]: #createreducer
+[20]: #parameters-6
+[21]: #examples-6
+[22]: #unfoldsaga
+[23]: #parameters-7
+[24]: #examples-7
+[25]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String
+[26]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Statements/function
+
+## License
+
+MIT © [hungnguyen2809](https://github.com/hungnguyen2809)

package/dist/action/index.d.ts

@@ -0,0 +1,140 @@
+import { UnfoldSagaActionCreator, UnfoldSagaStoreActionCreator } from '../types';
+/**
+ * @param key
+ * @returns {string} `${key}_BEGAN`
+ * @description Create onBegin action type
+ * @example
+ * ```ts
+ * import {createActionTypeOnBegin} from 'redux-unfold-saga-toolkit';
+ *
+ * createActionTypeOnBegin('DO_SOMETHING') // DO_SOMETHING_BEGAN
+ * ```
+ */
+export declare function createActionTypeOnBegin(key: string): string;
+/**
+ * @param key
+ * @returns {string} `${key}_FINISHED`
+ * @description Create onFinish action type
+ * @example
+ * ```ts
+ * import {createActionTypeOnFinish} from 'redux-unfold-saga-toolkit';
+ *
+ * createActionTypeOnFinish('DO_SOMETHING') // DO_SOMETHING_FINISHED
+ * ```
+ */
+export declare function createActionTypeOnFinish(key: string): string;
+/**
+ * @param key
+ * @returns {string} `${key}_SUCCEEDED`
+ * @description Create onSuccess action type
+ * @example
+ * ```ts
+ * import {createActionTypeOnSuccess} from 'redux-unfold-saga-toolkit';
+ *
+ * createActionTypeOnSuccess('DO_SOMETHING') // DO_SOMETHING_SUCCEEDED
+ * ```
+ */
+export declare function createActionTypeOnSuccess(key: string): string;
+/**
+ * @param key
+ * @returns {string} `${key}_FAILED`
+ * @description Create onFailure action type
+ * @example
+ * ```ts
+ * import {createActionTypeOnFailure} from 'redux-unfold-saga-toolkit';
+ *
+ * createActionTypeOnFailure('DO_SOMETHING') // DO_SOMETHING_FAILED
+ * ```
+ */
+export declare function createActionTypeOnFailure(key: string): string;
+/**
+ * @param type
+ * @returns {UnfoldSagaActionCreator} action
+ * @description Create an action for real life usage inside or even outside of a component, no dispatch to reducer
+ * @example
+ * ```ts
+ * import {createAction} from 'redux-unfold-saga-toolkit';
+ *
+ * const fetchPosts = createAction<IPostPayload>('FETCH_POSTS');
+ *
+ * dispatch(
+ *   fetchPosts(
+ *     {category: 'HOT'},
+ *     {
+ *       onBegin: () => {
+ *         // Do something before the query
+ *         setLoading(true);
+ *       },
+ *       onFailure: (error: Error) => {
+ *         // Do something in case of caught error
+ *       },
+ *       onSuccess: (posts: IPost[]) => {
+ *         // Do something after the query succeeded
+ *       },
+ *       onFinish: () => {
+ *         // Do something after everything is done
+ *         setLoading(false);
+ *       },
+ *     },
+ *   ),
+ * );
+ * ```
+ */
+export declare function createAction<PayloadType = any>(type: string): UnfoldSagaActionCreator<PayloadType>;
+/**
+ * @param type
+ * @returns {UnfoldSagaActionCreator} action
+ * @description Create an action for real life usage inside or even outside of a component, dispatch to reducer with automatic create action type
+ * @example
+ * // Action
+ * ```ts
+ * import {createStoreAction, createReducer} from 'redux-unfold-saga-toolkit';
+ *
+ * const fetchPosts = createStoreAction<IPostPayload>('FETCH_POSTS');
+ *
+ * dispatch(
+ *   fetchPosts(
+ *     {category: 'HOT'},
+ *     {
+ *       onBegin: () => {
+ *         // Do something before the query
+ *         setLoading(true);
+ *       },
+ *       onFailure: (error:Error) => {
+ *         // Do something in case of caught error
+ *       },
+ *       onSuccess: (posts:IPost) => {
+ *         // Do something after the query succeeded
+ *       },
+ *       onFinish: () => {
+ *         // Do something after everything is done
+ *         setLoading(false);
+ *       },
+ *     },
+ *   ),
+ * );
+ *
+ * // Reducer
+ * const initState = {
+ * 	posts: [],
+ * 	error: null,
+ * 	loading: true,
+ * };
+ *
+ * const postReducer = createReducer(initState, (builder) => {
+ *   builder.addCase<void>(fetchPosts.begin, (state, action) => {
+ *     state.loading = true;
+ *   });
+ *   builder.addCase<void>(fetchPosts.finish, (state, action) => {
+ *     state.loading = false;
+ *   });
+ *   builder.addCase<IPost[]>(fetchPosts.success, (state, action) => {
+ *     state.posts = action.payload;
+ *   });
+ *   builder.addCase<Error>(fetchPosts.failure, (state, action) => {
+ *     state.error = action.payload;
+ *   });
+ * })
+ * ```
+ */
+export declare function createStoreAction<PayloadType = any>(type: string): UnfoldSagaStoreActionCreator<PayloadType>;

package/dist/action/index.js

@@ -0,0 +1,175 @@
+/**
+ * @param key
+ * @returns {string} `${key}_BEGAN`
+ * @description Create onBegin action type
+ * @example
+ * ```ts
+ * import {createActionTypeOnBegin} from 'redux-unfold-saga-toolkit';
+ *
+ * createActionTypeOnBegin('DO_SOMETHING') // DO_SOMETHING_BEGAN
+ * ```
+ */
+export function createActionTypeOnBegin(key) {
+    return `${key}_BEGAN`;
+}
+/**
+ * @param key
+ * @returns {string} `${key}_FINISHED`
+ * @description Create onFinish action type
+ * @example
+ * ```ts
+ * import {createActionTypeOnFinish} from 'redux-unfold-saga-toolkit';
+ *
+ * createActionTypeOnFinish('DO_SOMETHING') // DO_SOMETHING_FINISHED
+ * ```
+ */
+export function createActionTypeOnFinish(key) {
+    return `${key}_FINISHED`;
+}
+/**
+ * @param key
+ * @returns {string} `${key}_SUCCEEDED`
+ * @description Create onSuccess action type
+ * @example
+ * ```ts
+ * import {createActionTypeOnSuccess} from 'redux-unfold-saga-toolkit';
+ *
+ * createActionTypeOnSuccess('DO_SOMETHING') // DO_SOMETHING_SUCCEEDED
+ * ```
+ */
+export function createActionTypeOnSuccess(key) {
+    return `${key}_SUCCEEDED`;
+}
+/**
+ * @param key
+ * @returns {string} `${key}_FAILED`
+ * @description Create onFailure action type
+ * @example
+ * ```ts
+ * import {createActionTypeOnFailure} from 'redux-unfold-saga-toolkit';
+ *
+ * createActionTypeOnFailure('DO_SOMETHING') // DO_SOMETHING_FAILED
+ * ```
+ */
+export function createActionTypeOnFailure(key) {
+    return `${key}_FAILED`;
+}
+/**
+ * @param type
+ * @returns {UnfoldSagaActionCreator} action
+ * @description Create an action for real life usage inside or even outside of a component, no dispatch to reducer
+ * @example
+ * ```ts
+ * import {createAction} from 'redux-unfold-saga-toolkit';
+ *
+ * const fetchPosts = createAction<IPostPayload>('FETCH_POSTS');
+ *
+ * dispatch(
+ *   fetchPosts(
+ *     {category: 'HOT'},
+ *     {
+ *       onBegin: () => {
+ *         // Do something before the query
+ *         setLoading(true);
+ *       },
+ *       onFailure: (error: Error) => {
+ *         // Do something in case of caught error
+ *       },
+ *       onSuccess: (posts: IPost[]) => {
+ *         // Do something after the query succeeded
+ *       },
+ *       onFinish: () => {
+ *         // Do something after everything is done
+ *         setLoading(false);
+ *       },
+ *     },
+ *   ),
+ * );
+ * ```
+ */
+export function createAction(type) {
+    function actionCreator(payload, callbacks = {}) {
+        return {
+            callbacks,
+            options: {},
+            payload,
+            type,
+        };
+    }
+    actionCreator.type = type;
+    actionCreator.toString = () => type;
+    return actionCreator;
+}
+/**
+ * @param type
+ * @returns {UnfoldSagaActionCreator} action
+ * @description Create an action for real life usage inside or even outside of a component, dispatch to reducer with automatic create action type
+ * @example
+ * // Action
+ * ```ts
+ * import {createStoreAction, createReducer} from 'redux-unfold-saga-toolkit';
+ *
+ * const fetchPosts = createStoreAction<IPostPayload>('FETCH_POSTS');
+ *
+ * dispatch(
+ *   fetchPosts(
+ *     {category: 'HOT'},
+ *     {
+ *       onBegin: () => {
+ *         // Do something before the query
+ *         setLoading(true);
+ *       },
+ *       onFailure: (error:Error) => {
+ *         // Do something in case of caught error
+ *       },
+ *       onSuccess: (posts:IPost) => {
+ *         // Do something after the query succeeded
+ *       },
+ *       onFinish: () => {
+ *         // Do something after everything is done
+ *         setLoading(false);
+ *       },
+ *     },
+ *   ),
+ * );
+ *
+ * // Reducer
+ * const initState = {
+ * 	posts: [],
+ * 	error: null,
+ * 	loading: true,
+ * };
+ *
+ * const postReducer = createReducer(initState, (builder) => {
+ *   builder.addCase<void>(fetchPosts.begin, (state, action) => {
+ *     state.loading = true;
+ *   });
+ *   builder.addCase<void>(fetchPosts.finish, (state, action) => {
+ *     state.loading = false;
+ *   });
+ *   builder.addCase<IPost[]>(fetchPosts.success, (state, action) => {
+ *     state.posts = action.payload;
+ *   });
+ *   builder.addCase<Error>(fetchPosts.failure, (state, action) => {
+ *     state.error = action.payload;
+ *   });
+ * })
+ * ```
+ */
+export function createStoreAction(type) {
+    function actionCreator(payload, callbacks = {}) {
+        return {
+            callbacks,
+            options: { stateful: true },
+            payload,
+            type,
+        };
+    }
+    actionCreator.type = type;
+    actionCreator.toString = () => type;
+    actionCreator.begin = createActionTypeOnBegin(type);
+    actionCreator.finish = createActionTypeOnFinish(type);
+    actionCreator.success = createActionTypeOnSuccess(type);
+    actionCreator.failure = createActionTypeOnFailure(type);
+    return actionCreator;
+}

package/dist/core/index.d.ts

@@ -0,0 +1,47 @@
+import { SagaIterator } from 'redux-saga';
+import { UnfoldSagaHandlerType } from '../types';
+/**
+ * @param {UnfoldSagaHandlerType} body
+ * @param {UnfoldSagaActionType} body.action Action
+ * @param {Function} body.handler Main handler function. Its returned value will become onSuccess callback param
+ * @returns {SagaIterator} SagaIterator
+ * @description Common saga helper that unifies handling side effects into only one standard form
+ * @example
+ * ```ts
+ * import {SagaIterator} from 'redux-saga';
+ * import {call, takeLatest} from 'redux-saga/effects';
+ * import {unfoldSaga} from 'redux-unfold-saga-toolkit';
+ * import {fetchPosts} from './action';
+ *
+ * // Saga function
+ * function* takeQueryPosts(action: UnfoldSagaActionType): Iterable<SagaIterator> {
+ *   yield unfoldSaga({
+ *   action: action,
+ *   handler: function* () {
+ *     const data = yield call(ApiPost.listPost);
+ *     return data;
+ *   },
+ *  });
+ * }
+ *
+ * or
+ *
+ * // Async function
+ * function* takeQueryPosts(action: UnfoldSagaActionType): Iterable<SagaIterator> {
+ *   yield unfoldSaga({
+ *   action: action,
+ *   handler: async function () {
+ *     const data = await ApiPost.listPost();
+ *     return data;
+ *   },
+ *  });
+ * }
+ *
+ * function* defaultSaga() {
+ *   yield takeLatest('FETCH_POSTS', takeQueryPosts);
+ *   // yield takeLatest(fetchPosts, takeQueryPosts);
+ *   // yield takeLatest(fetchPosts.type, takeQueryPosts);
+ * }
+ * ```
+ */
+export declare function unfoldSaga({ action, handler }: UnfoldSagaHandlerType): SagaIterator;

package/dist/core/index.js

@@ -0,0 +1,86 @@
+import { call, put } from 'redux-saga/effects';
+import { createActionTypeOnBegin, createActionTypeOnFailure, createActionTypeOnFinish, createActionTypeOnSuccess, } from '../action';
+import { noop } from '../helper';
+/**
+ * @param {UnfoldSagaHandlerType} body
+ * @param {UnfoldSagaActionType} body.action Action
+ * @param {Function} body.handler Main handler function. Its returned value will become onSuccess callback param
+ * @returns {SagaIterator} SagaIterator
+ * @description Common saga helper that unifies handling side effects into only one standard form
+ * @example
+ * ```ts
+ * import {SagaIterator} from 'redux-saga';
+ * import {call, takeLatest} from 'redux-saga/effects';
+ * import {unfoldSaga} from 'redux-unfold-saga-toolkit';
+ * import {fetchPosts} from './action';
+ *
+ * // Saga function
+ * function* takeQueryPosts(action: UnfoldSagaActionType): Iterable<SagaIterator> {
+ *   yield unfoldSaga({
+ *   action: action,
+ *   handler: function* () {
+ *     const data = yield call(ApiPost.listPost);
+ *     return data;
+ *   },
+ *  });
+ * }
+ *
+ * or
+ *
+ * // Async function
+ * function* takeQueryPosts(action: UnfoldSagaActionType): Iterable<SagaIterator> {
+ *   yield unfoldSaga({
+ *   action: action,
+ *   handler: async function () {
+ *     const data = await ApiPost.listPost();
+ *     return data;
+ *   },
+ *  });
+ * }
+ *
+ * function* defaultSaga() {
+ *   yield takeLatest('FETCH_POSTS', takeQueryPosts);
+ *   // yield takeLatest(fetchPosts, takeQueryPosts);
+ *   // yield takeLatest(fetchPosts.type, takeQueryPosts);
+ * }
+ * ```
+ */
+export function* unfoldSaga({ action, handler }) {
+    let data;
+    const defaultCallbacks = {
+        onBegin: noop,
+        onFinish: noop,
+        onSuccess: noop,
+        onFailure: noop,
+    };
+    const defaultOptions = {
+        stateful: false,
+    };
+    Object.assign(defaultCallbacks, action.callbacks);
+    Object.assign(defaultOptions, action.options);
+    try {
+        if (defaultOptions.stateful)
+            yield put({ type: createActionTypeOnBegin(action.type) });
+        yield call(defaultCallbacks.onBegin);
+        if (['GeneratorFunction', 'AsyncGeneratorFunction'].includes(handler.constructor.name)) {
+            data = yield* handler();
+        }
+        else {
+            data = yield call(handler);
+        }
+        if (defaultOptions.stateful)
+            yield put({ type: createActionTypeOnSuccess(action.type), payload: data });
+        yield call(defaultCallbacks.onSuccess, data);
+    }
+    catch (error) {
+        if (defaultOptions.stateful)
+            yield put({ type: createActionTypeOnFailure(action.type), payload: error });
+        yield call(defaultCallbacks.onFailure, error);
+    }
+    finally {
+        if (defaultOptions.stateful)
+            yield put({ type: createActionTypeOnFinish(action.type) });
+        yield call(defaultCallbacks.onFinish);
+    }
+    return data;
+}

package/dist/helper/index.d.ts

@@ -0,0 +1,2 @@
+declare function noop(): void;
+export { noop };

package/dist/helper/index.js

@@ -0,0 +1,2 @@
+function noop() { }
+export { noop };

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from './types';
+export * from './action';
+export * from './reducer';
+export * from './core';

package/dist/index.js

@@ -0,0 +1,4 @@
+export * from './types';
+export * from './action';
+export * from './reducer';
+export * from './core';

package/dist/reducer/index.d.ts

@@ -0,0 +1,62 @@
+import { UnfoldSagaActionReducerMapBuilder, UnfoldSagaActionType } from '../types';
+/**
+ *
+ * @param initialState
+ * @param builderCallback
+ * @returns State of reducer has immer
+ * @description A utility function that allows defining a reducer as a mapping from action
+ * type to *case reducer* functions that handle these action types. The
+ * reducer's initial state is passed as the first argument.
+ * @example
+ * // Action
+ * ```ts
+ * import {createStoreAction, createReducer} from 'redux-unfold-saga-toolkit';
+ *
+ * const fetchPosts = createStoreAction<IPostPayload>('FETCH_POSTS');
+ *
+ * dispatch(
+ *   fetchPosts(
+ *     {category: 'HOT'},
+ *     {
+ *       onBegin: () => {
+ *         // Do something before the query
+ *         setLoading(true);
+ *       },
+ *       onFailure: (error:Error) => {
+ *         // Do something in case of caught error
+ *       },
+ *       onSuccess: (posts:IPost) => {
+ *         // Do something after the query succeeded
+ *       },
+ *       onFinish: () => {
+ *         // Do something after everything is done
+ *         setLoading(false);
+ *       },
+ *     },
+ *   ),
+ * );
+ *
+ * // Reducer
+ * const initState = {
+ * 	posts: [],
+ * 	error: null,
+ * 	loading: true,
+ * };
+ *
+ * const postReducer = createReducer(initState, (builder) => {
+ *   builder.addCase<void>(fetchPosts.begin, (state, action) => {
+ *     state.loading = true;
+ *   });
+ *   builder.addCase<void>(fetchPosts.finish, (state, action) => {
+ *     state.loading = false;
+ *   });
+ *   builder.addCase<IPost[]>(fetchPosts.success, (state, action) => {
+ *     state.posts = action.payload;
+ *   });
+ *   builder.addCase<Error>(fetchPosts.failure, (state, action) => {
+ *     state.error = action.payload;
+ *   });
+ * })
+ * ```
+ */
+export declare function createReducer<S = any>(initialState: S, builderCallback: (builder: UnfoldSagaActionReducerMapBuilder<S>) => void): (state: S | undefined, action: UnfoldSagaActionType) => S;

package/dist/reducer/index.js

@@ -0,0 +1,83 @@
+import { produce } from 'immer';
+function executeReducerBuilderCallback(builderCallback) {
+    const actionsMap = {};
+    const builder = {
+        addCase: (action, reducer) => {
+            const type = typeof action === 'string' ? action : action.type;
+            actionsMap[type] = reducer;
+            return builder;
+        },
+    };
+    builderCallback(builder);
+    return actionsMap;
+}
+/**
+ *
+ * @param initialState
+ * @param builderCallback
+ * @returns State of reducer has immer
+ * @description A utility function that allows defining a reducer as a mapping from action
+ * type to *case reducer* functions that handle these action types. The
+ * reducer's initial state is passed as the first argument.
+ * @example
+ * // Action
+ * ```ts
+ * import {createStoreAction, createReducer} from 'redux-unfold-saga-toolkit';
+ *
+ * const fetchPosts = createStoreAction<IPostPayload>('FETCH_POSTS');
+ *
+ * dispatch(
+ *   fetchPosts(
+ *     {category: 'HOT'},
+ *     {
+ *       onBegin: () => {
+ *         // Do something before the query
+ *         setLoading(true);
+ *       },
+ *       onFailure: (error:Error) => {
+ *         // Do something in case of caught error
+ *       },
+ *       onSuccess: (posts:IPost) => {
+ *         // Do something after the query succeeded
+ *       },
+ *       onFinish: () => {
+ *         // Do something after everything is done
+ *         setLoading(false);
+ *       },
+ *     },
+ *   ),
+ * );
+ *
+ * // Reducer
+ * const initState = {
+ * 	posts: [],
+ * 	error: null,
+ * 	loading: true,
+ * };
+ *
+ * const postReducer = createReducer(initState, (builder) => {
+ *   builder.addCase<void>(fetchPosts.begin, (state, action) => {
+ *     state.loading = true;
+ *   });
+ *   builder.addCase<void>(fetchPosts.finish, (state, action) => {
+ *     state.loading = false;
+ *   });
+ *   builder.addCase<IPost[]>(fetchPosts.success, (state, action) => {
+ *     state.posts = action.payload;
+ *   });
+ *   builder.addCase<Error>(fetchPosts.failure, (state, action) => {
+ *     state.error = action.payload;
+ *   });
+ * })
+ * ```
+ */
+export function createReducer(initialState, builderCallback) {
+    const actionsMap = executeReducerBuilderCallback(builderCallback);
+    return function reducer(state = initialState, action) {
+        const caseReducer = actionsMap[action.type];
+        return produce(state, (draft) => {
+            if (caseReducer)
+                caseReducer(draft, action);
+        });
+    };
+}

package/dist/types/index.d.ts

@@ -0,0 +1,40 @@
+import { Draft } from 'immer';
+import { AnyAction } from 'redux-saga';
+export interface UnfoldSagaCallbacksType {
+    onBegin?: Function;
+    onFinish?: Function;
+    onSuccess?: Function;
+    onFailure?: Function;
+}
+export interface UnfoldSagaOptionsType {
+    stateful?: boolean;
+}
+export interface UnfoldSagaHandlerType {
+    action: UnfoldSagaActionType;
+    handler: Function | GeneratorFunction;
+}
+export interface UnfoldSagaPayloadAction<T = any> {
+    type: string;
+    payload: T;
+}
+export type Fn = (...args: any[]) => any;
+export type UnfoldSagaCaseReducer<S, P = any> = (state: Draft<S>, action: UnfoldSagaPayloadAction<P>) => void;
+export type UnfoldSagaActionReducer = UnfoldSagaActionCreator | string;
+export interface UnfoldSagaActionReducerMapBuilder<S> {
+    addCase: <P = any>(action: UnfoldSagaActionReducer, reducer: UnfoldSagaCaseReducer<S, P>) => UnfoldSagaActionReducerMapBuilder<S>;
+}
+export interface UnfoldSagaActionType<PayloadType = any> extends AnyAction {
+    payload: PayloadType;
+    options: UnfoldSagaOptionsType;
+    callbacks: UnfoldSagaCallbacksType;
+}
+export interface UnfoldSagaActionCreator<PayloadType = any> {
+    (payload?: PayloadType, callbacks?: UnfoldSagaCallbacksType): UnfoldSagaActionType;
+    type: string;
+}
+export interface UnfoldSagaStoreActionCreator<PayloadType = any> extends UnfoldSagaActionCreator<PayloadType> {
+    begin: string;
+    finish: string;
+    success: string;
+    failure: string;
+}

package/dist/types/index.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "redux-unfold-saga-toolkit",
+  "version": "1.0.1",
+  "description": "A no headache middleware helper for redux-saga.",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist/"
+  ],
+  "scripts": {
+    "test": "jest",
+    "build": "tsc",
+    "commit": "git cz",
+    "lint": "eslint .",
+    "prepare": "husky"
+  },
+  "author": {
+    "name": "Hung Nguyen",
+    "email": "hungnguyen.dev99@gmail.com",
+    "url": "https://github.com/hungnguyen2809"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hungnguyen2809/redux-unfold-saga-toolkit.git"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "keywords": [
+    "redux",
+    "redux-saga",
+    "redux-unfold-saga",
+    "redux-unfold-saga-toolkit"
+  ],
+  "peerDependencies": {
+    "immer": ">=10.0.0",
+    "redux-saga": "*"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "^20.2.0",
+    "@commitlint/config-conventional": "^20.2.0",
+    "@eslint/js": "^9.39.1",
+    "@types/jest": "^30.0.0",
+    "commitizen": "^4.3.1",
+    "eslint": "^9.39.1",
+    "git-cz": "^4.9.0",
+    "husky": "^9.1.7",
+    "immer": "10.0.0",
+    "jest": "^30.2.0",
+    "lint-staged": "^16.2.7",
+    "prettier": "^3.7.4",
+    "redux-saga": "1.4.2",
+    "ts-jest": "^29.4.6",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.48.1"
+  },
+  "lint-staged": {
+    "*.{js,jsx,ts,tsx}": [
+      "eslint --fix",
+      "prettier --write"
+    ],
+    "*.{json,md,yml}": [
+      "prettier --write"
+    ]
+  },
+  "config": {
+    "commitizen": {
+      "path": "git-cz"
+    }
+  }
+}