@equinor/fusion-framework-module-bookmark 0.1.0

package/dist/types/configurator.d.ts

@@ -0,0 +1,47 @@
+import { BookmarkConfigBuilderCallback } from './bookmark-config-builder';
+import type { ModuleInitializerArgs } from '@equinor/fusion-framework-module';
+import type { IApiProvider, ServicesModule } from '@equinor/fusion-framework-module-services';
+import type { SourceSystem } from './types';
+import type { ContextModule, IContextProvider } from '@equinor/fusion-framework-module-context';
+import type { AppModule, AppModuleProvider } from '@equinor/fusion-framework-module-app';
+import type { EventModule, IEventModuleProvider } from '@equinor/fusion-framework-module-event';
+import type { IBookmarkModuleProvider } from './bookmark-provider';
+import type { INavigationProvider, NavigationModule } from '@equinor/fusion-framework-module-navigation';
+import type { BookmarkClientConfig } from './client/bookmarkClient';
+export interface BookmarkModuleConfig {
+    sourceSystem: SourceSystem;
+    clientConfiguration: BookmarkClientConfig;
+    getContextId: () => string | undefined;
+    getCurrentAppIdentification?(): string | undefined;
+    resolveBookmarkId?(): string | null;
+    event?: IEventModuleProvider;
+}
+export type IBookmarkModuleConfigurator = {
+    addConfigBuilder(init: BookmarkConfigBuilderCallback): void;
+    createConfig(init: ModuleInitializerArgs<IBookmarkModuleConfigurator, [
+        ServicesModule,
+        AppModule,
+        ContextModule
+    ]>, parentProvider?: IBookmarkModuleProvider): Promise<BookmarkModuleConfig>;
+};
+export declare class BookmarkModuleConfigurator implements IBookmarkModuleConfigurator {
+    #private;
+    defaultExpireTime: number;
+    addConfigBuilder(init: BookmarkConfigBuilderCallback): void;
+    createConfig(init: ModuleInitializerArgs<IBookmarkModuleConfigurator, [
+        ServicesModule,
+        AppModule,
+        ContextModule
+    ]>, parentProvider?: IBookmarkModuleProvider): Promise<BookmarkModuleConfig>;
+    protected _createClientConfiguration(init: ModuleInitializerArgs<IBookmarkModuleConfigurator, [
+        ServicesModule,
+        AppModule,
+        ContextModule
+    ]>, config?: Partial<BookmarkClientConfig>): Promise<BookmarkClientConfig>;
+    protected _getServiceProvider(init: ModuleInitializerArgs<IBookmarkModuleConfigurator, [ServicesModule]>): Promise<IApiProvider>;
+    protected _getContextProvider(init: ModuleInitializerArgs<IBookmarkModuleConfigurator, [ContextModule]>): Promise<IContextProvider>;
+    protected _getAppProvider(init: ModuleInitializerArgs<IBookmarkModuleConfigurator, [AppModule]>): Promise<AppModuleProvider>;
+    protected _getEventProvider(init: ModuleInitializerArgs<IBookmarkModuleConfigurator, [EventModule]>): Promise<IEventModuleProvider>;
+    protected _getNavigationProvider(init: ModuleInitializerArgs<IBookmarkModuleConfigurator, [NavigationModule]>): Promise<INavigationProvider>;
+}
+export default BookmarkModuleConfigurator;

package/dist/types/enable-bookmark.d.ts

@@ -0,0 +1,4 @@
+import type { AnyModule, IModulesConfigurator, ModuleInitializerArgs } from '@equinor/fusion-framework-module';
+import { BookmarkConfigBuilder } from './bookmark-config-builder';
+import { IBookmarkModuleConfigurator } from './configurator';
+export declare const enableBookmark: (configurator: IModulesConfigurator<any, any>, builder?: (<TDeps extends AnyModule[] = []>(builder: BookmarkConfigBuilder<TDeps, ModuleInitializerArgs<IBookmarkModuleConfigurator, TDeps>>) => void | Promise<void>) | undefined) => void;

package/dist/types/index.d.ts

@@ -0,0 +1,5 @@
+export { BookmarkModuleConfigurator, IBookmarkModuleConfigurator, BookmarkModuleConfig, } from './configurator';
+export { default, BookmarkModule, module as bookmarkModule, moduleKey as bookmarkModuleKey, } from './module';
+export { IBookmarkModuleProvider, BookmarkModuleProvider } from './bookmark-provider';
+export { enableBookmark } from './enable-bookmark';
+export * from './types';

package/dist/types/module.d.ts

@@ -0,0 +1,22 @@
+import { Module } 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 { IBookmarkModuleProvider } from './bookmark-provider';
+import { IBookmarkModuleConfigurator } from './configurator';
+export type BookmarkModuleKey = 'bookmark';
+export declare const moduleKey: BookmarkModuleKey;
+export type BookmarkModule = Module<BookmarkModuleKey, IBookmarkModuleProvider, IBookmarkModuleConfigurator, [
+    EventModule,
+    ServicesModule,
+    AppModule,
+    ContextModule
+]>;
+export declare const module: BookmarkModule;
+declare module '@equinor/fusion-framework-module' {
+    interface Modules {
+        bookmark: BookmarkModule;
+    }
+}
+export default module;

package/dist/types/types.d.ts

@@ -0,0 +1,54 @@
+import { QueryFn, QueryCtorOptions } from '@equinor/fusion-query';
+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> = {
+    name: string;
+    description?: string;
+    isShared: boolean;
+    appKey: string;
+    contextId?: string;
+    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 {};

package/dist/types/utils/handle-url.d.ts

@@ -0,0 +1,2 @@
+export declare function removeBookmarkIdFromURL(): void;
+export declare const getBookmarkIdFormURL: () => string | null;

package/dist/types/utils/index.d.ts

@@ -0,0 +1 @@
+export { getBookmarkIdFormURL, removeBookmarkIdFromURL } from './handle-url';

package/package.json

@@ -0,0 +1,48 @@
+{
+    "name": "@equinor/fusion-framework-module-bookmark",
+    "version": "0.1.0",
+    "description": "",
+    "main": "./dist/esm/index.js",
+    "exports": {
+        ".": "./dist/esm/index.js",
+        "./package.json": "./package.json",
+        "./utils": "./dist/esm/utils/index.js"
+    },
+    "types": "./dist/types/index.d.ts",
+    "typesVersions": {
+        "*": {
+            "utils": [
+                "dist/types/utils/index.d.ts"
+            ]
+        }
+    },
+    "scripts": {
+        "build": "tsc -b",
+        "prepack": "yarn build"
+    },
+    "keywords": [],
+    "author": "",
+    "license": "ISC",
+    "publishConfig": {
+        "access": "public"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/equinor/fusion-framework.git",
+        "directory": "packages/modules/context"
+    },
+    "dependencies": {
+        "@equinor/fusion-query": "^2.0.7"
+    },
+    "devDependencies": {
+        "@equinor/fusion-framework-module": "^2.0.0",
+        "@equinor/fusion-framework-module-event": "^2.0.0",
+        "@equinor/fusion-framework-module-services": "^2.1.0",
+        "rxjs": "^7.5.7"
+    },
+    "peerDependencies": {
+        "@equinor/fusion-framework-module": ">=1.2.5",
+        "rxjs": "^7.5.7"
+    },
+    "gitHead": "d177e1925ca7b8692435b1fdefbcc0c8418d7625"
+}

package/src/bookmark-config-builder.ts

@@ -0,0 +1,171 @@
+import {
+    AnyModule,
+    ModuleInitializerArgs,
+    Modules,
+    ModuleType,
+} from '@equinor/fusion-framework-module';
+import { IEventModuleProvider } from '@equinor/fusion-framework-module-event';
+import { IHttpClient } from '@equinor/fusion-framework-module-http';
+import { BookmarksApiClient } from '@equinor/fusion-framework-module-services/bookmarks';
+
+import { QueryCtorOptions, QueryFn } from '@equinor/fusion-query';
+
+import {
+    BookmarkModuleConfig,
+    BookmarkModuleConfigurator,
+    IBookmarkModuleConfigurator,
+} from './configurator';
+import { Bookmark, GetAllBookmarksParameters, GetBookmarkParameters, SourceSystem } from './types';
+
+export type BookmarkConfigBuilderCallback = <TDeps extends Array<AnyModule> = []>(
+    builder: BookmarkConfigBuilder<TDeps, ModuleInitializerArgs<IBookmarkModuleConfigurator, TDeps>>
+) => void | Promise<void>;
+
+export class BookmarkConfigBuilder<
+    TModules extends Array<AnyModule> = [],
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    TInit extends ModuleInitializerArgs<any, any> = ModuleInitializerArgs<
+        BookmarkModuleConfigurator,
+        TModules
+    >
+> {
+    #init: TInit;
+    constructor(init: TInit, public config: Partial<BookmarkModuleConfig> = {}) {
+        this.#init = init;
+    }
+
+    requireInstance<TKey extends string = Extract<keyof Modules, string>>(
+        module: TKey
+    ): Promise<ModuleType<Modules[TKey]>>;
+
+    requireInstance<T>(module: string): Promise<T>;
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    requireInstance(module: string): Promise<any> {
+        return this.#init.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: 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: () => string | null) {
+        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: BookmarksApiClient<'fetch', IHttpClient, Bookmark<unknown>>
+    ) {
+        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: () => string | undefined) {
+        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: () => string | undefined) {
+        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: IEventModuleProvider) {
+        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: {
+        getAllBookmarks:
+            | QueryFn<Array<Bookmark<unknown>>, GetAllBookmarksParameters>
+            | QueryCtorOptions<Array<Bookmark<unknown>>, GetAllBookmarksParameters>;
+        getBookmarkById:
+            | QueryFn<Bookmark<unknown>, GetBookmarkParameters>
+            | QueryCtorOptions<Bookmark<unknown>, GetBookmarkParameters>;
+    }): void {
+        const expire: number = 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,
+            };
+        }
+    }
+}

package/src/bookmark-provider.ts

@@ -0,0 +1,288 @@
+import { ModuleType } from '@equinor/fusion-framework-module';
+
+import {
+    EventModule,
+    FrameworkEvent,
+    FrameworkEventInit,
+} from '@equinor/fusion-framework-module-event';
+
+import { BookmarkClient } from './client/bookmarkClient';
+
+import { BookmarkModuleConfig } from './configurator';
+import { Observable, Subscription } from 'rxjs';
+import { Bookmark, CreateBookmark } from './types';
+
+export interface IBookmarkModuleProvider {
+    /**
+     * @type {BookmarkModuleConfig} Readonly  configuration for the Bookmark Module used as a backdoor enabling bookmark configuration in a sub application.
+     */
+    readonly config: BookmarkModuleConfig;
+
+    /**
+     * Observable Bookmark providing current resolved bookmark.
+     * @type {(Observable<Bookmark<any> | undefined>)}
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    readonly currentBookmark$: Observable<Bookmark<any> | undefined>;
+    /**
+     *
+     * Observable list of bookmarks in the current configured system,
+     * filtered by the confirmed SourceSystem identifier. This is done by the portal development team;
+     * @type {Observable<Array<Bookmark<unknown>>>}
+     */
+    readonly bookmarks$: Observable<Array<Bookmark<unknown>>>;
+
+    /**
+     * The current bookmark available
+     * @type {Bookmark<unknown>}
+     */
+    currentBookmark?: Bookmark<unknown>;
+
+    /**
+     * Function fo setting the current applications state creator, is used to collect the state stored in a bookmark.
+     * This will enable the bookmark functionality for the application.
+     *
+     * @template T - Payload Type
+     * @param {CreateBookmarkFn<T>} cb - For creating the bookmark payload, this should ne wrapped in a useCallback, payload return can be a partial.
+     * @param {keyof T} [key] - User to that property to add partial payload to ,
+     * @return {*}  {VoidFunction} - Return a cleanup function for removing the stateCreator.
+     */
+    addStateCreator<T>(cb: CreateBookmarkFn<T>, key?: keyof T): VoidFunction;
+
+    /**
+     * Function for resolving a bookmark form api client
+     * @template T - Bookmark Payload type.
+     * @param {string} bookmarkId - bookmark indemnificator.
+     * @returns {Promise<Bookmark<T>>}
+     */
+    getBookmarkById<T>(bookmarkId: string): Promise<Bookmark<T>>;
+
+    /**
+     * Function for resolving all bookmarks for the current sub system.
+     * @return {Observable<Bookmark<T>>} - An observable of the all Bookmarks.
+     */
+    getAllBookmarks(): Observable<Array<Bookmark>>;
+
+    /**
+     * Function for resolving all bookmarks forthe current sub system.
+     * @return {Promise<Array<Bookmark<T><>} - Promise of all Bookmarks
+     */
+    getAllBookmarksAsync(): Promise<Array<Bookmark>>;
+
+    /**
+     * Function for updating bookmark a bookmark when successful this will update the bookmark list.
+     * @template T - Payload Type
+     * @param {string} bookmarkId
+     * @param {Bookmark<T>} bookmark
+     * @return {Observable<Bookmark<T>>} - An observable of the updated Bookmark.
+     */
+    updateBookmark<T>(bookmark: Bookmark<T>): Observable<Bookmark<T>>;
+
+    /**
+     * Function for updating bookmark a bookmark when successful this will update the bookmark list.
+     * @template T - Payload Type
+     * @param {string} bookmarkId
+     * @param {Bookmark<T>} bookmark
+     * @return {Promise<Bookmark<T>>} - Promise of a Bookmark
+     */
+    updateBookmarkAsync<T>(bookmark: Bookmark<T>): Promise<Bookmark<T>>;
+
+    /**
+     * Function for deleting a bookmark, when successful this will update the bookmark list.
+     * @param {string} bookmarkId
+     * @return {Observable<string>} Observable of the deletes BookmarkId
+     */
+    deleteBookmarkById(bookmarkId: string): Observable<string>;
+
+    /**
+     * Function for deleting a bookmark, when successful this will update the bookmark list.
+     * @param {string} bookmarkId
+     * @return {Promise<string>} - Promise of the deleted bookmarkId
+     */
+    deleteBookmarkByIdAsync(bookmarkId: string): Promise<string>;
+
+    /**
+     * Function for setting the current bookmark, when successful this will update the bookmark list.
+     * @template TData - Bookmark payload type.
+     * @param {(string | Bookmark<TData> | undefined)} idOrItem - can be full bookmark object or bookmarkId.
+     * If not provided the current bookmark state will be set to undefined.
+     */
+    setCurrentBookmark<TData>(idOrItem?: string | Bookmark<TData>): void;
+
+    /**
+     * Creates a new bookmark with the given arguments, and utilizes teh provided stateCreator to create the bookmark payload.
+     * @param {{ name: string; description: string; isShared: boolean }} args - Name, Description and isSheared
+     */
+    createBookmark<T>(args: {
+        name: string;
+        description: string;
+        isShared: boolean;
+    }): Promise<Bookmark<T>>;
+
+    /**
+     * A parent provider if configuration if application is needed. A backdoor enabling bookmark configuration in a sub application.
+     * This is not recommence and may result in unwanted behaviors if not used correctly.
+     * @type {IBookmarkModuleProvider}
+     */
+    parentBookmarkProvider?: IBookmarkModuleProvider;
+
+    /**
+     * Record of state creator, is used to collect the state stored in a bookmark.
+     * @type {Record<string, CreateBookmarkFn<unknown>>}
+     */
+    bookmarkCreators: Record<string, CreateBookmarkFn<unknown>>;
+}
+
+export type CreateBookmarkFn<T> = () => Promise<Partial<T>> | Partial<T>;
+
+export class BookmarkModuleProvider implements IBookmarkModuleProvider {
+    protected _bookmarkClient: BookmarkClient;
+
+    #event?: ModuleType<EventModule>;
+
+    config: BookmarkModuleConfig;
+    #subscriptions = new Subscription();
+
+    bookmarkCreators: Record<string | number | symbol, CreateBookmarkFn<unknown>> = {};
+    currentBookmark?: Bookmark<unknown>;
+    parentBookmarkProvider?: IBookmarkModuleProvider;
+
+    public get currentBookmark$() {
+        return this._bookmarkClient.currentBookmark$;
+    }
+
+    public get bookmarks$() {
+        return this._bookmarkClient.bookmarks$;
+    }
+
+    constructor(config: BookmarkModuleConfig, ref?: IBookmarkModuleProvider) {
+        this.config = config;
+        this.#event = config.event;
+        this._bookmarkClient = ref
+            ? (ref as unknown as BookmarkModuleProvider)._bookmarkClient
+            : new BookmarkClient(config.clientConfiguration, config.sourceSystem, config.event);
+
+        const initialBookmarkId = config.resolveBookmarkId && config.resolveBookmarkId();
+
+        if (initialBookmarkId) {
+            this._bookmarkClient.setCurrentBookmark(initialBookmarkId);
+        }
+
+        if (this.#event) {
+            this.#subscriptions.add(
+                this.#event.addEventListener('onCurrentAppChanged', this.#clearStateCreators)
+            );
+        }
+    }
+
+    public async getBookmarkById<T>(bookmarkId: string): Promise<Bookmark<T>> {
+        return await this._bookmarkClient.getBookmarkById<T>(bookmarkId);
+    }
+
+    public async setCurrentBookmark<TData>(idOrItem?: string | Bookmark<TData>): Promise<void> {
+        this._bookmarkClient.setCurrentBookmark(idOrItem);
+    }
+
+    public getAllBookmarks(): Observable<Bookmark<unknown>[]> {
+        return this._bookmarkClient.getAllBookmarks();
+    }
+
+    public async getAllBookmarksAsync(): Promise<Bookmark<unknown>[]> {
+        return this._bookmarkClient.getAllBookmarksAsync();
+    }
+
+    public updateBookmark<T>(bookmark: Bookmark<T>): Observable<Bookmark<T>> {
+        return this._bookmarkClient.updateBookmark<T>(bookmark);
+    }
+
+    public async updateBookmarkAsync<T>(bookmark: Bookmark<T>): Promise<Bookmark<T>> {
+        return this._bookmarkClient.updateBookmarkAsync<T>(bookmark);
+    }
+
+    public deleteBookmarkById(bookmarkId: string): Observable<string> {
+        return this._bookmarkClient.deleteBookmarkById(bookmarkId);
+    }
+
+    public deleteBookmarkByIdAsync(bookmarkId: string): Promise<string> {
+        return this._bookmarkClient.deleteBookmarkByIdAsync(bookmarkId);
+    }
+
+    public addStateCreator<T>(cb: CreateBookmarkFn<T>, key?: keyof T): VoidFunction {
+        const bookmarkCreatorKey = key ? key : '#creator';
+
+        if (this.#event) {
+            this.#event?.dispatchEvent('onAddCreator', {
+                source: this,
+                canBubble: true,
+                detail: { key, cb },
+            });
+        }
+
+        this.bookmarkCreators[bookmarkCreatorKey] = cb;
+        return () => {
+            delete this.bookmarkCreators[bookmarkCreatorKey];
+        };
+    }
+
+    public async createBookmark<T>(args: {
+        name: string;
+        description: string;
+        isShared: boolean;
+    }): Promise<Bookmark<T>> {
+        const payload = await this.#createPayload();
+
+        const contextId = this.config.getContextId && this.config.getContextId();
+        const appKey =
+            this.config.getCurrentAppIdentification && this.config.getCurrentAppIdentification();
+
+        if (!appKey)
+            throw new Error(`There is noe current application selected, can't create bookmark.`);
+
+        const bookmark: CreateBookmark<unknown> = {
+            ...args,
+            appKey,
+            contextId,
+            sourceSystem: this.config.sourceSystem,
+            payload,
+        };
+
+        return this._bookmarkClient.createBookmarkAsync(bookmark) as Promise<Bookmark<T>>;
+    }
+
+    #clearStateCreators = () => {
+        this.bookmarkCreators = {};
+    };
+
+    async #createPayload() {
+        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 await Object.entries(creator).reduce(async (cur, [key, fn]) => {
+            return Object.assign(await cur, { [key]: await fn() });
+        }, Promise.resolve({}));
+    }
+
+    public dispose() {
+        this.#subscriptions.unsubscribe();
+        this._bookmarkClient.dispose();
+    }
+}
+
+declare module '@equinor/fusion-framework-module-event' {
+    interface FrameworkEventMap {
+        /** dispatch before context changes */
+        onNavigateToApp: FrameworkEvent<FrameworkEventInit<URL, IBookmarkModuleProvider>>;
+        onAddCreator: FrameworkEvent<
+            FrameworkEventInit<
+                { cb: CreateBookmarkFn<unknown>; key?: keyof unknown },
+                BookmarkModuleProvider
+            >
+        >;
+    }
+}

package/src/client/bookmarkActions.ts

@@ -0,0 +1,34 @@
+import { createAsyncAction, ActionInstanceMap, ActionTypes } from '@equinor/fusion-observable';
+
+import { Bookmark, CreateBookmark } from '../types';
+
+export const actions = {
+    getAll: createAsyncAction(
+        'getAll',
+        (isValid: boolean) => ({ payload: isValid }),
+        (bookmarks: Bookmark[]) => ({ payload: bookmarks }),
+        (err: unknown) => ({ payload: err })
+    ),
+    delete: createAsyncAction(
+        'delete',
+        (id: string) => ({ payload: id }),
+        (id: string) => ({ payload: id })
+    ),
+    update: createAsyncAction(
+        'update',
+        (bookmark: Bookmark) => ({ payload: bookmark }),
+        (bookmark: Bookmark) => ({ payload: bookmark })
+    ),
+    create: createAsyncAction(
+        'create',
+        (bookmark: CreateBookmark) => ({ payload: bookmark }),
+        (bookmark: Bookmark) => ({ payload: bookmark }),
+        (err: unknown) => ({ payload: err })
+    ),
+};
+
+export type ActionBuilder = typeof actions;
+
+export type ActionMap = ActionInstanceMap<ActionBuilder>;
+
+export type Actions = ActionTypes<typeof actions>;