@equinor/fusion-framework-module-bookmark 1.2.13 → 2.0.0

package/src/BookmarkProvider.flows.ts

@@ -0,0 +1,426 @@
+import { from, of, merge, concat } from 'rxjs';
+import {
+    switchMap,
+    map,
+    catchError,
+    filter,
+    concatMap,
+    mergeMap,
+    groupBy,
+    throttleTime,
+} 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(
+                    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(
+                    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(
+                    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(
+                    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(
+                    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(
+                    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(
+                    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(
+                    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

@@ -0,0 +1,141 @@
+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 { BookmarkFlowError } from './BookmarkProvider.error';
+import { BookmarkWithoutData } from './types';
+
+/**
+ * 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);
+                });
+        },
+    );

package/src/BookmarkProvider.selectors.ts

@@ -0,0 +1,55 @@
+import { BookmarkFlowError } from './BookmarkProvider.error';
+import { BookmarkState } from './BookmarkProvider.store';
+import type { Bookmark, BookmarkData } from './types';
+
+/**
+ * Selects all bookmarks from the application state.
+ */
+export const bookmarksSelector = (state: BookmarkState): Bookmark[] => {
+    return Object.values(state.bookmarks) as Bookmark[];
+};
+
+/**
+ * Retrieves a bookmark from the state by its ID.
+ */
+export const bookmarkSelector = <T extends BookmarkData>(
+    state: BookmarkState,
+    id: string,
+): Bookmark<T> | undefined => {
+    return state.bookmarks[id] as Bookmark<T>;
+};
+
+/**
+ * Selects the active bookmark from the bookmark state.
+ *
+ * if there is an active bookmark, the function returns the bookmark data.
+ *
+ * if there is no active bookmark, the function returns null.
+ * if the active bookmark was never set, the function returns undefined.
+ */
+export const activeBookmarkSelector = <T extends BookmarkData>(
+    state: BookmarkState,
+): Bookmark<T> | null => {
+    const selectedBookmark = state.currentBookmark as Bookmark<T>;
+    return selectedBookmark || null;
+};
+
+/**
+ * Selects the status from the bookmark state.
+ *
+ * @param state - The bookmark state.
+ * @returns The status from the bookmark state.
+ */
+export const statusSelector = (state: BookmarkState): BookmarkState['status'] => {
+    return state.status;
+};
+
+/**
+ * Selects and returns an array of bookmark flow errors from the state.
+ *
+ * @param state - The bookmark state.
+ * @returns An array of bookmark flow errors.
+ */
+export const errorsSelector = (state: BookmarkState): Array<BookmarkFlowError> => {
+    return Object.values(state.errors);
+};

package/src/BookmarkProvider.store.ts

@@ -0,0 +1,52 @@
+import { FlowSubject, type ActionBaseType } from '@equinor/fusion-observable';
+
+import { type BookmarkActions } from './BookmarkProvider.actions';
+import { type BookmarkFlowError } from './BookmarkProvider.error';
+import { createBookmarkReducer } from './BookmarkProvider.reducer';
+import { bookmarkApiFlows } from './BookmarkProvider.flows';
+import type { IBookmarkClient } from './BookmarkClient.interface';
+import type { Bookmark, BookmarkWithoutData } from './types';
+
+/**
+ * Represents the state of the BookmarkProvider store.
+ */
+export type BookmarkState = {
+    // current actions performed on the store
+    status: Set<ActionBaseType<BookmarkActions>>;
+    // errors that have occurred during the bookmark flow
+    errors: Record<ActionBaseType<BookmarkActions>, BookmarkFlowError>;
+    // the currently active bookmark, if any
+    currentBookmark?: Bookmark | null;
+    // the collection of bookmarks, keyed by their IDs
+    bookmarks: Record<string, BookmarkWithoutData>;
+};
+
+// export type BookmarkStoreFunctions = ActionCalls<typeof bookmarkActions>;
+
+/**
+ * Represents the store for bookmarks, which is a flow subject that manages the state and actions for bookmarks.
+ */
+export type BookmarkStore = FlowSubject<BookmarkState, BookmarkActions>;
+
+/**
+ * Creates a new BookmarkStore instance with the provided initial state and client.
+ *
+ * @param args - An object containing the initial state and client for the bookmark store.
+ * @param args.initial - The initial state for the bookmark store.
+ * @param args.client - The IBookmarkClient instance to bookmark store flows.
+ * @returns A new BookmarkStore instance.
+ */
+export const createBookmarkStore = (args: {
+    initial?: Partial<BookmarkState>;
+    client: IBookmarkClient;
+}): BookmarkStore => {
+    // create the store
+    const store = new FlowSubject<BookmarkState, BookmarkActions>(
+        createBookmarkReducer(args.initial),
+    );
+
+    // add the bookmark API flows to the store
+    store.addFlow(bookmarkApiFlows(args.client));
+
+    return store;
+};