@equinor/fusion-framework-module-bookmark 2.1.4 → 2.1.6

package/dist/esm/BookmarkProvider.js

@@ -1,35 +1,3 @@
-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 __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-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, castDraft } from 'immer';
@@ -53,6 +21,14 @@ const defaultTimeout = 2 * 60 * 1000; // 2 minutes
  * 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 {
+    /** provided configuration for the bookmark provider */
+    #config;
+    /** state machine of the bookmark provider */
+    #store;
+    /** collection of callback for creating bookmark payload */
+    #payloadGenerators = [];
+    /** collection of subscriptions for bookmark events */
+    #subscriptions = new Subscription();
     /**
      * @deprecated
      * this will be removed as soon as applications have been migrated to use the bookmark provider
@@ -114,104 +90,104 @@ export class BookmarkProvider {
     }
     get filters() {
         // TODO - freeze the config object?
-        return __classPrivateFieldGet(this, _BookmarkProvider_config, "f").filters;
+        return this.#config.filters;
     }
     /**
      * Gets the `IBookmarkClient` instance used by this `BookmarkProvider`.
      */
     get client() {
-        return __classPrivateFieldGet(this, _BookmarkProvider_config, "f").client;
+        return this.#config.client;
     }
     /**
      * Gets the currently active bookmark (if any).
      */
     get currentBookmark$() {
-        return __classPrivateFieldGet(this, _BookmarkProvider_store, "f").select(activeBookmarkSelector, deepEqual);
+        return this.#store.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);
+        return this.#store.select(bookmarksSelector, deepEqual);
     }
     /**
      * Gets the current list of bookmarks.
      */
     get bookmarks() {
-        return bookmarksSelector(__classPrivateFieldGet(this, _BookmarkProvider_store, "f").value);
+        return bookmarksSelector(this.#store.value);
     }
     /**
      * Gets the currently active bookmark.
      */
     get currentBookmark() {
-        const bookmark = activeBookmarkSelector(__classPrivateFieldGet(this, _BookmarkProvider_store, "f").value);
+        const bookmark = activeBookmarkSelector(this.#store.value);
         return bookmark;
     }
     /**
      * Represents an observable stream of the bookmark status.
      */
     get status$() {
-        return __classPrivateFieldGet(this, _BookmarkProvider_store, "f").select((x) => x.status);
+        return this.#store.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);
+        return this.#store.select(errorsSelector, deepEqual);
     }
     /**
      * Determines whether there are any bookmark creators configured.
      * `true` if there are any bookmark creators configured, `false` otherwise.
      */
     get canCreateBookmarks() {
-        return __classPrivateFieldGet(this, _BookmarkProvider_payloadGenerators, "f").length > 0;
+        return this.#payloadGenerators.length > 0;
     }
     /**
      * Gets the source system value from the configuration.
      */
     get sourceSystem() {
-        return __classPrivateFieldGet(this, _BookmarkProvider_config, "f").sourceSystem;
+        return this.#config.sourceSystem;
     }
     /**
      * Gets the resolved application from the bookmark module configuration.
      */
     get resolvedApplication() {
-        return __classPrivateFieldGet(this, _BookmarkProvider_config, "f").resolve.application;
+        return this.#config.resolve.application;
     }
     /**
      * Gets the resolved context from the bookmark module configuration.
      */
     get resolvedContext() {
-        return __classPrivateFieldGet(this, _BookmarkProvider_config, "f").resolve.context;
+        return this.#config.resolve.context;
     }
     get _apiClient() {
-        return __classPrivateFieldGet(this, _BookmarkProvider_config, "f").client;
+        return this.#config.client;
     }
     /**
      * configured logger instance.
      */
     get _log() {
-        return __classPrivateFieldGet(this, _BookmarkProvider_config, "f").log;
+        return this.#config.log;
     }
     /**
      * configured resolvers
      */
     get _resolve() {
-        return __classPrivateFieldGet(this, _BookmarkProvider_config, "f").resolve;
+        return this.#config.resolve;
     }
     /**
      * configured event provider.
      */
     get _event() {
-        return __classPrivateFieldGet(this, _BookmarkProvider_config, "f").eventProvider;
+        return this.#config.eventProvider;
     }
     /**
      * configured parent bookmark provider
      */
     get _parent() {
-        return __classPrivateFieldGet(this, _BookmarkProvider_config, "f").parent;
+        return this.#config.parent;
     }
     /**
      * Constructs a new `BookmarkProvider` instance.
@@ -219,34 +195,24 @@ export class BookmarkProvider {
      * @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({
+        this.#config = config;
+        this.#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");
+            initial: { currentBookmark: this._parent?.currentBookmark ?? null },
+        });
         // add teardown logic for disposing the store
-        __classPrivateFieldGet(this, _BookmarkProvider_subscriptions, "f").add(() => __classPrivateFieldGet(this, _BookmarkProvider_store, "f").complete());
+        this.#subscriptions.add(() => this.#store.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;
+        this.#subscriptions.add(this.#store.action$.subscribe((action) => {
             if (isFailureAction(action)) {
-                (_a = this._log) === null || _a === void 0 ? void 0 : _a.error(`Action: ${action.type}`, action);
+                this._log?.error(`Action: ${action.type}`, action);
             }
             else {
-                (_b = this._log) === null || _b === void 0 ? void 0 : _b.debug(`Action: ${action.type}`, action);
+                this._log?.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.#subscriptions.add(this.#store.select(activeBookmarkSelector).subscribe((bookmark) => {
             // do not emit before the first value
             if (bookmark !== undefined) {
                 this._dispatchEvent('onCurrentBookmarkChanged', { detail: bookmark });
@@ -262,21 +228,21 @@ export class BookmarkProvider {
                     return;
                 // only update the current bookmark if the event source is not this provider
                 if (source !== this && detail !== this.currentBookmark) {
-                    __classPrivateFieldGet(this, _BookmarkProvider_store, "f").next(bookmarkActions.setCurrentBookmark(detail));
+                    this.#store.next(bookmarkActions.setCurrentBookmark(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$
+                this.#subscriptions.add(this._parent.currentBookmark$
                     .pipe(filter((x) => x !== undefined), filter((x) => x !== this.currentBookmark))
                     .subscribe((bookmark) => {
-                    __classPrivateFieldGet(this, _BookmarkProvider_store, "f").next(bookmarkActions.setCurrentBookmark(bookmark));
+                    this.#store.next(bookmarkActions.setCurrentBookmark(bookmark));
                 }));
             }
             catch (e) {
-                (_c = this._log) === null || _c === void 0 ? void 0 : _c.error('Failed to subscribe to parent bookmark provider', e);
+                this._log?.error('Failed to subscribe to parent bookmark provider', e);
             }
         }
     }
@@ -289,12 +255,11 @@ export class BookmarkProvider {
      * @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');
+            this._log?.warn('Failed to register event listener, event provider not configured');
             return () => { };
         }
-        return (_b = this._event) === null || _b === void 0 ? void 0 : _b.addEventListener(eventName, (event) => {
+        return this._event?.addEventListener(eventName, (event) => {
             if (event.source === this) {
                 callback(event);
             }
@@ -308,19 +273,17 @@ export class BookmarkProvider {
      * @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}`);
+        this._log?.debug(`adding bookmark payload generator: ${fn.name}`);
         // register the payload generator function
-        __classPrivateFieldGet(this, _BookmarkProvider_payloadGenerators, "f").push(fn);
+        this.#payloadGenerators.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");
+            this._log?.debug(`removing bookmark payload generator: ${fn.name}`);
+            this.#payloadGenerators = this.#payloadGenerators.filter((g) => g !== fn);
         };
     }
     /**
@@ -331,12 +294,11 @@ export class BookmarkProvider {
      * @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);
+        this._log?.debug(`generating payload`, initial);
         /**
          * Observable that emits the generated payload.
          */
-        const result$ = from(__classPrivateFieldGet(this, _BookmarkProvider_payloadGenerators, "f")).pipe(mergeScan((acc, generator) => this._producePayload(acc, generator), 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 }); }));
+        const result$ = from(this.#payloadGenerators).pipe(mergeScan((acc, generator) => this._producePayload(acc, generator), initial ?? {}, 1), tap((payload) => this._log?.debug(`generated payload`, { initial, payload })));
         return result$;
     }
     /**
@@ -355,26 +317,25 @@ export class BookmarkProvider {
      */
     _producePayload(value, generator, initial) {
         // produce payload from generator
-        return produce(value, (draft) => __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c;
+        return produce(value, async (draft) => {
             try {
-                const result = yield Promise.resolve(generator(draft, initial));
+                const result = await Promise.resolve(generator(draft, initial));
                 // cast the result to a draft object
                 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`);
+                    this._log?.warn(`bookmark data generator ${generator.name} returned a value, but it should not do this, since the data is an immer draft object`);
                     // Dirty fix since some developers are returning the reference object, which will freeze the object
                     return castDraft(JSON.parse(JSON.stringify(result)));
                 }
                 // clear the bookmark data if the generator returns null
                 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`);
+                    this._log?.info(`bookmark data generator ${generator.name} wish to clear the bookmark data`);
                     return undefined;
                 }
             }
             catch (error) {
-                (_c = this._log) === null || _c === void 0 ? void 0 : _c.error(`Failed to produce payload using generator ${generator.name}`, error);
+                this._log?.error(`Failed to produce payload using generator ${generator.name}`, error);
             }
-        }));
+        });
     }
     /**
      * Retrieves a bookmark with the specified bookmarkId and returns an observable that emits the combined result of fetching the bookmark and bookmark data.
@@ -384,21 +345,18 @@ export class BookmarkProvider {
      * @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);
+        this._log?.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),
+            payload: 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);
+            this._log?.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);
+            this._log?.debug(`Bookmark fetched: ${bookmark.id}`, bookmark);
         }));
     }
     /**
@@ -419,31 +377,28 @@ export class BookmarkProvider {
      */
     getAllBookmarks() {
         return new Observable((observer) => {
-            var _a, _b, _c;
-            (_a = this._log) === null || _a === void 0 ? void 0 : _a.debug(`fetching all bookmarks`);
+            this._log?.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))
+                appKey: this.#config.filters?.application
+                    ? from(this._resolve.application()).pipe(map((x) => 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))
+                contextId: this.#config.filters?.context
+                    ? from(this._resolve.context()).pipe(map((x) => 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);
+                this._log?.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));
+                this.#store.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);
+            const failure$ = this.#store.action$.pipe(filter(bookmarkActions.fetchBookmarks.failure.match), map((action) => {
+                this._log?.error('Failed to fetch bookmarks', action.payload);
                 throw new BookmarkProviderError('Failed to fetch bookmarks', action.payload);
             }), timeout({
                 each: defaultTimeout,
@@ -452,9 +407,8 @@ export class BookmarkProvider {
                 },
             }));
             // 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), tap((bookmarks) => {
-                var _a;
-                (_a = this._log) === null || _a === void 0 ? void 0 : _a.debug(`fetched all bookmarks`, bookmarks);
+            const request$ = this.#store.action$.pipe(filter(bookmarkActions.fetchBookmarks.success.match), map((a) => a.payload), tap((bookmarks) => {
+                this._log?.debug(`fetched all bookmarks`, bookmarks);
             }), raceWith(failure$), first());
             request$.subscribe(observer);
         });
@@ -464,10 +418,8 @@ export class BookmarkProvider {
      *
      * @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());
-        });
+    async getAllBookmarksAsync() {
+        return lastValueFrom(this.getAllBookmarks());
     }
     /**
      * Sets the current bookmark to the specified bookmark or ID.
@@ -481,34 +433,31 @@ export class BookmarkProvider {
      * @template T - The type of the bookmark data.
      */
     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);
+        this._log?.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;
+            : of(bookmark_or_id ?? null);
+        return next$.pipe(switchMap(async (next) => {
             const current = this.currentBookmark;
-            const { type, canceled } = yield this._dispatchEvent('onCurrentBookmarkChange', {
+            const { type, canceled } = await 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);
+                const error = new BookmarkProviderError(`event: ${type} was canceled by listener for change to ${next?.id ?? 'none'}, from ${current?.id ?? 'none'}`);
+                this._log?.info(error.message);
                 throw error;
             }
             return next;
-        })), tap((next) => {
+        }), tap((next) => {
             // set the current bookmark in the store
-            __classPrivateFieldGet(this, _BookmarkProvider_store, "f").next(bookmarkActions.setCurrentBookmark(next));
+            this.#store.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);
+            this._log?.error(error.message, error);
             throw error;
         }));
     }
@@ -533,61 +482,60 @@ export class BookmarkProvider {
      */
     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);
+            this._log?.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)) {
+                        if (!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),
+                contextId: this._resolve.context().then((context) => 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);
+                this._log?.error(error.message, error);
                 throw error;
             }), 
             // merge the resolved data with the new bookmark data
-            map((resolvedData) => (Object.assign(Object.assign({}, newBookmarkData), resolvedData))));
+            map((resolvedData) => ({
+                ...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;
+            const dispatch$ = bookmark$.pipe(switchMap(async (bookmark) => {
                 // notify listeners that a bookmark is about to be created
-                const { canceled, type } = yield this._dispatchEvent('onBookmarkCreate', {
+                const { canceled, type } = await 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);
+                    this._log?.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 }));
+                    this.#store.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);
+                this._log?.warn(error.message);
                 throw error;
             }), timeout({
                 each: defaultTimeout,
@@ -597,8 +545,7 @@ export class BookmarkProvider {
             }));
             // monitor the success case when creating a bookmark
             const request$ = action$.pipe(filter(bookmarkActions.createBookmark.success.match), map(({ payload }) => payload), tap((bookmark) => {
-                var _a;
-                (_a = this._log) === null || _a === void 0 ? void 0 : _a.info(`Bookmark created: ${bookmark.id}, ref: ${ref}`);
+                this._log?.info(`Bookmark created: ${bookmark.id}, ref: ${ref}`);
                 this._dispatchEvent('onBookmarkCreated', { detail: bookmark });
             }), raceWith(failure$), first());
             // emit the created bookmark
@@ -624,54 +571,54 @@ export class BookmarkProvider {
      * @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)) {
+        if (!bookmarkUpdates && 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}`);
+            this._log?.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)
+            const updates$ = options?.excludePayloadGeneration
                 ? of(bookmarkUpdates)
-                : this.generatePayload(bookmarkUpdates === null || bookmarkUpdates === void 0 ? void 0 : bookmarkUpdates.payload).pipe(map((payload) => (Object.assign(Object.assign({}, bookmarkUpdates), { payload }))));
+                : this.generatePayload(bookmarkUpdates?.payload).pipe(map((payload) => ({
+                    ...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', {
+            const dispatch$ = updates$.pipe(switchMap(async (updates) => {
+                const { canceled, type } = await this._dispatchEvent('onBookmarkUpdate', {
                     detail: {
-                        current: bookmarkSelector(__classPrivateFieldGet(this, _BookmarkProvider_store, "f").value, bookmarkId),
+                        current: bookmarkSelector(this.#store.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);
+                    this._log?.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 }));
+                    this.#store.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);
+                this._log?.info(error.message);
                 throw error;
             }), timeout({
                 each: defaultTimeout,
@@ -682,9 +629,11 @@ export class BookmarkProvider {
             // monitor the success case when updating a bookmark
             const request$ = action$.pipe(filter(bookmarkActions.updateBookmark.success.match), 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}`);
+            ({ payload }) => ({
+                ...bookmarkSelector(this.#store.value, payload.id),
+                payload: payload.payload,
+            })), tap((bookmark) => {
+                this._log?.info(`Bookmark updated: ${bookmark.id}, ref: ${ref}`);
                 this._dispatchEvent('onBookmarkUpdated', { detail: bookmark });
             }), raceWith(failure$), first());
             // emit the updated bookmark
@@ -703,7 +652,7 @@ export class BookmarkProvider {
         if (typeof id_or_bookmark === 'object') {
             // @deprecated
             console.warn('updateBookmarkAsync(bookmark, updates, options) is deprecated, use updateBookmarkAsync(id, updates, options) instead');
-            const _a = id_or_bookmark, { id } = _a, updates = __rest(_a, ["id"]);
+            const { id, ...updates } = id_or_bookmark;
             return lastValueFrom(this.updateBookmark(id, updates, {
                 excludePayloadGeneration: !updates_or_options.updatePayload,
             }).pipe(
@@ -721,11 +670,10 @@ export class BookmarkProvider {
      */
     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}`);
+            this._log?.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 : {
+            const bookmark = bookmarkSelector(this.#store.value, bookmarkId) ?? {
                 id: bookmarkId,
             };
             // observable that dispatches the 'onBookmarkDelete' event and maps the result
@@ -733,10 +681,9 @@ export class BookmarkProvider {
                 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);
+                    this._log?.warn(error.message);
                     throw error;
                 }
                 return detail;
@@ -746,16 +693,15 @@ export class BookmarkProvider {
                 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 }));
+                    this.#store.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);
+                this._log?.warn(error.message);
                 throw error;
             }), timeout({
                 each: defaultTimeout,
@@ -765,8 +711,7 @@ export class BookmarkProvider {
             }));
             // monitor the success case when deleting a bookmark
             const request$ = action$.pipe(filter(bookmarkActions.deleteBookmark.success.match), map(() => undefined), tap(() => {
-                var _a;
-                (_a = this._log) === null || _a === void 0 ? void 0 : _a.info(`Removed bookmark: ${bookmark.id}, ref: ${ref}`);
+                this._log?.info(`Removed bookmark: ${bookmark.id}, ref: ${ref}`);
                 this._dispatchEvent('onBookmarkDeleted', { detail: bookmark });
             }), raceWith(failure$), first());
             // emit the deleted bookmark
@@ -779,10 +724,8 @@ export class BookmarkProvider {
      * @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));
-        });
+    async deleteBookmarkAsync(bookmarkId) {
+        return lastValueFrom(this.deleteBookmark(bookmarkId));
     }
     /**
      * Adds a bookmark to the favorites.
@@ -796,18 +739,16 @@ export class BookmarkProvider {
          * 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}`);
+            this._log?.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);
+                    this._log?.info(error.message);
                     throw error;
                 }
             }));
@@ -815,14 +756,13 @@ export class BookmarkProvider {
             subscriber.add(dispatch$.subscribe({
                 error: (error) => subscriber.error(error),
                 next: () => {
-                    __classPrivateFieldGet(this, _BookmarkProvider_store, "f").next(bookmarkActions.addBookmarkAsFavourite(bookmarkId, { ref }));
+                    this.#store.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);
+                this._log?.warn(error.message);
                 throw error;
             }), timeout({
                 each: defaultTimeout,
@@ -832,8 +772,7 @@ export class BookmarkProvider {
             }));
             // 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._log?.info(`Added bookmark: ${bookmarkId} to favourites, ref: ${ref}`);
                 this._dispatchEvent('onBookmarkFavouriteAdded', { detail: bookmark });
             }), raceWith(failure$), first());
             // emit the added bookmark
@@ -862,20 +801,18 @@ export class BookmarkProvider {
          * 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}`);
+            this._log?.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 };
+            const bookmark = bookmarkSelector(this.#store.value, bookmarkId) ?? { 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);
+                    this._log?.warn(error.message);
                     throw error;
                 }
                 return detail;
@@ -885,16 +822,15 @@ export class BookmarkProvider {
                 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 }));
+                    this.#store.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);
+                this._log?.warn(error.message);
                 throw error;
             }), timeout({
                 each: defaultTimeout,
@@ -904,8 +840,7 @@ export class BookmarkProvider {
             }));
             // 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._log?.info(`Removed bookmark: ${bookmarkId} from favourites, ref: ${ref}`);
                 this._dispatchEvent('onBookmarkFavouriteRemoved', { detail: bookmark });
             }), map(() => { }), raceWith(failure$), first());
             // emit the removed bookmark
@@ -928,17 +863,14 @@ export class BookmarkProvider {
      * @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`);
+        this._log?.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);
+            this._log?.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`);
+            this._log?.debug(`Bookmark: ${bookmarkId} is ${isFavorite ? 'in' : 'not in'} favourites`);
         }));
     }
     /**
@@ -951,40 +883,38 @@ export class BookmarkProvider {
         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) => {
+        const failure$ = this.#store.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,
+            each: options?.timeout ?? 2 * 60 * 1000,
             with: () => {
                 throw new BookmarkProviderError(`Timeout while fetching bookmark data: ${bookmarkId}`);
             },
         }));
-        __classPrivateFieldGet(this, _BookmarkProvider_store, "f").next(bookmarkActions.fetchBookmark(bookmarkId, { ref: bookmarkId }));
+        this.#store.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) => {
+        const failure$ = this.#store.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,
+            each: options?.timeout ?? 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 }));
+        this.#store.next(bookmarkActions.fetchBookmarkData(bookmarkId, { ref: bookmarkId }));
         return success$.pipe(raceWith(failure$));
     }
     /**
@@ -994,41 +924,41 @@ export class BookmarkProvider {
      * @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;
+    async _dispatchEvent(type, args) {
+        // create a new event instance
+        const event = new FrameworkEvent(type, {
+            source: this,
+            canBubble: true,
+            ...args,
         });
+        if (this._event) {
+            this._log?.debug(`dispatching event ${type}`, args);
+            const { canceled } = await this._event.dispatchEvent(event);
+            if (canceled) {
+                this._log?.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());
+        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; }));
+        const action$ = this.#store.action$.pipe(filter((action) => 'meta' in action && action.meta?.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();
+        this._log?.debug('disposing BookmarkProvider');
+        this.#subscriptions.unsubscribe();
     }
-    [(_BookmarkProvider_config = new WeakMap(), _BookmarkProvider_store = new WeakMap(), _BookmarkProvider_payloadGenerators = new WeakMap(), _BookmarkProvider_subscriptions = new WeakMap(), Symbol.dispose)]() {
+    [Symbol.dispose]() {
         this.dispose();
     }
 }