@equinor/fusion-framework-module-bookmark 0.1.0

package/src/client/bookmarkClient.ts

@@ -0,0 +1,290 @@
+import {
+    FrameworkEvent,
+    FrameworkEventInit,
+    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 { createState } from '@equinor/fusion-observable';
+import { FlowState } from '@equinor/fusion-observable/src/create-state';
+import Query, { type QueryCtorOptions } from '@equinor/fusion-query';
+
+import { BehaviorSubject, lastValueFrom, map, Observable, Subscription } from 'rxjs';
+
+import {
+    Bookmark,
+    CreateBookmark,
+    GetAllBookmarksParameters,
+    GetBookmarkParameters,
+    SourceSystem,
+} from '../types';
+import { ActionBuilder, actions } from './bookmarkActions';
+import { reducer, State } from './bookmarkReducer';
+import {
+    handleBookmarkGetAll,
+    handleCreateBookmark,
+    handleDeleteBookmark,
+    handleUpdateBookmark,
+} from './bookmarkFlows';
+
+export type BookmarkClientConfig = {
+    client: BookmarksApiClient<'fetch', IHttpClient, Bookmark<unknown>>;
+    queryClientConfig: {
+        getAllBookmarks: QueryCtorOptions<Array<Bookmark<unknown>>, GetAllBookmarksParameters>;
+        getBookmarkById: QueryCtorOptions<Bookmark<unknown>, GetBookmarkParameters>;
+    };
+};
+
+export class BookmarkClient {
+    #queryBookmarkById: Query<Bookmark<unknown>, GetBookmarkParameters>;
+    #queryAllBookmarks: Query<Array<Bookmark<unknown>>, GetAllBookmarksParameters>;
+    #bookmarkAPiClient: BookmarksApiClient<'fetch', IHttpClient, unknown>;
+
+    #currentBookmark$: BehaviorSubject<Bookmark<unknown> | undefined>;
+
+    #sourceSystem: SourceSystem;
+    #event?: IEventModuleProvider;
+
+    #state: FlowState<State, ActionBuilder>;
+    #subscriptions = new Subscription();
+
+    appRoute?(appKey: string): string;
+
+    constructor(
+        config: BookmarkClientConfig,
+        sourceSystem: SourceSystem,
+        event?: IEventModuleProvider
+    ) {
+        this.#currentBookmark$ = new BehaviorSubject<Bookmark<unknown> | undefined>(undefined);
+
+        this.#bookmarkAPiClient = config.client;
+        this.#queryBookmarkById = new Query(config.queryClientConfig.getBookmarkById);
+        this.#queryAllBookmarks = new Query(config.queryClientConfig.getAllBookmarks);
+
+        this.#sourceSystem = sourceSystem;
+        this.#event = event;
+
+        this.#state = createState(actions, reducer);
+
+        // Add Bookmark API calls as flows
+        this.#addSubjectFlows();
+
+        // Add Events to actions success
+        this.#addStateEffects();
+
+        if (event) {
+            this.#subscriptions.add(
+                this.#currentBookmark$.subscribe((bookmark) => {
+                    event.dispatchEvent('onBookmarkChanged', {
+                        detail: bookmark,
+                        canBubble: true,
+                        source: this,
+                    });
+                })
+            );
+        }
+    }
+
+    public get currentBookmark$(): Observable<Bookmark | undefined> {
+        return this.#currentBookmark$.asObservable();
+    }
+
+    public get bookmarks$(): Observable<Bookmark[]> {
+        return this.#state.subject.pipe(
+            map((state) => Object.values(state.bookmarks).map((bookmark) => bookmark))
+        );
+    }
+
+    public async setCurrentBookmark<T>(idOrItem?: string | Bookmark<T>): Promise<void> {
+        if (!idOrItem) {
+            return this.#currentBookmark$.next(undefined);
+        }
+
+        if (typeof idOrItem === 'string') {
+            // TODO add custom error
+            const bookmark = await this.resolverBookmarkAsync<T>(idOrItem);
+            return this.setBookmark(bookmark);
+            // TODO do a deep fast equal, since propagated bookmarks can be of different instances
+        } else if (idOrItem !== this.#currentBookmark$.value) {
+            return this.setBookmark(idOrItem);
+        }
+    }
+
+    public async setBookmark<T>(bookmark?: Bookmark<T>): Promise<void> {
+        if (this.#event) {
+            /** notify that current bookmark is about to change */
+            const event = await this.#event.dispatchEvent('onBookmarkChange', {
+                detail: bookmark,
+                cancelable: true,
+                canBubble: true,
+                source: this,
+            });
+
+            /** check if any listeners requested canceling */
+            if (!event.canceled) {
+                this.#currentBookmark$.next(bookmark);
+            }
+        } else {
+            this.#currentBookmark$.next(bookmark);
+        }
+    }
+
+    public resolverBookmark<T>(bookmarkId: string): Observable<Bookmark<T>> {
+        return this.#queryBookmarkById
+            .query({
+                id: bookmarkId,
+            })
+            .pipe(
+                map((bookmark) => {
+                    return bookmark.value;
+                })
+            ) as Observable<Bookmark<T>>;
+    }
+
+    public resolverBookmarkAsync<T>(bookmarkId: string): Promise<Bookmark<T>> {
+        return lastValueFrom(this.resolverBookmark<T>(bookmarkId));
+    }
+
+    public getAllBookmarks(args = { isValid: false }): Observable<Array<Bookmark>> {
+        const { isValid } = args;
+        return new Observable((subscriber) => {
+            this.#state.dispatch.getAll(isValid);
+            subscriber.add(
+                this.#state.subject.addEffect('getAll::success', (action) => {
+                    subscriber.next(action.payload);
+                    subscriber.complete();
+                })
+            );
+        });
+    }
+
+    public async getAllBookmarksAsync(args = { isValid: false }): Promise<Array<Bookmark>> {
+        return lastValueFrom(this.getAllBookmarks(args));
+    }
+
+    public async getBookmarkById<T>(bookmarkId: string): Promise<Bookmark<T>> {
+        const result = await this.#bookmarkAPiClient.get('v1', { id: bookmarkId });
+        const bookmark = (await result.json()) as Bookmark<T>;
+        return bookmark;
+    }
+
+    public createBookmark(bookmark: CreateBookmark<unknown>): Observable<Bookmark<unknown>> {
+        return new Observable((subscriber) => {
+            this.#state.dispatch.create(bookmark);
+            subscriber.add(
+                this.#state.subject.addEffect('create::success', (action) => {
+                    subscriber.next(action.payload as Bookmark<unknown>);
+                    subscriber.complete();
+                })
+            );
+            subscriber.add(
+                this.#state.subject.addEffect('create::failure', (action) => {
+                    subscriber.error(action.payload);
+                })
+            );
+        });
+    }
+
+    public async createBookmarkAsync(
+        bookmark: CreateBookmark<unknown>
+    ): Promise<Bookmark<unknown>> {
+        return lastValueFrom(this.createBookmark(bookmark));
+    }
+
+    public updateBookmark<T>(bookmark: Bookmark<T>): Observable<Bookmark<T>> {
+        return new Observable((subscriber) => {
+            this.#state.dispatch.update(bookmark);
+            subscriber.add(
+                this.#state.subject.addEffect('update::success', (action) => {
+                    subscriber.next(action.payload as Bookmark<T>);
+                    subscriber.complete();
+                })
+            );
+        });
+    }
+
+    public async updateBookmarkAsync<T>(bookmark: Bookmark<T>): Promise<Bookmark<T>> {
+        return lastValueFrom(this.updateBookmark(bookmark));
+    }
+
+    public deleteBookmarkById(bookmarkId: string): Observable<string> {
+        return new Observable((subscriber) => {
+            this.#state.dispatch.delete(bookmarkId);
+            subscriber.add(
+                this.#state.subject.addEffect('delete::success', (action) => {
+                    subscriber.next(action.payload);
+                    subscriber.complete();
+                })
+            );
+        });
+    }
+
+    public async deleteBookmarkByIdAsync(bookmarkId: string): Promise<string> {
+        return lastValueFrom(this.deleteBookmarkById(bookmarkId));
+    }
+
+    dispose(): void {
+        this.#subscriptions.unsubscribe();
+    }
+
+    #addStateEffects() {
+        this.#state.subject.addEffect('create::success', (action) => {
+            this.#currentBookmark$.next(action.payload);
+            this.#event?.dispatchEvent('onBookmarkCreated', {
+                detail: action.payload,
+                canBubble: true,
+                source: this,
+            });
+        });
+        this.#state.subject.addEffect('delete::success', (action) => {
+            this.#event?.dispatchEvent('onBookmarkDeleted', {
+                detail: action.payload,
+                canBubble: true,
+                source: this,
+            });
+        });
+        this.#state.subject.addEffect('update::success', (action) => {
+            this.#event?.dispatchEvent('onBookmarkUpdated', {
+                detail: action.payload,
+                canBubble: true,
+                source: this,
+            });
+        });
+    }
+
+    #addSubjectFlows() {
+        this.#subscriptions.add(
+            this.#state.subject.addFlow(
+                handleBookmarkGetAll(this.#queryAllBookmarks, this.#sourceSystem.identifier)
+            )
+        );
+        this.#subscriptions.add(
+            this.#state.subject.addFlow(handleCreateBookmark(this.#bookmarkAPiClient))
+        );
+        this.#subscriptions.add(
+            this.#state.subject.addFlow(handleDeleteBookmark(this.#bookmarkAPiClient))
+        );
+        this.#subscriptions.add(
+            this.#state.subject.addFlow(handleUpdateBookmark(this.#bookmarkAPiClient))
+        );
+        this.#subscriptions.add(
+            this.#state.subject.addFlow(handleUpdateBookmark(this.#bookmarkAPiClient))
+        );
+    }
+}
+
+declare module '@equinor/fusion-framework-module-event' {
+    interface FrameworkEventMap {
+        /** dispatch before bookmark changes */
+        onBookmarkChanged: FrameworkEvent<FrameworkEventInit<Bookmark<unknown>, BookmarkClient>>;
+        /** dispatch before bookmarks changes */
+        onBookmarksChanged: FrameworkEvent<
+            FrameworkEventInit<Array<Bookmark<unknown>>, BookmarkClient>
+        >;
+        onBookmarkCreated: FrameworkEvent<FrameworkEventInit<Bookmark<unknown>, BookmarkClient>>;
+        onBookmarkUpdated: FrameworkEvent<FrameworkEventInit<Bookmark<unknown>, BookmarkClient>>;
+        onBookmarkDeleted: FrameworkEvent<FrameworkEventInit<boolean, BookmarkClient>>;
+        onBookmarkResolved: FrameworkEvent<FrameworkEventInit<Bookmark<unknown>, BookmarkClient>>;
+    }
+}

package/src/client/bookmarkFlows.ts

@@ -0,0 +1,66 @@
+import { IHttpClient } from '@equinor/fusion-framework-module-http';
+import { BookmarksApiClient } from '@equinor/fusion-framework-module-services/bookmarks';
+import { Observable } from '@equinor/fusion-observable';
+import { filterAction } from '@equinor/fusion-observable/operators';
+import { Query } from '@equinor/fusion-query';
+import { switchMap, map, catchError, EMPTY } from 'rxjs';
+import { GetAllBookmarksParameters, Bookmark } from '../types';
+import { actions, Actions } from './bookmarkActions';
+
+export const handleBookmarkGetAll =
+    (
+        queryAllBookmarks: Query<Array<Bookmark<unknown>>, GetAllBookmarksParameters>,
+        sourceSystemIdentifier: string
+    ) =>
+    (action$: Observable<Actions>) =>
+        action$.pipe(
+            filterAction(actions.getAll.type),
+            switchMap((action) => {
+                return queryAllBookmarks.query({ isValid: action.payload }).pipe(
+                    map((bookmarks) =>
+                        actions.getAll.success(
+                            bookmarks.value.filter(
+                                (bookmark) =>
+                                    bookmark.sourceSystem.identifier === sourceSystemIdentifier
+                            )
+                        )
+                    ),
+                    catchError(() => EMPTY)
+                );
+            })
+        );
+
+export const handleCreateBookmark =
+    (apiClient: BookmarksApiClient<'fetch', IHttpClient, unknown>) =>
+    (action$: Observable<Actions>) =>
+        action$.pipe(
+            filterAction(actions.create.type),
+            switchMap(async (action) => {
+                const response = await apiClient.post('v1', action.payload);
+                return actions.create.success(await response.json());
+            })
+        );
+
+export const handleUpdateBookmark =
+    (apiClient: BookmarksApiClient<'fetch', IHttpClient, unknown>) =>
+    (action$: Observable<Actions>) =>
+        action$.pipe(
+            filterAction(actions.update.type),
+            switchMap(async (action) => {
+                // Should payload be partial? then api client wil need to change.
+                const response = await apiClient.patch('v1', action.payload);
+                return actions.update.success(await response.json());
+            })
+        );
+
+export const handleDeleteBookmark =
+    (apiClient: BookmarksApiClient<'fetch', IHttpClient, unknown>) =>
+    (action$: Observable<Actions>) =>
+        action$.pipe(
+            filterAction(actions.delete.type),
+            switchMap(async (action) => {
+                const response = await apiClient.delete('v1', { id: action.payload });
+                if (response.ok) return actions.delete.success(action.payload);
+                return actions.delete.success(action.payload);
+            })
+        );

package/src/client/bookmarkReducer.ts

@@ -0,0 +1,29 @@
+import { createReducer } from '@equinor/fusion-observable';
+import { Bookmark } from '../types';
+import { actions } from './bookmarkActions';
+
+export type State = {
+    bookmarks: Record<string, Bookmark>;
+};
+
+const initialState: State = {
+    bookmarks: {},
+};
+
+export const reducer = createReducer<State>(initialState, (builder) => {
+    builder
+        .addCase(actions.create.success, (state, { payload }) => {
+            state.bookmarks[payload.id] = payload;
+        })
+        .addCase(actions.getAll.success, (state, { payload }) => {
+            payload.forEach((bookmark) => {
+                state.bookmarks[bookmark.id] = bookmark;
+            });
+        })
+        .addCase(actions.delete.success, (state, { payload }) => {
+            delete state.bookmarks[payload];
+        })
+        .addCase(actions.update.success, (state, { payload }) => {
+            state.bookmarks[payload.id] = payload;
+        });
+});

package/src/configurator.ts

@@ -0,0 +1,260 @@
+import { getBookmarkIdFormURL } from './utils/handle-url';
+import { BookmarkConfigBuilder, BookmarkConfigBuilderCallback } from './bookmark-config-builder';
+
+import type { ModuleInitializerArgs, ModulesInstanceType } 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 used when creating a new bookmark,
+     *  used as the identifier for the current client. Only used in app shell / portal configuration.
+     */
+    sourceSystem: SourceSystem;
+
+    /**
+     *  The clintConfiguration consist of both Api client configuration and query client configuration
+     */
+    clientConfiguration: BookmarkClientConfig;
+
+    /**
+     * It is possible to associate a Fusion context with a bookmark and this function is used to resolve the current context id applied.
+     * @returns - should return a fusion context id.
+     */
+    getContextId: () => string | undefined;
+
+    /**
+     * A bookmark kan be connected to a application this is used to resolve the current applications appKey.
+     */
+    getCurrentAppIdentification?(): string | undefined;
+
+    /**
+     * The resolves bookmarkId at startup, default configured to resolve id form URL with query parm
+     * ?bookmarkId=GUID but this can be resolved for any where if needed.
+     */
+    resolveBookmarkId?(): string | null;
+
+    /**
+     * default set to Fusion Events Module.
+     */
+    event?: IEventModuleProvider;
+}
+
+export type IBookmarkModuleConfigurator = {
+    /**
+     * @param init BookmarkConfigBuilderCallback for configuring the bookmark module.
+     * Configuration is only needed for application shell / portals.
+     */
+    addConfigBuilder(init: BookmarkConfigBuilderCallback): void;
+    /**
+     * Bookmark Config Factory Providing default configuration if no configuration is provided.
+     * @param init ModuleInitializerArgs<IBookmarkModuleConfigurator, [ServicesModule, AppModule, ContextModule]>
+     * @param parentProvider Parent IBookmarkModuleProvider
+     */
+    createConfig(
+        init: ModuleInitializerArgs<
+            IBookmarkModuleConfigurator,
+            [ServicesModule, AppModule, ContextModule]
+        >,
+        parentProvider?: IBookmarkModuleProvider
+    ): Promise<BookmarkModuleConfig>;
+};
+
+export class BookmarkModuleConfigurator implements IBookmarkModuleConfigurator {
+    defaultExpireTime = 1 * 60 * 1000;
+
+    #configBuilders: Array<BookmarkConfigBuilderCallback> = [];
+
+    addConfigBuilder(init: BookmarkConfigBuilderCallback): void {
+        this.#configBuilders.push(init);
+    }
+
+    async createConfig(
+        init: ModuleInitializerArgs<
+            IBookmarkModuleConfigurator,
+            [ServicesModule, AppModule, ContextModule]
+        >,
+        parentProvider?: IBookmarkModuleProvider
+    ): Promise<BookmarkModuleConfig> {
+        const config: Partial<BookmarkModuleConfig> = await this.#configBuilders.reduce(
+            async (cur, cb) => {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const builder = new BookmarkConfigBuilder<any, any>(init, await cur);
+                await Promise.resolve(cb(builder));
+                return Object.assign(cur, builder.config);
+            },
+            Promise.resolve({} as Partial<BookmarkModuleConfig>)
+        );
+
+        const appProvider = await this._getAppProvider(init);
+
+        this.#applyParentProviderConfiguration(parentProvider, config);
+
+        if (!config.resolveBookmarkId) {
+            config.resolveBookmarkId = getBookmarkIdFormURL;
+        }
+
+        if (!config.getCurrentAppIdentification) {
+            config.getCurrentAppIdentification = () => appProvider.current?.appKey;
+        }
+
+        if (!config.getContextId) {
+            const contextProvider = await this._getContextProvider(init);
+            config.getContextId = () => {
+                return contextProvider.currentContext?.id;
+            };
+        }
+
+        if (!config.event) {
+            const event = await this._getEventProvider(init);
+            config.event = event;
+        }
+
+        config.clientConfiguration = await this._createClientConfiguration(
+            init,
+            config.clientConfiguration
+        );
+
+        if (!config.sourceSystem) {
+            throw Error('missing sourceSystem configuration');
+        }
+
+        return config as BookmarkModuleConfig;
+    }
+
+    #applyParentProviderConfiguration(
+        parentProvider: IBookmarkModuleProvider | undefined,
+        config: Partial<BookmarkModuleConfig>
+    ) {
+        if (parentProvider) {
+            config.clientConfiguration = parentProvider.config.clientConfiguration;
+            config.sourceSystem = parentProvider.config.sourceSystem;
+            config.getContextId = parentProvider.config.getContextId;
+            config.getCurrentAppIdentification = parentProvider.config.getCurrentAppIdentification;
+        }
+    }
+
+    protected async _createClientConfiguration(
+        init: ModuleInitializerArgs<
+            IBookmarkModuleConfigurator,
+            [ServicesModule, AppModule, ContextModule]
+        >,
+        config: Partial<BookmarkClientConfig> = {}
+    ): Promise<BookmarkClientConfig> {
+        if (!config.client) {
+            const apiProvider = await this._getServiceProvider(init);
+            config.client = await apiProvider.createBookmarksClient('fetch');
+        }
+
+        if (!config.queryClientConfig) {
+            const apiProvider = await this._getServiceProvider(init);
+            const bookmarkClient = await apiProvider.createBookmarksClient('json$');
+
+            config.queryClientConfig = {
+                getBookmarkById: {
+                    client: {
+                        fn: (args) => bookmarkClient.get('v1', args),
+                    },
+                    key: ({ id }) => id,
+                    expire: this.defaultExpireTime,
+                },
+                getAllBookmarks: {
+                    client: {
+                        fn: () => bookmarkClient.getAll('v1'),
+                    },
+                    key: () => 'all-bookmarks',
+                    validate: ({ args }) => args.isValid,
+                    expire: this.defaultExpireTime,
+                },
+                ...bookmarkClient,
+            };
+        }
+
+        return config as BookmarkClientConfig;
+    }
+
+    protected async _getServiceProvider(
+        init: ModuleInitializerArgs<IBookmarkModuleConfigurator, [ServicesModule]>
+    ): Promise<IApiProvider> {
+        if (init.hasModule('services')) {
+            return init.requireInstance('services');
+        } else {
+            const parentServiceModule = (init.ref as ModulesInstanceType<[ServicesModule]>)
+                ?.services;
+            if (parentServiceModule) {
+                return parentServiceModule;
+            }
+            throw Error('[BookmarkConfigurator] No service provider configures [ServicesModule] ');
+        }
+    }
+
+    protected async _getContextProvider(
+        init: ModuleInitializerArgs<IBookmarkModuleConfigurator, [ContextModule]>
+    ): Promise<IContextProvider> {
+        if (init.hasModule('context')) {
+            return init.requireInstance('context');
+        } else {
+            const parentContextModule = (init.ref as ModulesInstanceType<[ContextModule]>)?.context;
+            if (parentContextModule) {
+                return parentContextModule;
+            }
+            throw Error('[BookmarkConfigurator] No context provider configures [ContextModule]');
+        }
+    }
+
+    protected async _getAppProvider(
+        init: ModuleInitializerArgs<IBookmarkModuleConfigurator, [AppModule]>
+    ): Promise<AppModuleProvider> {
+        if (init.hasModule('app')) {
+            return init.requireInstance('app');
+        } else {
+            const parentAppModule = (init.ref as ModulesInstanceType<[AppModule]>)?.app;
+            if (parentAppModule) {
+                return parentAppModule;
+            }
+            throw Error('[BookmarkConfigurator] No app provider configures [AppModule]');
+        }
+    }
+    protected async _getEventProvider(
+        init: ModuleInitializerArgs<IBookmarkModuleConfigurator, [EventModule]>
+    ): Promise<IEventModuleProvider> {
+        if (init.hasModule('event')) {
+            return init.requireInstance('event');
+        } else {
+            const parentEventModule = (init.ref as ModulesInstanceType<[EventModule]>)?.event;
+            if (parentEventModule) {
+                return parentEventModule;
+            }
+            throw Error('[BookmarkConfigurator] No event provider configures [EventModule]');
+        }
+    }
+
+    protected async _getNavigationProvider(
+        init: ModuleInitializerArgs<IBookmarkModuleConfigurator, [NavigationModule]>
+    ): Promise<INavigationProvider> {
+        if (init.hasModule('navigation')) {
+            return init.requireInstance('navigation');
+        } else {
+            const parentNavigationModule = (init.ref as ModulesInstanceType<[NavigationModule]>)
+                ?.navigation;
+            if (parentNavigationModule) {
+                return parentNavigationModule;
+            }
+            throw Error(
+                '[BookmarkConfigurator] No navigation provider configures [NavigationModule]'
+            );
+        }
+    }
+}
+
+export default BookmarkModuleConfigurator;

package/src/enable-bookmark.ts

@@ -0,0 +1,32 @@
+import type {
+    AnyModule,
+    IModulesConfigurator,
+    ModuleInitializerArgs,
+} from '@equinor/fusion-framework-module';
+import { BookmarkConfigBuilder } from './bookmark-config-builder';
+
+import { IBookmarkModuleConfigurator } from './configurator';
+
+import { module } from './module';
+
+/**
+ * Method for enabling Bookmark module
+ * @param configurator - configuration object
+ */
+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>
+): void => {
+    configurator.addConfig({
+        module,
+        configure: (contextConfigurator) => {
+            builder && contextConfigurator.addConfigBuilder(builder);
+        },
+    });
+};

package/src/index.ts

@@ -0,0 +1,18 @@
+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';