@equinor/fusion-framework-module-app 5.2.13 → 5.2.14

package/src/app/flows.ts

@@ -8,20 +8,35 @@ import type { AppModuleProvider } from '../AppModuleProvider';
 import type { Actions } from './actions';
 import type { AppBundleState } from './types';
 
+/**
+ * Handles the fetch manifest action by fetching the app manifest from the provider,
+ * dispatching success or failure actions based on the result.
+ *
+ * @param provider The AppModuleProvider used to fetch the app manifest.
+ * @returns A Flow function that takes an Observable of actions and returns an Observable of actions.
+ */
 export const handleFetchManifest =
     (provider: AppModuleProvider): Flow<Actions, AppBundleState> =>
     (action$) =>
         action$.pipe(
+            // only handle fetch manifest request actions
             filter(actions.fetchManifest.match),
+            // when request is received, abort any ongoing request and start new
             switchMap((action) => {
                 const {
                     payload: appKey,
                     meta: { update },
                 } = action;
+
+                // fetch manifest from provider
                 const subject = from(provider.getAppManifest(appKey)).pipe(
+                    // filter out null values
                     filter((x) => !!x),
+                    // allow multiple subscriptions
                     share(),
                 );
+
+                // first load manifest and then dispatch success action
                 return concat(
                     subject.pipe(map((manifest) => actions.setManifest(manifest, update))),
                     subject.pipe(
@@ -29,6 +44,7 @@ export const handleFetchManifest =
                         map((manifest) => actions.fetchManifest.success(manifest)),
                     ),
                 ).pipe(
+                    // catch any error and dispatch failure action
                     catchError((err) => {
                         return of(actions.fetchManifest.failure(err));
                     }),
@@ -36,16 +52,29 @@ export const handleFetchManifest =
             }),
         );
 
+/**
+ * Handles the fetch config action by fetching the app configuration from the provider,
+ * filtering out null values, and dispatching success or failure actions accordingly.
+ *
+ * @param provider The AppModuleProvider used to fetch the app configuration.
+ * @returns A Flow function that takes an Observable of actions and returns an Observable of actions.
+ */
 export const handleFetchConfig =
     (provider: AppModuleProvider): Flow<Actions, AppBundleState> =>
     (action$) =>
         action$.pipe(
+            // only handle fetch config request actions
             filter(actions.fetchConfig.match),
+            // when request is received, abort any ongoing request and start new
             switchMap(({ payload: appKey }) => {
+                // fetch manifest from provider
                 const subject = from(provider.getAppConfig(appKey)).pipe(
+                    // filter out null values
                     filter((x) => !!x),
+                    // allow multiple subscriptions
                     share(),
                 );
+                // first load manifest and then dispatch success action
                 return concat(
                     subject.pipe(map((manifest) => actions.setConfig(manifest))),
                     subject.pipe(
@@ -53,6 +82,7 @@ export const handleFetchConfig =
                         map((manifest) => actions.fetchConfig.success(manifest)),
                     ),
                 ).pipe(
+                    // catch any error and dispatch failure action
                     catchError((err) => {
                         return of(actions.fetchConfig.failure(err));
                     }),
@@ -60,12 +90,21 @@ export const handleFetchConfig =
             }),
         );
 
+/**
+ * Handles the import application flow.
+ * @returns A flow that takes in actions and returns an observable of AppBundleState.
+ */
 export const handleImportApplication = (): Flow<Actions, AppBundleState> => (action$) =>
     action$.pipe(
+        // only handle import script request actions
         filter(actions.importApp.match),
+        // when request is received, abort any ongoing request and start new
         switchMap(({ payload }) => {
+            // dynamically import the application script
             return from(import(payload)).pipe(
+                // dispatch success action
                 map(actions.importApp.success),
+                // catch any error and dispatch failure action
                 catchError((err) => of(actions.importApp.failure(err))),
             );
         }),

package/src/errors.ts

@@ -1,6 +1,15 @@
 type AppErrorType = 'not_found' | 'unauthorized' | 'unknown';
 
+/**
+ * Represents an error that occurs when loading an application manifest.
+ */
 export class AppManifestError extends Error {
+    /**
+     * Creates an instance of AppManifestError based on the HTTP response status.
+     * @param response The HTTP response.
+     * @param options Optional error options.
+     * @returns An instance of AppManifestError.
+     */
     static fromHttpResponse(response: Response, options?: ErrorOptions) {
         switch (response.status) {
             case 401:
@@ -18,6 +27,13 @@ export class AppManifestError extends Error {
             options,
         );
     }
+
+    /**
+     * Creates an instance of AppManifestError.
+     * @param type The type of the error.
+     * @param message The error message.
+     * @param options Optional error options.
+     */
     constructor(
         public readonly type: AppErrorType,
         message?: string,
@@ -27,8 +43,17 @@ export class AppManifestError extends Error {
     }
 }
 
+/**
+ * Represents an error that occurs in the application configuration.
+ */
 export class AppConfigError extends Error {
-    static fromHttpResponse(response: Response, options?: ErrorOptions) {
+    /**
+     * Creates an instance of `AppConfigError` based on the HTTP response status.
+     * @param response The HTTP response.
+     * @param options Additional error options.
+     * @returns An instance of `AppConfigError` based on the HTTP response status.
+     */
+    static fromHttpResponse(response: Response, options?: ErrorOptions): AppConfigError {
         switch (response.status) {
             case 401:
                 return new AppConfigError(
@@ -45,6 +70,13 @@ export class AppConfigError extends Error {
             options,
         );
     }
+
+    /**
+     * Creates an instance of `AppConfigError`.
+     * @param type The type of the application error.
+     * @param message The error message.
+     * @param options Additional error options.
+     */
     constructor(
         public readonly type: AppErrorType,
         message?: string,
@@ -54,7 +86,16 @@ export class AppConfigError extends Error {
     }
 }
 
+/**
+ * Represents an error that occurs when loading the application script.
+ */
 export class AppScriptModuleError extends Error {
+    /**
+     * Creates a new instance of the AppScriptModuleError class.
+     * @param type The type of the error.
+     * @param message The error message.
+     * @param options Additional options for the error.
+     */
     constructor(
         public readonly type: AppErrorType,
         message?: string,

package/src/helpers.ts

@@ -1,4 +1,17 @@
 import { AppManifest } from './types';
 
-export const compareAppManifest = <T extends AppManifest>(a?: T, b?: T): boolean =>
-    JSON.stringify(a) === JSON.stringify(b);
+// manifest properties to compare
+const compareKey: Array<keyof AppManifest> = ['key', 'version'];
+
+/**
+ * Compares two app manifests for equality.
+ *
+ * @template T - The type of the app manifest.
+ * @param a - The first app manifest.
+ * @param b - The second app manifest.
+ * @returns True if the app manifests are equal, false otherwise.
+ */
+export const compareAppManifest = <T extends AppManifest>(a?: T, b?: T): boolean => {
+    // use compareKey to compare only the keys that are important for equality
+    return compareKey.every((key) => a?.[key] === b?.[key]);
+};

package/src/module.ts

@@ -8,14 +8,35 @@ export const moduleKey = 'app';
 
 export type AppModule = Module<typeof moduleKey, AppModuleProvider, IAppConfigurator, ModuleDeps>;
 
+/**
+ * Represents a module for handling applications.
+ * Responsible for loading applications, configurations and manifests.
+ * @public
+ */
 export const module: AppModule = {
+    /**
+     * The name of the module.
+     */
     name: moduleKey,
+    /**
+     * Configures the module.
+     * @returns An instance of AppConfigurator.
+     */
     configure: () => new AppConfigurator(),
+    /**
+     * Initializes the module.
+     * @param args - The initialization arguments.
+     * @returns A new instance of AppModuleProvider.
+     */
     initialize: async (args) => {
         const config = await (args.config as AppConfigurator).createConfig(args);
         const event = await args.requireInstance('event').catch(() => undefined);
         return new AppModuleProvider({ config, event });
     },
+    /**
+     * Disposes the module.
+     * @param args - The disposal arguments.
+     */
     dispose: (args) => {
         (args.instance as unknown as AppModuleProvider).dispose();
     },

package/src/version.ts

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