@equinor/fusion-framework-module-widget 9.0.2 → 9.0.4

package/src/events.ts

@@ -3,73 +3,73 @@ import type { FrameworkEvent, FrameworkEventInit } from '@equinor/fusion-framewo
 import type { Widget } from './Widget';
 
 import type {
-    WidgetConfig,
-    WidgetManifest,
-    WidgetModulesInstance,
-    WidgetScriptModule,
+  WidgetConfig,
+  WidgetManifest,
+  WidgetModulesInstance,
+  WidgetScriptModule,
 } from './types';
 
 /** base event type for applications */
 export type WidgetEventInit<TDetail extends Record<string, unknown> | unknown = unknown> =
-    FrameworkEventInit<
-        /** additional event details and key of target event */
-        TDetail & { name: string },
-        /** source of the event */
-        Widget
-    >;
+  FrameworkEventInit<
+    /** additional event details and key of target event */
+    TDetail & { name: string },
+    /** source of the event */
+    Widget
+  >;
 
 export type WidgetEvent<TDetail extends Record<string, unknown> | unknown = unknown> =
-    FrameworkEvent<WidgetEventInit<TDetail>>;
+  FrameworkEvent<WidgetEventInit<TDetail>>;
 
 export type WidgetEventFailure = FrameworkEvent<
-    WidgetEventInit<{
-        error: WidgetConfig;
-    }>
+  WidgetEventInit<{
+    error: WidgetConfig;
+  }>
 >;
 
 declare module '@equinor/fusion-framework-module-event' {
-    interface FrameworkEventMap {
-        /** fired when the application has initiated its modules */
-        onWidgetModulesLoaded: WidgetEvent<{
-            /** initiated modules for application */
-            modules: WidgetModulesInstance;
-        }>;
+  interface FrameworkEventMap {
+    /** fired when the application has initiated its modules */
+    onWidgetModulesLoaded: WidgetEvent<{
+      /** initiated modules for application */
+      modules: WidgetModulesInstance;
+    }>;
 
-        onWidgetManifestLoad: WidgetEvent;
-        /** fired when the application has loaded corresponding manifest */
-        onWidgetManifestLoaded: WidgetEvent<{
-            manifest: WidgetManifest;
-        }>;
-        onWidgetManifestFailure: WidgetEventFailure;
+    onWidgetManifestLoad: WidgetEvent;
+    /** fired when the application has loaded corresponding manifest */
+    onWidgetManifestLoaded: WidgetEvent<{
+      manifest: WidgetManifest;
+    }>;
+    onWidgetManifestFailure: WidgetEventFailure;
 
-        onWidgetConfigLoad: WidgetEvent;
-        /** fired when the application has loaded corresponding config */
-        onWidgetConfigLoaded: WidgetEvent<{
-            config: WidgetConfig;
-        }>;
-        onWidgetConfigFailure: WidgetEventFailure;
+    onWidgetConfigLoad: WidgetEvent;
+    /** fired when the application has loaded corresponding config */
+    onWidgetConfigLoaded: WidgetEvent<{
+      config: WidgetConfig;
+    }>;
+    onWidgetConfigFailure: WidgetEventFailure;
 
-        /** fired when the application has loaded corresponding javascript module */
-        onAWidgetScriptLoad: WidgetEvent;
-        onWidgetScriptLoaded: WidgetEvent<{
-            script: WidgetScriptModule;
-        }>;
-        onWidgetScriptFailure: WidgetEventFailure;
+    /** fired when the application has loaded corresponding javascript module */
+    onAWidgetScriptLoad: WidgetEvent;
+    onWidgetScriptLoaded: WidgetEvent<{
+      script: WidgetScriptModule;
+    }>;
+    onWidgetScriptFailure: WidgetEventFailure;
 
-        /** fired before application loads manifest, config and script */
-        onWidgetInitialize: WidgetEvent;
+    /** fired before application loads manifest, config and script */
+    onWidgetInitialize: WidgetEvent;
 
-        /**
-         * fired after application has loaded manifest, config and script
-         *
-         * __note:__ not fired until all loaders has settled (last emit)
-         */
-        onWidgetInitialized: WidgetEvent;
+    /**
+     * fired after application has loaded manifest, config and script
+     *
+     * __note:__ not fired until all loaders has settled (last emit)
+     */
+    onWidgetInitialized: WidgetEvent;
 
-        /** fired when application fails to load either manifest, config and script */
-        onWidgetInitializeFailure: WidgetEventFailure;
+    /** fired when application fails to load either manifest, config and script */
+    onWidgetInitializeFailure: WidgetEventFailure;
 
-        /** fired when the application is disposed (unmounts) */
-        onWidgetDispose: FrameworkEvent<WidgetEventInit>;
-    }
+    /** fired when the application is disposed (unmounts) */
+    onWidgetDispose: FrameworkEvent<WidgetEventInit>;
+  }
 }

package/src/module.ts

@@ -1,38 +1,38 @@
-import { Module } from '@equinor/fusion-framework-module';
-import { ModuleDeps } from './types';
+import type { Module } from '@equinor/fusion-framework-module';
+import type { ModuleDeps } from './types';
 
 import { WidgetModuleConfigurator } from './WidgetModuleConfigurator';
-import { IWidgetModuleProvider, WidgetModuleProvider } from './WidgetModuleProvider';
+import { type IWidgetModuleProvider, WidgetModuleProvider } from './WidgetModuleProvider';
 
 export const moduleKey = 'widget';
 
 export type WidgetModule = Module<
-    typeof moduleKey,
-    IWidgetModuleProvider,
-    WidgetModuleConfigurator,
-    ModuleDeps
+  typeof moduleKey,
+  IWidgetModuleProvider,
+  WidgetModuleConfigurator,
+  ModuleDeps
 >;
 
 export const module: WidgetModule = {
-    name: moduleKey,
-    configure() {
-        const config = new WidgetModuleConfigurator();
-        return config;
-    },
-    initialize: async (args) => {
-        const config = await args.config.createConfigAsync(args);
-        const event = await args.requireInstance('event').catch(() => undefined);
-        return new WidgetModuleProvider({ config, event });
-    },
-    dispose: (args) => {
-        (args.instance as unknown as WidgetModuleProvider).dispose();
-    },
+  name: moduleKey,
+  configure() {
+    const config = new WidgetModuleConfigurator();
+    return config;
+  },
+  initialize: async (args) => {
+    const config = await args.config.createConfigAsync(args);
+    const event = await args.requireInstance('event').catch(() => undefined);
+    return new WidgetModuleProvider({ config, event });
+  },
+  dispose: (args) => {
+    (args.instance as unknown as WidgetModuleProvider).dispose();
+  },
 };
 
 export default module;
 
 declare module '@equinor/fusion-framework-module' {
-    interface Modules {
-        [moduleKey]: WidgetModule;
-    }
+  interface Modules {
+    [moduleKey]: WidgetModule;
+  }
 }

package/src/state/actions.ts

@@ -1,64 +1,64 @@
 import {
-    ActionInstanceMap,
-    ActionTypes,
-    createAction,
-    createAsyncAction,
+  type ActionInstanceMap,
+  type ActionTypes,
+  createAction,
+  createAsyncAction,
 } from '@equinor/fusion-observable';
-import {
-    GetWidgetParameters,
-    WidgetConfig,
-    WidgetManifest,
-    WidgetModulesInstance,
-    WidgetScriptModule,
+import type {
+  GetWidgetParameters,
+  WidgetConfig,
+  WidgetManifest,
+  WidgetModulesInstance,
+  WidgetScriptModule,
 } from '../types';
 
 const createActions = () => ({
-    /** Manifest loading */
-    setManifest: createAction('set_manifest', (manifest: WidgetManifest, update?: boolean) => ({
-        payload: manifest,
-        meta: {
-            created: Date.now(),
-            update,
-        },
-    })),
-    fetchManifest: createAsyncAction(
-        'fetch_manifest',
-        (payload: { key: string; args?: GetWidgetParameters['args'] }, update?: boolean) => ({
-            payload,
-            meta: { update },
-        }),
-        (manifest: WidgetManifest) => ({ payload: manifest }),
-        (error: unknown) => ({ payload: error }),
-    ),
-    /** Config loading */
-    setConfig: createAction('set_config', (config: WidgetConfig) => ({ payload: config })),
-    fetchConfig: createAsyncAction(
-        'fetch_config',
-        (payload: { key: string; args?: GetWidgetParameters['args'] }, update?: boolean) => ({
-            payload,
-            meta: { update },
-        }),
-        (config: WidgetConfig) => ({ payload: config }),
-        (error: unknown) => ({ payload: error }),
-    ),
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    setModule: createAction('set_module', (module: any) => ({ payload: module })),
-    importWidget: createAsyncAction(
-        'import_widget',
-        (entrypoint: string) => ({ payload: entrypoint }),
-        (module: WidgetScriptModule) => ({ payload: module }),
-        (error: unknown) => ({ payload: error }),
-    ),
-    // widget Instance
-    setInstance: createAction('set_instance', (instance: WidgetModulesInstance) => ({
-        payload: instance,
-    })),
-    initialize: createAsyncAction(
-        'initialize_widget',
-        () => ({ payload: null }),
-        () => ({ payload: null }),
-        (error: unknown) => ({ payload: error }),
-    ),
+  /** Manifest loading */
+  setManifest: createAction('set_manifest', (manifest: WidgetManifest, update?: boolean) => ({
+    payload: manifest,
+    meta: {
+      created: Date.now(),
+      update,
+    },
+  })),
+  fetchManifest: createAsyncAction(
+    'fetch_manifest',
+    (payload: { key: string; args?: GetWidgetParameters['args'] }, update?: boolean) => ({
+      payload,
+      meta: { update },
+    }),
+    (manifest: WidgetManifest) => ({ payload: manifest }),
+    (error: unknown) => ({ payload: error }),
+  ),
+  /** Config loading */
+  setConfig: createAction('set_config', (config: WidgetConfig) => ({ payload: config })),
+  fetchConfig: createAsyncAction(
+    'fetch_config',
+    (payload: { key: string; args?: GetWidgetParameters['args'] }, update?: boolean) => ({
+      payload,
+      meta: { update },
+    }),
+    (config: WidgetConfig) => ({ payload: config }),
+    (error: unknown) => ({ payload: error }),
+  ),
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  setModule: createAction('set_module', (module: any) => ({ payload: module })),
+  importWidget: createAsyncAction(
+    'import_widget',
+    (entrypoint: string) => ({ payload: entrypoint }),
+    (module: WidgetScriptModule) => ({ payload: module }),
+    (error: unknown) => ({ payload: error }),
+  ),
+  // widget Instance
+  setInstance: createAction('set_instance', (instance: WidgetModulesInstance) => ({
+    payload: instance,
+  })),
+  initialize: createAsyncAction(
+    'initialize_widget',
+    () => ({ payload: null }),
+    () => ({ payload: null }),
+    (error: unknown) => ({ payload: error }),
+  ),
 });
 
 export const actions = createActions();

package/src/state/create-reducer.ts

@@ -1,44 +1,44 @@
 import {
-    getBaseType,
-    createReducer as makeReducer,
-    isCompleteAction,
-    isRequestAction,
+  getBaseType,
+  createReducer as makeReducer,
+  isCompleteAction,
+  isRequestAction,
 } from '@equinor/fusion-observable';
 
 import { enableMapSet } from 'immer';
 
 enableMapSet();
 
-import { Actions, actions } from './actions';
-import { WidgetStateInitial, WidgetState } from '../types';
+import { type Actions, actions } from './actions';
+import type { WidgetStateInitial, WidgetState } from '../types';
 
 export const createReducer = (value: WidgetStateInitial) =>
-    makeReducer<WidgetState, Actions>({ ...value, status: new Set() } as WidgetState, (builder) =>
-        builder
-            .addCase(actions.setManifest, (state, action) => {
-                if (action.meta.update) {
-                    state.manifest = { ...state.manifest, ...action.payload };
-                } else {
-                    state.manifest = action.payload;
-                }
-            })
-            .addCase(actions.setConfig, (state, action) => {
-                state.config = action.payload;
-            })
-            .addCase(actions.setModule, (state, action) => {
-                state.modules = action.payload;
-            })
-            .addCase(actions.setInstance, (state, action) => {
-                state.instance = action.payload;
-            })
-            /** mark status as loading {{type}} */
-            .addMatcher(isRequestAction, (state, action) => {
-                state.status.add(getBaseType(action.type));
-            })
-            /** clear status {{type}} */
-            .addMatcher(isCompleteAction, (state, action) => {
-                state.status.delete(getBaseType(action.type));
-            }),
-    );
+  makeReducer<WidgetState, Actions>({ ...value, status: new Set() } as WidgetState, (builder) =>
+    builder
+      .addCase(actions.setManifest, (state, action) => {
+        if (action.meta.update) {
+          state.manifest = { ...state.manifest, ...action.payload };
+        } else {
+          state.manifest = action.payload;
+        }
+      })
+      .addCase(actions.setConfig, (state, action) => {
+        state.config = action.payload;
+      })
+      .addCase(actions.setModule, (state, action) => {
+        state.modules = action.payload;
+      })
+      .addCase(actions.setInstance, (state, action) => {
+        state.instance = action.payload;
+      })
+      /** mark status as loading {{type}} */
+      .addMatcher(isRequestAction, (state, action) => {
+        state.status.add(getBaseType(action.type));
+      })
+      /** clear status {{type}} */
+      .addMatcher(isCompleteAction, (state, action) => {
+        state.status.delete(getBaseType(action.type));
+      }),
+  );
 
 export default createReducer;

package/src/state/create-state.ts

@@ -5,17 +5,17 @@ import { createReducer } from './create-reducer';
 import { handleFetchManifest, handleImportWidget, handleFetchConfig } from './flows';
 
 import type { Actions } from './actions';
-import { WidgetState, WidgetStateInitial } from '../types';
-import WidgetModuleProvider from '../WidgetModuleProvider';
+import type { WidgetState, WidgetStateInitial } from '../types';
+import type WidgetModuleProvider from '../WidgetModuleProvider';
 
 export const createState = (
-    value: WidgetStateInitial,
-    provider: WidgetModuleProvider,
+  value: WidgetStateInitial,
+  provider: WidgetModuleProvider,
 ): FlowSubject<WidgetState, Actions> => {
-    const reducer = createReducer(value);
-    const state = new FlowSubject<WidgetState, Actions>(reducer);
-    state.addFlow(handleFetchManifest(provider));
-    state.addFlow(handleImportWidget());
-    state.addFlow(handleFetchConfig(provider));
-    return state;
+  const reducer = createReducer(value);
+  const state = new FlowSubject<WidgetState, Actions>(reducer);
+  state.addFlow(handleFetchManifest(provider));
+  state.addFlow(handleImportWidget());
+  state.addFlow(handleFetchConfig(provider));
+  return state;
 };

package/src/state/flows.ts

@@ -6,70 +6,70 @@ import { actions } from './actions';
 import type { Flow } from '@equinor/fusion-observable';
 
 import type { Actions } from './actions';
-import { WidgetState } from '../types';
+import type { WidgetState } from '../types';
 import type WidgetModuleProvider from '../WidgetModuleProvider';
 
 export const handleFetchManifest =
-    (provider: WidgetModuleProvider): Flow<Actions, WidgetState> =>
-    (action$) =>
-        action$.pipe(
-            filter(actions.fetchManifest.match),
-            switchMap((action) => {
-                const {
-                    payload: { key, args },
-                    meta: { update },
-                } = action;
+  (provider: WidgetModuleProvider): Flow<Actions, WidgetState> =>
+  (action$) =>
+    action$.pipe(
+      filter(actions.fetchManifest.match),
+      switchMap((action) => {
+        const {
+          payload: { key, args },
+          meta: { update },
+        } = action;
 
-                const subject = from(provider.getWidgetManifest(key, args)).pipe(
-                    filter((x) => !!x),
-                    share(),
-                );
-                return concat(
-                    subject.pipe(map((manifest) => actions.setManifest(manifest, update))),
-                    subject.pipe(
-                        last(),
-                        map((manifest) => actions.fetchManifest.success(manifest)),
-                    ),
-                ).pipe(
-                    catchError((err) => {
-                        console.error(err, action.payload);
-                        return of(actions.fetchManifest.failure(err));
-                    }),
-                );
-            }),
+        const subject = from(provider.getWidgetManifest(key, args)).pipe(
+          filter((x) => !!x),
+          share(),
+        );
+        return concat(
+          subject.pipe(map((manifest) => actions.setManifest(manifest, update))),
+          subject.pipe(
+            last(),
+            map((manifest) => actions.fetchManifest.success(manifest)),
+          ),
+        ).pipe(
+          catchError((err) => {
+            console.error(err, action.payload);
+            return of(actions.fetchManifest.failure(err));
+          }),
         );
+      }),
+    );
 
 export const handleFetchConfig =
-    (provider: WidgetModuleProvider): Flow<Actions, WidgetState> =>
-    (action$) =>
-        action$.pipe(
-            filter(actions.fetchConfig.match),
-            switchMap(({ payload: { key, args } }) => {
-                const subject = from(provider.getWidgetConfig(key, args)).pipe(
-                    filter((x) => !!x),
-                    share(),
-                );
-                return concat(
-                    subject.pipe(map((manifest) => actions.setConfig(manifest))),
-                    subject.pipe(
-                        last(),
-                        map((manifest) => actions.fetchConfig.success(manifest)),
-                    ),
-                ).pipe(
-                    catchError((err) => {
-                        return of(actions.fetchConfig.failure(err));
-                    }),
-                );
-            }),
+  (provider: WidgetModuleProvider): Flow<Actions, WidgetState> =>
+  (action$) =>
+    action$.pipe(
+      filter(actions.fetchConfig.match),
+      switchMap(({ payload: { key, args } }) => {
+        const subject = from(provider.getWidgetConfig(key, args)).pipe(
+          filter((x) => !!x),
+          share(),
         );
+        return concat(
+          subject.pipe(map((manifest) => actions.setConfig(manifest))),
+          subject.pipe(
+            last(),
+            map((manifest) => actions.fetchConfig.success(manifest)),
+          ),
+        ).pipe(
+          catchError((err) => {
+            return of(actions.fetchConfig.failure(err));
+          }),
+        );
+      }),
+    );
 
 export const handleImportWidget = (): Flow<Actions, WidgetState> => (action$) =>
-    action$.pipe(
-        filter(actions.importWidget.match),
-        switchMap(({ payload }) => {
-            return from(import(/* @vite-ignore */ payload)).pipe(
-                map(actions.importWidget.success),
-                catchError((err) => of(actions.importWidget.failure(err))),
-            );
-        }),
-    );
+  action$.pipe(
+    filter(actions.importWidget.match),
+    switchMap(({ payload }) => {
+      return from(import(/* @vite-ignore */ payload)).pipe(
+        map(actions.importWidget.success),
+        catchError((err) => of(actions.importWidget.failure(err))),
+      );
+    }),
+  );