@equinor/fusion-framework-module-widget 2.0.10 → 3.0.0

package/dist/types/Widget.d.ts

@@ -0,0 +1,78 @@
+import { ModuleType } from '@equinor/fusion-framework-module';
+import { GetWidgetParameters, WidgetConfig, WidgetManifest, WidgetScriptModule, WidgetState, WidgetStateInitial } from './types';
+import { EventModule } from '@equinor/fusion-framework-module-event';
+import { Observable } from 'rxjs';
+import WidgetModuleProvider from './WidgetModuleProvider';
+import { WidgetModuleConfig } from './WidgetModuleConfigurator';
+import './events';
+export declare class Widget {
+    #private;
+    name: string;
+    config?: WidgetModuleConfig;
+    widgetPrams?: GetWidgetParameters['args'];
+    get state(): WidgetState;
+    /**
+     * Constructs a new Widget instance.
+     * @param value - Initial state of the widget.
+     * @param args - Configuration and event parameters for the widget.
+     */
+    constructor(value: WidgetStateInitial, args: {
+        provider: WidgetModuleProvider;
+        config?: WidgetModuleConfig;
+        event?: ModuleType<EventModule>;
+        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.
+     */
+    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.
+     */
+    getConfig(force_refresh?: boolean): Observable<WidgetConfig>;
+    /**
+     * Loads the configuration for the widget.
+     * @param update - Flag to force an update of the configuration.
+     */
+    loadConfig(update?: boolean): void;
+    /**
+     * Loads the manifest for the widget.
+     * @param update - Flag to force an update of the manifest.
+     */
+    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.
+     */
+    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.
+     */
+    initialize(): Observable<{
+        manifest: WidgetManifest;
+        script: WidgetScriptModule;
+        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.
+     */
+    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.
+     */
+    updateManifest(manifest: WidgetManifest, replace?: false): void;
+    /**
+     * Disposes of the widget by unsubscribing from any active subscriptions.
+     */
+    dispose(): void;
+}

package/dist/types/WidgetModuleConfigurator.d.ts

@@ -1,29 +1,29 @@
-import { ModuleInitializerArgs } from '@equinor/fusion-framework-module';
-import { HttpModule, IHttpClient } from '@equinor/fusion-framework-module-http';
-import { ServiceDiscoveryModule } from '@equinor/fusion-framework-module-service-discovery';
-import { QueryCtorOptions } from '@equinor/fusion-query';
-import { WidgetModuleConfigBuilderCallback, WidgetEndpointBuilder } from './WidgetModuleConfigBuilder';
-import type { GetWidgetParameters, WidgetManifest } from './types';
-export interface WidgetModuleConfig {
-    client: {
-        getWidget: QueryCtorOptions<WidgetManifest, GetWidgetParameters>;
-    };
-    endpointBuilder: WidgetEndpointBuilder;
-}
-export interface IWidgetModuleConfigurator {
-    addConfigBuilder: (init: WidgetModuleConfigBuilderCallback) => void;
-}
-export declare class WidgetModuleConfigurator implements IWidgetModuleConfigurator {
-    #private;
+import { BaseConfigBuilder, type ConfigBuilderCallback } from '@equinor/fusion-framework-module';
+import { ConfigBuilderCallbackArgs } from '@equinor/fusion-framework-module';
+import type { IClient } from './types';
+export type WidgetModuleConfig = {
+    client: IClient;
+};
+export type WidgetModuleConfigBuilderCallback = (builder: WidgetModuleConfigurator) => void | Promise<void>;
+export declare class WidgetModuleConfigurator extends BaseConfigBuilder<WidgetModuleConfig> {
     defaultExpireTime: number;
-    addConfigBuilder(init: WidgetModuleConfigBuilderCallback): void;
-    constructor(apiVersion?: string);
-    protected _createHttpClient(init: ModuleInitializerArgs<IWidgetModuleConfigurator, [
-        HttpModule,
-        ServiceDiscoveryModule
-    ]>): Promise<IHttpClient>;
-    createConfig(init: ModuleInitializerArgs<IWidgetModuleConfigurator, [
-        HttpModule,
-        ServiceDiscoveryModule
-    ]>): Promise<WidgetModuleConfig>;
+    /**
+     * Set the client for the WidgetModule configuration.
+     * @param cb - Callback function to configure the client.
+     */
+    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.
+     */
+    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.
+     */
+    protected _processConfig(config: Partial<WidgetModuleConfig>, _init: ConfigBuilderCallbackArgs): Promise<WidgetModuleConfig>;
 }

package/dist/types/WidgetModuleProvider.d.ts

@@ -1,21 +1,60 @@
 import { Observable } from 'rxjs';
 import { ModuleType } from '@equinor/fusion-framework-module';
 import { EventModule } from '@equinor/fusion-framework-module-event';
-import type { GetWidgetParameters, WidgetManifest } from './types';
+import type { GetWidgetParameters, WidgetConfig, WidgetManifest } from './types';
 import { WidgetModuleConfig } from './WidgetModuleConfigurator';
+import { Widget } from './Widget';
 export interface IWidgetModuleProvider {
-    getWidget(widgetKey: GetWidgetParameters['widgetKey'], args: GetWidgetParameters['args']): Observable<WidgetManifest>;
+    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 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.
+     */
     constructor(args: {
         config: WidgetModuleConfig;
         event?: ModuleType<EventModule>;
     });
-    getWidget(name: string): Observable<WidgetManifest>;
-    getWidgetByVersion(name: string, version: string): Observable<WidgetManifest>;
-    getWidgetByTag(name: string, tag: string): Observable<WidgetManifest>;
+    /**
+     * 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.
+     */
+    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.
+     */
+    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.
+     */
+    getWidgetConfig(name: string, widgetPrams?: GetWidgetParameters['args']): Observable<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
+     */
     protected _getWidget(widgetKey: GetWidgetParameters['widgetKey'], args?: GetWidgetParameters['args']): Observable<WidgetManifest>;
+    /**
+     * Disposes of the widget provider by unsubscribing from any active subscriptions.
+     */
     dispose(): void;
 }
 export default WidgetModuleProvider;

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

@@ -1,3 +1,7 @@
 import type { IModulesConfigurator } from '@equinor/fusion-framework-module';
-import type { WidgetModuleConfigBuilderCallback } from './WidgetModuleConfigBuilder';
+import { WidgetModuleConfigBuilderCallback } from './WidgetModuleConfigurator';
+/**
+ * Method for enabling the widget module
+ * @param configurator - configuration object
+ */
 export declare const enableWidgetModule: (configurator: IModulesConfigurator<any, any>, builder?: WidgetModuleConfigBuilderCallback) => void;

package/dist/types/errors.d.ts

@@ -1,7 +1,12 @@
 type WidgetErrorType = 'not_found' | 'unauthorized' | 'unknown';
-export declare class GetWidgetError extends Error {
+export declare class WidgetManifestLoadError extends Error {
     readonly type: WidgetErrorType;
-    static fromHttpResponse(response: Response, options?: ErrorOptions): GetWidgetError;
+    static fromHttpResponse(response: Response, options?: ErrorOptions): WidgetManifestLoadError;
+    constructor(type: WidgetErrorType, message?: string, options?: ErrorOptions);
+}
+export declare class WidgetConfigLoadError extends Error {
+    readonly type: WidgetErrorType;
+    static fromHttpResponse(response: Response, options?: ErrorOptions): WidgetConfigLoadError;
     constructor(type: WidgetErrorType, message?: string, options?: ErrorOptions);
 }
 export declare class WidgetScriptModuleError extends Error {

package/dist/types/events.d.ts

@@ -0,0 +1,54 @@
+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 & {
+    name: string;
+}, 
+/** source of the event */
+Widget>;
+export type WidgetEvent<TDetail extends Record<string, unknown> | unknown = unknown> = FrameworkEvent<WidgetEventInit<TDetail>>;
+export type WidgetEventFailure = FrameworkEvent<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;
+        }>;
+        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;
+        /** 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 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 the application is disposed (unmounts) */
+        onWidgetDispose: FrameworkEvent<WidgetEventInit>;
+    }
+}

package/dist/types/index.d.ts

@@ -1,4 +1,4 @@
-export { WidgetModuleConfigurator, IWidgetModuleConfigurator, WidgetModuleConfig, } from './WidgetModuleConfigurator';
+export { WidgetModuleConfigurator, WidgetModuleConfig } from './WidgetModuleConfigurator';
 export { WidgetModuleProvider } from './WidgetModuleProvider';
 export type { IWidgetModuleProvider } from './WidgetModuleProvider';
 export * from './types';

package/dist/types/module.d.ts

@@ -1,13 +1,13 @@
 import { Module } from '@equinor/fusion-framework-module';
 import { ModuleDeps } from './types';
-import { IWidgetModuleConfigurator } from './WidgetModuleConfigurator';
+import { WidgetModuleConfigurator } from './WidgetModuleConfigurator';
 import { IWidgetModuleProvider } from './WidgetModuleProvider';
 export declare const moduleKey = "widget";
-export type WidgetModule = Module<typeof moduleKey, IWidgetModuleProvider, IWidgetModuleConfigurator, ModuleDeps>;
+export type WidgetModule = Module<typeof moduleKey, IWidgetModuleProvider, WidgetModuleConfigurator, ModuleDeps>;
 export declare const module: WidgetModule;
 export default module;
 declare module '@equinor/fusion-framework-module' {
     interface Modules {
-        widget: WidgetModule;
+        [moduleKey]: WidgetModule;
     }
 }

package/dist/types/state/actions.d.ts

@@ -0,0 +1,92 @@
+import { ActionInstanceMap, ActionTypes } from '@equinor/fusion-observable';
+import { GetWidgetParameters, WidgetConfig, WidgetManifest, WidgetModulesInstance, WidgetScriptModule } from '../types';
+declare const createActions: () => {
+    /** Manifest loading */
+    setManifest: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[manifest: WidgetManifest, update?: boolean | undefined], WidgetManifest, "set_manifest", never, {
+        created: number;
+        update: boolean | undefined;
+    }>;
+    fetchManifest: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[payload: {
+        key: string;
+        args?: GetWidgetParameters['args'];
+    }, update?: boolean | undefined], {
+        key: string;
+        args?: GetWidgetParameters['args'];
+    }, "fetch_manifest::request", never, {
+        update: boolean | undefined;
+    }> & {
+        success: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[manifest: WidgetManifest], WidgetManifest, "fetch_manifest::success", never, never>;
+        failure: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[error: unknown], unknown, "fetch_manifest::failure", never, never>;
+    };
+    /** Config loading */
+    setConfig: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[config: WidgetConfig], WidgetConfig, "set_config", never, never>;
+    fetchConfig: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[payload: {
+        key: string;
+        args?: GetWidgetParameters['args'];
+    }, update?: boolean | undefined], {
+        key: string;
+        args?: GetWidgetParameters['args'];
+    }, "fetch_config::request", never, {
+        update: boolean | undefined;
+    }> & {
+        success: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[config: WidgetConfig], WidgetConfig, "fetch_config::success", never, never>;
+        failure: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[error: unknown], unknown, "fetch_config::failure", never, never>;
+    };
+    setModule: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[module: any], any, "set_module", never, never>;
+    importWidget: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[entrypoint: string], string, "import_widget::request", never, never> & {
+        success: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[module: WidgetScriptModule], WidgetScriptModule, "import_widget::success", never, never>;
+        failure: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[error: unknown], unknown, "import_widget::failure", never, never>;
+    };
+    setInstance: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[instance: WidgetModulesInstance], WidgetModulesInstance, "set_instance", never, never>;
+    initialize: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[], null, "initialize_widget::request", never, never> & {
+        success: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[], null, "initialize_widget::success", never, never>;
+        failure: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[error: unknown], unknown, "initialize_widget::failure", never, never>;
+    };
+};
+export declare const actions: {
+    /** Manifest loading */
+    setManifest: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[manifest: WidgetManifest, update?: boolean | undefined], WidgetManifest, "set_manifest", never, {
+        created: number;
+        update: boolean | undefined;
+    }>;
+    fetchManifest: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[payload: {
+        key: string;
+        args?: GetWidgetParameters['args'];
+    }, update?: boolean | undefined], {
+        key: string;
+        args?: GetWidgetParameters['args'];
+    }, "fetch_manifest::request", never, {
+        update: boolean | undefined;
+    }> & {
+        success: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[manifest: WidgetManifest], WidgetManifest, "fetch_manifest::success", never, never>;
+        failure: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[error: unknown], unknown, "fetch_manifest::failure", never, never>;
+    };
+    /** Config loading */
+    setConfig: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[config: WidgetConfig], WidgetConfig, "set_config", never, never>;
+    fetchConfig: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[payload: {
+        key: string;
+        args?: GetWidgetParameters['args'];
+    }, update?: boolean | undefined], {
+        key: string;
+        args?: GetWidgetParameters['args'];
+    }, "fetch_config::request", never, {
+        update: boolean | undefined;
+    }> & {
+        success: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[config: WidgetConfig], WidgetConfig, "fetch_config::success", never, never>;
+        failure: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[error: unknown], unknown, "fetch_config::failure", never, never>;
+    };
+    setModule: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[module: any], any, "set_module", never, never>;
+    importWidget: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[entrypoint: string], string, "import_widget::request", never, never> & {
+        success: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[module: WidgetScriptModule], WidgetScriptModule, "import_widget::success", never, never>;
+        failure: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[error: unknown], unknown, "import_widget::failure", never, never>;
+    };
+    setInstance: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[instance: WidgetModulesInstance], WidgetModulesInstance, "set_instance", never, never>;
+    initialize: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[], null, "initialize_widget::request", never, never> & {
+        success: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[], null, "initialize_widget::success", never, never>;
+        failure: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[error: unknown], unknown, "initialize_widget::failure", never, never>;
+    };
+};
+export type ActionBuilder = ReturnType<typeof createActions>;
+export type ActionMap = ActionInstanceMap<ActionBuilder>;
+export type Actions = ActionTypes<typeof actions>;
+export {};

package/dist/types/state/create-reducer.d.ts

@@ -0,0 +1,3 @@
+import { WidgetStateInitial, WidgetState } from '../types';
+export declare const createReducer: (value: WidgetStateInitial) => import("@equinor/fusion-observable").ReducerWithInitialState<WidgetState, import("@equinor/fusion-observable").AnyAction>;
+export default createReducer;

package/dist/types/state/create-state.d.ts

@@ -0,0 +1,5 @@
+import { FlowSubject } from '@equinor/fusion-observable';
+import type { Actions } from './actions';
+import { WidgetState, WidgetStateInitial } from '../types';
+import WidgetModuleProvider from '../WidgetModuleProvider';
+export declare const createState: (value: WidgetStateInitial, provider: WidgetModuleProvider) => FlowSubject<WidgetState, Actions>;

package/dist/types/state/flows.d.ts

@@ -0,0 +1,7 @@
+import type { Flow } from '@equinor/fusion-observable';
+import type { Actions } from './actions';
+import { WidgetState } from '../types';
+import type WidgetModuleProvider from '../WidgetModuleProvider';
+export declare const handleFetchManifest: (provider: WidgetModuleProvider) => Flow<Actions, WidgetState>;
+export declare const handleFetchConfig: (provider: WidgetModuleProvider) => Flow<Actions, WidgetState>;
+export declare const handleImportWidget: () => Flow<Actions, WidgetState>;

package/dist/types/types.d.ts

@@ -2,11 +2,32 @@ import type { AnyModule, CombinedModules, ModulesInstance } from '@equinor/fusio
 import type { EventModule } from '@equinor/fusion-framework-module-event';
 import type { HttpModule } from '@equinor/fusion-framework-module-http';
 import type { ServiceDiscoveryModule } from '@equinor/fusion-framework-module-service-discovery';
+import { QueryCtorOptions } from '@equinor/fusion-query';
 type Fusion = any;
-export type WidgetEnv = {
-    config?: WidgetManifest;
+/**
+ * WidgetEnv type represents the environment configuration for a widget.
+ */
+export type WidgetEnv<TProps = unknown> = {
+    basename?: string;
+    manifest?: WidgetManifest;
+    props?: TProps;
 };
+/**
+ * IClient interface represents a client with properties and methods for widget-related operations.
+ */
+export type IClient = {
+    apiVersion: string;
+    baseImportUrl: string;
+    getWidgetManifest: QueryCtorOptions<WidgetManifest, GetWidgetParameters>;
+    getWidgetConfig: QueryCtorOptions<WidgetConfig, GetWidgetParameters>;
+};
+/**
+ * ModuleDeps type represents a tuple of dependencies required for a module.
+ */
 export type ModuleDeps = [HttpModule, ServiceDiscoveryModule, EventModule];
+/**
+ * GetWidgetParameters type represents parameters for retrieving widget information.
+ */
 export type GetWidgetParameters = {
     widgetKey: string;
     args?: {
@@ -14,6 +35,13 @@ export type GetWidgetParameters = {
         value: string;
     };
 };
+/**
+ * WidgetEndpointBuilder type represents a function for building widget endpoints based on GetWidgetParameters.
+ */
+export type WidgetEndpointBuilder = (args: GetWidgetParameters) => string;
+/**
+ * WidgetManifest type represents the manifest information of a widget.
+ */
 export type WidgetManifest = {
     id: string;
     name: string;
@@ -22,19 +50,67 @@ export type WidgetManifest = {
     maintainers?: string[];
     entryPoint: string;
     assetPath: string;
-    importBundle: () => Promise<WidgetScriptModule>;
 };
+/**
+ * Endpoint type represents an endpoint with properties like name, uri, and optional scopes.
+ */
+export type Endpoint = {
+    name: string;
+    uri: string;
+    scopes?: string[];
+};
+/**
+ * WidgetConfig type represents the configuration for a widget, including environment and endpoints.
+ */
+export type WidgetConfig<TEnvironment = unknown> = {
+    environment: TEnvironment;
+    endpoints: Record<string, string | Endpoint>;
+};
+/**
+ * WidgetModules type represents a combination of modules related to events and service discovery.
+ */
 export type WidgetModules<TModules extends Array<AnyModule> | unknown = unknown> = CombinedModules<TModules, [
     EventModule,
     ServiceDiscoveryModule
 ]>;
-export type WidgetRenderArgs<TFusion extends Fusion = Fusion, TEnv = WidgetEnv> = {
+/**
+ * WidgetProps type represents widget properties as a record of PropertyKey to unknown.
+ */
+export type WidgetProps = Record<PropertyKey, unknown>;
+/**
+ * WidgetRenderArgs type represents arguments for rendering a widget, including fusion, environment, and optional properties.
+ */
+export type WidgetRenderArgs<TFusion extends Fusion = Fusion, TEnv = WidgetEnv, TProps extends WidgetProps = WidgetProps> = {
     fusion: TFusion;
     env: TEnv;
+    props?: TProps;
 };
-export type WidgetScriptModule<TProps extends Record<PropertyKey, unknown> = Record<PropertyKey, unknown>> = {
+/**
+ * WidgetScriptModule type represents a script module for a widget with functions for rendering, rendering icons, etc.
+ */
+export type WidgetScriptModule<TProps extends WidgetProps = WidgetProps> = {
     default: (el: HTMLElement, args: WidgetRenderArgs, props?: TProps) => VoidFunction;
     renderWidget: (el: HTMLElement, args: WidgetRenderArgs, props?: TProps) => VoidFunction;
+    renderIcon: (el: HTMLElement, args: WidgetRenderArgs, props?: TProps) => VoidFunction;
+    render: (el: HTMLElement, args: WidgetRenderArgs, props?: TProps) => VoidFunction;
 };
+/**
+ * WidgetModulesInstance type represents an instance of widget modules.
+ */
 export type WidgetModulesInstance<TModules extends Array<AnyModule> | unknown = unknown> = ModulesInstance<WidgetModules<TModules>>;
+/**
+ * WidgetState type represents the state of a widget, including properties like name, status, config, manifest, modules, and instance.
+ */
+export type WidgetState<TModules = any> = {
+    name: string;
+    status: Set<string>;
+    config?: WidgetConfig;
+    manifest?: WidgetManifest;
+    modules?: WidgetScriptModule;
+    instance?: WidgetModulesInstance<TModules>;
+};
+/**
+ * WidgetStateInitial type represents an initial state of a widget, omitting the status property.
+ */
+export type WidgetStateInitial = Omit<WidgetState, 'status'>;
 export {};

package/dist/types/utils.d.ts

@@ -0,0 +1,5 @@
+import { IClient, WidgetEndpointBuilder } from './types';
+import { IHttpClient } from '@equinor/fusion-framework-module-http';
+export declare const defaultManifestEndpointBuilder: (apiVersion: string) => WidgetEndpointBuilder;
+export declare const defaultConfigEndpointBuilder: (apiVersion: string) => WidgetEndpointBuilder;
+export declare const createDefaultClient: (httpClient: IHttpClient) => IClient;

package/dist/types/version.d.ts

@@ -1 +1 @@
-export declare const version = "2.0.10";
+export declare const version = "3.0.0";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@equinor/fusion-framework-module-widget",
-  "version": "2.0.10",
+  "version": "3.0.0",
   "description": "",
   "main": "dist/esm/index.js",
   "exports": {
@@ -33,12 +33,15 @@
     "directory": "packages/modules/widget"
   },
   "dependencies": {
+    "immer": "^9.0.16",
     "rxjs": "^7.8.1",
+    "@equinor/fusion-observable": "^8.1.5",
     "@equinor/fusion-query": "^4.0.6"
   },
   "devDependencies": {
     "typescript": "^5.1.3",
     "@equinor/fusion-framework-module": "^4.2.7",
+    "@equinor/fusion-query": "^4.0.6",
     "@equinor/fusion-framework-module-event": "^4.0.8",
     "@equinor/fusion-framework-module-http": "^5.1.6",
     "@equinor/fusion-framework-module-service-discovery": "^7.0.20"