@equinor/fusion-framework-module-widget 14.0.2-next.0 → 15.0.1

package/dist/types/Widget.d.ts

@@ -5,16 +5,47 @@ import { Observable } from 'rxjs';
 import type WidgetModuleProvider from './WidgetModuleProvider';
 import type { WidgetModuleConfig } from './WidgetModuleConfigurator';
 import './events';
+/**
+ * Manages the full lifecycle of a single Fusion widget.
+ *
+ * A `Widget` encapsulates fetching its manifest, dynamically importing its
+ * script entry point, loading configuration, and emitting lifecycle events.
+ * Internally it uses an RxJS-based `FlowSubject` state machine driven by
+ * actions and flows defined in the `state/` directory.
+ *
+ * Create instances via {@link WidgetModuleProvider.getWidget} rather than
+ * constructing directly.
+ *
+ * @example
+ * ```typescript
+ * const widget = provider.getWidget('my-widget');
+ * widget.initialize().subscribe(({ manifest, script }) => {
+ *   script.renderWidget(el, { fusion, env: { manifest } });
+ * });
+ * ```
+ */
 export declare class Widget {
     #private;
+    /** Human-readable widget name used as the lookup key for manifest and config. */
     name: string;
+    /** Module-level HTTP client configuration used to resolve asset URLs. */
     config?: WidgetModuleConfig;
+    /** Optional version or tag parameters forwarded to manifest/config endpoints. */
     widgetPrams?: GetWidgetParameters['args'];
+    /** Current snapshot of the widget's internal state (manifest, config, modules, status). */
     get state(): WidgetState;
     /**
-     * Constructs a new Widget instance.
-     * @param value - Initial state of the widget.
-     * @param args - Configuration and event parameters for the widget.
+     * Constructs a new `Widget` instance.
+     *
+     * Prefer using {@link WidgetModuleProvider.getWidget} instead of calling
+     * this constructor directly.
+     *
+     * @param value - Initial widget state (at minimum, the widget `name`).
+     * @param args - Dependencies required by the widget.
+     * @param args.provider - The owning {@link WidgetModuleProvider}.
+     * @param args.config - Optional module-level HTTP client configuration.
+     * @param args.event - Optional event module for dispatching lifecycle events.
+     * @param args.widgetPrams - Optional version/tag selector for the widget.
      */
     constructor(value: WidgetStateInitial, args: {
         provider: WidgetModuleProvider;
@@ -23,36 +54,61 @@ export declare class Widget {
         widgetPrams?: GetWidgetParameters['args'];
     });
     /**
-     * Retrieves the manifest of the widget as an observable stream.
-     * @param force_refresh - Flag to force refresh the manifest.
-     * @returns An observable stream of the widget manifest.
+     * Retrieves the widget manifest as an observable stream.
+     *
+     * If the manifest is already cached in state it is emitted immediately.
+     * When `force_refresh` is `true`, a new fetch is dispatched regardless of
+     * cache status.
+     *
+     * @param force_refresh - When `true`, re-fetches the manifest even if cached.
+     * @returns Observable that emits the {@link WidgetManifest} and completes.
+     * @throws {Error} When the manifest fetch fails (wraps the underlying cause).
      */
     getManifest(force_refresh?: boolean): Observable<WidgetManifest>;
     /**
-     * Retrieves the configuration of the widget as an observable stream.
-     * @param force_refresh - Flag to force refresh the configuration.
-     * @returns An observable stream of the widget configuration.
+     * Retrieves the widget configuration as an observable stream.
+     *
+     * Returns the cached config immediately when available. Set `force_refresh`
+     * to `true` to force a new fetch from the backend API.
+     *
+     * @param force_refresh - When `true`, re-fetches the config even if cached.
+     * @returns Observable that emits the {@link WidgetConfig} and completes.
+     * @throws {Error} When the config fetch fails (wraps the underlying cause).
      */
     getConfig(force_refresh?: boolean): Observable<WidgetConfig>;
     /**
-     * Loads the configuration for the widget.
-     * @param update - Flag to force an update of the configuration.
+     * Dispatches a config fetch action into the state machine.
+     *
+     * @param update - When `true`, merges the fetched config with existing state
+     *   instead of replacing it.
      */
     loadConfig(update?: boolean): void;
     /**
-     * Loads the manifest for the widget.
-     * @param update - Flag to force an update of the manifest.
+     * Dispatches a manifest fetch action into the state machine.
+     *
+     * @param update - When `true`, merges the fetched manifest with existing
+     *   state instead of replacing it.
      */
     loadManifest(update?: boolean): void;
     /**
-     * Retrieves the widget module as an observable stream.
-     * @param force_refresh - Flag to force refresh the widget module.
-     * @returns An observable stream of the widget module.
+     * Retrieves the widget's script module as an observable stream.
+     *
+     * Resolves the manifest first, builds the full import URL from the asset
+     * path and entry point, then dynamically imports the script. The imported
+     * module is cached in state for subsequent calls.
+     *
+     * @param force_refresh - When `true`, re-imports the script even if cached.
+     * @returns Observable that emits the {@link WidgetScriptModule} and completes.
+     * @throws {Error} When the script import fails (wraps the underlying cause).
      */
     getWidgetModule(force_refresh?: boolean): Observable<WidgetScriptModule>;
     /**
-     * Initializes the widget and returns an observable stream with the combined results.
-     * @returns An observable stream with the manifest, script, and configuration.
+     * Initializes the widget by loading the manifest, importing the script, and
+     * preparing configuration. Emits a combined result when all resources are ready.
+     *
+     * @returns Observable that emits `{ manifest, script, config }` and completes
+     *   once all resources have been resolved.
+     * @throws {Error} When any initialization step fails.
      */
     initialize(): Observable<{
         manifest: WidgetManifest;
@@ -60,19 +116,29 @@ export declare class Widget {
         config?: WidgetConfig;
     }>;
     /**
-     * Retrieves the widget module asynchronously as a Promise.
-     * @param allow_cache - Flag to allow caching of the widget module.
-     * @returns A Promise containing the widget module.
+     * Retrieves the widget script module as a `Promise`.
+     *
+     * When `allow_cache` is `true` (default), resolves with the first emitted
+     * value (which may be cached). When `false`, waits for the last emission
+     * after a forced refresh.
+     *
+     * @param allow_cache - When `true`, uses `firstValueFrom`; when `false`,
+     *   uses `lastValueFrom` after forcing a re-import.
+     * @returns Promise that resolves with the {@link WidgetScriptModule}.
      */
     getWidgetModuleAsync(allow_cache?: boolean): Promise<WidgetScriptModule>;
     /**
-     * Updates the manifest of the widget.
-     * @param manifest - The new manifest for the widget.
-     * @param replace - Flag to replace the existing manifest.
+     * Replaces or merges the widget manifest in state.
+     *
+     * @param manifest - The new or partial manifest to set.
+     * @param replace - When `false` (default), the new manifest is merged with
+     *   the existing one. Pass explicit `false` to merge, or omit to merge.
      */
     updateManifest(manifest: WidgetManifest, replace?: false): void;
     /**
-     * Disposes of the widget by unsubscribing from any active subscriptions.
+     * Disposes of the widget by unsubscribing from all internal subscriptions.
+     *
+     * After disposal the widget instance should not be reused.
      */
     dispose(): void;
 }

package/dist/types/WidgetModuleConfigurator.d.ts

@@ -1,29 +1,63 @@
 import { BaseConfigBuilder, type ConfigBuilderCallback } from '@equinor/fusion-framework-module';
 import type { ConfigBuilderCallbackArgs } from '@equinor/fusion-framework-module';
 import type { IClient } from './types';
+/**
+ * Resolved configuration produced by {@link WidgetModuleConfigurator}.
+ *
+ * Contains the {@link IClient} used to fetch widget manifests and configs
+ * from the backend API.
+ */
 export type WidgetModuleConfig = {
+    /** HTTP client abstraction for widget API calls. */
     client: IClient;
 };
+/**
+ * Callback signature accepted by {@link enableWidgetModule} for customizing
+ * the widget module configuration.
+ *
+ * @param builder - The {@link WidgetModuleConfigurator} instance to configure.
+ */
 export type WidgetModuleConfigBuilderCallback = (builder: WidgetModuleConfigurator) => void | Promise<void>;
+/**
+ * Configuration builder for the widget module.
+ *
+ * Extends `BaseConfigBuilder` to produce a {@link WidgetModuleConfig}. If no
+ * custom client is provided via {@link setClient}, a default HTTP client is
+ * created from the `apps` service-discovery endpoint.
+ *
+ * @example
+ * ```typescript
+ * enableWidgetModule(configurator, (builder) => {
+ *   builder.setClient(async () => myCustomClient);
+ * });
+ * ```
+ */
 export declare class WidgetModuleConfigurator extends BaseConfigBuilder<WidgetModuleConfig> {
+    /** Default cache expiration time in milliseconds (1 minute). */
     defaultExpireTime: number;
     /**
-     * Set the client for the WidgetModule configuration.
-     * @param cb - Callback function to configure the client.
+     * Registers a custom {@link IClient} factory for the widget module.
+     *
+     * @param cb - Callback that receives config-builder args and returns an
+     *   `IClient` instance (or a `Promise` thereof).
      */
     setClient(cb: ConfigBuilderCallback<IClient>): void;
     /**
-     * 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.
+     * Creates an HTTP client by resolving the `apps` client from the HTTP module
+     * or falling back to service discovery.
+     *
+     * @param clientId - Registered HTTP client identifier (typically `'apps'`).
+     * @param init - Framework config-builder callback args providing module instances.
+     * @returns An `IHttpClient` instance for widget API calls.
      */
     private _createHttpClient;
     /**
-     * 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.
+     * Finalizes the configuration by creating the default HTTP client when no
+     * custom client has been set.
+     *
+     * @param config - Partial configuration accumulated by builder callbacks.
+     * @param _init - Framework config-builder callback args.
+     * @returns The fully resolved {@link WidgetModuleConfig}.
      */
     protected _processConfig(config: Partial<WidgetModuleConfig>, _init: ConfigBuilderCallbackArgs): Promise<WidgetModuleConfig>;
 }

package/dist/types/WidgetModuleProvider.d.ts

@@ -4,56 +4,116 @@ import type { EventModule } from '@equinor/fusion-framework-module-event';
 import type { GetWidgetParameters, WidgetConfig, WidgetManifest } from './types';
 import type { WidgetModuleConfig } from './WidgetModuleConfigurator';
 import { Widget } from './Widget';
+/**
+ * Public interface for the widget module provider.
+ *
+ * Consumers depend on this interface rather than the concrete
+ * {@link WidgetModuleProvider} class, enabling testability and
+ * alternative implementations.
+ */
 export interface IWidgetModuleProvider {
+    /**
+     * Creates a {@link Widget} instance for the given widget key.
+     *
+     * @param widgetKey - Unique identifier (name) of the widget.
+     * @param args - Optional version or tag selector.
+     * @returns A new `Widget` ready for initialization.
+     */
     getWidget(widgetKey: GetWidgetParameters['widgetKey'], args?: GetWidgetParameters['args']): Widget;
+    /**
+     * Fetches the manifest for a widget as an observable stream.
+     *
+     * @param widgetKey - Unique identifier (name) of the widget.
+     * @param args - Optional version or tag selector.
+     * @returns Observable that emits the {@link WidgetManifest}.
+     */
     getWidgetManifest(widgetKey: GetWidgetParameters['widgetKey'], args?: GetWidgetParameters['args']): Observable<WidgetManifest>;
+    /**
+     * Fetches the configuration for a widget as an observable stream.
+     *
+     * @param widgetKey - Unique identifier (name) of the widget.
+     * @param args - Optional version or tag selector.
+     * @returns Observable that emits the {@link WidgetConfig}.
+     */
     getWidgetConfig(widgetKey: GetWidgetParameters['widgetKey'], args?: GetWidgetParameters['args']): Observable<WidgetConfig>;
 }
 /**
- * The `WidgetModuleProvider` class implements the `IWidgetModuleProvider` interface and serves as a provider for managing widgets.
+ * Concrete provider that manages widget instances and performs API queries
+ * for widget manifests and configurations.
+ *
+ * Created automatically during module initialization; see {@link module} and
+ * {@link enableWidgetModule}.
+ *
+ * @example
+ * ```typescript
+ * const widget = provider.getWidget('my-widget');
+ * widget.initialize().subscribe(result => { ... });
+ * ```
  */
 export declare class WidgetModuleProvider implements IWidgetModuleProvider {
     #private;
     /**
-     * Constructs a new `WidgetModuleProvider` instance.
-     * @param args - An object containing configuration and optional event module for the widget provider.
+     * Creates a new `WidgetModuleProvider`.
+     *
+     * @param args - Provider dependencies.
+     * @param args.config - Resolved {@link WidgetModuleConfig} with HTTP client.
+     * @param args.event - Optional event module for dispatching lifecycle events.
      */
     constructor(args: {
         config: WidgetModuleConfig;
         event?: ModuleType<EventModule>;
     });
     /**
-     * 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.
+     * Creates a new {@link Widget} instance for the given name.
+     *
+     * The returned widget has not been initialized yet — call
+     * {@link Widget.initialize} to start the lifecycle.
+     *
+     * @param name - Unique widget name (used as lookup key).
+     * @param widgetPrams - Optional version or tag selector.
      * @returns A new `Widget` instance.
      */
     getWidget(name: string, widgetPrams?: GetWidgetParameters['args']): Widget;
     /**
-     * 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.
+     * Fetches the manifest for a widget via the configured HTTP client.
+     *
+     * @param name - Unique widget name.
+     * @param widgetPrams - Optional version or tag selector.
+     * @returns Observable that emits the {@link WidgetManifest} and completes.
+     * @throws {WidgetManifestLoadError} When the manifest request fails.
      */
     getWidgetManifest(name: string, widgetPrams?: GetWidgetParameters['args']): Observable<WidgetManifest>;
     /**
-     * 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.
+     * Fetches the configuration for a widget via the configured HTTP client.
+     *
+     * @param name - Unique widget name.
+     * @param widgetPrams - Optional version or tag selector.
+     * @returns Observable that emits the {@link WidgetConfig} and completes.
+     * @throws {WidgetConfigLoadError} When the config request fails.
      */
     getWidgetConfig(name: string, widgetPrams?: GetWidgetParameters['args']): Observable<WidgetConfig>;
+    /**
+     * Internal: queries widget config from the API and maps HTTP errors to
+     * typed {@link WidgetConfigLoadError} instances.
+     *
+     * @param widgetKey - Widget identifier.
+     * @param args - Optional version or tag selector.
+     * @returns Observable emitting the {@link WidgetConfig}.
+     */
     protected _getWidgetConfig(widgetKey: GetWidgetParameters['widgetKey'], args?: GetWidgetParameters['args']): Observable<WidgetConfig>;
     /**
-     * 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
+     * Internal: queries widget manifest from the API and maps HTTP errors to
+     * typed {@link WidgetManifestLoadError} instances.
+     *
+     * @param widgetKey - Widget identifier.
+     * @param args - Optional version or tag selector.
+     * @returns Observable emitting the {@link WidgetManifest}.
      */
     protected _getWidget(widgetKey: GetWidgetParameters['widgetKey'], args?: GetWidgetParameters['args']): Observable<WidgetManifest>;
     /**
-     * Disposes of the widget provider by unsubscribing from any active subscriptions.
+     * Disposes all internal query subscriptions.
+     *
+     * After disposal the provider should not be reused.
      */
     dispose(): void;
 }

package/dist/types/enable-widget-module.d.ts

@@ -1,7 +1,21 @@
 import type { IModulesConfigurator } from '@equinor/fusion-framework-module';
 import type { WidgetModuleConfigBuilderCallback } from './WidgetModuleConfigurator';
 /**
- * Method for enabling the widget module
- * @param configurator - configuration object
+ * Registers the widget module on a Fusion Framework configurator.
+ *
+ * Call this during framework setup to enable widget loading, manifest
+ * resolution, and script import capabilities.
+ *
+ * @param configurator - The framework modules configurator to register the
+ *   widget module on.
+ * @param builder - Optional callback to customize the
+ *   {@link WidgetModuleConfigurator} (e.g., set a custom HTTP client).
+ *
+ * @example
+ * ```typescript
+ * import { enableWidgetModule } from '@equinor/fusion-framework-module-widget';
+ *
+ * enableWidgetModule(configurator);
+ * ```
  */
 export declare const enableWidgetModule: (configurator: IModulesConfigurator<any, any>, builder?: WidgetModuleConfigBuilderCallback) => void;

package/dist/types/errors.d.ts

@@ -1,16 +1,73 @@
+/**
+ * Discriminator for categorizing widget HTTP errors.
+ *
+ * - `'not_found'` — HTTP 404
+ * - `'unauthorized'` — HTTP 401
+ * - `'unknown'` — any other error
+ */
 type WidgetErrorType = 'not_found' | 'unauthorized' | 'unknown';
+/**
+ * Error thrown when a widget manifest cannot be loaded from the backend API.
+ *
+ * Use the static {@link fromHttpResponse} factory to create instances from
+ * HTTP responses with appropriate type mapping.
+ */
 export declare class WidgetManifestLoadError extends Error {
     readonly type: WidgetErrorType;
+    /**
+     * Creates a `WidgetManifestLoadError` from an HTTP `Response`.
+     *
+     * Maps HTTP 401 to `'unauthorized'`, 404 to `'not_found'`, and all other
+     * status codes to `'unknown'`.
+     *
+     * @param response - The failing HTTP response.
+     * @param options - Standard `ErrorOptions` (e.g., `cause`).
+     * @returns A typed `WidgetManifestLoadError`.
+     */
     static fromHttpResponse(response: Response, options?: ErrorOptions): WidgetManifestLoadError;
+    /**
+     * @param type - Error category discriminator.
+     * @param message - Human-readable error description.
+     * @param options - Standard `ErrorOptions` (e.g., `cause`).
+     */
     constructor(type: WidgetErrorType, message?: string, options?: ErrorOptions);
 }
+/**
+ * Error thrown when a widget configuration cannot be loaded from the backend API.
+ *
+ * Use the static {@link fromHttpResponse} factory to create instances from
+ * HTTP responses with appropriate type mapping.
+ */
 export declare class WidgetConfigLoadError extends Error {
     readonly type: WidgetErrorType;
+    /**
+     * Creates a `WidgetConfigLoadError` from an HTTP `Response`.
+     *
+     * Maps HTTP 401 to `'unauthorized'`, 404 to `'not_found'`, and all other
+     * status codes to `'unknown'`.
+     *
+     * @param response - The failing HTTP response.
+     * @param options - Standard `ErrorOptions` (e.g., `cause`).
+     * @returns A typed `WidgetConfigLoadError`.
+     */
     static fromHttpResponse(response: Response, options?: ErrorOptions): WidgetConfigLoadError;
+    /**
+     * @param type - Error category discriminator.
+     * @param message - Human-readable error description.
+     * @param options - Standard `ErrorOptions` (e.g., `cause`).
+     */
     constructor(type: WidgetErrorType, message?: string, options?: ErrorOptions);
 }
+/**
+ * Error thrown when a widget script module cannot be dynamically imported.
+ */
 export declare class WidgetScriptModuleError extends Error {
     readonly type: WidgetErrorType;
+    /**
+     * @param type - Error category discriminator.
+     * @param message - Human-readable error description.
+     * @param options - Standard `ErrorOptions` (e.g., `cause`).
+     */
     constructor(type: WidgetErrorType, message?: string, options?: ErrorOptions);
 }
 export {};

package/dist/types/events.d.ts

@@ -1,54 +1,74 @@
 import type { FrameworkEvent, FrameworkEventInit } from '@equinor/fusion-framework-module-event';
 import type { Widget } from './Widget';
 import type { 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 & {
+/**
+ * Base event-init shape for all widget lifecycle events.
+ *
+ * Extends `FrameworkEventInit` with a mandatory `name` field identifying
+ * the widget, and sets the event `source` to the originating {@link Widget}
+ * instance.
+ *
+ * @template TDetail - Additional detail properties merged with `{ name: string }`.
+ */
+export type WidgetEventInit<TDetail extends Record<string, unknown> | unknown = unknown> = FrameworkEventInit<TDetail & {
     name: string;
-}, 
-/** source of the event */
-Widget>;
+}, Widget>;
+/**
+ * Concrete framework-event type for widget lifecycle events.
+ *
+ * @template TDetail - Additional detail properties.
+ */
 export type WidgetEvent<TDetail extends Record<string, unknown> | unknown = unknown> = FrameworkEvent<WidgetEventInit<TDetail>>;
+/**
+ * Framework-event type for widget lifecycle failure events.
+ *
+ * Carries an `error` property in the event detail for error inspection.
+ */
 export type WidgetEventFailure = FrameworkEvent<WidgetEventInit<{
     error: WidgetConfig;
 }>>;
 declare module '@equinor/fusion-framework-module-event' {
     interface FrameworkEventMap {
-        /** fired when the application has initiated its modules */
+        /** Fired when a widget has finished initializing its framework modules. */
         onWidgetModulesLoaded: WidgetEvent<{
-            /** initiated modules for application */
+            /** The initialized module instances. */
             modules: WidgetModulesInstance;
         }>;
+        /** Fired when a widget manifest fetch starts. */
         onWidgetManifestLoad: WidgetEvent;
-        /** fired when the application has loaded corresponding manifest */
+        /** Fired when a widget manifest has been successfully loaded. */
         onWidgetManifestLoaded: WidgetEvent<{
             manifest: WidgetManifest;
         }>;
+        /** Fired when a widget manifest fetch fails. */
         onWidgetManifestFailure: WidgetEventFailure;
+        /** Fired when a widget config fetch starts. */
         onWidgetConfigLoad: WidgetEvent;
-        /** fired when the application has loaded corresponding config */
+        /** Fired when a widget config has been successfully loaded. */
         onWidgetConfigLoaded: WidgetEvent<{
             config: WidgetConfig;
         }>;
+        /** Fired when a widget config fetch fails. */
         onWidgetConfigFailure: WidgetEventFailure;
-        /** fired when the application has loaded corresponding javascript module */
+        /** Fired when a widget script import starts. */
         onAWidgetScriptLoad: WidgetEvent;
+        /** Fired when a widget script has been successfully imported. */
         onWidgetScriptLoaded: WidgetEvent<{
             script: WidgetScriptModule;
         }>;
+        /** Fired when a widget script import fails. */
         onWidgetScriptFailure: WidgetEventFailure;
-        /** fired before application loads manifest, config and script */
+        /** Fired before the widget begins loading manifest, config, and script. */
         onWidgetInitialize: WidgetEvent;
         /**
-         * fired after application has loaded manifest, config and script
+         * Fired after the widget has loaded manifest, config, and script.
          *
-         * __note:__ not fired until all loaders has settled (last emit)
+         * Not emitted until all loaders have settled (last emission).
          */
         onWidgetInitialized: WidgetEvent;
-        /** fired when application fails to load either manifest, config and script */
+        /** Fired when the widget fails to load manifest, config, or script. */
         onWidgetInitializeFailure: WidgetEventFailure;
-        /** fired when the application is disposed (unmounts) */
+        /** Fired when the widget is disposed (unmounted from the DOM). */
         onWidgetDispose: FrameworkEvent<WidgetEventInit>;
     }
 }

package/dist/types/index.d.ts

@@ -1,6 +1,15 @@
-export { WidgetModuleConfigurator, WidgetModuleConfig } from './WidgetModuleConfigurator';
+/**
+ * Fusion Framework Widget Module
+ *
+ * Provides runtime loading, configuration, and lifecycle management for
+ * remote widget micro-frontends. Widgets are dynamically fetched, imported,
+ * and mounted into a host application.
+ *
+ * @packageDocumentation
+ */
+export { WidgetModuleConfigurator, type WidgetModuleConfig } from './WidgetModuleConfigurator';
 export { WidgetModuleProvider } from './WidgetModuleProvider';
 export type { IWidgetModuleProvider } from './WidgetModuleProvider';
 export * from './types';
 export { enableWidgetModule } from './enable-widget-module';
-export { default, WidgetModule, module, moduleKey } from './module';
+export { default, type WidgetModule, module, moduleKey } from './module';

package/dist/types/module.d.ts

@@ -2,10 +2,31 @@ import type { Module } from '@equinor/fusion-framework-module';
 import type { ModuleDeps } from './types';
 import { WidgetModuleConfigurator } from './WidgetModuleConfigurator';
 import { type IWidgetModuleProvider } from './WidgetModuleProvider';
+/** Module registration key used in the Fusion Framework module map. */
 export declare const moduleKey = "widget";
+/**
+ * Module type definition binding the `'widget'` key to the
+ * {@link IWidgetModuleProvider} instance, {@link WidgetModuleConfigurator}
+ * configuration builder, and required {@link ModuleDeps}.
+ */
 export type WidgetModule = Module<typeof moduleKey, IWidgetModuleProvider, WidgetModuleConfigurator, ModuleDeps>;
+/**
+ * Widget module descriptor.
+ *
+ * Defines how the widget module is configured, initialized, and disposed
+ * within the Fusion Framework module system.
+ *
+ * - `configure` — creates a fresh {@link WidgetModuleConfigurator}
+ * - `initialize` — resolves the config, optionally acquires the event module,
+ *   and returns a {@link WidgetModuleProvider}
+ * - `dispose` — cleans up provider subscriptions
+ */
 export declare const module: WidgetModule;
 export default module;
+/**
+ * Augments the global Fusion Framework `Modules` interface so that
+ * `modules.widget` is typed as {@link WidgetModule}.
+ */
 declare module '@equinor/fusion-framework-module' {
     interface Modules {
         [moduleKey]: WidgetModule;