@equinor/fusion-framework-react 8.0.0-next.0 → 8.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@equinor/fusion-framework-react",
-  "version": "8.0.0-next.0",
+  "version": "8.0.0",
   "description": "",
   "main": "dist/esm/index.js",
   "types": "dist/types/index.d.ts",
@@ -72,30 +72,31 @@
   },
   "dependencies": {
     "rxjs": "^7.8.1",
-    "@equinor/fusion-framework": "^7.4.3-next.0",
-    "@equinor/fusion-framework-react-module": "^4.0.0-next.0",
-    "@equinor/fusion-framework-module": "^5.0.6-next.0",
-    "@equinor/fusion-observable": "^9.0.0-next.0",
-    "@equinor/fusion-framework-react-module-http": "^11.0.0-next.0"
+    "@equinor/fusion-framework": "^8.0.0",
+    "@equinor/fusion-framework-module": "^6.0.0",
+    "@equinor/fusion-framework-react-module-http": "^11.0.0",
+    "@equinor/fusion-framework-react-module": "^4.0.0",
+    "@equinor/fusion-observable": "^9.0.0"
   },
   "devDependencies": {
     "@types/react": "^19.2.7",
     "@types/react-dom": "^19.2.3",
     "react": "^19.2.1",
     "react-dom": "^19.2.1",
-    "typescript": "^5.8.2",
-    "@equinor/fusion-framework-module-feature-flag": "^2.0.0-next.0",
-    "@equinor/fusion-framework-module-app": "^7.2.0-next.0",
-    "@equinor/fusion-framework-module-msal": "^7.0.0-next.0",
-    "@equinor/fusion-framework-react-module-context": "^7.0.0-next.0",
-    "@equinor/fusion-framework-module-event": "^4.4.1-next.0"
+    "typescript": "^5.9.3",
+    "@equinor/fusion-framework-module-app": "^8.0.0",
+    "@equinor/fusion-framework-module-event": "^6.0.0",
+    "@equinor/fusion-framework-module-feature-flag": "^2.0.0",
+    "@equinor/fusion-framework-module-msal": "^8.0.0",
+    "@equinor/fusion-framework-react-module-context": "^7.0.0",
+    "@equinor/fusion-framework-react-module-signalr": "^4.0.0"
   },
   "peerDependencies": {
     "@types/react": "^18.0.0 || ^19.0.0",
     "react": "^18.0.0 || ^19.0.0",
     "react-dom": "^18.0.0 || ^19.0.0",
-    "@equinor/fusion-framework-module-feature-flag": "^2.0.0-next.0",
-    "@equinor/fusion-framework-react-module-signalr": "^4.0.0-next.0"
+    "@equinor/fusion-framework-react-module-signalr": "^4.0.0",
+    "@equinor/fusion-framework-module-feature-flag": "^2.0.0"
   },
   "peerDependenciesMeta": {
     "@equinor/fusion-framework-module-event": {

package/src/Framework.tsx

@@ -4,8 +4,45 @@ import { type PropsWithChildren, type ReactNode, Suspense, useMemo } from 'react
 import { useModules } from '@equinor/fusion-framework-react-module';
 import type { ModulesInstance } from '@equinor/fusion-framework-module';
 
+/**
+ * Callback invoked during framework initialisation to configure modules.
+ *
+ * @param configurator - The framework configurator instance to apply settings to.
+ */
 type ConfigureCallback = (configurator: FrameworkConfigurator) => void;
 
+/**
+ * Declarative React component that initialises a Fusion Framework instance
+ * and provides it to descendant components via context.
+ *
+ * @remarks
+ * Internally calls {@link createFrameworkProvider} and wraps the lazy-loaded
+ * provider in a `<Suspense>` boundary. This is the recommended high-level
+ * component for portal / host applications that need to bootstrap the
+ * framework inside a React tree.
+ *
+ * @param props.configure - Callback that receives a {@link FrameworkConfigurator}
+ *   for registering modules and configuration.
+ * @param props.fallback - React node shown while the framework is initialising.
+ * @param props.parent - Optional parent module instance to inherit configuration from.
+ * @param props.children - Application content rendered after initialisation.
+ *
+ * @example
+ * ```tsx
+ * import { Framework } from '@equinor/fusion-framework-react';
+ *
+ * const App = () => (
+ *   <Framework
+ *     configure={(configurator) => {
+ *       configurator.http.configureClient('my-api', { baseUri: 'https://api.example.com' });
+ *     }}
+ *     fallback={<span>Loading…</span>}
+ *   >
+ *     <MyApp />
+ *   </Framework>
+ * );
+ * ```
+ */
 export const Framework = (
   props: PropsWithChildren<{
     readonly configure: ConfigureCallback;

package/src/app/index.ts

@@ -1,3 +1,13 @@
+/**
+ * Application React hooks.
+ *
+ * @remarks
+ * Available via the `@equinor/fusion-framework-react/app` sub-entry-point.
+ * Provides hooks and types for querying application manifests, observing
+ * the currently active app, and accessing app-level modules.
+ *
+ * @module
+ */
 export type { AppConfig, AppManifest, AppType, IApp } from '@equinor/fusion-framework-module-app';
 
 export { useCurrentApp } from './useCurrentApp';

package/src/app/useAppProvider.ts

@@ -4,8 +4,17 @@ import type { AppModule } from '@equinor/fusion-framework-module-app';
 import { useFramework } from '../useFramework';
 
 /**
- * React Hook - get appProvider interface
- * @returns framework AppModule
+ * React hook that returns the App module provider from the framework.
+ *
+ * @returns The app module instance (`AppModule`) for querying and managing
+ *   application manifests and the currently active app.
+ * @throws {Error} If the `AppModule` is not configured in the framework.
+ *
+ * @example
+ * ```ts
+ * const provider = useAppProvider();
+ * provider.getAppManifests().subscribe(console.log);
+ * ```
  */
 export const useAppProvider = (): FusionModulesInstance<[AppModule]>['app'] => {
   const provider = useFramework<[AppModule]>().modules.app;

package/src/app/useApps.ts

@@ -12,9 +12,23 @@ type UseAppsArgs = {
 };
 
 /**
- * React Hook - Get apps from framework
- * @param args Object with filterByCurrentUser: boolean
- * @returns Object {apps, isLoading, error} where apps is Array of ApplicationManifest, isLoading is a boolean on observable complete
+ * React hook that retrieves available application manifests from the framework.
+ *
+ * @param args - Optional filtering options.
+ * @param args.filterByCurrentUser - When `true`, only apps accessible to the
+ *   current user are returned.
+ * @returns An object containing:
+ *   - `apps` — Array of {@link AppManifest} objects, or `undefined` while loading.
+ *   - `isLoading` — `true` until the observable completes.
+ *   - `error` — Any error emitted by the underlying observable.
+ *
+ * @example
+ * ```tsx
+ * const { apps, isLoading, error } = useApps({ filterByCurrentUser: true });
+ * if (isLoading) return <Spinner />;
+ * return <AppList apps={apps} />;
+ * ```
+ *
  * @since 7.1.1
  */
 export const useApps = (

package/src/app/useCurrentApp.ts

@@ -12,12 +12,33 @@ import type {
 import { useFramework } from '../useFramework';
 
 /**
- * Observers the stream of current app and return the latest application
+ * React hook that observes and returns the currently active application.
  *
- * __Warning:__ type hint templates are only hints, this does not check if the modules are actually enabled!
+ * @remarks
+ * Subscribes to the `current$` stream on the App module and returns the
+ * latest value together with helpers to change or clear the active app.
  *
- * @template TModule type hint modules which the application has configured
- * @template TEnv type hint what kind of environment config the application has
+ * **Warning:** The template parameters are compile-time hints only — the
+ * hook does not validate that the specified modules are actually enabled.
+ *
+ * @template TModules - Tuple of module types the current app is expected to
+ *   have configured (type-hint only).
+ * @template TEnv - Expected environment configuration shape (type-hint only).
+ *
+ * @returns An object containing:
+ *   - `currentApp` — The current {@link CurrentApp} instance, `null` when
+ *     explicitly cleared, or `undefined` while loading.
+ *   - `setCurrentApp(appKey)` — Sets the active app by its key.
+ *   - `clearCurrentApp()` — Clears the currently active app.
+ *   - `error` — Any error emitted by the observable.
+ *
+ * @throws {Error} If the `AppModule` is not configured in the framework.
+ *
+ * @example
+ * ```tsx
+ * const { currentApp, setCurrentApp } = useCurrentApp();
+ * return <button onClick={() => setCurrentApp('my-app')}>{currentApp?.manifest?.name}</button>;
+ * ```
  */
 export const useCurrentApp = <
   TModules extends Array<AnyModule> = [],

package/src/app/useCurrentAppModule.ts

@@ -8,14 +8,20 @@ import type {
 import useCurrentAppModules from './useCurrentAppModules';
 
 /**
- * Retrieves the current app module based on the provided module key.
- * @template TType - The type of the module.
- * @template TKey - The type of the module key.
- * @param {TKey} moduleKey - The key of the module to retrieve.
- * @returns {AnyModule | null | undefined} - The current app module or null if not found.
+ * React hook that retrieves a specific module from the current application.
+ *
+ * @template TType - The expected module type.
+ * @template TKey - The module key used for look-up.
+ * @param moduleKey - The key of the module to retrieve.
+ * @returns An object containing:
+ *   - `module` — The resolved module instance, `null` when no app is
+ *     selected, or `undefined` if the app does not enable the requested module.
+ *   - `error` — Any error emitted during initialisation.
+ *   - `complete` — `true` when the observable has completed.
+ *
  * @remarks
- *  - when module is null, there are no current selected application
- *  - when undefined is, the application has not enabled the requested module
+ * - A `null` value means no application is currently selected.
+ * - An `undefined` value means the application has not enabled the requested module.
  */
 export const useCurrentAppModule = <
   TType extends AnyModule | unknown = unknown,

package/src/app/useCurrentAppModules.ts

@@ -7,12 +7,22 @@ import type { AnyModule } from '@equinor/fusion-framework-module';
 import { useObservableState } from '@equinor/fusion-observable/react';
 
 /**
- * Observers the stream of current app initialized modules
+ * React hook that observes the initialised modules of the current application.
  *
- * __Warning:__ type hint templates are only hints, this does not check if the modules are actually enabled!
+ * @remarks
+ * Subscribes to the `instance$` stream of the current app and returns the
+ * resolved module instances.
  *
- * @template TModule type hint modules which the application has configured
- * @returns the observable instance of initialized modules of the application
+ * **Warning:** The template parameter is a compile-time hint only — the
+ * hook does not validate that the specified modules are actually enabled.
+ *
+ * @template TModules - Tuple of module types expected on the current app
+ *   (type-hint only).
+ * @returns An object containing:
+ *   - `modules` — The initialised {@link AppModulesInstance}, `null` when no
+ *     app is selected, or `undefined` while loading.
+ *   - `error` — Any error emitted during initialisation.
+ *   - `complete` — `true` when the observable has completed.
  */
 export const useCurrentAppModules = <TModules extends Array<AnyModule> = []>(): {
   modules?: AppModulesInstance<TModules> | null;

package/src/context/index.ts

@@ -1,3 +1,13 @@
+/**
+ * Context React hooks.
+ *
+ * @remarks
+ * Available via the `@equinor/fusion-framework-react/context` sub-entry-point.
+ * Re-exports the context module’s React API and adds a convenience
+ * `useCurrentContext` hook that resolves the module from the framework.
+ *
+ * @module
+ */
 export * from '@equinor/fusion-framework-react-module-context';
 
 export { useCurrentContext } from './useCurrentContext';

package/src/context/useCurrentContext.ts

@@ -1,6 +1,22 @@
 import { useCurrentContext as _useCurrentContext } from '@equinor/fusion-framework-react-module-context';
 import { useFramework } from '../useFramework';
 
+/**
+ * React hook that returns the currently selected Fusion context.
+ *
+ * @remarks
+ * This is a convenience wrapper that resolves the context module from the
+ * framework instance and delegates to the underlying
+ * `useCurrentContext` hook from `@equinor/fusion-framework-react-module-context`.
+ *
+ * @returns The current context state as defined by the context module.
+ *
+ * @example
+ * ```ts
+ * const { currentContext } = useCurrentContext();
+ * console.log(currentContext?.id);
+ * ```
+ */
 export const useCurrentContext = () => _useCurrentContext(useFramework().modules.context);
 
 export default useCurrentContext;

package/src/context.ts

@@ -1,6 +1,15 @@
 import { createContext } from 'react';
 import type { Fusion } from '@equinor/fusion-framework';
 
+/**
+ * Internal React context that holds the current {@link Fusion} instance.
+ *
+ * @remarks
+ * Consumers should not use this directly — prefer the {@link useFramework}
+ * hook or the {@link FrameworkProvider} component.
+ *
+ * @internal
+ */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export const context = createContext<Fusion<any> | null>(null);
 

package/src/create-framework-provider.tsx

@@ -8,20 +8,41 @@ import type { AnyModule, ModulesInstanceType } from '@equinor/fusion-framework-m
 import { ModuleProvider } from '@equinor/fusion-framework-react-module';
 
 /**
- * Create a framework provider for react.
+ * Creates a lazy-loaded React component that initialises a Fusion Framework
+ * instance and exposes it via context providers.
  *
- * This function is for providers of framework, like a portal.
+ * @remarks
+ * This is the low-level factory used by the {@link Framework} component.
+ * Call it when you need fine-grained control over memoisation or when you
+ * want to embed the provider in a custom `<Suspense>` boundary.
+ *
+ * The returned component is created with `React.lazy`, so it **must** be
+ * rendered inside a `<Suspense>` boundary.
+ *
+ * @template TModules - Tuple of additional module types to register.
+ * @template TRef - Type of the optional parent module-instance reference.
+ *
+ * @param cb - Callback that receives a {@link FrameworkConfigurator} (and an
+ *   optional parent ref) for registering modules and configuration.
+ * @param ref - Optional parent module instance to inherit configuration from.
+ * @returns A `React.lazy` component that provides the initialised framework
+ *   to its children.
  *
- * @param configurator - callback for configuring modules
  * @example
  * ```tsx
- * const config: FrameworkConfigurator = (config) => {}
+ * import { createFrameworkProvider } from '@equinor/fusion-framework-react';
+ *
  * const Portal = () => {
- *   const Framework = createFrameworkProvider(config);
+ *   const FrameworkProvider = createFrameworkProvider((config) => {
+ *     config.http.configureClient('my-api', { baseUri: 'https://api.example.com' });
+ *   });
+ *
  *   return (
- *      <Suspense fallback={<span>loading...</span>}>
- *          <Framework>{children}</Framework>
- *      </Suspense>
+ *     <Suspense fallback={<span>Loading…</span>}>
+ *       <FrameworkProvider>
+ *         <App />
+ *       </FrameworkProvider>
+ *     </Suspense>
  *   );
  * };
  * ```

package/src/feature-flag/index.ts

@@ -1,3 +1,13 @@
+/**
+ * Feature-flag React hooks.
+ *
+ * @remarks
+ * Available via the `@equinor/fusion-framework-react/feature-flag` sub-entry-point.
+ * Provides hooks to read, toggle, and observe feature flags at the
+ * framework or application level.
+ *
+ * @module
+ */
 export { useFeature } from './useFeature';
 export { useFeatures } from './useFeatures';
 export { useCurrentAppFeatures } from './useCurrentAppFeatures';

package/src/feature-flag/useCurrentAppFeatures.ts

@@ -3,8 +3,18 @@ import { useCurrentAppModule } from '../app';
 import { useFeatures, type UseFeaturesResult } from './useFeatures';
 
 /**
- * Custom hook that returns the current app features and provides a function to toggle a feature.
- * @returns An object containing the current app features, a function to toggle a feature, and any error that occurred.
+ * React hook that returns feature flags registered on the current application.
+ *
+ * @returns A {@link UseFeaturesResult} containing:
+ *   - `features` — Array of feature flags for the current app.
+ *   - `toggleFeature(key, enable?)` — Toggles a feature flag on or off.
+ *   - `error` — Any error from the feature-flag or app-module streams.
+ *
+ * @example
+ * ```ts
+ * const { features, toggleFeature } = useCurrentAppFeatures();
+ * toggleFeature('dark-mode', true);
+ * ```
  */
 export const useCurrentAppFeatures = (): UseFeaturesResult => {
   const { module, error: moduleError } = useCurrentAppModule<FeatureFlagModule>('featureFlag');

package/src/feature-flag/useFeature.ts

@@ -11,22 +11,39 @@ import { useObservableState } from '@equinor/fusion-observable/react';
 
 import { findFeature } from '@equinor/fusion-framework-module-feature-flag/selectors';
 
+/**
+ * Return type of the {@link useFeature} hook.
+ *
+ * @template T - Value type carried by the feature flag.
+ */
 export interface UseFeatureResult<T> {
+  /** The resolved feature flag, or `undefined` while loading. */
   feature?: IFeatureFlag<T>;
+  /** Any error emitted by the feature-flag observable. */
   error?: unknown;
   /**
-   * @param enable - Optional provide new enabled state of the feature flag. _Defaults to inversion of current feature flag state_
+   * Toggles the feature flag.
+   *
+   * @param enable - Explicit enabled state. When omitted the current state
+   *   is inverted.
    */
   toggleFeature: (enable?: boolean) => void;
 }
 
 /**
- * Custom hook that retrieves a feature flag from a feature flag provider.
+ * React hook that retrieves and manages a single feature flag.
+ *
+ * @template T - Value type carried by the feature flag.
+ * @param provider - The feature-flag provider instance.
+ * @param key - Unique key identifying the feature flag.
+ * @returns A {@link UseFeatureResult} with the flag value, toggle helper,
+ *   and any error.
  *
- * @template T - The type of the feature flag value.
- * @param {IFeatureFlagProvider} provider - The feature flag provider.
- * @param {string} key - The key of the feature flag.
- * @returns {UseFeatureResult<T>} - An object containing the feature flag value, a function to toggle the feature flag, and any error that occurred.
+ * @example
+ * ```ts
+ * const { feature, toggleFeature } = useFeature(provider, 'dark-mode');
+ * console.log(feature?.enabled);
+ * ```
  */
 export const useFeature = <T = unknown>(
   provider: IFeatureFlagProvider,

package/src/feature-flag/useFeatures.ts

@@ -12,23 +12,40 @@ import type { FeatureSelectorFn } from '@equinor/fusion-framework-module-feature
 
 import { useObservableState } from '@equinor/fusion-observable/react';
 
+/**
+ * Return type of the {@link useFeatures} hook.
+ */
 export interface UseFeaturesResult {
+  /** Array of all resolved feature flags. */
   features: IFeatureFlag[];
+  /** Any error emitted by the feature-flag observable. */
   error: unknown;
   /**
+   * Toggles a feature flag by key.
+   *
    * @param key - The key of the feature flag.
-   * @param enable - Optional provide new enabled state of the feature flag. _Defaults to inversion of current feature flag state_
+   * @param enable - Explicit enabled state. When omitted the current state
+   *   is inverted.
    */
   toggleFeature: (key: string, enable?: boolean) => void;
 }
 
 /**
- * Custom hook that provides access to the feature flags and their values.
+ * React hook that returns all feature flags from a provider, with optional
+ * filtering.
+ *
+ * @param provider - The feature-flag provider instance, or `null`/`undefined`
+ *   when not yet available.
+ * @param selector - Optional predicate to filter the feature flags.
+ * @returns A {@link UseFeaturesResult} with the flags, a toggle helper,
+ *   and any error.
+ * @throws {Error} If `toggleFeature` is called when the provider is missing.
  *
- * @param provider - The feature flag provider.
- * @param selector - Optional function to filter the feature flags.
- * @returns An object containing the features, any error that occurred while retrieving them, and a function to set the enabled state of a feature flag.
- * @throws Error if the feature flag provider is missing.
+ * @example
+ * ```ts
+ * const { features, toggleFeature } = useFeatures(provider);
+ * toggleFeature('beta', true);
+ * ```
  */
 export const useFeatures = (
   provider?: IFeatureFlagProvider | null,

package/src/feature-flag/useFrameworkFeature.ts

@@ -4,12 +4,19 @@ import { useFrameworkModule } from '../useFrameworkModule';
 import { useFeature } from './useFeature';
 
 /**
- * Custom hook that allows accessing a framework feature based on a given feature flag key.
+ * React hook that retrieves a single feature flag from the **framework-level**
+ * feature-flag provider.
  *
- * @template T - The type of the feature.
- * @param {string} key - The feature flag key.
- * @returns {ReturnType<typeof useFeature<T>>} - The result of the feature hook.
- * @throws {Error} - If feature flagging is not enabled in the framework.
+ * @template T - Value type carried by the feature flag.
+ * @param key - Unique key identifying the feature flag.
+ * @returns A {@link UseFeatureResult} with the flag value, toggle helper,
+ *   and any error.
+ * @throws {Error} If the `FeatureFlagModule` is not enabled in the framework.
+ *
+ * @example
+ * ```ts
+ * const { feature, toggleFeature } = useFrameworkFeature('experimental-ui');
+ * ```
  */
 export const useFrameworkFeature = <T>(key: string): ReturnType<typeof useFeature<T>> => {
   const provider = useFrameworkModule<FeatureFlagModule>('featureFlag');

package/src/feature-flag/useFrameworkFeatures.ts

@@ -4,10 +4,17 @@ import { useFrameworkModule } from '../useFrameworkModule';
 import { useFeatures } from './useFeatures';
 
 /**
- * Custom hook that provides access to framework-specific feature flags.
- * It returns the result of the `useFeatures` hook from the `featureFlag` module.
- * @returns The result of the `useFeatures` hook.
- * @throws Error if feature flagging is not enabled in the framework.
+ * React hook that returns all feature flags from the **framework-level**
+ * feature-flag provider.
+ *
+ * @returns A {@link UseFeaturesResult} containing all framework feature flags,
+ *   a toggle helper, and any error.
+ * @throws {Error} If the `FeatureFlagModule` is not enabled in the framework.
+ *
+ * @example
+ * ```ts
+ * const { features, toggleFeature } = useFrameworkFeatures();
+ * ```
  */
 export const useFrameworkFeatures = (): ReturnType<typeof useFeatures> => {
   const provider = useFrameworkModule<FeatureFlagModule>('featureFlag');

package/src/hooks/index.ts

@@ -1,2 +1,10 @@
+/**
+ * Convenience hooks for common framework operations.
+ *
+ * @remarks
+ * Available via the `@equinor/fusion-framework-react/hooks` sub-entry-point.
+ *
+ * @module
+ */
 export { useCurrentUser } from './use-current-user';
 export { useHttpClient } from './use-http-client';

package/src/hooks/use-current-user.ts

@@ -1,6 +1,20 @@
 import type { AccountInfo } from '@equinor/fusion-framework-module-msal';
 import { useFramework } from '../useFramework';
 
+/**
+ * React hook that returns the currently authenticated user's account info.
+ *
+ * @returns The {@link AccountInfo} of the signed-in user, or `undefined` if
+ *   no user is authenticated.
+ *
+ * @example
+ * ```tsx
+ * const UserGreeting = () => {
+ *   const user = useCurrentUser();
+ *   return <span>Hello, {user?.name ?? 'Guest'}</span>;
+ * };
+ * ```
+ */
 export const useCurrentUser = (): AccountInfo | undefined => {
   const framework = useFramework();
   return framework.modules.auth.account || undefined;

package/src/hooks/use-http-client.ts

@@ -2,9 +2,25 @@ import { useMemo } from 'react';
 import type { Fusion } from '@equinor/fusion-framework';
 import { useFramework } from '../useFramework';
 
+/** Resolved HTTP client instance returned by the framework HTTP module. */
 type HttpClient = ReturnType<Fusion['modules']['http']['createClient']>;
+
+/** Well-known HTTP client keys pre-configured by the framework. */
 type FrameworkHttpClient = 'portal' | 'people';
 
+/**
+ * React hook that returns a pre-configured HTTP client from the framework.
+ *
+ * @param name - Key of the HTTP client to retrieve (e.g. `'portal'` or `'people'`).
+ * @returns The resolved {@link HttpClient} instance.
+ * @throws {Error} If no client is configured for the given key.
+ *
+ * @example
+ * ```ts
+ * const client = useHttpClient('portal');
+ * client.fetch('/api/data').subscribe(console.log);
+ * ```
+ */
 export const useHttpClient = (name: FrameworkHttpClient): HttpClient => {
   const framework = useFramework();
 

package/src/http/index.ts

@@ -1,3 +1,13 @@
+/**
+ * HTTP sub-entry-point (`@equinor/fusion-framework-react/http`).
+ *
+ * @remarks
+ * Re-exports the framework-level {@link useHttpClient} hook as
+ * `useFrameworkHttpClient` together with all exports from the
+ * standalone HTTP React module.
+ *
+ * @module
+ */
 export { useHttpClient as useFrameworkHttpClient } from '../hooks/use-http-client';
 
 export * from '@equinor/fusion-framework-react-module-http';

package/src/index.tsx

@@ -1,4 +1,12 @@
 /**
+ * React bindings for the Fusion Framework.
+ *
+ * @remarks
+ * This package provides React components, context providers, and hooks for
+ * initialising and consuming a Fusion Framework instance inside a React
+ * application tree. It is the main entry-point for portals and host
+ * applications that need to bootstrap the framework with React.
+ *
  * [[include:framework-react/README.MD]]
  * @module
  */