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

package/src/WidgetModuleConfigurator.ts

@@ -1,67 +1,67 @@
 import { BaseConfigBuilder, type ConfigBuilderCallback } from '@equinor/fusion-framework-module';
-import { ConfigBuilderCallbackArgs } from '@equinor/fusion-framework-module';
+import type { ConfigBuilderCallbackArgs } from '@equinor/fusion-framework-module';
 import { createDefaultClient } from './utils';
 import type { IClient } from './types';
 
 // Define the configuration type for the WidgetModule
 export type WidgetModuleConfig = {
-    client: IClient;
+  client: IClient;
 };
 
 // Define a callback type for configuring the WidgetModule
 export type WidgetModuleConfigBuilderCallback = (
-    builder: WidgetModuleConfigurator,
+  builder: WidgetModuleConfigurator,
 ) => void | Promise<void>;
 
 // Class responsible for configuring the WidgetModule
 export class WidgetModuleConfigurator extends BaseConfigBuilder<WidgetModuleConfig> {
-    // Default expiration time for configurations (1 minute)
-    defaultExpireTime = 1 * 60 * 1000;
+  // Default expiration time for configurations (1 minute)
+  defaultExpireTime = 1 * 60 * 1000;
 
-    /**
-     * Set the client for the WidgetModule configuration.
-     * @param cb - Callback function to configure the client.
-     */
-    public setClient(cb: ConfigBuilderCallback<IClient>) {
-        this._set('client', cb);
-    }
+  /**
+   * Set the client for the WidgetModule configuration.
+   * @param cb - Callback function to configure the client.
+   */
+  public setClient(cb: ConfigBuilderCallback<IClient>) {
+    this._set('client', cb);
+  }
 
-    /**
-     * Create an HTTP client based on the provided parameters.
-     * @param clientId - Identifier for the client.
-     * @param init - Configuration builder callback arguments.
-     * @returns An instance of the HTTP client.
-     */
-    private async _createHttpClient(clientId: string, init: ConfigBuilderCallbackArgs) {
-        const http = await init.requireInstance('http');
+  /**
+   * Create an HTTP client based on the provided parameters.
+   * @param clientId - Identifier for the client.
+   * @param init - Configuration builder callback arguments.
+   * @returns An instance of the HTTP client.
+   */
+  private async _createHttpClient(clientId: string, init: ConfigBuilderCallbackArgs) {
+    const http = await init.requireInstance('http');
 
-        if (http.hasClient(clientId)) {
-            return http.createClient(clientId);
-        } else {
-            /** load service discovery module */
-            const serviceDiscovery = await init.requireInstance('serviceDiscovery');
-            return await serviceDiscovery.createClient(clientId);
-        }
+    if (http.hasClient(clientId)) {
+      return http.createClient(clientId);
+    } else {
+      /** load service discovery module */
+      const serviceDiscovery = await init.requireInstance('serviceDiscovery');
+      return await serviceDiscovery.createClient(clientId);
     }
+  }
 
-    /**
-     * Process the WidgetModule configuration and create an HTTP client if needed.
-     * @param config - Partial configuration for the WidgetModule.
-     * @param _init - Configuration builder callback arguments.
-     * @returns The processed WidgetModule configuration.
-     */
-    protected async _processConfig(
-        config: Partial<WidgetModuleConfig>,
-        _init: ConfigBuilderCallbackArgs,
-    ) {
-        // Create an HTTP client using the specified client ID and initialization parameters
-        const httpClient = await this._createHttpClient('apps', _init);
+  /**
+   * Process the WidgetModule configuration and create an HTTP client if needed.
+   * @param config - Partial configuration for the WidgetModule.
+   * @param _init - Configuration builder callback arguments.
+   * @returns The processed WidgetModule configuration.
+   */
+  protected async _processConfig(
+    config: Partial<WidgetModuleConfig>,
+    _init: ConfigBuilderCallbackArgs,
+  ) {
+    // Create an HTTP client using the specified client ID and initialization parameters
+    const httpClient = await this._createHttpClient('apps', _init);
 
-        // If the configuration does not have a client, use the default client
-        if (!config.client) {
-            config.client = createDefaultClient(httpClient);
-        }
-        // Return the processed configuration as a WidgetModuleConfig object
-        return config as WidgetModuleConfig;
+    // If the configuration does not have a client, use the default client
+    if (!config.client) {
+      config.client = createDefaultClient(httpClient);
     }
+    // Return the processed configuration as a WidgetModuleConfig object
+    return config as WidgetModuleConfig;
+  }
 }

package/src/WidgetModuleProvider.ts

@@ -1,164 +1,164 @@
-import { catchError, Observable, Subscription } from 'rxjs';
+import { catchError, type Observable, Subscription } from 'rxjs';
 
-import { ModuleType } from '@equinor/fusion-framework-module';
+import type { ModuleType } from '@equinor/fusion-framework-module';
 import { HttpResponseError } from '@equinor/fusion-framework-module-http';
-import { EventModule } from '@equinor/fusion-framework-module-event';
+import type { EventModule } from '@equinor/fusion-framework-module-event';
 
 import { Query } from '@equinor/fusion-query';
 
 import type { GetWidgetParameters, WidgetConfig, WidgetManifest } from './types';
 
-import { WidgetModuleConfig } from './WidgetModuleConfigurator';
+import type { WidgetModuleConfig } from './WidgetModuleConfigurator';
 import { WidgetManifestLoadError, WidgetConfigLoadError } from './errors';
 import { Widget } from './Widget';
 
 export interface IWidgetModuleProvider {
-    getWidget(
-        widgetKey: GetWidgetParameters['widgetKey'],
-        args?: GetWidgetParameters['args'],
-    ): Widget;
-    getWidgetManifest(
-        widgetKey: GetWidgetParameters['widgetKey'],
-        args?: GetWidgetParameters['args'],
-    ): Observable<WidgetManifest>;
-    getWidgetConfig(
-        widgetKey: GetWidgetParameters['widgetKey'],
-        args?: GetWidgetParameters['args'],
-    ): Observable<WidgetConfig>;
+  getWidget(
+    widgetKey: GetWidgetParameters['widgetKey'],
+    args?: GetWidgetParameters['args'],
+  ): Widget;
+  getWidgetManifest(
+    widgetKey: GetWidgetParameters['widgetKey'],
+    args?: GetWidgetParameters['args'],
+  ): Observable<WidgetManifest>;
+  getWidgetConfig(
+    widgetKey: GetWidgetParameters['widgetKey'],
+    args?: GetWidgetParameters['args'],
+  ): Observable<WidgetConfig>;
 }
 
 /**
  * The `WidgetModuleProvider` class implements the `IWidgetModuleProvider` interface and serves as a provider for managing widgets.
  */
 export class WidgetModuleProvider implements IWidgetModuleProvider {
-    // Private fields
-    #subscription = new Subscription();
-    #config: WidgetModuleConfig;
-    #event?: ModuleType<EventModule>;
-
-    /**
-     * Constructs a new `WidgetModuleProvider` instance.
-     * @param args - An object containing configuration and optional event module for the widget provider.
-     */
-    constructor(args: { config: WidgetModuleConfig; event?: ModuleType<EventModule> }) {
-        const { config, event } = args;
-        this.#event = event;
-        this.#config = config;
-    }
-
-    /**
-     * Retrieves a widget instance based on the provided name and optional parameters.
-     * @param name - The name of the widget.
-     * @param widgetParams - Optional parameters for the widget.
-     * @returns A new `Widget` instance.
-     */
-    public getWidget(name: string, widgetPrams?: GetWidgetParameters['args']): Widget {
-        return new Widget(
-            { name },
-            { provider: this, event: this.#event, widgetPrams, config: this.#config },
-        );
-    }
-
-    /**
-     * Retrieves the manifest of a widget as an observable stream.
-     * @param name - The name of the widget.
-     * @param widgetParams - Optional parameters for the widget.
-     * @returns An observable stream of the widget manifest.
-     */
-    public getWidgetManifest(
-        name: string,
-        widgetPrams?: GetWidgetParameters['args'],
-    ): Observable<WidgetManifest> {
-        return this._getWidget(name, widgetPrams);
-    }
-
-    /**
-     * Retrieves the config of a widget as an observable stream.
-     * @param name - The name of the widget.
-     * @param widgetParams - Optional parameters for the widget.
-     * @returns An observable stream of the widget config.
-     */
-    public getWidgetConfig(
-        name: string,
-        widgetPrams?: GetWidgetParameters['args'],
-    ): Observable<WidgetConfig> {
-        return this._getWidgetConfig(name, widgetPrams);
-    }
-
-    protected _getWidgetConfig(
-        widgetKey: GetWidgetParameters['widgetKey'],
-        args?: GetWidgetParameters['args'],
-    ): Observable<WidgetConfig> {
-        const client = new Query(this.#config.client.getWidgetConfig);
-        this.#subscription.add(() => client.complete());
-        return Query.extractQueryValue(
-            client.query({ widgetKey, args }).pipe(
-                catchError((err) => {
-                    // Extract the cause since the error will be a `QueryError`
-                    const { cause } = err;
-
-                    // Handle specific errors and throw a `GetWidgetManifestError` if applicable
-                    if (cause instanceof WidgetManifestLoadError) {
-                        throw cause;
-                    }
-                    if (cause instanceof HttpResponseError) {
-                        throw WidgetManifestLoadError.fromHttpResponse(cause.response, {
-                            cause,
-                        });
-                    }
-                    // Throw a generic `GetWidgetManifestError` for unknown errors
-                    throw new WidgetManifestLoadError('unknown', 'failed to load config', {
-                        cause,
-                    });
-                }),
-            ),
-        );
-    }
-
-    /**
-     * Fetches the configuration for a widget using a query.
-     * @param widgetKey - The key identifying the widget.
-     * @param args - Optional arguments for the widget.
-     * @returns An observable stream of the widget manifest.
-     * @protected
-     */
-    protected _getWidget(
-        widgetKey: GetWidgetParameters['widgetKey'],
-        args?: GetWidgetParameters['args'],
-    ): Observable<WidgetManifest> {
-        // Create a new query using the configured client
-        const client = new Query(this.#config.client.getWidgetManifest);
-        this.#subscription.add(() => client.complete());
-
-        // Execute the query and handle errors
-        return Query.extractQueryValue(
-            client.query({ widgetKey, args }).pipe(
-                catchError((err) => {
-                    // Extract the cause since the error will be a `QueryError`
-                    const { cause } = err;
-
-                    // Handle specific errors and throw a `GetWidgetConfigError` if applicable
-                    if (cause instanceof WidgetConfigLoadError) {
-                        throw cause;
-                    }
-                    if (cause instanceof HttpResponseError) {
-                        throw WidgetConfigLoadError.fromHttpResponse(cause.response, { cause });
-                    }
-                    // Throw a generic `GetWidgetManifestError` for unknown errors
-                    throw new WidgetConfigLoadError('unknown', 'failed to load config', {
-                        cause,
-                    });
-                }),
-            ),
-        );
-    }
-
-    /**
-     * Disposes of the widget provider by unsubscribing from any active subscriptions.
-     */
-    public dispose() {
-        this.#subscription.unsubscribe();
-    }
+  // Private fields
+  #subscription = new Subscription();
+  #config: WidgetModuleConfig;
+  #event?: ModuleType<EventModule>;
+
+  /**
+   * Constructs a new `WidgetModuleProvider` instance.
+   * @param args - An object containing configuration and optional event module for the widget provider.
+   */
+  constructor(args: { config: WidgetModuleConfig; event?: ModuleType<EventModule> }) {
+    const { config, event } = args;
+    this.#event = event;
+    this.#config = config;
+  }
+
+  /**
+   * Retrieves a widget instance based on the provided name and optional parameters.
+   * @param name - The name of the widget.
+   * @param widgetParams - Optional parameters for the widget.
+   * @returns A new `Widget` instance.
+   */
+  public getWidget(name: string, widgetPrams?: GetWidgetParameters['args']): Widget {
+    return new Widget(
+      { name },
+      { provider: this, event: this.#event, widgetPrams, config: this.#config },
+    );
+  }
+
+  /**
+   * Retrieves the manifest of a widget as an observable stream.
+   * @param name - The name of the widget.
+   * @param widgetParams - Optional parameters for the widget.
+   * @returns An observable stream of the widget manifest.
+   */
+  public getWidgetManifest(
+    name: string,
+    widgetPrams?: GetWidgetParameters['args'],
+  ): Observable<WidgetManifest> {
+    return this._getWidget(name, widgetPrams);
+  }
+
+  /**
+   * Retrieves the config of a widget as an observable stream.
+   * @param name - The name of the widget.
+   * @param widgetParams - Optional parameters for the widget.
+   * @returns An observable stream of the widget config.
+   */
+  public getWidgetConfig(
+    name: string,
+    widgetPrams?: GetWidgetParameters['args'],
+  ): Observable<WidgetConfig> {
+    return this._getWidgetConfig(name, widgetPrams);
+  }
+
+  protected _getWidgetConfig(
+    widgetKey: GetWidgetParameters['widgetKey'],
+    args?: GetWidgetParameters['args'],
+  ): Observable<WidgetConfig> {
+    const client = new Query(this.#config.client.getWidgetConfig);
+    this.#subscription.add(() => client.complete());
+    return Query.extractQueryValue(
+      client.query({ widgetKey, args }).pipe(
+        catchError((err) => {
+          // Extract the cause since the error will be a `QueryError`
+          const { cause } = err;
+
+          // Handle specific errors and throw a `GetWidgetManifestError` if applicable
+          if (cause instanceof WidgetManifestLoadError) {
+            throw cause;
+          }
+          if (cause instanceof HttpResponseError) {
+            throw WidgetManifestLoadError.fromHttpResponse(cause.response, {
+              cause,
+            });
+          }
+          // Throw a generic `GetWidgetManifestError` for unknown errors
+          throw new WidgetManifestLoadError('unknown', 'failed to load config', {
+            cause,
+          });
+        }),
+      ),
+    );
+  }
+
+  /**
+   * Fetches the configuration for a widget using a query.
+   * @param widgetKey - The key identifying the widget.
+   * @param args - Optional arguments for the widget.
+   * @returns An observable stream of the widget manifest.
+   * @protected
+   */
+  protected _getWidget(
+    widgetKey: GetWidgetParameters['widgetKey'],
+    args?: GetWidgetParameters['args'],
+  ): Observable<WidgetManifest> {
+    // Create a new query using the configured client
+    const client = new Query(this.#config.client.getWidgetManifest);
+    this.#subscription.add(() => client.complete());
+
+    // Execute the query and handle errors
+    return Query.extractQueryValue(
+      client.query({ widgetKey, args }).pipe(
+        catchError((err) => {
+          // Extract the cause since the error will be a `QueryError`
+          const { cause } = err;
+
+          // Handle specific errors and throw a `GetWidgetConfigError` if applicable
+          if (cause instanceof WidgetConfigLoadError) {
+            throw cause;
+          }
+          if (cause instanceof HttpResponseError) {
+            throw WidgetConfigLoadError.fromHttpResponse(cause.response, { cause });
+          }
+          // Throw a generic `GetWidgetManifestError` for unknown errors
+          throw new WidgetConfigLoadError('unknown', 'failed to load config', {
+            cause,
+          });
+        }),
+      ),
+    );
+  }
+
+  /**
+   * Disposes of the widget provider by unsubscribing from any active subscriptions.
+   */
+  public dispose() {
+    this.#subscription.unsubscribe();
+  }
 }
 
 export default WidgetModuleProvider;

package/src/enable-widget-module.ts

@@ -1,21 +1,21 @@
 import type { IModulesConfigurator } from '@equinor/fusion-framework-module';
 
 import { module } from './module';
-import { WidgetModuleConfigBuilderCallback } from './WidgetModuleConfigurator';
+import type { WidgetModuleConfigBuilderCallback } from './WidgetModuleConfigurator';
 
 /**
  * Method for enabling the widget module
  * @param configurator - configuration object
  */
 export const enableWidgetModule = (
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    configurator: IModulesConfigurator<any, any>,
-    builder?: WidgetModuleConfigBuilderCallback,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  configurator: IModulesConfigurator<any, any>,
+  builder?: WidgetModuleConfigBuilderCallback,
 ): void => {
-    configurator.addConfig({
-        module,
-        configure: (widgetConfigurator) => {
-            builder && builder(widgetConfigurator);
-        },
-    });
+  configurator.addConfig({
+    module,
+    configure: (widgetConfigurator) => {
+      builder && builder(widgetConfigurator);
+    },
+  });
 };

package/src/errors.ts

@@ -1,72 +1,68 @@
 type WidgetErrorType = 'not_found' | 'unauthorized' | 'unknown';
 
 export class WidgetManifestLoadError extends Error {
-    static fromHttpResponse(response: Response, options?: ErrorOptions) {
-        switch (response.status) {
-            case 401:
-                return new WidgetManifestLoadError(
-                    'unauthorized',
-                    'failed to load widget manifest, request not authorized',
-                    options,
-                );
-            case 404:
-                return new WidgetManifestLoadError(
-                    'not_found',
-                    'widget manifest not found',
-                    options,
-                );
-        }
+  static fromHttpResponse(response: Response, options?: ErrorOptions) {
+    switch (response.status) {
+      case 401:
         return new WidgetManifestLoadError(
-            'unknown',
-            `failed to load widget manifest, status code ${response.status}`,
-            options,
+          'unauthorized',
+          'failed to load widget manifest, request not authorized',
+          options,
         );
+      case 404:
+        return new WidgetManifestLoadError('not_found', 'widget manifest not found', options);
     }
-    constructor(
-        public readonly type: WidgetErrorType,
-        message?: string,
-        options?: ErrorOptions,
-    ) {
-        super(message, options);
-        this.name = 'GetWidgetLoadManifestErrors';
-    }
+    return new WidgetManifestLoadError(
+      'unknown',
+      `failed to load widget manifest, status code ${response.status}`,
+      options,
+    );
+  }
+  constructor(
+    public readonly type: WidgetErrorType,
+    message?: string,
+    options?: ErrorOptions,
+  ) {
+    super(message, options);
+    this.name = 'GetWidgetLoadManifestErrors';
+  }
 }
 
 export class WidgetConfigLoadError extends Error {
-    static fromHttpResponse(response: Response, options?: ErrorOptions) {
-        switch (response.status) {
-            case 401:
-                return new WidgetConfigLoadError(
-                    'unauthorized',
-                    'failed to load widget config, request not authorized',
-                    options,
-                );
-            case 404:
-                return new WidgetConfigLoadError('not_found', 'widget config not found', options);
-        }
+  static fromHttpResponse(response: Response, options?: ErrorOptions) {
+    switch (response.status) {
+      case 401:
         return new WidgetConfigLoadError(
-            'unknown',
-            `failed to load widget config, status code ${response.status}`,
-            options,
+          'unauthorized',
+          'failed to load widget config, request not authorized',
+          options,
         );
+      case 404:
+        return new WidgetConfigLoadError('not_found', 'widget config not found', options);
     }
-    constructor(
-        public readonly type: WidgetErrorType,
-        message?: string,
-        options?: ErrorOptions,
-    ) {
-        super(message, options);
-        this.name = 'GetWidgetLoadConfigError';
-    }
+    return new WidgetConfigLoadError(
+      'unknown',
+      `failed to load widget config, status code ${response.status}`,
+      options,
+    );
+  }
+  constructor(
+    public readonly type: WidgetErrorType,
+    message?: string,
+    options?: ErrorOptions,
+  ) {
+    super(message, options);
+    this.name = 'GetWidgetLoadConfigError';
+  }
 }
 
 export class WidgetScriptModuleError extends Error {
-    constructor(
-        public readonly type: WidgetErrorType,
-        message?: string,
-        options?: ErrorOptions,
-    ) {
-        super(message, options);
-        this.name = 'WidgetScriptModuleError';
-    }
+  constructor(
+    public readonly type: WidgetErrorType,
+    message?: string,
+    options?: ErrorOptions,
+  ) {
+    super(message, options);
+    this.name = 'WidgetScriptModuleError';
+  }
 }