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

package/src/bookmark-config.schema.ts

@@ -0,0 +1,41 @@
+import { z } from 'zod';
+
+import { LogLevel, type ILogger } from '@equinor/fusion-log';
+
+import type { IEventModuleProvider } from '@equinor/fusion-framework-module-event';
+
+import type { BookmarkProvider } from './BookmarkProvider';
+import type { IBookmarkClient } from './BookmarkClient.interface';
+
+import { bookmarkSourceSystemSchema } from './bookmark.schemas';
+
+export const bookmarkConfigSchema = z.object({
+    log: z.custom<ILogger>().optional(),
+    logLevel: z.nativeEnum(LogLevel).optional(),
+    eventProvider: z.custom<IEventModuleProvider>().optional(),
+    sourceSystem: bookmarkSourceSystemSchema
+        .optional()
+        .describe('The source system for the bookmarks'),
+    parent: z.custom<BookmarkProvider>().describe('Parent Bookmark provider').optional().nullable(),
+    client: z.custom<IBookmarkClient>().describe('API client for interacting with bookmarks'),
+    resolve: z
+        .object({
+            context: z.function().returns(z.promise(z.object({ id: z.string() }).optional())),
+            application: z
+                .function()
+                .returns(
+                    z.promise(
+                        z.object({ appKey: z.string(), name: z.string().optional() }).optional(),
+                    ),
+                ),
+        })
+        .describe('Functions for resolving context and application'),
+    filters: z
+        .object({
+            context: z.boolean().optional().default(false),
+            application: z.boolean().optional().default(false),
+        })
+        .describe('Flags for enabling resolving when fetching bookmarks')
+        .optional()
+        .default({ context: false, application: false }),
+});

package/src/bookmark-module.ts

@@ -0,0 +1,70 @@
+import { Module, ModulesInstance, SemanticVersion } from '@equinor/fusion-framework-module';
+import { EventModule } from '@equinor/fusion-framework-module-event';
+import { ServicesModule } from '@equinor/fusion-framework-module-services';
+import { AppModule } from '@equinor/fusion-framework-module-app';
+import { ContextModule } from '@equinor/fusion-framework-module-context';
+import { BookmarkProvider } from './BookmarkProvider';
+import { BookmarkModuleConfigurator } from './BookmarkConfigurator';
+import { ConsoleLogger, ILogger } from '@equinor/fusion-log';
+import { lastValueFrom } from 'rxjs';
+import { version } from './version';
+
+export type BookmarkModuleKey = 'bookmark';
+
+export const moduleKey: BookmarkModuleKey = 'bookmark';
+
+export type BookmarkModule = Module<
+    BookmarkModuleKey,
+    BookmarkProvider,
+    BookmarkModuleConfigurator,
+    [EventModule, ServicesModule, AppModule, ContextModule]
+>;
+
+// TODO - remove when all framework uses log
+const fallbackLogger: ILogger = new ConsoleLogger('BookmarkModule');
+
+export const module: BookmarkModule = {
+    name: moduleKey,
+    version: new SemanticVersion(version),
+    configure: (args) => {
+        // use parent logger if available, else fallback to console logger
+        const log: ILogger =
+            (args?.log as ILogger)?.createSubLogger('BookmarkModule') || fallbackLogger;
+
+        // Set client from parent module if available
+        const ref = args?.ref as ModulesInstance<[BookmarkModule]>;
+
+        // create a configurator instance
+        const configurator = new BookmarkModuleConfigurator({ log, ref });
+
+        return configurator;
+    },
+    initialize: async (args) => {
+        const parent = args.ref?.bookmark as BookmarkProvider;
+        const config = await lastValueFrom(
+            args.config.createConfig(args, {
+                filters: parent?.filters,
+                sourceSystem: parent?.sourceSystem,
+                resolve: parent
+                    ? {
+                          application: parent.resolvedApplication.bind(parent),
+                          context: parent.resolvedContext.bind(parent),
+                      }
+                    : undefined,
+            }),
+        );
+        const provider = new BookmarkProvider(config);
+        return provider;
+    },
+    dispose: (args) => {
+        (args.instance as BookmarkProvider).dispose();
+    },
+};
+
+declare module '@equinor/fusion-framework-module' {
+    interface Modules {
+        bookmark: BookmarkModule;
+    }
+}
+
+export default module;

package/src/bookmark.schemas.ts

@@ -0,0 +1,50 @@
+import * as z from 'zod';
+import { BookmarkData } from './types';
+
+const bookmarkUserSchema = z.object({
+    azureUniqueId: z.string(),
+    name: z.string(),
+    mail: z.string().optional(),
+    phoneNumber: z.string().optional(),
+    jobTitle: z.string().optional(),
+    accountType: z.enum(['Employee', 'Consultant', 'External', 'Application', 'Local']).optional(),
+    accountClassification: z.enum(['Unclassified', 'Internal', 'External']).optional(),
+});
+
+export const bookmarkSourceSystemSchema = z.object({
+    identifier: z.string(),
+    name: z.string().optional(),
+    subSystem: z.string().optional(),
+});
+
+const bookmarkContextSchema = z.object({
+    id: z.string(),
+    name: z.string().optional(),
+    type: z.string().optional(),
+});
+
+export const bookmarkSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    appKey: z.string(),
+    description: z.string().optional(),
+    isShared: z.boolean().optional(),
+    created: z.date(),
+    createdBy: bookmarkUserSchema,
+    updated: z.date().optional(),
+    updatedBy: bookmarkUserSchema.optional(),
+    context: bookmarkContextSchema.optional(),
+    sourceSystem: bookmarkSourceSystemSchema.optional(),
+});
+
+export const bookmarksSchema = z.array(bookmarkSchema);
+
+export const bookmarkWithDataSchema = <
+    T extends BookmarkData = BookmarkData,
+    S extends z.ZodSchema<T> = z.ZodSchema<T>,
+>(
+    schema: S = z.record(z.unknown()).or(z.string()).optional() as unknown as S,
+) =>
+    bookmarkSchema.extend({
+        payload: schema,
+    });

package/src/enable-bookmark.ts

@@ -1,32 +1,25 @@
-import type {
-    AnyModule,
-    IModulesConfigurator,
-    ModuleInitializerArgs,
-} from '@equinor/fusion-framework-module';
-import { BookmarkConfigBuilder } from './bookmark-config-builder';
+import type { IModulesConfigurator } from '@equinor/fusion-framework-module';
 
-import { IBookmarkModuleConfigurator } from './configurator';
-
-import { module } from './module';
+import { module } from './bookmark-module';
+import { BookmarkModuleConfigurator } from './BookmarkConfigurator';
 
 /**
- * Method for enabling Bookmark module
- * @param configurator - configuration object
+ * Enables the Bookmark module
+ *
+ * @param configurator - The configuration object for the modules.
+ * @param callback - An optional callback function that receives the `BookmarkModuleConfigurator` instance, allowing for further configuration.
  */
 export const enableBookmark = (
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    configurator: IModulesConfigurator<any, any>,
-    builder?: <TDeps extends Array<AnyModule> = []>(
-        builder: BookmarkConfigBuilder<
-            TDeps,
-            ModuleInitializerArgs<IBookmarkModuleConfigurator, TDeps>
-        >,
-    ) => void | Promise<void>,
+    configurator: IModulesConfigurator<any>,
+    callback?: (builder: BookmarkModuleConfigurator) => void | Promise<void>,
 ): void => {
     configurator.addConfig({
         module,
-        configure: (contextConfigurator) => {
-            builder && contextConfigurator.addConfigBuilder(builder);
+        configure: async (builder) => {
+            if (callback) {
+                Promise.resolve(callback(builder));
+            }
         },
     });
 };

package/src/index.ts

@@ -1,17 +1,25 @@
-export {
-    BookmarkModuleConfigurator,
-    IBookmarkModuleConfigurator,
-    BookmarkModuleConfig,
-} from './configurator';
+export { BookmarkModuleConfigurator } from './BookmarkConfigurator';
+
+export type {
+    IBookmarkClient,
+    BookmarkNew,
+    BookmarkUpdate,
+    BookmarksFilter,
+} from './BookmarkClient.interface';
 
 export {
     default,
     BookmarkModule,
     module as bookmarkModule,
     moduleKey as bookmarkModuleKey,
-} from './module';
+} from './bookmark-module';
 
-export { IBookmarkModuleProvider, BookmarkModuleProvider } from './bookmark-provider';
+export {
+    BookmarkProvider,
+    type BookmarkPayloadGenerator,
+    type BookmarkCreateArgs,
+    type BookmarkUpdateOptions,
+} from './BookmarkProvider';
 
 export { enableBookmark } from './enable-bookmark';
 

package/src/types.ts

@@ -1,73 +1,46 @@
-import { QueryFn, QueryCtorOptions } from '@equinor/fusion-query';
-
-export interface PatchBookmark<TData = unknown> extends Partial<Bookmark<TData>> {
-    id: string;
-    appKey: string;
-}
-export interface Bookmark<TData = unknown> {
-    id: string;
-    name: string;
-    description: string;
-    isShared: boolean;
-    payload: TData;
-    appKey: string;
-    context?: Context;
-    createdBy: CreatedBy;
-    updatedBy: CreatedBy;
-    created: string;
-    updated: string;
-    sourceSystem?: SourceSystem;
-}
-
-export type CreateBookmark<TData = unknown> = {
-    /** Display name of the bookmark */
-    name: string;
-    description?: string;
-    /** Is the bookmark shared with others */
-    isShared: boolean;
-    /** Name of the app it belongs too, should correspond to a fusion appkey */
-    appKey: string;
-    contextId?: string;
-    /** Any JSON object to store as the bookmark payload */
-    payload: TData;
-    sourceSystem?: Partial<SourceSystem>;
-};
-
-export interface SourceSystem {
-    identifier: string;
-    name: string;
-    subSystem: string;
-}
-
-interface CreatedBy {
-    azureUniqueId: string;
-    mail: string;
-    name: string;
-    phoneNumber: string;
-    jobTitle: string;
-    accountType: number;
-    accountClassification: number;
-}
-
-interface Context {
-    id: string;
-    name: string;
-    type: string;
-}
-
-export type GetBookmarkParameters = { id: string };
-
-export type GetAllBookmarksParameters = { isValid: boolean };
-
-export interface BookmarkQueryClient {
-    getAllBookmarks:
-        | QueryFn<Array<Bookmark<unknown>>, GetAllBookmarksParameters>
-        | QueryCtorOptions<Array<Bookmark<unknown>>, GetAllBookmarksParameters>;
-    getBookmarkById:
-        | QueryFn<Bookmark<unknown>, GetBookmarkParameters>
-        | QueryCtorOptions<Bookmark<unknown>, GetBookmarkParameters>;
-}
-
-export type UpdateBookmarkOptions = {
-    updatePayload: boolean;
-};
+import z from 'zod';
+
+import {
+    bookmarkSchema,
+    bookmarkSourceSystemSchema,
+    bookmarksSchema,
+    bookmarkWithDataSchema,
+} from './bookmark.schemas';
+
+import { bookmarkConfigSchema } from './bookmark-config.schema';
+
+/**
+ * Represents the source system for a bookmark.
+ */
+export type SourceSystem = z.infer<typeof bookmarkSourceSystemSchema>;
+
+/**
+ * Represents the data associated with a bookmark.
+ * This is a generic type that can hold any arbitrary data as a key-value map.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type BookmarkData = Record<string, any> | string;
+
+/**
+ * Represents a collection of bookmarks.
+ */
+export type Bookmarks = z.infer<typeof bookmarksSchema>;
+
+/**
+ * Represents a bookmark without any associated data.
+ */
+export type BookmarkWithoutData = z.infer<typeof bookmarkSchema>;
+
+/**
+ * Represents a bookmark with associated data.
+ * @template T - The type of the bookmark data.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type Bookmark<T extends BookmarkData = any> = z.infer<
+    ReturnType<typeof bookmarkWithDataSchema<T>>
+>;
+
+/**
+ * Represents the configuration options for a bookmark module.
+ */
+export type BookmarkModuleConfig = z.infer<typeof bookmarkConfigSchema>;

package/src/version.ts

@@ -1,2 +1,2 @@
 // Generated by genversion.
-export const version = '1.2.13';
+export const version = '2.0.0';

package/dist/esm/bookmark-config-builder.js

@@ -1,131 +0,0 @@
-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 __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 _BookmarkConfigBuilder_init;
-export class BookmarkConfigBuilder {
-    constructor(init, config = {}) {
-        this.config = config;
-        _BookmarkConfigBuilder_init.set(this, void 0);
-        __classPrivateFieldSet(this, _BookmarkConfigBuilder_init, init, "f");
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    requireInstance(module) {
-        return __classPrivateFieldGet(this, _BookmarkConfigBuilder_init, "f").requireInstance(module);
-    }
-    /**
-     *
-     * This will sett the SourceSystem used when creating a new bookmark,
-     * used as the identifier for the current client. Only used in app shell / portal configuration.
-     *
-     * @param {SourceSystem} sourceSystem
-     * ```ts
-     * interface SourceSystem {
-     *  identifier: string;
-     *  name: string;
-     *  subSystem: string;
-     * }
-     * ```
-     * @memberof BookmarkConfigBuilder
-     */
-    setSourceSystem(sourceSystem) {
-        this.config.sourceSystem = sourceSystem;
-    }
-    /**
-     * Used to over write the default  Url id resolving.
-     *
-     * @param {(() => string | null)} fn - Resolver for bookmarkId
-     * @memberof BookmarkConfigBuilder
-     */
-    setBookmarkIdResolver(fn) {
-        this.config.resolveBookmarkId = fn;
-    }
-    /**
-     * This allow for custom BookmarkApiClient to be added.
-     *
-     * @param {BookmarksApiClient<'fetch', IHttpClient, Bookmark<unknown>>} client - Custom Api client
-     * @memberof BookmarkConfigBuilder
-     */
-    serCustomBookmarkApiClient(client) {
-        if (this.config.clientConfiguration) {
-            this.config.clientConfiguration.client = client;
-        }
-    }
-    /**
-     * Used to over with the default context id resolver.
-     *
-     * @param {(() => string | undefined)} fn - Function for providing current contextId
-     * @memberof BookmarkConfigBuilder
-     */
-    setContextIdResolver(fn) {
-        this.config.getContextId = fn;
-    }
-    /**
-     * Used to over withe the default function for getting the current applications
-     * key identifier.
-     *
-     * @param {(() => string | undefined)}  - A function for getting the current application key
-     * @memberof BookmarkConfigBuilder
-     */
-    setCurrentAppIdResolver(fn) {
-        this.config.getCurrentAppIdentification = fn;
-    }
-    /**
-     * Enable the over write default Event provider if needed.
-     * Should not be used if all event providers are changes in the current environment
-     *
-     * @param {IEventModuleProvider} provider - Custom Event provider
-     * @memberof BookmarkConfigBuilder
-     */
-    setEventProvider(provider) {
-        this.config.event = provider;
-    }
-    /**
-     * Use for override the bookmark query client
-     *
-     * @param {({
-     *             getAllBookmarks:
-     *                 | QueryFn<Array<Bookmark<unknown>>, GetAllBookmarksParameters>
-     *                 | QueryCtorOptions<Array<Bookmark<unknown>>, GetAllBookmarksParameters>;
-     *             getBookmarkById:
-     *                 | QueryFn<Bookmark<unknown>, GetBookmarkParameters>
-     *                 | QueryCtorOptions<Bookmark<unknown>, GetBookmarkParameters>;
-     *         })} client - Custom client definition.
-     * @memberof BookmarkConfigBuilder
-     */
-    setBookmarkQueryClient(client) {
-        const expire = 1 * 60 * 1000;
-        if (this.config.clientConfiguration) {
-            this.config.clientConfiguration.queryClientConfig = {
-                getAllBookmarks: typeof client.getAllBookmarks === 'function'
-                    ? {
-                        key: () => 'all-bookmarks',
-                        client: {
-                            fn: client.getAllBookmarks,
-                        },
-                        validate: ({ args }) => args.isValid,
-                    }
-                    : client.getAllBookmarks,
-                getBookmarkById: typeof client.getBookmarkById === 'function'
-                    ? {
-                        key: ({ id }) => id,
-                        client: {
-                            fn: client.getBookmarkById,
-                        },
-                        expire,
-                        validate: () => false,
-                    }
-                    : client.getBookmarkById,
-            };
-        }
-    }
-}
-_BookmarkConfigBuilder_init = new WeakMap();
-//# sourceMappingURL=bookmark-config-builder.js.map

package/dist/esm/bookmark-config-builder.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"bookmark-config-builder.js","sourceRoot":"","sources":["../../src/bookmark-config-builder.ts"],"names":[],"mappings":";;;;;;;;;;;;AA0BA,MAAM,OAAO,qBAAqB;IAS9B,YACI,IAAW,EACJ,SAAwC,EAAE;QAA1C,WAAM,GAAN,MAAM,CAAoC;QAHrD,8CAAa;QAKT,uBAAA,IAAI,+BAAS,IAAI,MAAA,CAAC;IACtB,CAAC;IAQD,8DAA8D;IAC9D,eAAe,CAAC,MAAc;QAC1B,OAAO,uBAAA,IAAI,mCAAM,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC;IAC9C,CAAC;IAED;;;;;;;;;;;;;;OAcG;IACH,eAAe,CAAC,YAA0B;QACtC,IAAI,CAAC,MAAM,CAAC,YAAY,GAAG,YAAY,CAAC;IAC5C,CAAC;IAED;;;;;OAKG;IACH,qBAAqB,CAAC,EAAuB;QACzC,IAAI,CAAC,MAAM,CAAC,iBAAiB,GAAG,EAAE,CAAC;IACvC,CAAC;IAED;;;;;OAKG;IACH,0BAA0B,CACtB,MAAmE;QAEnE,IAAI,IAAI,CAAC,MAAM,CAAC,mBAAmB,EAAE,CAAC;YAClC,IAAI,CAAC,MAAM,CAAC,mBAAmB,CAAC,MAAM,GAAG,MAAM,CAAC;QACpD,CAAC;IACL,CAAC;IAED;;;;;OAKG;IACH,oBAAoB,CAAC,EAA4B;QAC7C,IAAI,CAAC,MAAM,CAAC,YAAY,GAAG,EAAE,CAAC;IAClC,CAAC;IAED;;;;;;OAMG;IACH,uBAAuB,CAAC,EAA4B;QAChD,IAAI,CAAC,MAAM,CAAC,2BAA2B,GAAG,EAAE,CAAC;IACjD,CAAC;IAED;;;;;;OAMG;IACH,gBAAgB,CAAC,QAA8B;QAC3C,IAAI,CAAC,MAAM,CAAC,KAAK,GAAG,QAAQ,CAAC;IACjC,CAAC;IAED;;;;;;;;;;;;OAYG;IACH,sBAAsB,CAAC,MAOtB;QACG,MAAM,MAAM,GAAW,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC;QACrC,IAAI,IAAI,CAAC,MAAM,CAAC,mBAAmB,EAAE,CAAC;YAClC,IAAI,CAAC,MAAM,CAAC,mBAAmB,CAAC,iBAAiB,GAAG;gBAChD,eAAe,EACX,OAAO,MAAM,CAAC,eAAe,KAAK,UAAU;oBACxC,CAAC,CAAC;wBACI,GAAG,EAAE,GAAG,EAAE,CAAC,eAAe;wBAC1B,MAAM,EAAE;4BACJ,EAAE,EAAE,MAAM,CAAC,eAAe;yBAC7B;wBACD,QAAQ,EAAE,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,OAAO;qBACvC;oBACH,CAAC,CAAC,MAAM,CAAC,eAAe;gBAChC,eAAe,EACX,OAAO,MAAM,CAAC,eAAe,KAAK,UAAU;oBACxC,CAAC,CAAC;wBACI,GAAG,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE;wBACnB,MAAM,EAAE;4BACJ,EAAE,EAAE,MAAM,CAAC,eAAe;yBAC7B;wBACD,MAAM;wBACN,QAAQ,EAAE,GAAG,EAAE,CAAC,KAAK;qBACxB;oBACH,CAAC,CAAC,MAAM,CAAC,eAAe;aACnC,CAAC;QACN,CAAC;IACL,CAAC;CACJ"}

package/dist/esm/bookmark-provider.js

@@ -1,155 +0,0 @@
-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 __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 __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 _BookmarkModuleProvider_instances, _BookmarkModuleProvider_event, _BookmarkModuleProvider_subscriptions, _BookmarkModuleProvider_clearStateCreators, _BookmarkModuleProvider_createPayload, _BookmarkModuleProvider_getAppKey;
-import { BookmarkClient } from './client/bookmarkClient';
-import { Subscription } from 'rxjs';
-export class BookmarkModuleProvider {
-    get currentBookmark$() {
-        return this._bookmarkClient.currentBookmark$;
-    }
-    get bookmarks$() {
-        return this._bookmarkClient.bookmarks$;
-    }
-    constructor(config, ref) {
-        _BookmarkModuleProvider_instances.add(this);
-        _BookmarkModuleProvider_event.set(this, void 0);
-        _BookmarkModuleProvider_subscriptions.set(this, new Subscription());
-        this.bookmarkCreators = {};
-        _BookmarkModuleProvider_clearStateCreators.set(this, () => {
-            this.bookmarkCreators = {};
-        });
-        this.config = config;
-        __classPrivateFieldSet(this, _BookmarkModuleProvider_event, config.event, "f");
-        this._bookmarkClient = ref
-            ? ref._bookmarkClient
-            : new BookmarkClient(config.clientConfiguration, config.sourceSystem, config.event);
-        const initialBookmarkId = config.resolveBookmarkId && config.resolveBookmarkId();
-        if (initialBookmarkId) {
-            this._bookmarkClient.setCurrentBookmark(initialBookmarkId);
-        }
-        if (__classPrivateFieldGet(this, _BookmarkModuleProvider_event, "f")) {
-            __classPrivateFieldGet(this, _BookmarkModuleProvider_subscriptions, "f").add(__classPrivateFieldGet(this, _BookmarkModuleProvider_event, "f").addEventListener('onCurrentAppChanged', __classPrivateFieldGet(this, _BookmarkModuleProvider_clearStateCreators, "f")));
-        }
-    }
-    getBookmarkById(bookmarkId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this._bookmarkClient.getBookmarkById(bookmarkId);
-        });
-    }
-    setCurrentBookmark(idOrItem) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this._bookmarkClient.setCurrentBookmark(idOrItem);
-        });
-    }
-    getAllBookmarks() {
-        return this._bookmarkClient.getAllBookmarks();
-    }
-    getAllBookmarksAsync() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this._bookmarkClient.getAllBookmarksAsync();
-        });
-    }
-    updateBookmark(bookmark) {
-        return this._bookmarkClient.updateBookmark(bookmark);
-    }
-    updateBookmarkAsync(bookmark, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (__classPrivateFieldGet(this, _BookmarkModuleProvider_instances, "m", _BookmarkModuleProvider_getAppKey).call(this) !== bookmark.appKey) {
-                return;
-            }
-            if (options === null || options === void 0 ? void 0 : options.updatePayload) {
-                const payload = (yield __classPrivateFieldGet(this, _BookmarkModuleProvider_instances, "m", _BookmarkModuleProvider_createPayload).call(this));
-                bookmark = Object.assign(Object.assign({}, bookmark), { payload });
-            }
-            return this._bookmarkClient.updateBookmarkAsync(bookmark);
-        });
-    }
-    deleteBookmarkById(bookmarkId) {
-        return this._bookmarkClient.deleteBookmarkById(bookmarkId);
-    }
-    deleteBookmarkByIdAsync(bookmarkId) {
-        return this._bookmarkClient.deleteBookmarkByIdAsync(bookmarkId);
-    }
-    addBookmarkFavoriteAsync(bookmarkId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this._bookmarkClient.addBookmarkFavoriteAsync(bookmarkId);
-        });
-    }
-    removeBookmarkFavoriteAsync(bookmarkId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this._bookmarkClient.removeBookmarkFavoriteAsync(bookmarkId);
-        });
-    }
-    verifyBookmarkFavoriteAsync(bookmarkId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this._bookmarkClient.verifyBookmarkFavoriteAsync(bookmarkId);
-        });
-    }
-    addStateCreator(cb, key) {
-        var _a;
-        const bookmarkCreatorKey = key ? key : '#creator';
-        if (__classPrivateFieldGet(this, _BookmarkModuleProvider_event, "f")) {
-            (_a = __classPrivateFieldGet(this, _BookmarkModuleProvider_event, "f")) === null || _a === void 0 ? void 0 : _a.dispatchEvent('onAddCreator', {
-                source: this,
-                canBubble: true,
-                detail: { key, cb },
-            });
-        }
-        this.bookmarkCreators[bookmarkCreatorKey] = cb;
-        return () => {
-            delete this.bookmarkCreators[bookmarkCreatorKey];
-        };
-    }
-    createBookmark(args) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const payload = yield __classPrivateFieldGet(this, _BookmarkModuleProvider_instances, "m", _BookmarkModuleProvider_createPayload).call(this);
-            const contextId = this.config.getContextId && this.config.getContextId();
-            const appKey = __classPrivateFieldGet(this, _BookmarkModuleProvider_instances, "m", _BookmarkModuleProvider_getAppKey).call(this);
-            const bookmark = Object.assign(Object.assign({}, args), { appKey,
-                contextId, sourceSystem: this.config.sourceSystem, payload });
-            return this._bookmarkClient.createBookmarkAsync(bookmark);
-        });
-    }
-    dispose() {
-        __classPrivateFieldGet(this, _BookmarkModuleProvider_subscriptions, "f").unsubscribe();
-        this._bookmarkClient.dispose();
-    }
-}
-_BookmarkModuleProvider_event = new WeakMap(), _BookmarkModuleProvider_subscriptions = new WeakMap(), _BookmarkModuleProvider_clearStateCreators = new WeakMap(), _BookmarkModuleProvider_instances = new WeakSet(), _BookmarkModuleProvider_createPayload = function _BookmarkModuleProvider_createPayload() {
-    return __awaiter(this, void 0, void 0, function* () {
-        const creator = this.bookmarkCreators;
-        if (!creator || Object.keys(creator).length === 0) {
-            throw Error('No creator registered on this BookmarkProvider');
-        }
-        if (typeof creator['#creator'] === 'function') {
-            return creator['#creator']();
-        }
-        return yield Object.entries(creator).reduce((cur_1, _a) => __awaiter(this, [cur_1, _a], void 0, function* (cur, [key, fn]) {
-            return Object.assign(yield cur, { [key]: yield fn() });
-        }), Promise.resolve({}));
-    });
-}, _BookmarkModuleProvider_getAppKey = function _BookmarkModuleProvider_getAppKey() {
-    const appKey = this.config.getCurrentAppIdentification && this.config.getCurrentAppIdentification();
-    if (!appKey)
-        throw new Error(`There is noe current application selected, can't create bookmark.`);
-    return appKey;
-};
-//# sourceMappingURL=bookmark-provider.js.map