@equinor/fusion-framework-module-bookmark 1.2.7 → 1.2.8

package/dist/types/bookmark-config-builder.d.ts

@@ -12,12 +12,72 @@ export declare class BookmarkConfigBuilder<TModules extends Array<AnyModule> = [
     constructor(init: TInit, config?: Partial<BookmarkModuleConfig>);
     requireInstance<TKey extends string = Extract<keyof Modules, string>>(module: TKey): Promise<ModuleType<Modules[TKey]>>;
     requireInstance<T>(module: string): Promise<T>;
+    /**
+     *
+     * 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): void;
+    /**
+     * Used to over write the default  Url id resolving.
+     *
+     * @param {(() => string | null)} fn - Resolver for bookmarkId
+     * @memberof BookmarkConfigBuilder
+     */
     setBookmarkIdResolver(fn: () => string | null): void;
+    /**
+     * 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>>): void;
+    /**
+     * Used to over with the default context id resolver.
+     *
+     * @param {(() => string | undefined)} fn - Function for providing current contextId
+     * @memberof BookmarkConfigBuilder
+     */
     setContextIdResolver(fn: () => string | undefined): void;
+    /**
+     * 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): void;
+    /**
+     * 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): void;
+    /**
+     * 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>;

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

@@ -4,28 +4,127 @@ import { BookmarkModuleConfig } from './configurator';
 import { Observable } from 'rxjs';
 import { Bookmark, PatchBookmark, UpdateBookmarkOptions } 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>)}
+     */
     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
+     * @param {UpdateBookmarkOptions} options - optional options that allow for configuration of bookmark payload update.
+     * @return {Promise<Bookmark<T>>} - Promise of a Bookmark
+     */
     updateBookmarkAsync<T>(bookmark: PatchBookmark<T>, options?: UpdateBookmarkOptions): Promise<Bookmark<T> | undefined>;
+    /**
+     * 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 adding external bookmark to user's bookmarks.
+     * @param {string} bookmarkId
+     * @return {Promise<string>} void
+     */
     addBookmarkFavoriteAsync(bookmarkId: string): Promise<void>;
+    /**
+     * Function for removing external bookmark to user's bookmarks.
+     * @param {string} bookmarkId
+     * @return {Promise<void>} - void
+     */
     removeBookmarkFavoriteAsync(bookmarkId: string): Promise<void>;
+    /**
+     * Function for verifying that a bookmark belongs to the current user.
+     * @param {string} bookmarkId
+     * @return {Promise<string>} - void
+     */
     verifyBookmarkFavoriteAsync(bookmarkId: string): Promise<boolean>;
+    /**
+     * 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>;
@@ -60,6 +159,7 @@ export declare class BookmarkModuleProvider implements IBookmarkModuleProvider {
 }
 declare module '@equinor/fusion-framework-module-event' {
     interface FrameworkEventMap {
+        /** dispatch before context changes */
         onNavigateToApp: FrameworkEvent<FrameworkEventInit<URL, IBookmarkModuleProvider>>;
         onAddCreator: FrameworkEvent<FrameworkEventInit<{
             cb: CreateBookmarkFn<unknown>;

package/dist/types/client/bookmarkClient.d.ts

@@ -41,7 +41,9 @@ export declare class BookmarkClient {
 }
 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>>;

package/dist/types/client/bookmarkFlows.d.ts

@@ -8,15 +8,15 @@ export declare const handleBookmarkGetAll: (queryAllBookmarks: Query<Array<Bookm
     payload: Bookmark<unknown>[];
     type: "getAll::success";
 }>;
-export declare const handleCreateBookmark: (apiClient: BookmarksApiClient<'fetch', IHttpClient, unknown>) => (action$: Observable<Actions>) => Observable<{
+export declare const handleCreateBookmark: (apiClient: BookmarksApiClient<"fetch", IHttpClient, unknown>) => (action$: Observable<Actions>) => Observable<{
     payload: Bookmark<unknown>;
     type: "create::success";
 }>;
-export declare const handleUpdateBookmark: (apiClient: BookmarksApiClient<'fetch', IHttpClient, unknown>) => (action$: Observable<Actions>) => Observable<{
+export declare const handleUpdateBookmark: (apiClient: BookmarksApiClient<"fetch", IHttpClient, unknown>) => (action$: Observable<Actions>) => Observable<{
     payload: Bookmark<unknown>;
     type: "update::success";
 }>;
-export declare const handleDeleteBookmark: (apiClient: BookmarksApiClient<'fetch', IHttpClient, unknown>) => (action$: Observable<Actions>) => Observable<{
+export declare const handleDeleteBookmark: (apiClient: BookmarksApiClient<"fetch", IHttpClient, unknown>) => (action$: Observable<Actions>) => Observable<{
     payload: string;
     type: "delete::success";
 }>;

package/dist/types/configurator.d.ts

@@ -8,15 +8,45 @@ import type { EventModule, IEventModuleProvider } from '@equinor/fusion-framewor
 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,

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

@@ -1,4 +1,8 @@
 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;
+/**
+ * Method for enabling Bookmark module
+ * @param configurator - configuration object
+ */
+export declare const enableBookmark: (configurator: IModulesConfigurator<any, any>, builder?: <TDeps extends Array<AnyModule> = []>(builder: BookmarkConfigBuilder<TDeps, ModuleInitializerArgs<IBookmarkModuleConfigurator, TDeps>>) => void | Promise<void>) => void;

package/dist/types/types.d.ts

@@ -18,11 +18,15 @@ export interface Bookmark<TData = unknown> {
     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>;
 };

package/dist/types/version.d.ts

@@ -1 +1 @@
-export declare const version = "1.2.7";
+export declare const version = "1.2.8";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@equinor/fusion-framework-module-bookmark",
-  "version": "1.2.7",
+  "version": "1.2.8",
   "description": "",
   "main": "./dist/esm/index.js",
   "exports": {
@@ -35,17 +35,17 @@
   },
   "dependencies": {
     "rxjs": "^7.8.1",
-    "@equinor/fusion-framework-module": "^4.3.1",
-    "@equinor/fusion-query": "^5.0.5",
-    "@equinor/fusion-observable": "^8.3.2"
+    "@equinor/fusion-framework-module": "^4.3.2",
+    "@equinor/fusion-observable": "^8.3.3",
+    "@equinor/fusion-query": "^5.1.0"
   },
   "devDependencies": {
-    "typescript": "^5.4.2",
-    "@equinor/fusion-framework-module-app": "^5.3.7",
-    "@equinor/fusion-framework-module-context": "^5.0.7",
-    "@equinor/fusion-framework-module-event": "^4.1.2",
-    "@equinor/fusion-framework-module-http": "^6.0.0",
-    "@equinor/fusion-framework-module-services": "^4.1.0"
+    "typescript": "^5.5.3",
+    "@equinor/fusion-framework-module-app": "^5.3.8",
+    "@equinor/fusion-framework-module-event": "^4.2.0",
+    "@equinor/fusion-framework-module-http": "^6.0.1",
+    "@equinor/fusion-framework-module-context": "^5.0.8",
+    "@equinor/fusion-framework-module-services": "^4.1.1"
   },
   "scripts": {
     "build": "tsc -b"

package/src/version.ts

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