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

package/src/client/bookmarkClient.ts

@@ -1,327 +0,0 @@
-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, FlowState } from '@equinor/fusion-observable';
-import Query, { type QueryCtorOptions } from '@equinor/fusion-query';
-
-import { BehaviorSubject, lastValueFrom, map, Observable, Subscription } from 'rxjs';
-
-import {
-    Bookmark,
-    CreateBookmark,
-    GetAllBookmarksParameters,
-    GetBookmarkParameters,
-    PatchBookmark,
-    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();
-
-                    this.#event?.dispatchEvent('onBookmarksChanged', {
-                        detail: action.payload,
-                        source: this,
-                    });
-                }),
-            );
-        });
-    }
-
-    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: PatchBookmark<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();
-                    this.#queryBookmarkById.cache.invalidate(action.payload.id);
-                }),
-            );
-        });
-    }
-
-    public async updateBookmarkAsync<T>(bookmark: PatchBookmark<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();
-                    this.#queryBookmarkById.cache.invalidate(action.payload);
-                }),
-            );
-        });
-    }
-
-    public async deleteBookmarkByIdAsync(bookmarkId: string): Promise<string> {
-        return lastValueFrom(this.deleteBookmarkById(bookmarkId));
-    }
-
-    public async addBookmarkFavoriteAsync(bookmarkId: string): Promise<void> {
-        const response = await this.#bookmarkAPiClient.addFavorite('v1', { bookmarkId });
-        if (response.ok && this.#currentBookmark$.value) {
-            this.#state.dispatch.addFavorite(this.#currentBookmark$.value);
-        }
-    }
-
-    public async removeBookmarkFavoriteAsync(bookmarkId: string): Promise<void> {
-        const response = await this.#bookmarkAPiClient.removeFavorite('v1', { bookmarkId });
-        if (response.ok) {
-            this.#state.dispatch.removeFavorite(bookmarkId);
-        }
-    }
-
-    public async verifyBookmarkFavoriteAsync(bookmarkId: string): Promise<boolean> {
-        const response = await this.#bookmarkAPiClient.verifyFavorite('v1', { bookmarkId });
-        if (response.ok) return true;
-        return false;
-    }
-
-    dispose(): void {
-        this.#subscriptions.unsubscribe();
-    }
-
-    #addStateEffects() {
-        this.#state.subject.addEffect('create::success', (action) => {
-            this.#queryAllBookmarks.cache.invalidate('all-bookmarks');
-            this.#event?.dispatchEvent('onBookmarkCreated', {
-                detail: action.payload,
-                canBubble: true,
-                source: this,
-            });
-        });
-        this.#state.subject.addEffect('delete::success', (action) => {
-            console.log('here');
-            this.#queryAllBookmarks.cache.invalidate('all-bookmarks');
-            this.#event?.dispatchEvent('onBookmarkDeleted', {
-                detail: action.payload,
-                canBubble: true,
-                source: this,
-            });
-        });
-        this.#state.subject.addEffect('update::success', (action) => {
-            this.#queryAllBookmarks.cache.invalidate('all-bookmarks');
-            this.#event?.dispatchEvent('onBookmarkUpdated', {
-                detail: action.payload,
-                canBubble: true,
-                source: this,
-            });
-        });
-        this.#state.subject.addEffect('addFavorite::request', () => {
-            this.#queryAllBookmarks.cache.invalidate('all-bookmarks');
-        });
-
-        this.#state.subject.addEffect('removeFavorite::request', () => {
-            this.#queryAllBookmarks.cache.invalidate('all-bookmarks');
-        });
-    }
-
-    #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

@@ -1,67 +0,0 @@
-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, last } 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(
-                    last(),
-                    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

@@ -1,35 +0,0 @@
-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.removeFavorite, (state, { payload }) => {
-            delete state.bookmarks[payload];
-        })
-        .addCase(actions.addFavorite, (state, { payload }) => {
-            state.bookmarks[payload.id] = payload;
-        })
-        .addCase(actions.update.success, (state, { payload }) => {
-            state.bookmarks[payload.id] = payload;
-        });
-});

package/src/configurator.ts

@@ -1,235 +0,0 @@
-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 { 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,
-        );
-
-        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]');
-        }
-    }
-}
-
-export default BookmarkModuleConfigurator;