saga-toolkit 2.1.2 → 2.2.2

package/README.md

@@ -1,135 +1,149 @@
 # Saga Toolkit
 
-An extension for [redux-toolkit][redux-toolkit] that allows sagas to resolve async thunk actions. 🌝
+**Seamlessly integrate Redux Toolkit with Redux Saga.**
 
-## install
+`saga-toolkit` acts as a bridge between Redux Toolkit's `createAsyncThunk` and Redux Saga. It allows you to dispatch actions that trigger Sagas, while retaining the ability to `await` the result (promise) directly in your components or thunks.
 
-`npm i saga-toolkit`
+If you love the "fire-and-forget" nature of Sagas for complex flows but miss the convenience of `await dispatch(action)` for simple request/response patterns (like form submissions), this library is for you.
 
-## example - takeEveryAsync
+## Features
 
-With `takeEveryAsync` each saga action dispatched runs their saga.
+- 🤝 **Bridge Pattern**: Connects `createAsyncThunk` (RTK) with `takeEvery` / `takeLatest` (Saga).
+- 🔄 **Promise Support**: `await` your Saga actions in React components.
+- ⚡ **Reduce Boilerplate**: Easily handle loading/success/error states in slices using standard RTK patterns.
+- 🛑 **Cancellation**: Propagates cancellation from the promise to the Saga.
 
-`slice.js`
-```js
+## Installation
+
+```bash
+npm install saga-toolkit
+# or
+yarn add saga-toolkit
+```
+
+*Peer Dependencies: `@reduxjs/toolkit`, `redux-saga`*
+
+## Usage Guide
+
+### 1. Create a "Saga Action"
+
+Instead of `createAsyncThunk` or standard standard action creators, use `createSagaAction`. This creates a thunk that returns a promise which your Saga will resolve or reject.
+
+```javascript
+/* slice.js */
 import { createSlice } from '@reduxjs/toolkit'
-import { createSagaAction  } from 'saga-toolkit'
+import { createSagaAction } from 'saga-toolkit'
+
+const name = 'users'
 
-const name = 'example'
+// Define the action
+export const fetchUser = createSagaAction(`${name}/fetchUser`)
 
 const initialState = {
-  started: false,
-  result: null,
+  data: null,
   loading: false,
   error: null,
 }
 
-export const appStart = createSagaAction(`${name}/appStart`)
-export const fetchThings = createSagaAction(`${name}/fetchThings`)
-
 const slice = createSlice({
   name,
   initialState,
-  extraReducers: {
-    [fetchThings.pending]: state => ({
-      ...state,
-      loading: true,
-    }),
-    [fetchThings.fulfilled]: (state, { payload }) => ({
-      ...state,
-      result: payload,
-      loading: false,
-    }),
-    [fetchThings.rejected]: (state, { error }) => ({
-      ...state,
-      error,
-      loading: false,
-    }),
-    [appStart.fulfilled]: state => {
-      state.started = true // immer allows this
-      return state
-    },
+  extraReducers: (builder) => {
+    builder
+      .addCase(fetchUser.pending, (state) => {
+        state.loading = true
+        state.error = null
+      })
+      .addCase(fetchUser.fulfilled, (state, { payload }) => {
+        state.loading = false
+        state.data = payload
+      })
+      .addCase(fetchUser.rejected, (state, { error }) => {
+        state.loading = false
+        state.error = error
+      })
   },
 })
 
 export default slice.reducer
 ```
 
-`sagas.js`
-```js
-import { put, call } from 'redux-saga/effects'
-import { takeEveryAsync, putAsync } from 'saga-toolkit'
-import API from 'hyper-super-api'
-import * as actions from './slice'
-
-function* appStart() {
-  const promise = yield put(fetchThings({ someArg: 'example' }))
-  try {
-    const fetchThingsActionFulfulled = yield promise // optionally we can wait for an action to finish and get its result
-  } catch(error) {
-    // we can handle error to avoid appStart to get rejected if we want
-  }
-  return result
-}
+### 2. Connect to a Saga
 
-// or using putAsync
-function* appStart() {
-  try {
-    const payload = yield putAsync(fetchThings({ someArg: 'example' }))
-  } catch(error) {
-    // handle uncatched error from saga
-  }
-  return result
-}
+Use `takeEveryAsync` (or `takeLatestAsync`, etc.) to listen for the action. The return value of your saga becomes the `fulfilled` payload. Throwing an error becomes the `rejected` payload.
+
+```javascript
+/* sagas.js */
+import { call } from 'redux-saga/effects'
+import { takeEveryAsync } from 'saga-toolkit'
+import { fetchUser } from './slice'
+import API from './api'
 
-function* fetchThings({ meta }) {
-  const { someArg } = meta
-  const result = yield call(() => API.get('/things', { body: someArg }))
-  return result
+function* fetchUserSaga({ meta }) {
+  // meta.arg contains the argument passed to the dispatch
+  const userId = meta.arg
+  
+  // The return value here resolves the promise!
+  const user = yield call(API.getUser, userId)
+  return user 
 }
 
-export default [
-  takeEveryAsync(actions.appStart.type, appStart),
-  takeEveryAsync(actions.fetchThings.type, fetchThings),
-]
+export default function* rootSaga() {
+  yield takeEveryAsync(fetchUser.type, fetchUserSaga)
+}
 ```
 
-`SomeComponent.js`
-```js
-// import things
+### 3. Dispatch and Await in Component
+
+Now you can treat the Saga logic as if it were a simple async function.
 
-const SomeComponent() {
+```javascript
+/* UserComponent.jsx */
+import { useDispatch } from 'react-redux'
+import { useEffect } from 'react'
+import { fetchUser } from './slice'
+
+const UserComponent = ({ id }) => {
   const dispatch = useDispatch()
 
-  useEffect(() => {
-    const promise = dispatch(appStart()) // dispatch action from component
-    promise.then(...).catch(...) // optionally do something with promise
-  }, [])
+  const handleFetch = async () => {
+    try {
+      // This waits for the Saga to finish!
+      const user = await dispatch(fetchUser(id)).unwrap() 
+      console.log('Got user:', user)
+    } catch (error) {
+      console.error('Failed to fetch:', error)
+    }
+  }
 
-  return (
-    ...
-  )
+  return <button onClick={handleFetch}>Load User</button>
 }
 ```
 
-## example2 - takeLatestAsync
+## API Reference
 
-With `takeLatestAsync` the latter saga cancels the previous one in case that has not finished running. Action will be rejected with error message 'Saga cancelled'.
+### `createSagaAction(typePrefix)`
+Creates a Redux Toolkit Async Thunk that is specially designed to work with the effects below.
+- **Returns**: An enhanced thunk action creator.
 
-```js
-export default [
-  takeLatestAsync(actions.fetchThings.type, fetchThings),
-]
-```
+### `takeEveryAsync(pattern, saga, ...args)`
+Spawns a `saga` on each action dispatched to the Store that matches `pattern`.
+- Automatically resolves the promise associated with the action when the saga returns.
+- Automatically rejects the promise if the saga errors.
 
-## example3 - takeAggregateAsync
+### `takeLatestAsync(pattern, saga, ...args)`
+Same as `takeEveryAsync`, but cancels any previous running task if a new matching action is dispatched.
+- **Note**: Cancelled tasks will reject the promise with an "Aborted" error (or similar).
 
-With `takeAggregateAsync` the underlying promise that is created by the first action dispatch will be used and shared accross all subsequent actions. Each subsequent action will be resolved / rejected with the result of the first action. In other words, one single saga runs at a time that is passed to this effect.
+### `takeAggregateAsync(pattern, saga, ...args)`
+Wait for the saga to finish for the first action. If subsequent actions with the same pattern are dispatched *while only one is running*, they will all share the **same promise result** as the first one.
+- Useful for de-duplicating identical requests (e.g., multiple components requesting "load config" simultaneously).
 
-```js
-export default [
-  takeAggregateAsync(actions.fetchThings.type, fetchThings),
-]
-```
+### `putAsync(action)`
+Dispatches an action to the store and waits for the result.
+- Useful when you want to call another saga-action from within a saga and wait for it (composition).
+- **Example**: `const result = yield putAsync(otherAction())`
+
+## License
 
-[redux-toolkit]: https://redux-toolkit.js.org/ "redux-toolkit"
+ISC

package/dist/index.d.mts

@@ -0,0 +1,28 @@
+import { AsyncThunk, AsyncThunkAction } from '@reduxjs/toolkit';
+import * as redux_saga_effects from 'redux-saga/effects';
+import { ActionPattern, PutEffect } from 'redux-saga/effects';
+import { Channel } from 'redux-saga';
+import { Action } from 'redux';
+
+type SagaWorker = (...args: unknown[]) => unknown;
+interface Deferred<T = unknown> {
+    resolve: (value: T) => void;
+    reject: (error: unknown) => void;
+    promise: Promise<T>;
+}
+interface Request {
+    requestId?: string;
+    deferred?: Deferred;
+    onAdd?: (request: Request) => void;
+    abort?: () => void;
+}
+type SagaAction<Returned, ThunkArg = void> = AsyncThunk<Returned, ThunkArg, object>;
+
+declare function takeEveryAsync<A extends Action = Action>(pattern: ActionPattern<A> | Channel<A>, saga: (action: A, ...args: unknown[]) => unknown, ...args: unknown[]): redux_saga_effects.ForkEffect<never>;
+declare function takeLatestAsync<A extends Action = Action>(pattern: ActionPattern<A> | Channel<A>, saga: (action: A, ...args: unknown[]) => unknown, ...args: unknown[]): redux_saga_effects.ForkEffect<Generator<unknown, void, unknown>>;
+declare function takeAggregateAsync<A extends Action = Action>(pattern: ActionPattern<A> | Channel<A>, saga: (action: A, ...args: unknown[]) => unknown, ...args: unknown[]): redux_saga_effects.ForkEffect<never>;
+declare function putAsync(action: Action | PutEffect | AsyncThunkAction<unknown, unknown, object>): Generator<PutEffect | Promise<unknown>, unknown, unknown>;
+
+declare const createSagaAction: <Returned, ThunkArg = void>(type: string) => SagaAction<Returned, ThunkArg>;
+
+export { type Deferred, type Request, type SagaAction, type SagaWorker, createSagaAction, putAsync, takeAggregateAsync, takeEveryAsync, takeLatestAsync };

package/dist/index.d.ts

@@ -0,0 +1,28 @@
+import { AsyncThunk, AsyncThunkAction } from '@reduxjs/toolkit';
+import * as redux_saga_effects from 'redux-saga/effects';
+import { ActionPattern, PutEffect } from 'redux-saga/effects';
+import { Channel } from 'redux-saga';
+import { Action } from 'redux';
+
+type SagaWorker = (...args: unknown[]) => unknown;
+interface Deferred<T = unknown> {
+    resolve: (value: T) => void;
+    reject: (error: unknown) => void;
+    promise: Promise<T>;
+}
+interface Request {
+    requestId?: string;
+    deferred?: Deferred;
+    onAdd?: (request: Request) => void;
+    abort?: () => void;
+}
+type SagaAction<Returned, ThunkArg = void> = AsyncThunk<Returned, ThunkArg, object>;
+
+declare function takeEveryAsync<A extends Action = Action>(pattern: ActionPattern<A> | Channel<A>, saga: (action: A, ...args: unknown[]) => unknown, ...args: unknown[]): redux_saga_effects.ForkEffect<never>;
+declare function takeLatestAsync<A extends Action = Action>(pattern: ActionPattern<A> | Channel<A>, saga: (action: A, ...args: unknown[]) => unknown, ...args: unknown[]): redux_saga_effects.ForkEffect<Generator<unknown, void, unknown>>;
+declare function takeAggregateAsync<A extends Action = Action>(pattern: ActionPattern<A> | Channel<A>, saga: (action: A, ...args: unknown[]) => unknown, ...args: unknown[]): redux_saga_effects.ForkEffect<never>;
+declare function putAsync(action: Action | PutEffect | AsyncThunkAction<unknown, unknown, object>): Generator<PutEffect | Promise<unknown>, unknown, unknown>;
+
+declare const createSagaAction: <Returned, ThunkArg = void>(type: string) => SagaAction<Returned, ThunkArg>;
+
+export { type Deferred, type Request, type SagaAction, type SagaWorker, createSagaAction, putAsync, takeAggregateAsync, takeEveryAsync, takeLatestAsync };

package/dist/index.js

@@ -0,0 +1,214 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  createSagaAction: () => createSagaAction,
+  putAsync: () => putAsync,
+  takeAggregateAsync: () => takeAggregateAsync,
+  takeEveryAsync: () => takeEveryAsync,
+  takeLatestAsync: () => takeLatestAsync
+});
+module.exports = __toCommonJS(index_exports);
+var import_toolkit2 = require("@reduxjs/toolkit");
+
+// node_modules/@redux-saga/deferred/dist/redux-saga-deferred.esm.js
+function deferred() {
+  var def = {};
+  def.promise = new Promise(function(resolve, reject) {
+    def.resolve = resolve;
+    def.reject = reject;
+  });
+  return def;
+}
+
+// src/utils.ts
+var requests = {};
+var addRequest = (requestId) => {
+  const deferred2 = deferred();
+  const request = {
+    ...requests[requestId],
+    requestId,
+    deferred: deferred2
+  };
+  if (requests[requestId]) {
+    requests[requestId].deferred = deferred2;
+    if (requests[requestId].onAdd) {
+      requests[requestId].onAdd(request);
+    }
+  } else {
+    requests[requestId] = request;
+  }
+  return deferred2.promise;
+};
+var cleanup = (requestId) => {
+  delete requests[requestId];
+};
+var setRequestAbort = (requestId, abort) => {
+  if (requests[requestId]) {
+    requests[requestId].abort = abort;
+  }
+};
+function* getRequest(requestId) {
+  const request = requests[requestId];
+  if (!request) {
+    const result = yield new Promise((onAdd) => {
+      requests[requestId] = {
+        onAdd: (req) => onAdd(req)
+      };
+    });
+    return result;
+  }
+  return request;
+}
+var wrap = (saga) => function* (action, ...rest) {
+  const { requestId } = action.meta;
+  const request = yield getRequest(requestId);
+  if (!request.deferred) return;
+  const deferred2 = request.deferred;
+  let isFinished = false;
+  try {
+    const result = yield saga(action, ...rest);
+    deferred2.resolve(result);
+    isFinished = true;
+  } catch (error) {
+    deferred2.reject(error);
+    isFinished = true;
+  } finally {
+    if (!isFinished) {
+      deferred2.reject(new Error("Aborted"));
+      const currentRequest = requests[requestId];
+      if (currentRequest && currentRequest.abort) {
+        currentRequest.abort();
+      }
+    }
+    cleanup(requestId);
+  }
+};
+
+// src/effects.ts
+var import_effects = require("redux-saga/effects");
+var import_toolkit = require("@reduxjs/toolkit");
+var takeEveryHelper = (patternOrChannel, worker, ...args) => (0, import_effects.fork)(function* () {
+  while (true) {
+    const action = yield (0, import_effects.take)(patternOrChannel);
+    yield (0, import_effects.fork)(worker, ...args.concat(action));
+  }
+});
+function takeEveryAsync(pattern, saga, ...args) {
+  return takeEveryHelper(pattern, wrap(saga), ...args);
+}
+function takeLatestAsync(pattern, saga, ...args) {
+  const tasks = {};
+  let deferred2;
+  function* wrapper(action, ...rest) {
+    if (deferred2) {
+      const lastRequestId = yield deferred2.promise;
+      const request = yield getRequest(lastRequestId);
+      if (request.abort) {
+        request.abort();
+      }
+      const task = yield tasks[lastRequestId].promise;
+      yield (0, import_effects.cancel)(task);
+    }
+    deferred2 = deferred();
+    const { requestId } = action.meta;
+    yield getRequest(requestId);
+    if (deferred2) {
+      deferred2.resolve(requestId);
+    }
+    yield wrap(saga)(action, ...rest);
+    deferred2 = null;
+  }
+  const customTakeEvery = (patternOrChannel, saga2, ...args2) => (0, import_effects.fork)(function* () {
+    while (true) {
+      const action = yield (0, import_effects.take)(patternOrChannel);
+      const { requestId } = action.meta;
+      tasks[requestId] = deferred();
+      const task = yield (0, import_effects.fork)(saga2, ...args2.concat(action));
+      tasks[requestId].resolve(task);
+    }
+  });
+  return customTakeEvery(pattern, wrapper, ...args);
+}
+function takeAggregateAsync(pattern, saga, ...args) {
+  let deferred2;
+  function* wrapper(action, ...rest) {
+    const { requestId } = action.meta;
+    if (deferred2) {
+      const request = yield getRequest(requestId);
+      if (request.deferred) {
+        const { resolve, reject } = request.deferred;
+        const { promise } = yield deferred2.promise;
+        promise.then(resolve, reject).finally(() => cleanup(requestId)).catch(() => {
+        });
+      }
+    } else {
+      deferred2 = deferred();
+      const request = yield getRequest(requestId);
+      if (request.deferred) {
+        const { promise } = request.deferred;
+        yield wrap(saga)(action, ...rest);
+        if (deferred2) {
+          deferred2.resolve({ promise });
+        }
+        deferred2 = null;
+      }
+    }
+  }
+  return takeEveryHelper(pattern, wrapper, ...args);
+}
+function* putAsync(action) {
+  const promise = yield (0, import_effects.put)(action);
+  const result = yield promise;
+  return (0, import_toolkit.unwrapResult)(result);
+}
+
+// src/index.ts
+var createSagaAction = (type) => {
+  const thunk = (0, import_toolkit2.createAsyncThunk)(type, (_, { requestId }) => addRequest(requestId));
+  function actionCreator(arg) {
+    const originalActionCreator = thunk(arg);
+    return (dispatch, getState, extra) => {
+      const promise = originalActionCreator(dispatch, getState, extra);
+      if (promise.requestId) {
+        setRequestAbort(promise.requestId, promise.abort);
+      }
+      return promise;
+    };
+  }
+  Object.assign(actionCreator, {
+    pending: thunk.pending,
+    rejected: thunk.rejected,
+    fulfilled: thunk.fulfilled,
+    typePrefix: thunk.typePrefix,
+    type: thunk.pending.type
+  });
+  return actionCreator;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createSagaAction,
+  putAsync,
+  takeAggregateAsync,
+  takeEveryAsync,
+  takeLatestAsync
+});
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../node_modules/@redux-saga/deferred/dist/redux-saga-deferred.esm.js","../src/utils.ts","../src/effects.ts"],"sourcesContent":["import { createAsyncThunk } from '@reduxjs/toolkit'\nimport type { ThunkDispatch } from '@reduxjs/toolkit'\nimport type { Action } from 'redux'\nimport { addRequest, setRequestAbort } from './utils'\nimport { SagaAction } from './types'\n\nexport * from './types'\nexport * from './effects'\n\nexport const createSagaAction = <Returned, ThunkArg = void>(type: string): SagaAction<Returned, ThunkArg> => {\n    const thunk = createAsyncThunk<Returned, ThunkArg>(type, (_, { requestId }) => addRequest(requestId) as Promise<Returned>)\n\n    function actionCreator(arg: ThunkArg) {\n        const originalActionCreator = thunk(arg)\n\n        return (dispatch: ThunkDispatch<unknown, unknown, Action>, getState: () => unknown, extra: unknown) => {\n            const promise = originalActionCreator(dispatch, getState, extra)\n            if (promise.requestId) {\n                setRequestAbort(promise.requestId, promise.abort)\n            }\n\n            return promise\n        }\n    }\n\n    Object.assign(actionCreator, {\n        pending: thunk.pending,\n        rejected: thunk.rejected,\n        fulfilled: thunk.fulfilled,\n        typePrefix: thunk.typePrefix,\n        type: (thunk.pending as unknown as { type: string }).type,\n    })\n\n    return actionCreator as unknown as SagaAction<Returned, ThunkArg>\n}\n","function deferred() {\n  var def = {};\n  def.promise = new Promise(function (resolve, reject) {\n    def.resolve = resolve;\n    def.reject = reject;\n  });\n  return def;\n}\nfunction arrayOfDeferred(length) {\n  var arr = [];\n  for (var i = 0; i < length; i++) {\n    arr.push(deferred());\n  }\n  return arr;\n}\n\nexport { arrayOfDeferred, deferred as default };\n","import createDeferred from '@redux-saga/deferred'\nimport { Request, SagaWorker } from './types'\n\nconst requests: Record<string, Request> = {}\n\nexport const addRequest = (requestId: string) => {\n    const deferred = createDeferred()\n    const request: Request = {\n        ...requests[requestId],\n        requestId,\n        deferred,\n    }\n\n    if (requests[requestId]) {\n        requests[requestId].deferred = deferred\n        if (requests[requestId].onAdd) {\n            requests[requestId].onAdd(request)\n        }\n    } else {\n        requests[requestId] = request\n    }\n\n    return deferred.promise\n}\n\nexport const cleanup = (requestId: string) => {\n    delete requests[requestId]\n}\n\nexport const setRequestAbort = (requestId: string, abort: () => void) => {\n    if (requests[requestId]) {\n        requests[requestId].abort = abort\n    }\n}\n\nexport function* getRequest(requestId: string): Generator<unknown, Request, unknown> {\n    const request = requests[requestId]\n\n    if (!request) {\n        const result = yield (new Promise(onAdd => {\n            requests[requestId] = {\n                onAdd: (req: Request) => onAdd(req)\n            }\n        }))\n        return result as Request\n    }\n\n    return request\n}\n\nexport const wrap = (saga: SagaWorker) => function* (action: unknown, ...rest: unknown[]): Generator<unknown, void, unknown> {\n    const { requestId } = (action as { meta: { requestId: string } }).meta\n    const request = (yield getRequest(requestId)) as Request\n\n    if (!request.deferred) return\n\n    const deferred = request.deferred\n    let isFinished = false\n\n    try {\n        const result = yield saga(action, ...rest)\n        deferred.resolve(result)\n        isFinished = true\n    } catch (error) {\n        deferred.reject(error)\n        isFinished = true\n    } finally {\n        if (!isFinished) {\n            deferred.reject(new Error('Aborted'))\n            const currentRequest = requests[requestId]\n            if (currentRequest && currentRequest.abort) {\n                currentRequest.abort()\n            }\n        }\n        cleanup(requestId)\n    }\n}\n","import { put, take, fork, cancel } from 'redux-saga/effects'\nimport type { PutEffect, ActionPattern } from 'redux-saga/effects'\nimport type { Task, Channel } from 'redux-saga'\nimport type { Action } from 'redux'\nimport createDeferred from '@redux-saga/deferred'\nimport { AsyncThunkAction, unwrapResult } from '@reduxjs/toolkit'\nimport { SagaWorker, Deferred, Request } from './types'\nimport { wrap, getRequest, cleanup } from './utils'\n\n// Helper to avoid 'takeEvery' overload issues with spread arguments\nconst takeEveryHelper = (patternOrChannel: ActionPattern | Channel<Action>, worker: SagaWorker, ...args: unknown[]) => fork(function* () {\n    while (true) {\n        const action = (yield take(patternOrChannel as unknown as ActionPattern)) as Action\n        yield fork(worker, ...args.concat(action))\n    }\n})\n\nexport function takeEveryAsync<A extends Action = Action>(pattern: ActionPattern<A> | Channel<A>, saga: (action: A, ...args: unknown[]) => unknown, ...args: unknown[]) {\n    return takeEveryHelper(pattern as ActionPattern | Channel<Action>, wrap(saga as unknown as SagaWorker), ...args)\n}\n\nexport function takeLatestAsync<A extends Action = Action>(pattern: ActionPattern<A> | Channel<A>, saga: (action: A, ...args: unknown[]) => unknown, ...args: unknown[]) {\n    const tasks: Record<string, Deferred> = {}\n    let deferred: Deferred | null\n\n    function* wrapper(action: unknown, ...rest: unknown[]): Generator<unknown, void, unknown> {\n        if (deferred) {\n            const lastRequestId = (yield deferred.promise) as string\n            const request = (yield getRequest(lastRequestId)) as Request\n\n            if (request.abort) {\n                request.abort()\n            }\n\n            const task = (yield tasks[lastRequestId].promise) as Task\n\n            yield cancel(task)\n        }\n\n        deferred = createDeferred()\n        const { requestId } = (action as { meta: { requestId: string } }).meta\n\n        yield getRequest(requestId) // Ensure request is registered/ready if needed\n\n        if (deferred) {\n            deferred.resolve(requestId)\n        }\n\n        yield wrap(saga as unknown as SagaWorker)(action, ...rest)\n\n        deferred = null\n    }\n\n    const customTakeEvery = (patternOrChannel: ActionPattern | Channel<Action>, saga: SagaWorker, ...args: unknown[]) => fork(function* (): Generator<unknown, void, unknown> {\n        while (true) {\n            const action = (yield take(patternOrChannel as unknown as ActionPattern)) as { meta: { requestId: string } }\n            const { requestId } = action.meta\n            tasks[requestId] = createDeferred()\n            const task = (yield fork(saga, ...args.concat(action))) as Task\n            tasks[requestId].resolve(task)\n        }\n    })\n\n    return customTakeEvery(pattern as ActionPattern | Channel<Action>, wrapper, ...args)\n}\n\nexport function takeAggregateAsync<A extends Action = Action>(pattern: ActionPattern<A> | Channel<A>, saga: (action: A, ...args: unknown[]) => unknown, ...args: unknown[]) {\n    let deferred: Deferred | null\n\n    function* wrapper(action: unknown, ...rest: unknown[]): Generator<unknown, void, unknown> {\n        const { requestId } = (action as { meta: { requestId: string } }).meta\n\n        if (deferred) {\n            const request = (yield getRequest(requestId)) as Request\n            if (request.deferred) {\n                const { resolve, reject } = request.deferred\n                const { promise } = (yield deferred.promise) as { promise: Promise<unknown> }\n\n                promise\n                    .then(resolve, reject)\n                    .finally(() => cleanup(requestId))\n                    .catch(() => { })\n            }\n        } else {\n            deferred = createDeferred()\n            const request = (yield getRequest(requestId)) as Request\n            if (request.deferred) {\n                const { promise } = request.deferred\n\n                yield wrap(saga as unknown as SagaWorker)(action, ...rest)\n\n                if (deferred) {\n                    deferred.resolve({ promise })\n                }\n                deferred = null\n            }\n        }\n    }\n\n    return takeEveryHelper(pattern as ActionPattern | Channel<Action>, wrapper, ...args)\n}\n\nexport function* putAsync(action: Action | PutEffect | AsyncThunkAction<unknown, unknown, object>): Generator<PutEffect | Promise<unknown>, unknown, unknown> {\n    const promise = yield put(action as Action)\n    const result = yield (promise as Promise<unknown>)\n    return unwrapResult(result as { payload: unknown, error?: unknown, meta?: unknown })\n}\n"],"mappings":"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","names":["import_toolkit","deferred","deferred","saga","args"]}