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

package/dist/esm/BookmarkProvider.js

@@ -0,0 +1,937 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _BookmarkProvider_config, _BookmarkProvider_store, _BookmarkProvider_payloadGenerators, _BookmarkProvider_subscriptions;
+import { Observable, Subscription, forkJoin, from, lastValueFrom, of } from 'rxjs';
+import { filter, switchMap, tap, map, mergeScan, timeout, raceWith, first, catchError, } from 'rxjs/operators';
+import { produce, enablePatches, castDraft } from 'immer';
+import { v4 as generateGUID } from 'uuid';
+import deepEqual from 'fast-deep-equal/es6';
+import { FrameworkEvent } from '@equinor/fusion-framework-module-event';
+import { isFailureAction } from '@equinor/fusion-observable';
+import { SemanticVersion } from '@equinor/fusion-framework-module';
+import { bookmarkActions } from './BookmarkProvider.actions';
+import { createBookmarkStore } from './BookmarkProvider.store';
+import { activeBookmarkSelector, bookmarkSelector, bookmarksSelector, errorsSelector, } from './BookmarkProvider.selectors';
+import { BookmarkProviderError } from './BookmarkProvider.error';
+import { version } from './version';
+enablePatches();
+const defaultTimeout = 2 * 60 * 1000; // 2 minutes
+/**
+ * The `BookmarkProvider` class is responsible for managing bookmarks in the application.
+ * It provides methods for creating, updating, and removing bookmarks, as well as managing the current bookmark and the list of bookmarks.
+ *
+ * The `BookmarkProvider` uses a `BookmarkStore` to manage the state of the bookmarks, and an `IBookmarkClient` to interact with the backend API.
+ *
+ * The `BookmarkProvider` also supports event listeners for various bookmark-related events, such as when the current bookmark changes or when a bookmark is created, updated, or removed.
+ */
+export class BookmarkProvider {
+    /**
+     * Gets the semantic version of the bookmark provider.
+     */
+    get version() {
+        return new SemanticVersion(version);
+    }
+    get filters() {
+        // TODO - freeze the config object?
+        return __classPrivateFieldGet(this, _BookmarkProvider_config, "f").filters;
+    }
+    /**
+     * Gets the `IBookmarkClient` instance used by this `BookmarkProvider`.
+     */
+    get client() {
+        return __classPrivateFieldGet(this, _BookmarkProvider_config, "f").client;
+    }
+    /**
+     * Gets the currently active bookmark (if any).
+     */
+    get currentBookmark$() {
+        return __classPrivateFieldGet(this, _BookmarkProvider_store, "f").select(activeBookmarkSelector, deepEqual);
+    }
+    /**
+     * Gets an observable that emits the current list of bookmarks.
+     */
+    get bookmarks$() {
+        this.getAllBookmarksAsync();
+        return __classPrivateFieldGet(this, _BookmarkProvider_store, "f").select(bookmarksSelector, deepEqual);
+    }
+    /**
+     * Gets the current list of bookmarks.
+     */
+    get bookmarks() {
+        return bookmarksSelector(__classPrivateFieldGet(this, _BookmarkProvider_store, "f").value);
+    }
+    /**
+     * Gets the currently active bookmark.
+     */
+    get currentBookmark() {
+        return activeBookmarkSelector(__classPrivateFieldGet(this, _BookmarkProvider_store, "f").value);
+    }
+    /**
+     * Represents an observable stream of the bookmark status.
+     */
+    get status$() {
+        return __classPrivateFieldGet(this, _BookmarkProvider_store, "f").select((x) => x.status);
+    }
+    /**
+     * Gets an observable that emits the current list of bookmark errors.
+     */
+    get errors$() {
+        // TODO - add deep diff
+        return __classPrivateFieldGet(this, _BookmarkProvider_store, "f").select(errorsSelector, deepEqual);
+    }
+    /**
+     * Determines whether there are any bookmark creators configured.
+     * `true` if there are any bookmark creators configured, `false` otherwise.
+     */
+    get hasBookmarkCreators() {
+        return __classPrivateFieldGet(this, _BookmarkProvider_payloadGenerators, "f").length > 0;
+    }
+    /**
+     * Gets the source system value from the configuration.
+     */
+    get sourceSystem() {
+        return __classPrivateFieldGet(this, _BookmarkProvider_config, "f").sourceSystem;
+    }
+    /**
+     * Gets the resolved application from the bookmark module configuration.
+     */
+    get resolvedApplication() {
+        return __classPrivateFieldGet(this, _BookmarkProvider_config, "f").resolve.application;
+    }
+    /**
+     * Gets the resolved context from the bookmark module configuration.
+     */
+    get resolvedContext() {
+        return __classPrivateFieldGet(this, _BookmarkProvider_config, "f").resolve.context;
+    }
+    get _apiClient() {
+        return __classPrivateFieldGet(this, _BookmarkProvider_config, "f").client;
+    }
+    /**
+     * configured logger instance.
+     */
+    get _log() {
+        return __classPrivateFieldGet(this, _BookmarkProvider_config, "f").log;
+    }
+    /**
+     * configured resolvers
+     */
+    get _resolve() {
+        return __classPrivateFieldGet(this, _BookmarkProvider_config, "f").resolve;
+    }
+    /**
+     * configured event provider.
+     */
+    get _event() {
+        return __classPrivateFieldGet(this, _BookmarkProvider_config, "f").eventProvider;
+    }
+    /**
+     * configured parent bookmark provider
+     */
+    get _parent() {
+        return __classPrivateFieldGet(this, _BookmarkProvider_config, "f").parent;
+    }
+    /**
+     * Constructs a new `BookmarkProvider` instance.
+     *
+     * @param config - The configuration for the bookmark module, including the client, initial state, and optional parent provider.
+     */
+    constructor(config) {
+        var _a, _b, _c;
+        /** provided configuration for the bookmark provider */
+        _BookmarkProvider_config.set(this, void 0);
+        /** state machine of the bookmark provider */
+        _BookmarkProvider_store.set(this, void 0);
+        /** collection of callback for creating bookmark payload */
+        _BookmarkProvider_payloadGenerators.set(this, []);
+        /** collection of subscriptions for bookmark events */
+        _BookmarkProvider_subscriptions.set(this, new Subscription());
+        __classPrivateFieldSet(this, _BookmarkProvider_config, config, "f");
+        __classPrivateFieldSet(this, _BookmarkProvider_store, createBookmarkStore({
+            client: config.client,
+            initial: { currentBookmark: (_b = (_a = this._parent) === null || _a === void 0 ? void 0 : _a.currentBookmark) !== null && _b !== void 0 ? _b : null },
+        }), "f");
+        // add teardown logic for disposing the store
+        __classPrivateFieldGet(this, _BookmarkProvider_subscriptions, "f").add(() => __classPrivateFieldGet(this, _BookmarkProvider_store, "f").complete());
+        // subscribe to the store actions and log them
+        __classPrivateFieldGet(this, _BookmarkProvider_subscriptions, "f").add(__classPrivateFieldGet(this, _BookmarkProvider_store, "f").action$.subscribe((action) => {
+            var _a, _b;
+            if (isFailureAction(action)) {
+                (_a = this._log) === null || _a === void 0 ? void 0 : _a.error(`Action: ${action.type}`, action);
+            }
+            else {
+                (_b = this._log) === null || _b === void 0 ? void 0 : _b.debug(`Action: ${action.type}`, action);
+            }
+        }));
+        // subscribe to the current bookmark changes and dispatch events
+        __classPrivateFieldGet(this, _BookmarkProvider_subscriptions, "f").add(__classPrivateFieldGet(this, _BookmarkProvider_store, "f").select(activeBookmarkSelector).subscribe((bookmark) => {
+            this._dispatchEvent('onCurrentBookmarkChanged', { detail: bookmark });
+        }));
+        // subscribe to child bookmark provider changes
+        // TODO - add support for disabling this feature
+        if (this._event) {
+            this._event.addEventListener('onCurrentBookmarkChanged', (event) => {
+                // only update the current bookmark if the event source is not this provider
+                if (event.source !== this) {
+                    this.setCurrentBookmarkAsync(event.detail);
+                }
+            });
+        }
+        if (this._parent) {
+            // if a parent bookmark provider is configured, subscribe to its current bookmark changes
+            try {
+                __classPrivateFieldGet(this, _BookmarkProvider_subscriptions, "f").add(this._parent.currentBookmark$.subscribe((bookmark) => {
+                    this.setCurrentBookmarkAsync(bookmark);
+                }));
+            }
+            catch (e) {
+                (_c = this._log) === null || _c === void 0 ? void 0 : _c.error('Failed to subscribe to parent bookmark provider', e);
+            }
+        }
+    }
+    /**
+     * Registers an event listener for the specified event on the BookmarkProvider.
+     *
+     * @param eventName - The name of the event to listen for. Must be a key of the `BookmarkProviderEventMap` type.
+     * @param callback - The callback function to be invoked when the event is triggered.
+     *      The callback will receive the event object as its parameter, which will be of the type corresponding to the `eventName`.
+     * @returns A function that can be called to remove the event listener.
+     */
+    on(eventName, callback) {
+        var _a, _b;
+        if (!this._event) {
+            (_a = this._log) === null || _a === void 0 ? void 0 : _a.warn('Failed to register event listener, event provider not configured');
+            return () => { };
+        }
+        return (_b = this._event) === null || _b === void 0 ? void 0 : _b.addEventListener(eventName, callback);
+    }
+    /**
+     * Adds a new payload generator function to the BookmarkProvider.
+     * The payload generator function will be used to generate the payload for a bookmark-related action.
+     *
+     * @param fn - The payload generator function to add. It should be of type `PayloadGenerator<T>`, where `T` is the type of the bookmark data.
+     * @returns A function that can be called to remove the added payload generator.
+     */
+    addPayloadGenerator(fn) {
+        var _a;
+        (_a = this._log) === null || _a === void 0 ? void 0 : _a.debug(`adding bookmark payload generator: ${fn.name}`);
+        // register the payload generator function
+        __classPrivateFieldGet(this, _BookmarkProvider_payloadGenerators, "f").push(fn);
+        // dispatch event to notify listeners of the added payload generator
+        this._dispatchEvent('onBookmarkPayloadCreatorAdded', {
+            detail: fn,
+        });
+        // return a function to remove the added payload generator
+        return () => {
+            var _a;
+            (_a = this._log) === null || _a === void 0 ? void 0 : _a.debug(`removing bookmark payload generator: ${fn.name}`);
+            __classPrivateFieldSet(this, _BookmarkProvider_payloadGenerators, __classPrivateFieldGet(this, _BookmarkProvider_payloadGenerators, "f").filter((g) => g !== fn), "f");
+        };
+    }
+    /**
+     * Generates a payload by applying registered generator functions to an accumulator object.
+     *
+     * @param initial - The initial value of the accumulator object.
+     * @returns An observable that emits the generated payload.
+     * @template T - The type of the generated payload.
+     */
+    generatePayload(initial) {
+        var _a;
+        (_a = this._log) === null || _a === void 0 ? void 0 : _a.debug(`generating payload`, initial);
+        /**
+         * Generates a payload by applying a generator function to an accumulator object.
+         * The generator function can modify the accumulator object using immer's draft mechanism.
+         *
+         * @param acc - The accumulator object.
+         * @param generator - The generator function that modifies the accumulator object.
+         * @returns A promise that resolves to the generated payload.
+         */
+        const generatePayload = (acc, generator) => __awaiter(this, void 0, void 0, function* () {
+            // produce payload from generator
+            return produce(acc, (draft) => __awaiter(this, void 0, void 0, function* () {
+                var _a, _b;
+                // execute the generator
+                const result = yield Promise.resolve(generator(draft, initial));
+                if (result) {
+                    (_a = this._log) === null || _a === void 0 ? void 0 : _a.warn(`bookmark data generator ${generator.name} returned a value, but it should not do this, since the data is an immer draft object`);
+                    return castDraft(result);
+                }
+                else if (result === null) {
+                    (_b = this._log) === null || _b === void 0 ? void 0 : _b.info(`bookmark data generator ${generator.name} wish to clear the bookmark data`);
+                    return null;
+                }
+            }), (patches) => {
+                var _a;
+                if (patches.length > 0) {
+                    (_a = this._log) === null || _a === void 0 ? void 0 : _a.debug(`bookmark data generator ${generator.name} produced patches`, patches);
+                }
+            });
+        });
+        /**
+         * Observable that emits the generated payload.
+         */
+        const result$ = from(__classPrivateFieldGet(this, _BookmarkProvider_payloadGenerators, "f")).pipe(mergeScan(generatePayload, initial !== null && initial !== void 0 ? initial : {}, 1), tap((payload) => { var _a; return (_a = this._log) === null || _a === void 0 ? void 0 : _a.debug(`generated payload`, { initial, payload }); }));
+        return result$;
+    }
+    /**
+     * Retrieves a bookmark with the specified bookmarkId and returns an observable that emits the combined result of fetching the bookmark and bookmark data.
+     * @template T The type of the bookmark payload.
+     * @param bookmarkId The unique identifier of the bookmark.
+     * @param options An optional object that allows excluding the bookmark payload from the result.
+     * @returns An observable that emits the combined result of fetching the bookmark and bookmark data.
+     */
+    getBookmark(bookmarkId, options) {
+        var _a;
+        (_a = this._log) === null || _a === void 0 ? void 0 : _a.debug(`fetching bookmark: ${bookmarkId}`, options);
+        // fetch the bookmark and bookmark data
+        return forkJoin({
+            bookmark: this._getBookmarkInfo(bookmarkId),
+            payload: (options === null || options === void 0 ? void 0 : options.excludePayload) ? of({}) : this._getBookmarkData(bookmarkId),
+        }).pipe(catchError((error) => {
+            var _a;
+            (_a = this._log) === null || _a === void 0 ? void 0 : _a.error(`Failed to fetch bookmark: ${bookmarkId}`, error);
+            throw error;
+        }), 
+        // combine the bookmark and payload into a single object
+        map(({ bookmark, payload }) => Object.assign({}, bookmark, { payload })), tap((bookmark) => {
+            var _a;
+            (_a = this._log) === null || _a === void 0 ? void 0 : _a.debug(`Bookmark fetched: ${bookmark.id}`, bookmark);
+        }));
+    }
+    /**
+     * Retrieves a bookmark asynchronously.
+     *
+     * @param id - The ID of the bookmark to retrieve.
+     * @param options - Optional parameters for the retrieval.
+     * @param options.excludePayload - Specifies whether to exclude the payload from the bookmark.
+     * @returns A promise that resolves to the retrieved bookmark, or null if the bookmark is not found.
+     */
+    getBookmarkAsync(id, options) {
+        return lastValueFrom(this.getBookmark(id, options));
+    }
+    /**
+     * Asynchronously retrieves all bookmarks from the store.
+     *
+     * @returns A Promise that resolves to the Bookmarks object containing all bookmarks.
+     */
+    getAllBookmarks() {
+        return new Observable((observer) => {
+            var _a, _b, _c;
+            (_a = this._log) === null || _a === void 0 ? void 0 : _a.debug(`fetching all bookmarks`);
+            // generate the filter parameters
+            const filter$ = forkJoin({
+                sourceSystem: of(this.sourceSystem),
+                appKey: ((_b = __classPrivateFieldGet(this, _BookmarkProvider_config, "f").filters) === null || _b === void 0 ? void 0 : _b.application)
+                    ? from(this._resolve.application()).pipe(map((x) => x === null || x === void 0 ? void 0 : x.appKey))
+                    : of(undefined),
+                contextId: ((_c = __classPrivateFieldGet(this, _BookmarkProvider_config, "f").filters) === null || _c === void 0 ? void 0 : _c.context)
+                    ? from(this._resolve.context()).pipe(map((x) => x === null || x === void 0 ? void 0 : x.id))
+                    : of(undefined),
+            }).pipe(catchError((err) => {
+                var _a;
+                const error = new BookmarkProviderError('Could not fetch bookmarks, failed to resolve filter parameters', err);
+                (_a = this._log) === null || _a === void 0 ? void 0 : _a.error(error.message, error);
+                throw error;
+            }));
+            // execute the fetch bookmarks action when the filter parameters are resolved
+            observer.add(filter$.subscribe((filter) => {
+                __classPrivateFieldGet(this, _BookmarkProvider_store, "f").next(bookmarkActions.fetchBookmarks(filter));
+            }));
+            // monitor the failure case when fetching bookmarks
+            const failure$ = __classPrivateFieldGet(this, _BookmarkProvider_store, "f").action$.pipe(filter(bookmarkActions.fetchBookmarks.failure.match), map((action) => {
+                var _a;
+                (_a = this._log) === null || _a === void 0 ? void 0 : _a.error('Failed to fetch bookmarks', action.payload);
+                throw new BookmarkProviderError('Failed to fetch bookmarks', action.payload);
+            }), timeout({
+                each: defaultTimeout,
+                with: () => {
+                    throw new BookmarkProviderError('Timeout while fetching bookmarks');
+                },
+            }));
+            // monitor the success case when fetching bookmarks
+            const request$ = __classPrivateFieldGet(this, _BookmarkProvider_store, "f").action$.pipe(filter(bookmarkActions.fetchBookmarks.success.match), map((a) => a.payload), first(), tap((bookmarks) => {
+                var _a;
+                (_a = this._log) === null || _a === void 0 ? void 0 : _a.debug(`fetched all bookmarks`, bookmarks);
+            }), raceWith(failure$));
+            request$.subscribe(observer);
+        });
+    }
+    /**
+     * Asynchronously retrieves all bookmarks from the store.
+     *
+     * @returns A Promise that resolves to the Bookmarks object containing all bookmarks.
+     */
+    getAllBookmarksAsync() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return lastValueFrom(this.getAllBookmarks());
+        });
+    }
+    /**
+     * Sets the current bookmark to the specified bookmark or ID.
+     * If the bookmark is already the current bookmark, it returns the bookmark directly.
+     * Otherwise, it emits the next bookmark or null through an observable.
+     *
+     * By proving `null` as the bookmark_or_id, the current bookmark will be cleared.
+     *
+     * @param bookmark_or_id - The bookmark or ID to set as the current bookmark.
+     * @returns An observable that emits the next bookmark or null.
+     * @template T - The type of the bookmark data.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    setCurrentBookmark(bookmark_or_id) {
+        var _a;
+        // check if the bookmark is already the current bookmark
+        if (bookmark_or_id == this.currentBookmark)
+            return of(bookmark_or_id);
+        (_a = this._log) === null || _a === void 0 ? void 0 : _a.debug(`setting current bookmark`, bookmark_or_id);
+        // resolve the next bookmark
+        const next$ = typeof bookmark_or_id === 'string'
+            ? this.getBookmark(bookmark_or_id)
+            : of(bookmark_or_id !== null && bookmark_or_id !== void 0 ? bookmark_or_id : null);
+        return next$.pipe(switchMap((next) => __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            const current = this.currentBookmark;
+            const { type, canceled } = yield this._dispatchEvent('onCurrentBookmarkChange', {
+                detail: { current, next },
+            });
+            if (canceled) {
+                const error = new BookmarkProviderError(`event: ${type} was canceled by listener for change to ${(_a = next === null || next === void 0 ? void 0 : next.id) !== null && _a !== void 0 ? _a : 'none'}, from ${(_b = current === null || current === void 0 ? void 0 : current.id) !== null && _b !== void 0 ? _b : 'none'}`);
+                (_c = this._log) === null || _c === void 0 ? void 0 : _c.info(error.message);
+                throw error;
+            }
+            return next;
+        })), tap((next) => {
+            // set the current bookmark in the store
+            __classPrivateFieldGet(this, _BookmarkProvider_store, "f").next(bookmarkActions.setCurrentBookmark(next));
+        }), catchError((err) => {
+            var _a;
+            const error = new BookmarkProviderError('Could not set current bookmark, resolve of bookmark failed', err);
+            (_a = this._log) === null || _a === void 0 ? void 0 : _a.error(error.message, error);
+            throw error;
+        }));
+    }
+    /**
+     * Sets the current bookmark.
+     * This method dispatches an event to notify listeners of a change in the current bookmark,
+     * and then dispatches a request to set the active bookmark in the application state.
+     *
+     * The request will be canceled if the subscription is unsubscribed before the request completes.
+     *
+     * @param bookmarkId - The ID of the bookmark to set as the current bookmark.
+     * @returns A subscription to the operation that sets the current bookmark.
+     */
+    setCurrentBookmarkAsync(bookmark_or_id) {
+        return lastValueFrom(this.setCurrentBookmark(bookmark_or_id));
+    }
+    /**
+     * Creates a new bookmark with the provided bookmark data.
+     * @template T - The type of bookmark data.
+     * @param {BookmarkCreateArgs<T>} newBookmarkData - The data for creating the bookmark.
+     * @returns {Observable<Bookmark<T>>} - An observable that emits the created bookmark.
+     */
+    createBookmark(newBookmarkData) {
+        return new Observable((subscriber) => {
+            var _a;
+            const { ref, action$ } = this._useScopedActions();
+            (_a = this._log) === null || _a === void 0 ? void 0 : _a.debug(`creating new bookmark, ref: ${ref}`, newBookmarkData);
+            // resolve the bookmark
+            const bookmark$ = forkJoin({
+                appKey: newBookmarkData.appKey
+                    ? of(newBookmarkData.appKey)
+                    : from(this._resolve.application()).pipe(map((app) => {
+                        if (!(app === null || app === void 0 ? void 0 : app.appKey)) {
+                            throw new BookmarkProviderError('Failed to resolve application key');
+                        }
+                        return app.appKey;
+                    })),
+                contextId: this._resolve.context().then((context) => context === null || context === void 0 ? void 0 : context.id),
+                payload: this.generatePayload(newBookmarkData.payload),
+                sourceSystem: of(this.sourceSystem),
+            }).pipe(catchError((err) => {
+                var _a;
+                const error = new BookmarkProviderError('Could not create new bookmark, failed to resolve bookmark data', err);
+                (_a = this._log) === null || _a === void 0 ? void 0 : _a.error(error.message, error);
+                throw error;
+            }), 
+            // merge the resolved data with the new bookmark data
+            map((resolvedData) => (Object.assign(Object.assign({}, newBookmarkData), resolvedData))));
+            // notify listeners that a bookmark is about to be created
+            const dispatch$ = bookmark$.pipe(switchMap((bookmark) => __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                // notify listeners that a bookmark is about to be created
+                const { canceled, type } = yield this._dispatchEvent('onBookmarkCreate', {
+                    detail: bookmark,
+                    cancelable: true,
+                });
+                // throw an error if the event is canceled
+                if (canceled) {
+                    const error = new BookmarkProviderError(`event: ${type} was canceled by listener for creating bookmark: ${ref}`);
+                    (_a = this._log) === null || _a === void 0 ? void 0 : _a.info(error.message);
+                    throw error;
+                }
+                return bookmark;
+            })));
+            // execute the create bookmark action when the bookmark is resolved and not canceled
+            subscriber.add(dispatch$.subscribe({
+                error: (error) => subscriber.error(error),
+                next: (newBookmark) => {
+                    // request the store to create the bookmark
+                    __classPrivateFieldGet(this, _BookmarkProvider_store, "f").next(bookmarkActions.createBookmark(newBookmark, { ref }));
+                },
+            }));
+            // monitor the failure case when creating a bookmark
+            const failure$ = action$.pipe(filter(bookmarkActions.createBookmark.failure.match), map(({ payload: cause }) => {
+                var _a;
+                const error = new BookmarkProviderError(`Failed to create bookmark: ${ref}`, {
+                    cause,
+                });
+                (_a = this._log) === null || _a === void 0 ? void 0 : _a.warn(error.message);
+                throw error;
+            }), timeout({
+                each: defaultTimeout,
+                with: () => {
+                    throw new BookmarkProviderError(`Timeout while creating bookmark: ${ref}`);
+                },
+            }));
+            // monitor the success case when creating a bookmark
+            const request$ = action$.pipe(filter(bookmarkActions.createBookmark.success.match), map(({ payload }) => payload), first(), tap((bookmark) => {
+                var _a;
+                (_a = this._log) === null || _a === void 0 ? void 0 : _a.info(`Bookmark created: ${bookmark.id}, ref: ${ref}`);
+                this._dispatchEvent('onBookmarkCreated', { detail: bookmark });
+            }), raceWith(failure$));
+            // emit the created bookmark
+            request$.subscribe(subscriber);
+        });
+    }
+    /**
+     * Asynchronously creates a new bookmark.
+     *
+     * @param bookmark - The new bookmark to create.
+     * @returns A promise that resolves to the created bookmark with its associated data.
+     */
+    createBookmarkAsync(args) {
+        return lastValueFrom(this.createBookmark(args));
+    }
+    /**
+     * Updates a bookmark with the specified bookmarkId and bookmarkUpdates.
+     *
+     * @template T - The type of the bookmark data.
+     * @param {string} bookmarkId - The identifier of the bookmark to update.
+     * @param {BookmarkUpdate<T>} [bookmarkUpdates] - The updates to apply to the bookmark.
+     * @param {BookmarkUpdateOptions} [options] - The options for updating the bookmark.
+     * @returns {Promise<Bookmark<T>>} - A promise that resolves to the updated bookmark.
+     */
+    updateBookmark(bookmarkId, bookmarkUpdates, options) {
+        if (!bookmarkUpdates && (options === null || options === void 0 ? void 0 : options.excludePayloadGeneration)) {
+            throw new BookmarkProviderError('Cannot update bookmark without updates and excludePayloadGeneration option');
+        }
+        return new Observable((subscriber) => {
+            var _a;
+            const { ref, action$ } = this._useScopedActions();
+            (_a = this._log) === null || _a === void 0 ? void 0 : _a.debug(`Updating bookmark: ${bookmarkId}, ref: ${ref}`);
+            /**
+             * Generate updates with payload
+             * @remarks
+             * If `excludePayloadGeneration` is `true`, it emits the `bookmarkUpdates` directly.
+             * If `excludePayloadGeneration` is `false`, it generates the payload using the `generatePayload` method and emits the updated `bookmarkUpdates` with the generated payload.
+             */
+            const updates$ = (options === null || options === void 0 ? void 0 : options.excludePayloadGeneration)
+                ? of(bookmarkUpdates)
+                : this.generatePayload(bookmarkUpdates === null || bookmarkUpdates === void 0 ? void 0 : bookmarkUpdates.payload).pipe(map((payload) => (Object.assign(Object.assign({}, bookmarkUpdates), { payload }))));
+            // notify listeners that a bookmark is about to be updated
+            const dispatch$ = updates$.pipe(switchMap((updates) => __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                const { canceled, type } = yield this._dispatchEvent('onBookmarkUpdate', {
+                    detail: {
+                        current: bookmarkSelector(__classPrivateFieldGet(this, _BookmarkProvider_store, "f").value, bookmarkId),
+                        updates,
+                    },
+                    cancelable: true,
+                });
+                if (canceled) {
+                    const error = new BookmarkProviderError(`event: ${type} was canceled by listener for updating bookmark: ${bookmarkId}, ref: ${ref}`);
+                    (_a = this._log) === null || _a === void 0 ? void 0 : _a.warn(error.message, updates);
+                    throw error;
+                }
+                return updates;
+            })));
+            // execute the update bookmark action when the updates are resolved and not canceled
+            subscriber.add(dispatch$.subscribe({
+                error: (error) => subscriber.error(error),
+                next: (updates) => {
+                    // trigger the store to update the bookmark
+                    __classPrivateFieldGet(this, _BookmarkProvider_store, "f").next(bookmarkActions.updateBookmark({ bookmarkId, updates }, { ref }));
+                },
+            }));
+            // monitor the failure case when updating a bookmark
+            const failure$ = action$.pipe(filter(bookmarkActions.updateBookmark.failure.match), map(({ payload: cause }) => {
+                var _a;
+                const error = new BookmarkProviderError(`Failed to update bookmark: ${bookmarkId}`, {
+                    cause,
+                });
+                (_a = this._log) === null || _a === void 0 ? void 0 : _a.info(error.message);
+                throw error;
+            }), timeout({
+                each: defaultTimeout,
+                with: () => {
+                    throw new BookmarkProviderError(`Timeout while updating bookmark: ${bookmarkId}`);
+                },
+            }));
+            // monitor the success case when updating a bookmark
+            const request$ = action$.pipe(filter(bookmarkActions.updateBookmark.success.match), first(), map(
+            // TODO: add payload if current bookmark is the same as the updated bookmark
+            ({ payload }) => (Object.assign(Object.assign({}, bookmarkSelector(__classPrivateFieldGet(this, _BookmarkProvider_store, "f").value, payload.id)), { payload: payload.payload }))), tap((bookmark) => {
+                var _a;
+                (_a = this._log) === null || _a === void 0 ? void 0 : _a.info(`Bookmark updated: ${bookmark.id}, ref: ${ref}`);
+                this._dispatchEvent('onBookmarkUpdated', { detail: bookmark });
+            }), raceWith(failure$));
+            // emit the updated bookmark
+            request$.subscribe(subscriber);
+        });
+    }
+    /**
+     * Updates a bookmark asynchronously.
+     *
+     * @param bookmark - The bookmark to update.
+     * @returns A promise that resolves to the updated bookmark with its associated data.
+     */
+    updateBookmarkAsync(bookmarkId, bookmarkUpdates, options) {
+        return lastValueFrom(this.updateBookmark(bookmarkId, bookmarkUpdates, options));
+    }
+    /**
+     * Deletes a bookmark with the specified bookmarkId.
+     *
+     * @param bookmarkId - The unique identifier of the bookmark to be deleted.
+     * @returns A Promise that resolves when the bookmark is successfully deleted.
+     * @throws {BookmarkProviderError} If there is an error deleting the bookmark.
+     */
+    deleteBookmark(bookmarkId) {
+        return new Observable((subscriber) => {
+            var _a, _b;
+            const { ref, action$ } = this._useScopedActions();
+            (_a = this._log) === null || _a === void 0 ? void 0 : _a.debug(`Removing bookmark: ${bookmarkId}, ref: ${ref}`);
+            // bookmark to delete
+            const bookmark = (_b = bookmarkSelector(__classPrivateFieldGet(this, _BookmarkProvider_store, "f").value, bookmarkId)) !== null && _b !== void 0 ? _b : {
+                id: bookmarkId,
+            };
+            // observable that dispatches the 'onBookmarkDelete' event and maps the result
+            const dispatch$ = from(this._dispatchEvent('onBookmarkDelete', {
+                detail: bookmark,
+                cancelable: true,
+            })).pipe(map(({ canceled, type, detail }) => {
+                var _a;
+                if (canceled) {
+                    const error = new BookmarkProviderError(`event: ${type} was canceled by listener for removing bookmark: ${bookmarkId}, ref: ${ref}`);
+                    (_a = this._log) === null || _a === void 0 ? void 0 : _a.warn(error.message);
+                    throw error;
+                }
+                return detail;
+            }));
+            // execute the delete bookmark action when the event is not canceled
+            subscriber.add(dispatch$.subscribe({
+                error: (error) => subscriber.error(error),
+                next: (bookmark) => {
+                    // request the store to delete the bookmark
+                    __classPrivateFieldGet(this, _BookmarkProvider_store, "f").next(bookmarkActions.deleteBookmark(bookmark.id, { ref }));
+                },
+            }));
+            // monitor the failure case when deleting a bookmark
+            const failure$ = action$.pipe(filter(bookmarkActions.deleteBookmark.failure.match), map(({ payload: cause }) => {
+                var _a;
+                const error = new BookmarkProviderError(`Failed to update bookmark: ${bookmarkId}`, {
+                    cause,
+                });
+                (_a = this._log) === null || _a === void 0 ? void 0 : _a.warn(error.message);
+                throw error;
+            }), timeout({
+                each: defaultTimeout,
+                with: () => {
+                    throw new BookmarkProviderError(`Timeout while updating bookmark: ${bookmarkId}`);
+                },
+            }));
+            // monitor the success case when deleting a bookmark
+            const request$ = action$.pipe(filter(bookmarkActions.deleteBookmark.success.match), map(() => undefined), first(), tap(() => {
+                var _a;
+                (_a = this._log) === null || _a === void 0 ? void 0 : _a.info(`Removed bookmark: ${bookmark.id}, ref: ${ref}`);
+                this._dispatchEvent('onBookmarkDeleted', { detail: bookmark });
+            }), raceWith(failure$));
+            // emit the deleted bookmark
+            request$.subscribe(subscriber);
+        });
+    }
+    /**
+     * Deletes a bookmark asynchronously.
+     *
+     * @param bookmarkId - The ID of the bookmark to delete.
+     * @returns A Promise that resolves when the bookmark is deleted.
+     */
+    deleteBookmarkAsync(bookmarkId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return lastValueFrom(this.deleteBookmark(bookmarkId));
+        });
+    }
+    /**
+     * Adds a bookmark to the favorites.
+     *
+     * @param bookmarkId - The ID of the bookmark to add.
+     * @returns A Promise that resolves to the added bookmark, or null if the bookmark was not added.
+     */
+    addBookmarkToFavorites(bookmarkId) {
+        /**
+         * Observable that represents the result of adding a bookmark as a favorite.
+         * Emits a `Bookmark` object or `undefined` if the operation fails to resolve added bookmark.
+         */
+        const result$ = new Observable((subscriber) => {
+            var _a;
+            const { ref, action$ } = this._useScopedActions();
+            (_a = this._log) === null || _a === void 0 ? void 0 : _a.debug(`Adding bookmark: ${bookmarkId} to favourites, ref: ${ref}`);
+            // observable that dispatches the 'onBookmarkFavouriteAdd' event and maps the result
+            const dispatch$ = from(this._dispatchEvent('onBookmarkFavouriteAdd', {
+                detail: { id: bookmarkId },
+                cancelable: true,
+            })).pipe(map(({ canceled, type }) => {
+                var _a;
+                if (canceled) {
+                    const error = new BookmarkProviderError(`event: ${type} was canceled by listener for adding favourite bookmark: ${bookmarkId}, ref: ${ref}`);
+                    (_a = this._log) === null || _a === void 0 ? void 0 : _a.info(error.message);
+                    throw error;
+                }
+            }));
+            // execute the add bookmark as a favorite action when the event is not canceled
+            subscriber.add(dispatch$.subscribe({
+                error: (error) => subscriber.error(error),
+                next: () => {
+                    __classPrivateFieldGet(this, _BookmarkProvider_store, "f").next(bookmarkActions.addBookmarkAsFavourite(bookmarkId, { ref }));
+                },
+            }));
+            // monitor the failure case when adding a bookmark as a favorite
+            const failure$ = action$.pipe(filter(bookmarkActions.addBookmarkAsFavourite.failure.match), map(({ payload: cause }) => {
+                var _a;
+                const error = new BookmarkProviderError(`Failed to add bookmark to favorites: ${bookmarkId}`, { cause });
+                (_a = this._log) === null || _a === void 0 ? void 0 : _a.warn(error.message);
+                throw error;
+            }), timeout({
+                each: defaultTimeout,
+                with: () => {
+                    throw new BookmarkProviderError(`Timeout while adding bookmark to favorites: ${bookmarkId}`);
+                },
+            }));
+            // monitor the success case when adding a bookmark as a favorite
+            const request$ = action$.pipe(filter(bookmarkActions.addBookmarkAsFavourite.success.match), switchMap(({ payload }) => this.getBookmark(payload, { excludePayload: true })), tap((bookmark) => {
+                var _a;
+                (_a = this._log) === null || _a === void 0 ? void 0 : _a.info(`Added bookmark: ${bookmarkId} to favourites, ref: ${ref}`);
+                this._dispatchEvent('onBookmarkFavouriteAdded', { detail: bookmark });
+            }), raceWith(failure$));
+            // emit the added bookmark
+            return request$.subscribe(subscriber);
+        });
+        return result$;
+    }
+    /**
+     * Asynchronously adds a bookmark to the user's favorites.
+     *
+     * @param bookmarkId - The ID of the bookmark to add to the user's favorites.
+     * @returns A Promise that resolves to the added Bookmark, or null if the operation failed.
+     */
+    addBookmarkToFavoritesAsync(bookmarkId) {
+        return lastValueFrom(this.addBookmarkToFavorites(bookmarkId));
+    }
+    /**
+     * Removes a bookmark as a favorite.
+     *
+     * @param bookmarkId - The ID of the bookmark to remove as a favorite.
+     * @returns A Promise that resolves when the bookmark is successfully removed as a favorite.
+     * @throws {BookmarkProviderError} If the event is canceled or if there is a failure in removing the bookmark as a favorite.
+     */
+    removeBookmarkAsFavorite(bookmarkId) {
+        /**
+         * Represents an observable that emits void values when a bookmark's favorite is removed.
+         */
+        const result$ = new Observable((subscriber) => {
+            var _a, _b;
+            const { ref, action$ } = this._useScopedActions();
+            (_a = this._log) === null || _a === void 0 ? void 0 : _a.debug(`Removing bookmark: ${bookmarkId} from favourites, ref: ${ref}`);
+            // get the bookmark to remove as a favorite
+            const bookmark = (_b = bookmarkSelector(__classPrivateFieldGet(this, _BookmarkProvider_store, "f").value, bookmarkId)) !== null && _b !== void 0 ? _b : { id: bookmarkId };
+            // observable that dispatches the 'onBookmarkFavouriteRemove' event and maps the result
+            const dispatch$ = from(this._dispatchEvent('onBookmarkFavouriteRemove', {
+                detail: bookmark,
+                cancelable: true,
+            })).pipe(map(({ canceled, type, detail }) => {
+                var _a;
+                if (canceled) {
+                    const error = new BookmarkProviderError(`event: ${type} was canceled by listener for removing favourite bookmark: ${bookmarkId}, ref: ${ref}`);
+                    (_a = this._log) === null || _a === void 0 ? void 0 : _a.warn(error.message);
+                    throw error;
+                }
+                return detail;
+            }));
+            // execute the remove bookmark as a favorite action when the event is not canceled
+            subscriber.add(dispatch$.subscribe({
+                error: (error) => subscriber.error(error),
+                next: (detail) => {
+                    // request the store to remove the bookmark as a favorite
+                    __classPrivateFieldGet(this, _BookmarkProvider_store, "f").next(bookmarkActions.removeBookmarkAsFavourite(detail.id, { ref }));
+                },
+            }));
+            // monitor the failure case when removing a bookmark as a favorite
+            const failure$ = action$.pipe(filter(bookmarkActions.removeBookmarkAsFavourite.failure.match), map(({ payload: cause }) => {
+                var _a;
+                const error = new BookmarkProviderError(`Failed to remove bookmark: ${bookmarkId} from favourites`, {
+                    cause,
+                });
+                (_a = this._log) === null || _a === void 0 ? void 0 : _a.warn(error.message);
+                throw error;
+            }), timeout({
+                each: defaultTimeout,
+                with: () => {
+                    throw new BookmarkProviderError(`Timeout while removing bookmark: ${bookmarkId} from favourites`);
+                },
+            }));
+            // monitor the success case when removing a bookmark as a favorite
+            const request$ = action$.pipe(filter(bookmarkActions.removeBookmarkAsFavourite.success.match), tap(() => {
+                var _a;
+                (_a = this._log) === null || _a === void 0 ? void 0 : _a.info(`Removed bookmark: ${bookmarkId} from favourites, ref: ${ref}`);
+                this._dispatchEvent('onBookmarkFavouriteRemoved', { detail: bookmark });
+            }), map(() => { }), raceWith(failure$));
+            // emit the removed bookmark
+            request$.subscribe(subscriber);
+        });
+        return result$;
+    }
+    /**
+     * Removes a bookmark as a favorite asynchronously.
+     *
+     * @param bookmarkId - The ID of the bookmark to remove as a favorite.
+     * @returns A Promise that resolves when the bookmark is successfully removed as a favorite.
+     */
+    removeBookmarkAsFavoriteAsync(bookmarkId) {
+        return lastValueFrom(this.removeBookmarkAsFavorite(bookmarkId));
+    }
+    /**
+     * Checks if a bookmark is in the favorites.
+     * @param bookmarkId - The ID of the bookmark to check.
+     * @returns A promise that resolves to a boolean indicating whether the bookmark is in the favorites.
+     */
+    isBookmarkInFavorites(bookmarkId) {
+        var _a;
+        (_a = this._log) === null || _a === void 0 ? void 0 : _a.debug(`Checking if bookmark: ${bookmarkId} is in favourites`);
+        // Check if the bookmark is a favorite
+        return from(this._apiClient.isBookmarkFavorite(bookmarkId)).pipe(catchError((err) => {
+            var _a;
+            const error = new BookmarkProviderError(`Failed to check if bookmark: ${bookmarkId} is in favourites`, err);
+            (_a = this._log) === null || _a === void 0 ? void 0 : _a.error(error.message, error);
+            throw error;
+        }), tap((isFavorite) => {
+            var _a;
+            (_a = this._log) === null || _a === void 0 ? void 0 : _a.debug(`Bookmark: ${bookmarkId} is ${isFavorite ? 'in' : 'not in'} favourites`);
+        }));
+    }
+    /**
+     * Checks if the specified bookmark is in the user's favorites.
+     *
+     * @param bookmarkId - The ID of the bookmark to check.
+     * @returns A Promise that resolves to a boolean indicating whether the bookmark is in the user's favorites.
+     */
+    isBookmarkInFavoritesAsync(bookmarkId) {
+        return lastValueFrom(this.isBookmarkInFavorites(bookmarkId));
+    }
+    _getBookmarkInfo(bookmarkId, options) {
+        var _a;
+        // only actions with the specified reference are considered
+        const { action$ } = this._useScopedActions(bookmarkId);
+        // observable stream that emits the bookmark data when the fetch action is successful
+        const success$ = action$.pipe(filter(bookmarkActions.fetchBookmark.success.match), map((action) => action.payload), first());
+        // observable stream that emits an error when fetching bookmark data fails
+        const failure$ = __classPrivateFieldGet(this, _BookmarkProvider_store, "f").action$.pipe(filter(bookmarkActions.fetchBookmark.failure.match), map((action) => {
+            throw new BookmarkProviderError(`Failed to fetch bookmark data: ${bookmarkId}`, action.payload);
+        }), timeout({
+            each: (_a = options === null || options === void 0 ? void 0 : options.timeout) !== null && _a !== void 0 ? _a : 2 * 60 * 1000,
+            with: () => {
+                throw new BookmarkProviderError(`Timeout while fetching bookmark data: ${bookmarkId}`);
+            },
+        }));
+        __classPrivateFieldGet(this, _BookmarkProvider_store, "f").next(bookmarkActions.fetchBookmark(bookmarkId, { ref: bookmarkId }));
+        return success$.pipe(raceWith(failure$));
+    }
+    _getBookmarkData(bookmarkId, options) {
+        var _a;
+        // only actions with the specified reference are considered
+        const { action$ } = this._useScopedActions(bookmarkId);
+        // observable stream that emits the bookmark data when the fetch action is successful
+        const success$ = action$.pipe(filter(bookmarkActions.fetchBookmarkData.success.match), map((action) => action.payload.data), first());
+        // observable stream that emits an error when fetching bookmark data fails
+        const failure$ = __classPrivateFieldGet(this, _BookmarkProvider_store, "f").action$.pipe(filter(bookmarkActions.fetchBookmarkData.failure.match), map((action) => {
+            throw new BookmarkProviderError(`Failed to fetch bookmark data: ${bookmarkId}`, action.payload);
+        }), timeout({
+            each: (_a = options === null || options === void 0 ? void 0 : options.timeout) !== null && _a !== void 0 ? _a : defaultTimeout,
+            with: () => {
+                throw new BookmarkProviderError(`Timeout while fetching bookmark data: ${bookmarkId}`);
+            },
+        }));
+        // request the store to fetch the bookmark data
+        __classPrivateFieldGet(this, _BookmarkProvider_store, "f").next(bookmarkActions.fetchBookmarkData(bookmarkId, { ref: bookmarkId }));
+        return success$.pipe(raceWith(failure$));
+    }
+    /**
+     * Dispatches an event of the specified type with the provided arguments.
+     *
+     * @param type - The type of the event to dispatch.
+     * @param args - The arguments to pass to the event.
+     * @returns A promise that resolves with the result of the event dispatch.
+     */
+    _dispatchEvent(type, args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            // create a new event instance
+            const event = new FrameworkEvent(type, Object.assign({ source: this, canBubble: true }, args));
+            if (this._event) {
+                (_a = this._log) === null || _a === void 0 ? void 0 : _a.debug(`dispatching event ${type}`, args);
+                const { canceled } = yield this._event.dispatchEvent(event);
+                if (canceled) {
+                    (_b = this._log) === null || _b === void 0 ? void 0 : _b.debug(`event ${type} was canceled`, args);
+                }
+            }
+            return event;
+        });
+    }
+    _useScopedActions(ref) {
+        /**
+         * Generates a unique identifier for the operation
+         */
+        ref !== null && ref !== void 0 ? ref : (ref = generateGUID());
+        /**
+         * Observable stream of actions filtered by a specific reference.
+         */
+        const action$ = __classPrivateFieldGet(this, _BookmarkProvider_store, "f").action$.pipe(filter((action) => { var _a; return 'meta' in action && ((_a = action.meta) === null || _a === void 0 ? void 0 : _a.ref) === ref; }));
+        return { ref, action$ };
+    }
+    /**
+     * Disposes the BookmarkProvider.
+     */
+    dispose() {
+        var _a;
+        (_a = this._log) === null || _a === void 0 ? void 0 : _a.debug('disposing BookmarkProvider');
+        __classPrivateFieldGet(this, _BookmarkProvider_subscriptions, "f").unsubscribe();
+    }
+}
+_BookmarkProvider_config = new WeakMap(), _BookmarkProvider_store = new WeakMap(), _BookmarkProvider_payloadGenerators = new WeakMap(), _BookmarkProvider_subscriptions = new WeakMap();
+//# sourceMappingURL=BookmarkProvider.js.map