@equinor/fusion-framework-module-bookmark 4.0.2 → 4.0.3

package/dist/types/BookmarkProvider.flows.d.ts

@@ -1,79 +0,0 @@
-import { type Flow } from '@equinor/fusion-observable';
-import { type BookmarkActions } from './BookmarkProvider.actions';
-import type { IBookmarkClient } from './BookmarkClient.interface';
-import type { BookmarkState } from './BookmarkProvider.store';
-/**
- * Handles the fetch bookmark action by making an API request to get the bookmark by its ID.
- *
- * @param api - The bookmark client API.
- * @returns A flow that handles the fetch bookmark action.
- */
-export declare const handleFetchBookmark: (api: IBookmarkClient) => Flow<BookmarkActions>;
-/**
- * Creates a flow for handling fetching bookmark data.
- *
- * @param api - The bookmark client API.
- * @returns A flow of bookmark actions.
- */
-export declare const handleFetchBookmarkData: (api: IBookmarkClient) => Flow<BookmarkActions>;
-/**
- * Creates a Flow for handling fetching users bookmarks.
- *
- * @param api - The bookmark API client to use for fetching bookmarks.
- * @param options - Optional configuration options, including a `throttle` value in milliseconds.
- * @returns An observable that emits the result of the bookmark fetch operation.
- */
-export declare const handleFetchAllBookmark: (api: IBookmarkClient) => Flow<BookmarkActions>;
-/**
- * Creates a Flow for handling creating bookmarks.
- *
- * @param api - An instance of the `IBookmarkClient` interface, which provides the necessary API methods for creating bookmarks.
- * @returns A flow that listens for `createBookmark` actions, creates a new bookmark using the provided API.
- */
-export declare const handleCreateBookmark: (api: IBookmarkClient) => Flow<BookmarkActions>;
-/**
- * Creates a Flow for handling updating bookmarks.
- *
- * @param api - An instance of the `IBookmarkClient` interface, which provides the necessary API methods for updating bookmarks.
- * @returns A flow that listens for `updateBookmark` actions, updates the bookmark using the provided API.
- */
-export declare const handleUpdateBookmark: (api: IBookmarkClient) => Flow<BookmarkActions>;
-/**
- * Creates a flow for handling deleting bookmarks.
- *
- * @param api - An instance of the `IBookmarkClient` interface, which provides the necessary API methods for deleting bookmarks.
- * @returns A flow that listens for `deleteBookmark` actions, deletes the bookmark using the provided API.
- */
-export declare const handleDeleteBookmark: (api: IBookmarkClient) => Flow<BookmarkActions>;
-/**
- * Creates a Flow for handling deleting bookmarks.
- *
- * @param api - An instance of the `IBookmarkClient` interface, which provides the necessary API methods for managing favorite bookmarks.
- * @returns A flow that listens for `removeBookmarkAsFavorite` actions, removes the bookmark from the user's favorites using the provided API.
- */
-export declare const handleRemoveBookmarkFromFavorites: (api: IBookmarkClient) => Flow<BookmarkActions>;
-/**
- * Handles the flow of adding a bookmark as a favorite.
- *
- * @param api - The `IBookmarkClient` API instance to use for interacting with bookmarks.
- * @returns An RxJS `Flow` that handles the `addBookmarkAsFavourite` action.
- */
-export declare const handleAddBookmarkAsFavorite: (api: IBookmarkClient) => Flow<BookmarkActions>;
-/**
- * Creates a flow for handling bookmark removal.
- *
- * This function observes actions related to deleting a bookmark or removing a bookmark as a favorite, and dispatches the appropriate actions for each case.
- * If the bookmark is currently a favorite, it will dispatch an action to remove it as a favorite.
- * If the bookmark is not a favorite, it will dispatch an action to delete it.
- *
- * @param api - An instance of the `IBookmarkClient` interface, which provides the necessary API methods checking if bookmarks are favorites.
- * @returns A flow that handles the removal of a bookmark.
- */
-export declare const handleRemoveBookmark: (api: IBookmarkClient) => Flow<BookmarkActions>;
-/**
- * Defines a set of flows that handle various bookmark-related actions, such as fetching, creating, updating, and deleting bookmarks.
- *
- * @param api - An instance of `IBookmarkClient` that provides the necessary API methods for interacting with the bookmark service.
- * @returns A combined flow that handles all the bookmark-related actions.
- */
-export declare const bookmarkApiFlows: (api: IBookmarkClient) => Flow<BookmarkActions, BookmarkState>;

package/src/BookmarkProvider.flows.ts

@@ -1,421 +0,0 @@
-import { from, of, merge, concat } from 'rxjs';
-import {
-  switchMap,
-  map,
-  catchError,
-  filter,
-  concatMap,
-  mergeMap,
-  groupBy,
-  throttleTime,
-  last,
-} from 'rxjs/operators';
-
-import { type Flow, type Observable, getBaseType } from '@equinor/fusion-observable';
-
-import { bookmarkActions as actions, type BookmarkActions } from './BookmarkProvider.actions';
-import type { IBookmarkClient } from './BookmarkClient.interface';
-import type { BookmarkState } from './BookmarkProvider.store';
-import { BookmarkFlowError } from './BookmarkProvider.error';
-
-const defaultThrottleTime = 200;
-
-/**
- * Handles the fetch bookmark action by making an API request to get the bookmark by its ID.
- *
- * @param api - The bookmark client API.
- * @returns A flow that handles the fetch bookmark action.
- */
-export const handleFetchBookmark =
-  (api: IBookmarkClient): Flow<BookmarkActions> =>
-  (action$) => {
-    /**
-     * Observable that represents the flow of fetching bookmarks.
-     * It listens for `fetchBookmark` actions, makes an API request to get the bookmark by ID,
-     * and emits corresponding success or failure actions based on the API response.
-     */
-    const flow$ = action$.pipe(
-      filter(actions.fetchBookmark.match),
-      groupBy((action) => action.payload),
-      mergeMap((group) => group.pipe(throttleTime(defaultThrottleTime))),
-      switchMap((action) =>
-        from(api.getBookmarkById(action.payload)).pipe(
-          last(),
-          map((bookmark) => actions.fetchBookmark.success(bookmark, action.meta)),
-          catchError((error) =>
-            of(
-              actions.fetchBookmark.failure(
-                new BookmarkFlowError('Failed to fetch bookmark', action, {
-                  cause: error,
-                }),
-                action.meta,
-              ),
-            ),
-          ),
-        ),
-      ),
-    );
-    return flow$;
-  };
-
-/**
- * Creates a flow for handling fetching bookmark data.
- *
- * @param api - The bookmark client API.
- * @returns A flow of bookmark actions.
- */
-export const handleFetchBookmarkData =
-  (api: IBookmarkClient): Flow<BookmarkActions> =>
-  (action$) => {
-    const flow$ = action$.pipe(
-      filter(actions.fetchBookmarkData.match),
-      groupBy((action) => JSON.stringify(action.payload)),
-      mergeMap((group) => group.pipe(throttleTime(defaultThrottleTime))),
-      switchMap((action) => {
-        return from(api.getBookmarkData(action.payload)).pipe(
-          last(),
-          map((data) => actions.fetchBookmarkData.success(action.payload, data, action.meta)),
-          catchError((error) =>
-            of(
-              actions.fetchBookmarkData.failure(
-                new BookmarkFlowError('Failed to fetch bookmark payload', action, {
-                  cause: error,
-                }),
-                action.meta,
-              ),
-            ),
-          ),
-        );
-      }),
-    );
-    return flow$;
-  };
-
-/**
- * Creates a Flow for handling fetching users bookmarks.
- *
- * @param api - The bookmark API client to use for fetching bookmarks.
- * @param options - Optional configuration options, including a `throttle` value in milliseconds.
- * @returns An observable that emits the result of the bookmark fetch operation.
- */
-export const handleFetchAllBookmark =
-  (api: IBookmarkClient): Flow<BookmarkActions> =>
-  (action$: Observable<BookmarkActions>) => {
-    /**
-     * This flow is triggered by the `fetchBookmarks` action and uses the `throttleTime` operator
-     * to limit the number of requests made to the API. The `switchMap` operator is used to make
-     * the API call and map the response to the appropriate action (success or failure).
-     */
-    const flow$ = action$.pipe(
-      filter(actions.fetchBookmarks.match),
-      groupBy((action) => JSON.stringify(action.payload)),
-      switchMap((group) => group.pipe(throttleTime(defaultThrottleTime))),
-      switchMap((action) =>
-        from(api.getAllBookmarks(action.payload)).pipe(
-          last(),
-          map((value) => actions.fetchBookmarks.success(value, action.meta)),
-          catchError((error) =>
-            of(
-              actions.fetchBookmarks.failure(
-                new BookmarkFlowError('Failed to fetch all bookmarks', action, {
-                  cause: error,
-                }),
-                action.meta,
-              ),
-            ),
-          ),
-        ),
-      ),
-    );
-    return flow$;
-  };
-
-/**
- * Creates a Flow for handling creating bookmarks.
- *
- * @param api - An instance of the `IBookmarkClient` interface, which provides the necessary API methods for creating bookmarks.
- * @returns A flow that listens for `createBookmark` actions, creates a new bookmark using the provided API.
- */
-export const handleCreateBookmark =
-  (api: IBookmarkClient): Flow<BookmarkActions> =>
-  (action$: Observable<BookmarkActions>) => {
-    /**
-     * This flow listens for the `createBookmark` action, and then uses the `api.createBookmark` function to create a new bookmark.
-     * If the bookmark is created successfully, it dispatches the `createBookmark.success` action with the new bookmark.
-     * If there is an error creating the bookmark, it dispatches the `fetchBookmark.failure` action with an error.
-     *
-     * The `concatMap` operator is used to prevent aborting the request if a new `createBookmark` action is dispatched while the previous request is in flight.
-     */
-    const flow$ = action$.pipe(
-      filter(actions.createBookmark.match),
-      concatMap((action) => {
-        return from(api.createBookmark(action.payload)).pipe(
-          last(),
-          map((bookmark) => actions.createBookmark.success(bookmark, action.meta)),
-          catchError((error) =>
-            of(
-              actions.createBookmark.failure(
-                new BookmarkFlowError('Failed to create new bookmark', action, {
-                  cause: error,
-                }),
-                action.meta,
-              ),
-            ),
-          ),
-        );
-      }),
-    );
-    return flow$;
-  };
-
-/**
- * Creates a Flow for handling updating bookmarks.
- *
- * @param api - An instance of the `IBookmarkClient` interface, which provides the necessary API methods for updating bookmarks.
- * @returns A flow that listens for `updateBookmark` actions, updates the bookmark using the provided API.
- */
-export const handleUpdateBookmark =
-  (api: IBookmarkClient): Flow<BookmarkActions> =>
-  (action$: Observable<BookmarkActions>) => {
-    /**
-     * This flow listens for `updateBookmark` actions, then calls the `api.updateBookmark` function with the action payload.
-     * If the update is successful, it dispatches a `updateBookmark.success` action with the updated bookmark.
-     * If there is an error, it dispatches a `fetchBookmark.failure` action with the error.
-     *
-     * The `concatMap` operator is used to prevent aborting the request if a new `updateBookmark` action is dispatched while the previous request is in flight.
-     */
-    const flow$ = action$.pipe(
-      filter(actions.updateBookmark.match),
-      concatMap((action) => {
-        const { bookmarkId, updates } = action.payload;
-        return from(api.updateBookmark(bookmarkId, updates)).pipe(
-          last(),
-          map((bookmark) => actions.updateBookmark.success(bookmark, action.meta)),
-          catchError((error) =>
-            of(
-              actions.updateBookmark.failure(
-                new BookmarkFlowError('Failed to update bookmark', action, {
-                  cause: error,
-                }),
-                action.meta,
-              ),
-            ),
-          ),
-        );
-      }),
-    );
-    return flow$;
-  };
-
-/**
- * Creates a flow for handling deleting bookmarks.
- *
- * @param api - An instance of the `IBookmarkClient` interface, which provides the necessary API methods for deleting bookmarks.
- * @returns A flow that listens for `deleteBookmark` actions, deletes the bookmark using the provided API.
- */
-export const handleDeleteBookmark =
-  (api: IBookmarkClient): Flow<BookmarkActions> =>
-  (action$: Observable<BookmarkActions>) => {
-    /**
-     * - Listens for the `deleteBookmark` action.
-     * - Calls the `api.deleteBookmark` function to delete the bookmark.
-     * - Maps the successful response to the `deleteBookmark.success` action.
-     * - Handles errors by dispatching the `fetchBookmark.failure` action with a `BookmarkFlowError`.
-     * - Uses `concatMap` to prevent aborting the request if a new action is dispatched while the previous request is in flight.
-     */
-    const flow$ = action$.pipe(
-      filter(actions.deleteBookmark.match),
-      concatMap((action) =>
-        from(api.deleteBookmark(action.payload)).pipe(
-          last(),
-          map(() => actions.deleteBookmark.success(action.payload, action.meta)),
-          catchError((error) =>
-            of(
-              actions.deleteBookmark.failure(
-                new BookmarkFlowError('Failed to delete bookmark', action, {
-                  cause: error,
-                }),
-                action.meta,
-              ),
-            ),
-          ),
-        ),
-      ),
-    );
-    return flow$;
-  };
-
-/**
- * Creates a Flow for handling deleting bookmarks.
- *
- * @param api - An instance of the `IBookmarkClient` interface, which provides the necessary API methods for managing favorite bookmarks.
- * @returns A flow that listens for `removeBookmarkAsFavorite` actions, removes the bookmark from the user's favorites using the provided API.
- */
-export const handleRemoveBookmarkFromFavorites =
-  (api: IBookmarkClient): Flow<BookmarkActions> =>
-  (action$: Observable<BookmarkActions>) => {
-    /**
-     * - Listens for the `removeBookmarkAsFavourite` action.
-     * - Calls the `api.removeBookmarkFromFavorites` function to remove the bookmark from favorites.
-     * - On success, dispatches the `removeBookmarkAsFavourite.success` action.
-     * - On error, dispatches the `fetchBookmark.failure` action with a `BookmarkFlowError`.
-     * - Uses `concatMap` to prevent aborting the request if a new action is dispatched while the previous request is in flight.
-     */
-    const flow$ = action$.pipe(
-      filter(actions.removeBookmarkAsFavourite.match),
-      // use concat to prevent aborting the request if a new action is dispatched while the previous request is in flight
-      concatMap((action) =>
-        from(api.removeBookmarkFromFavorites(action.payload)).pipe(
-          last(),
-          map(() => actions.removeBookmarkAsFavourite.success(action.payload, action.meta)),
-          catchError((error) =>
-            of(
-              actions.removeBookmarkAsFavourite.failure(
-                new BookmarkFlowError('Failed to remove bookmark as favorite', action, {
-                  cause: error,
-                }),
-                action.meta,
-              ),
-            ),
-          ),
-        ),
-      ),
-    );
-
-    return flow$;
-  };
-
-/**
- * Handles the flow of adding a bookmark as a favorite.
- *
- * @param api - The `IBookmarkClient` API instance to use for interacting with bookmarks.
- * @returns An RxJS `Flow` that handles the `addBookmarkAsFavourite` action.
- */
-export const handleAddBookmarkAsFavorite =
-  (api: IBookmarkClient): Flow<BookmarkActions> =>
-  (action$: Observable<BookmarkActions>) => {
-    /**
-     * Handles the flow for adding a bookmark as a favorite.
-     *
-     * This flow listens for the `addBookmarkAsFavourite` action, and then:
-     * 1. Calls the `addBookmarkToFavorites` API to add the bookmark to the user's favorites.
-     * 2. If the API call is successful, dispatches the `addBookmarkAsFavourite.success` action.
-     * 3. If the API call fails, dispatches the `addBookmarkAsFavourite.failure` action with an error.
-     */
-    const flow$ = action$.pipe(
-      filter(actions.addBookmarkAsFavourite.match),
-      concatMap((action) =>
-        from(api.addBookmarkToFavorites(action.payload)).pipe(
-          last(),
-          map(() => actions.addBookmarkAsFavourite.success(action.payload, action.meta)),
-          catchError((error) =>
-            of(
-              actions.addBookmarkAsFavourite.failure(
-                new BookmarkFlowError('Failed to add bookmark as favorite', action, {
-                  cause: error,
-                }),
-                action.meta,
-              ),
-            ),
-          ),
-        ),
-      ),
-    );
-
-    return flow$;
-  };
-
-/**
- * Creates a flow for handling bookmark removal.
- *
- * This function observes actions related to deleting a bookmark or removing a bookmark as a favorite, and dispatches the appropriate actions for each case.
- * If the bookmark is currently a favorite, it will dispatch an action to remove it as a favorite.
- * If the bookmark is not a favorite, it will dispatch an action to delete it.
- *
- * @param api - An instance of the `IBookmarkClient` interface, which provides the necessary API methods checking if bookmarks are favorites.
- * @returns A flow that handles the removal of a bookmark.
- */
-export const handleRemoveBookmark =
-  (api: IBookmarkClient): Flow<BookmarkActions> =>
-  (action$) => {
-    /**
-     * Handles the removal of a bookmark from the application.
-     *
-     * This function is responsible for determining whether the bookmark being removed is a favorite or not,
-     * and then dispatching the appropriate action to either remove the bookmark as a favorite or delete the bookmark entirely.
-     *
-     * Uses `concatMap` to prevent aborting the request if a new action is dispatched while the previous request is in flight.
-     */
-    const dispatch$ = action$.pipe(
-      filter(actions.removeBookmark.match),
-      concatMap(({ payload: bookmarkId }) => {
-        return from(api.isBookmarkFavorite(bookmarkId)).pipe(
-          map((isFavorite) => {
-            const action = isFavorite ? actions.removeBookmarkAsFavourite : actions.deleteBookmark;
-            return action(bookmarkId);
-          }),
-        );
-      }),
-    );
-
-    /**
-     * Handles failures for deleting a bookmark or removing a bookmark as a favorite.
-     */
-    const failure$ = merge(
-      action$.pipe(filter(actions.deleteBookmark.failure.match)),
-      action$.pipe(filter(actions.removeBookmarkAsFavourite.failure.match)),
-    ).pipe(map((action) => actions.removeBookmark.failure(action.payload, action.meta)));
-
-    /**
-     * Handles the success of deleting a bookmark or removing a bookmark as a favorite.
-     */
-    const success$ = merge(
-      action$.pipe(filter(actions.deleteBookmark.success.match)),
-      action$.pipe(filter(actions.removeBookmarkAsFavourite.success.match)),
-    ).pipe(
-      map((action) =>
-        actions.removeBookmark.success(
-          {
-            type: getBaseType(action.type),
-            bookmarkId: action.payload,
-          },
-          action.meta,
-        ),
-      ),
-    );
-
-    /**
-     * First dispatch either deletions of bookmark or removals of bookmarks as favorites.
-     * Then observer the results of those actions and dispatch the appropriate actions.
-     */
-    const flow$ = concat(dispatch$, merge(failure$, success$));
-
-    return flow$;
-  };
-
-/**
- * Defines a set of flows that handle various bookmark-related actions, such as fetching, creating, updating, and deleting bookmarks.
- *
- * @param api - An instance of `IBookmarkClient` that provides the necessary API methods for interacting with the bookmark service.
- * @returns A combined flow that handles all the bookmark-related actions.
- */
-export const bookmarkApiFlows = (api: IBookmarkClient): Flow<BookmarkActions, BookmarkState> => {
-  // return handleFetchAllBookmark(api);
-  /**
-   * Combines multiple Bookmark-related observable flows into a single observable stream.
-   * The resulting observable stream emits the combined effects of these flows,
-   * which can be used to update the application state.
-   */
-  return (actions$: Observable<BookmarkActions>, state$: Observable<BookmarkState>) =>
-    of(
-      handleFetchBookmark,
-      handleFetchBookmarkData,
-      handleFetchAllBookmark,
-      handleCreateBookmark,
-      handleUpdateBookmark,
-      handleDeleteBookmark,
-      handleRemoveBookmark,
-      handleRemoveBookmarkFromFavorites,
-      handleAddBookmarkAsFavorite,
-    ).pipe(mergeMap((flow) => flow(api)(actions$, state$)));
-};

package/src/BookmarkProvider.reducer.ts

@@ -1,144 +0,0 @@
-import {
-  createReducer,
-  getBaseType,
-  isCompleteAction,
-  isFailureAction,
-  isRequestAction,
-  isSuccessAction,
-  type ActionBaseType,
-} from '@equinor/fusion-observable';
-
-import { bookmarkActions, type BookmarkActions } from './BookmarkProvider.actions';
-import type { BookmarkState } from './BookmarkProvider.store';
-import type { BookmarkFlowError } from './BookmarkProvider.error';
-import type { BookmarkWithoutData } from './types';
-import { enableMapSet } from 'immer';
-
-enableMapSet();
-
-/**
- * Utility function that extracts the base action type from a given action object.
- */
-const getBookmarkBaseAction = <T extends BookmarkActions>(action: T): ActionBaseType<T> => {
-  return getBaseType(action.type) as ActionBaseType<T>;
-};
-
-/**
- * The default initial state for the BookmarkProvider reducer.
- */
-const defaultInitialState: BookmarkState = {
-  status: new Set<ActionBaseType<BookmarkActions>>(),
-  errors: {} as Record<ActionBaseType<BookmarkActions>, BookmarkFlowError>,
-  bookmarks: {},
-};
-
-/**
- * Creates a reducer for managing the state of bookmarks.
- *
- * @todo add fast-deep-equal to compare bookmarks
- *
- * @param initialState - The initial state of the bookmarks.
- * @returns A reducer function for managing the bookmarks state.
- */
-export const createBookmarkReducer = (initialState?: Partial<BookmarkState>) =>
-  createReducer<BookmarkState, BookmarkActions>(
-    { ...defaultInitialState, ...initialState },
-    (builder) => {
-      builder
-        .addCase(bookmarkActions.fetchBookmark.success, (state, action) => {
-          if (action.payload.id in state.bookmarks) {
-            state.bookmarks[action.payload.id] = action.payload;
-          }
-        })
-        .addCase(bookmarkActions.fetchBookmarkData.success, (state, action) => {
-          const { bookmarkId, data } = action.payload;
-          if (state.currentBookmark?.id === bookmarkId) {
-            state.currentBookmark.payload = data;
-          }
-        })
-        .addCase(bookmarkActions.fetchBookmarks.success, (state, action) => {
-          // normalize the bookmarks array into a record
-          state.bookmarks = action.payload.reduce(
-            (acc, bookmark) => {
-              acc[bookmark.id] = bookmark;
-              return acc;
-            },
-            {} as Record<string, BookmarkWithoutData>,
-          );
-        })
-        .addCase(bookmarkActions.setBookmark, (state, action) => {
-          const bookmarkId = action.payload.id;
-          if (bookmarkId in state.bookmarks) {
-            state.bookmarks[bookmarkId] = action.payload;
-          }
-          if (state.currentBookmark?.id === bookmarkId) {
-            state.currentBookmark = action.payload;
-          }
-        })
-        .addCase(bookmarkActions.setCurrentBookmark, (state, action) => {
-          state.currentBookmark = action.payload;
-        })
-        .addCase(bookmarkActions.createBookmark.success, (state, action) => {
-          // eslint-disable-next-line @typescript-eslint/no-unused-vars
-          const { payload, ...bookmark } = action.payload;
-          state.bookmarks[bookmark.id] = bookmark;
-        })
-        .addCase(bookmarkActions.updateBookmark.success, (state, action) => {
-          const bookmarkId = action.payload.id;
-          const hasBookmark = bookmarkId in state.bookmarks;
-          const isCurrent = state.currentBookmark?.id === bookmarkId;
-
-          // get the current bookmark
-          const current = hasBookmark
-            ? state.bookmarks[bookmarkId]
-            : isCurrent
-              ? state.currentBookmark
-              : null;
-
-          // merge the current bookmark with the new data
-          const next = { ...current, ...action.payload };
-
-          // if the bookmark is in the current state, update it
-          if (hasBookmark) {
-            state.bookmarks[bookmarkId] = next;
-          }
-
-          // if the bookmark is the selected bookmark, update it
-          if (isCurrent) {
-            state.currentBookmark = next;
-          }
-        })
-
-        /** removal of bookmarks */
-        .addCase(bookmarkActions.deleteBookmark.success, (state, action) => {
-          delete state.bookmarks[action.payload];
-        })
-        .addCase(bookmarkActions.removeBookmarkAsFavourite.success, (state, action) => {
-          delete state.bookmarks[action.payload];
-        })
-
-        /** when a request is made, add the action type to the status object */
-        .addMatcher(isRequestAction, (state, action) => {
-          const actionName = getBookmarkBaseAction(action);
-          state.status.add(actionName);
-        })
-
-        /** when a request succeeds, remove the error from the errors object */
-        .addMatcher(isSuccessAction, (state, action) => {
-          const actionName = getBookmarkBaseAction(action);
-          delete state.errors[actionName];
-        })
-
-        /** when a request fails, add the error to the errors object */
-        .addMatcher(isFailureAction, (state, action) => {
-          const actionName = getBookmarkBaseAction(action);
-          state.errors[actionName] = action.payload;
-        })
-
-        /** when a request is complete, remove the status from the status set */
-        .addMatcher(isCompleteAction, (state, action) => {
-          const actionName = getBookmarkBaseAction(action);
-          state.status.delete(actionName);
-        });
-    },
-  );