@equinor/fusion-framework-module-context 8.0.3 → 9.0.0-next.0

package/dist/types/mock/module.d.ts

@@ -0,0 +1,38 @@
+import type { IModulesConfigurator } from '@equinor/fusion-framework-module';
+import { type ContextModule } from '../module';
+import { ContextMockConfigurator } from './ContextMockConfigurator';
+/**
+ * The context module with an in-memory mock configurator instead of a real
+ * context API.
+ *
+ * @remarks
+ * Only `configure` differs from the real module. `initialize` is the production
+ * one, untouched, so a test exercises the real `ContextProvider` startup path,
+ * `validateContext`/`resolveContext`, and parent-context propagation — a
+ * rehearsal of the module, not a stand-in for it.
+ */
+export declare const contextMockModule: ContextModule;
+/**
+ * Configuration callback for {@link enableContextMock}.
+ */
+export type ContextMockConfigFn = (mock: ContextMockConfigurator) => void | Promise<void>;
+/**
+ * Enables the context module against in-memory seeded data, so a test needs no
+ * context API, no HTTP mock, and no service-discovery mock.
+ *
+ * @remarks
+ * Registered last, this replaces whichever context module the configurator
+ * already carries, so it works on a `FrameworkConfigurator` that pre-registers
+ * the real one.
+ *
+ * @param configurator - The modules configurator to register on.
+ * @param configure - Optional callback to seed context items or override resolution.
+ *
+ * @example
+ * ```ts
+ * enableContextMock(configurator, (mock) => {
+ *   mock.setCurrentContext({ id: 'my-ctx', type: { id: 'ProjectMaster' }, value: {} });
+ * });
+ * ```
+ */
+export declare const enableContextMock: (configurator: IModulesConfigurator<any, any>, configure?: ContextMockConfigFn) => void;

package/dist/types/module.d.ts

@@ -2,7 +2,8 @@ import type { Module } from '@equinor/fusion-framework-module';
 import type { EventModule } from '@equinor/fusion-framework-module-event';
 import type { ServicesModule } from '@equinor/fusion-framework-module-services';
 import type { NavigationModule } from '@equinor/fusion-framework-module-navigation';
-import { type IContextModuleConfigurator } from './configurator';
+import { type TelemetryModule } from '@equinor/fusion-framework-module-telemetry';
+import { type IContextModuleConfigurator } from './ContextModuleConfigurator';
 import { type IContextProvider } from './ContextProvider';
 /**
  * Literal type identifying the context module within the Fusion Framework module system.
@@ -23,14 +24,15 @@ export declare const moduleKey: ContextModuleKey;
  * @typeParam ContextModuleKey - The unique key identifying the context module.
  * @typeParam IContextProvider - The provider interface for context-related services.
  * @typeParam IContextModuleConfigurator - The configurator interface for customizing the context module.
- * @typeParam [ServicesModule, EventModule, NavigationModule] - The tuple of dependent modules required by the context module.
+ * @typeParam [ServicesModule, EventModule, NavigationModule, TelemetryModule] - The tuple of dependent modules required by the context module.
  *
  * @see Module
  */
 export type ContextModule = Module<ContextModuleKey, IContextProvider, IContextModuleConfigurator, [
     ServicesModule,
     EventModule,
-    NavigationModule
+    NavigationModule,
+    TelemetryModule
 ]>;
 /**
  * The `module` object implements the `ContextModule` interface and provides the configuration,

package/dist/types/{get-context-selector.d.ts → selectors/get-context-selector.d.ts}

@@ -1,9 +1,7 @@
-import type { ContextItem } from './types';
+import type { ContextItem } from '../types';
 /**
  * Parse the response from the GetContext API into a context item.
  * @param response The response object containing the context item.
  * @returns A promise that resolves to the context item.
  */
 export declare const getContextSelector: (response: Response) => Promise<ContextItem>;
-export { queryContextSelector } from './query-context-selector';
-export { relatedContextSelector } from './related-context-selector';

package/dist/types/selectors/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Response selectors that parse raw context API responses into {@link ContextItem}s.
+ *
+ * - {@link getContextSelector} — parses a single-item GetContext response.
+ * - {@link queryContextSelector} — parses a multi-item QueryContext response.
+ * - {@link relatedContextSelector} — parses a multi-item RelatedContext response.
+ *
+ * @packageDocumentation
+ */
+export { getContextSelector } from './get-context-selector';
+export { queryContextSelector } from './query-context-selector';
+export { relatedContextSelector } from './related-context-selector';

package/dist/types/{query-context-selector.d.ts → selectors/query-context-selector.d.ts}

@@ -1,4 +1,4 @@
-import type { ContextItem } from './types';
+import type { ContextItem } from '../types';
 /**
  * Parse the response from the QueryContext API into an array of context items.
  * @param response The response object.

package/dist/types/{related-context-selector.d.ts → selectors/related-context-selector.d.ts}

@@ -1,4 +1,4 @@
-import type { ContextItem } from './types';
+import type { ContextItem } from '../types';
 /**
  * Parse the response from the RelatedContext API into an array of context items.
  * @param response The response object containing the related context items.

package/dist/types/utils/enable-context.d.ts

@@ -1,11 +1,10 @@
-import type { IModulesConfigurator, AnyModule, ModuleInitializerArgs } from '@equinor/fusion-framework-module';
-import type { IContextModuleConfigurator } from '../configurator';
-import type { ContextConfigBuilder } from '../ContextConfigBuilder';
+import type { IModulesConfigurator } from '@equinor/fusion-framework-module';
+import type { ContextConfigBuilderCallback } from '../ContextModuleConfigurator.interface';
 /**
  * Enables context configuration for a given modules configurator.
  *
  * @param configurator - The modules configurator instance to which the context module will be added.
- * @param builder - An optional function that receives a context configuration builder. This function can be used to further configure the context module. It can be asynchronous.
+ * @param builder - An optional function that receives the {@link IContextModuleConfigurator}. This function can be used to further configure the context module. It can be asynchronous.
  *
  * @remarks
  * This utility function adds the context module to the provided configurator and optionally applies additional configuration using the provided builder function.
@@ -21,4 +20,4 @@ import type { ContextConfigBuilder } from '../ContextConfigBuilder';
  * };
  * ```
  */
-export declare const enableContext: (configurator: IModulesConfigurator<any, any>, builder?: <TDeps extends Array<AnyModule> = []>(builder: ContextConfigBuilder<TDeps, ModuleInitializerArgs<IContextModuleConfigurator, TDeps>>) => void | Promise<void>) => void;
+export declare const enableContext: (configurator: IModulesConfigurator<any, any>, builder?: ContextConfigBuilderCallback) => void;

package/dist/types/utils/index.d.ts

@@ -5,9 +5,11 @@
  * - {@link resolveInitialContext} — default initial-context resolver (path → parent fallback).
  * - {@link extractContextIdFromPath} — extract a GUID context ID from a URL path.
  * - {@link resolveContextFromPath} — resolve a context item from a URL path.
+ * - {@link parseContextItem} — parse a raw API context entity into a `ContextItem`.
  *
  * @packageDocumentation
  */
 export { enableContext } from './enable-context';
 export { resolveInitialContext } from './resolve-initial-context';
 export { extractContextIdFromPath, resolveContextFromPath } from './resolve-context-from-path';
+export { parseContextItem } from './parse-context-item';

package/dist/types/{parse-context-item.d.ts → utils/parse-context-item.d.ts}

@@ -1,5 +1,5 @@
 import type { ApiVersion, ApiContextEntity } from '@equinor/fusion-framework-module-services/context';
-import type { ContextItem } from './types';
+import type { ContextItem } from '../types';
 /**
  * Parses an ApiContextEntity object into a ContextItem object.
  * @param item The ApiContextEntity object to parse.

package/dist/types/utils/resolve-initial-context.d.ts

@@ -1,4 +1,4 @@
-import type { ContextModuleConfig } from '../configurator';
+import type { ContextModuleConfig } from '../ContextModuleConfig';
 import { type ContextPathResolveArgs } from './resolve-context-from-path';
 /**
  * Resolves the initial context from the parent module.

package/dist/types/version.d.ts

@@ -1 +1 @@
-export declare const version = "8.0.3";
+export declare const version = "9.0.0-next.0";

package/docs/data-model.md

@@ -0,0 +1,134 @@
+# Data Model
+
+What a context item actually looks like, how context *types* relate to each other, and the
+shapes used to query and filter them.
+
+## `ContextItem`
+
+A context item is the thing your application or portal is currently scoped to — a project, a
+facility, a contract, or any other entity the Fusion context API knows about.
+
+```ts
+type ContextItem<TValue = Record<string, unknown>> = {
+  id: string;
+  type: ContextItemType;
+  value: TValue;
+  externalId?: string;
+  source?: string;
+  title?: string;
+  subTitle?: string;
+  isActive?: boolean;
+  isDeleted?: boolean;
+  created?: Date;
+  updated?: Date;
+  graphic?: string | { type: 'html' | 'svg'; content: string };
+  meta?: string | { type: 'html' | 'svg'; content: string };
+};
+```
+
+The fields that matter most day to day:
+
+- **`id`** — the identifier the context module itself uses everywhere: `setCurrentContextById`,
+  `extractContextIdFromPath`, cache keys, and equality checks (`connectParentContext` only
+  reacts when `id` actually changes).
+- **`type`** — see [`ContextItemType`](#contextitemtype-and-hierarchies) below; this is what
+  `contextType` allow-lists and `validateContext` check against.
+- **`value`** — the domain payload for this item (e.g. the actual project or facility record).
+  Type it with the generic parameter, `ContextItem<MyProjectShape>`, when you know the shape.
+- **`externalId`** and **`source`** — identifiers from an upstream system, when the context item
+  was imported or mirrored from somewhere other than the context API itself.
+- **`title`** / **`subTitle`** / **`graphic`** / **`meta`** — presentation hints for UI
+  components (e.g. a context switcher) to render without needing to know the `value` shape.
+
+> [!NOTE]
+> `ContextItem` is currently a hand-written type, not yet backed by a runtime schema — see
+> [issue #5122](https://github.com/equinor/fusion-framework/issues/5122). Values coming back
+> from a real context API are not validated at the type boundary; a custom `setContextClient`
+> is responsible for shaping its own responses correctly.
+
+## `ContextItemType` and hierarchies
+
+```ts
+interface ContextItemType {
+  id: string;
+  isChildType?: boolean;
+  parentTypeIds?: string[];
+}
+```
+
+Every context item carries a `type` that says what *kind* of entity it is — `'ProjectMaster'`,
+`'Facility'`, `'Contract'`, and so on. Types can be organized as a shallow hierarchy:
+`isChildType: true` plus `parentTypeIds` marks a type as a child of one or more parent types
+(e.g. a `'Facility'` that belongs to a `'ProjectMaster'`).
+
+This hierarchy is informational — nothing in this module walks `parentTypeIds` automatically.
+It exists so that:
+
+- application code can build a "these types are related" UI (e.g. grouping facilities under
+  their parent project) without a second API call,
+- a custom `resolveContext` or `contextParameterFn` can use `parentTypeIds` to broaden a search
+  or a relation lookup by type family instead of a single exact type ID.
+
+`setContextType(['ProjectMaster'])` restricts which type **IDs** `validateContext` accepts — it
+does not expand automatically to include child or parent types unless you list them explicitly
+or write a custom `setValidateContext`.
+
+> [!NOTE]
+> Type ID matching in `validateContext`'s default implementation is case-insensitive, so
+> `'projectmaster'` and `'ProjectMaster'` are treated the same.
+
+## Querying and relating
+
+```ts
+type QueryContextParameters = {
+  search?: string;
+  filter?: { type?: string[]; externalId?: string };
+};
+
+type RelatedContextParameters = {
+  item: ContextItem;
+  filter?: { type?: string[] };
+};
+
+type ContextFilterFn = (items: ContextItem[]) => ContextItem[];
+```
+
+- **`QueryContextParameters`** is what `queryContext`/`queryContextAsync` sends to the query
+  client, after `contextParameterFn` has had a chance to transform it — see
+  [`setContextParameterFn`](../README.md#configuration-reference) and the
+  [OData recipe](recipes.md#odata-query-parameters) for a non-default mapping.
+- **`RelatedContextParameters`** is what `relatedContexts`/`relatedContextsAsync` sends when
+  looking up items related to a given `item` — this is what the default `resolveContext`
+  uses internally when validation fails; see [Lifecycle](lifecycle.md#resolving-context).
+- **`ContextFilterFn`** (`setContextFilter`) runs *after* a query returns, entirely client-side —
+  use it to hide items the API returned but that shouldn't be selectable (e.g. `isDeleted`
+  items), as opposed to `contextParameterFn`, which shapes the request itself.
+
+## The context client
+
+`ContextClient` is the piece that actually holds "the current context" and fetches a single
+item by ID. It underlies `currentContext`/`currentContext$` on `ContextProvider` — the provider
+does not keep its own separate copy of the state.
+
+```ts
+type GetContextParameters = { id: string };
+```
+
+`currentContext$` (and `currentContext`) can be in exactly three states, and the difference
+matters for anything that reacts to it:
+
+| Value | Meaning |
+|---|---|
+| `undefined` | No context has been resolved yet — the provider hasn't initialized (or finished initial-context resolution). |
+| `null` | Context was explicitly cleared, e.g. via `clearCurrentContext()`. |
+| a `ContextItem` | A context is actively set. |
+
+Treat `undefined` and `null` differently in UI code: `undefined` usually means "still loading,
+don't show an empty state yet", while `null` means "there really is no context — show the
+picker".
+
+## Errors
+
+`ContextClient`/the query clients throw `FusionContextSearchError` for domain-specific search
+failures thrown from a custom `setContextClient`'s `query` — see
+[Errors](../README.md#errors) in the README for a full example.

package/docs/lifecycle.md

@@ -0,0 +1,163 @@
+# Lifecycle
+
+How the context module decides whether to accept a new context, how it resolves one
+automatically on startup, and how a parent/child pair of instances stay in sync.
+
+## Setting context
+
+`setCurrentContext(item, opt)` is the entry point behind `setCurrentContextById`,
+`connectParentContext`, and the initial-context resolver below. It takes two options, both
+optional and both defaulting to `true`:
+
+- **`validate`** — check `item` against `validateContext` before accepting it.
+- **`resolve`** — when validation fails, try to resolve a related item instead of throwing.
+
+```mermaid
+flowchart TD
+  callSet["setCurrentContext"] --> sameId{"same id as current context?"}
+  sameId -- "yes, unchanged" --> keepCurrent["keep current context"]
+  sameId -- "no" --> shouldValidate{"validate requested?"}
+
+  shouldValidate -- "no" --> changeEvent[["onCurrentContextChange"]]
+  changeEvent -- "canceled" --> throwChange["throw: change rejected"]
+  changeEvent -- "not canceled" --> applyContext["apply item as current context"]
+
+  shouldValidate -- "yes" --> runValidate["run validateContext"]
+  runValidate -- "valid" --> changeEvent
+  runValidate -- "invalid" --> shouldResolve{"resolve requested?"}
+
+  shouldResolve -- "no" --> throwInvalid["throw: item did not validate"]
+  shouldResolve -- "yes" --> resolveEvent[["onSetContextResolve"]]
+  resolveEvent -- "canceled" --> throwResolveCanceled["throw: resolution canceled"]
+  resolveEvent -- "not canceled" --> runResolve["run resolveContext"]
+
+  runResolve -- "failed" --> throwResolveFailed["throw: no related item resolved"]
+  runResolve -- "resolved" --> resolvedEvent[["onSetContextResolved"]]
+  resolvedEvent -- "canceled" --> throwResolvedCanceled["throw: resolved item rejected"]
+  resolvedEvent -- "not canceled" --> callSet
+```
+
+A few things worth calling out that aren't obvious from the diagram alone:
+
+- **Setting context is queued, not immediate.** Every call to `setCurrentContext` is pushed
+  onto an internal queue and processed in order — even if nobody subscribes to the returned
+  `Observable`. This means two rapid calls (e.g. a user clicking two picker items quickly)
+  resolve one after another rather than racing.
+- **Unsubscribing aborts the queued task.** If the caller unsubscribes from the returned
+  observable before it completes, that in-flight context change is aborted and removed from the
+  queue — it will not silently apply later.
+- **`onCurrentContextChange` (no "d") fires *before* the context actually changes** and is
+  cancelable — a listener calling `event.preventDefault()` makes `setCurrentContext` throw
+  instead of silently no-op-ing.
+- **`onCurrentContextChanged` (with "d") fires *after*** a change has been applied, and is
+  *not* cancelable — it's an announcement, not a gate. This is the event `connectParentContext`
+  listens for to bubble changes to a parent.
+
+## Resolving context
+
+When validation fails and `opt.resolve` is `true`, the provider looks for a related item of an
+accepted type instead of rejecting the item outright:
+
+```mermaid
+flowchart LR
+  start["run resolveContext"] --> related["fetch relatedContexts for item"]
+  related --> filterValid["keep items where validateContext passes"]
+  filterValid -- "one or more found" --> firstMatch["return the first matching item"]
+  filterValid -- "none found" --> fail["throw: no related item found"]
+```
+
+> [!NOTE]
+> If no `contextType` allow-list is configured (`setContextType`), every context item
+> validates, so resolution never has anything left to correct — see
+> [Configuration](../README.md#configuration).
+
+The default `resolveContext` implementation can be replaced entirely with `setResolveContext`
+when the "look at related items of an accepted type" strategy doesn't fit — see the
+[Configuration reference](../README.md#configuration-reference) in the README.
+
+## Resolving the initial context
+
+When a context module instance is initialized, it tries — without any application code asking
+it to — to figure out what its current context should be, in this order:
+
+1. **From the URL.** If this instance (or its parent, when nested) has a `navigation` module,
+   its current path is run through `extractContextIdFromPath` (a GUID matcher by default). If an
+   ID is found, that item is fetched via the context client's `get` and used as a candidate.
+2. **From the parent context.** If step 1 doesn't produce anything — no navigation module, no
+   ID in the path, or no matching item — the instance falls back to its parent context module's
+   *current* context, if it has one.
+3. Whichever of the two resolves first is set as the current context, with both
+   `validate: true` and `resolve: true` — so an ID found in the URL still has to pass
+   `validateContext` (and can fall through to `resolveContext`) before it "sticks".
+
+```mermaid
+flowchart TD
+  init["module initializes"] --> tryPath{"path available and id extracted?"}
+  tryPath -- "yes" --> fetchById["fetch context item by id"]
+  fetchById -- "found" --> apply["set current context, validate and resolve"]
+  fetchById -- "not found or errors" --> tryParent
+  tryPath -- "no" --> tryParent{"parent has a current context?"}
+  tryParent -- "yes" --> apply
+  tryParent -- "no" --> none["current context stays unresolved"]
+```
+
+A portal opened directly at `/apps/my-app/7fd97952-...` resolves its context straight from that
+GUID; an app embedded inside a portal with no context in its own URL instead inherits whatever
+project the portal already has selected.
+
+Replace this entire strategy with `setResolveInitialContext` when neither source fits — for
+example, an application that always derives its context from a non-GUID slug, or one that must
+never auto-adopt a parent's context. Failures here are caught and logged as a warning rather
+than thrown, so a broken initial-context lookup doesn't block the rest of module
+initialization.
+
+## Parent/child propagation
+
+Every context module instance observes its nearest ancestor's current context and mirrors it
+locally, unless a listener opts out. This is what keeps a portal's selected project and an
+embedded application's context in sync without either side polling the other — set once in the
+portal, and it propagates down; a validated change from the app can bubble back up.
+
+```mermaid
+flowchart TD
+  subgraph parent["parent instance, e.g. a portal"]
+    parentSet["setCurrentContext is called"]
+    parentObserve["listens for onCurrentContextChanged"] --> sourceCheck{"event source is a different provider?"}
+    sourceCheck -- "yes" --> parentSet
+  end
+  subgraph child["child instance, e.g. an embedded app"]
+    childSubscribe["subscribes to parent currentContext stream"] --> parentChangedEvent[["onParentContextChanged"]]
+    parentChangedEvent -- "not canceled" --> childValidate["validate context"]
+    childValidate -- "fails" --> childResolve["resolve context"]
+    childValidate -- "passes" --> childChanged[["onCurrentContextChanged"]]
+    childResolve -- "resolved" --> childChanged
+    childResolve -- "fails" --> childNone["child keeps no current context"]
+  end
+  parentSet -.->|"currentContext stream emits"| childSubscribe
+  childChanged -- "not stopped" --> parentObserve
+```
+
+- A listener calls `event.stopPropagation()` on `onCurrentContextChanged` to keep a context
+  change local, so it never reaches ancestors or siblings.
+- A listener calls `event.preventDefault()` on `onParentContextChanged` to reject an incoming
+  context change from a parent instead of mirroring it.
+- A child that fails to validate *and* resolve a parent's context is left with **no current
+  context** — the parent's context is never force-applied. This is deliberate: an app that only
+  understands `'Facility'` context shouldn't be silently handed a `'Contract'` it can't use.
+- Only the first parent-context emission after connecting can be skipped
+  (`connectParentContext(provider, { skipFirst: true })`), and even without that option, a
+  context that already matches the child's current context by `id` is ignored — so a child
+  reconnecting to a parent it's already in sync with does not re-trigger validation.
+
+```ts
+// constrain a context change to this instance only, never bubbling to ancestors
+modules.event.addEventListener('onCurrentContextChanged', (event) => {
+  if (event.source === modules.context) {
+    event.stopPropagation();
+  }
+});
+```
+
+See [Events](../README.md#events) in the README for the full list of dispatched events and
+whether each is cancelable, and [Data model](data-model.md) for what a context item and its
+`type` actually look like.

package/docs/recipes.md

@@ -0,0 +1,89 @@
+# Recipes
+
+Configuration patterns that go beyond the [Configuration reference](../README.md#configuration-reference)
+in the README.
+
+## OData query parameters
+
+`setContextParameterFn` maps a search + type into the parameters `setContextClient`'s `query`
+receives. The default shape is a plain `{ search, filter: { type } }` object, but a context API
+backed by OData can build the filter with [`odata-query`](https://www.npmjs.com/package/odata-query)
+instead:
+
+```ts
+import buildQuery from 'odata-query';
+
+enableContext(configurator, (builder) => {
+  builder.setContextParameterFn(({ search, type }) =>
+    buildQuery({
+      search,
+      filter: { type: { in: type } },
+    }),
+  );
+});
+```
+
+## Rewriting a path on context change
+
+`setContextPathGenerator` builds the URL a navigation module pushes to when the current
+context changes. Beyond a simple GUID swap, a path can also carry an application-specific key
+derived from the resolved item:
+
+```ts
+enableContext(configurator, (builder) => {
+  builder.setContextPathGenerator((item, path) => {
+    // /app/old-app-key/overview -> /app/new-app-key/overview
+    return path.replace(/^(\/)?app\/[^/]+(.*)$/, `/app/${item.value.appKey}$2`);
+  });
+});
+```
+
+Pair this with a matching `setContextPathExtractor` so the same key round-trips back into a
+context id on page load — see [setContextPathExtractor](../README.md#configuration-reference)
+in the README.
+
+## Accepting a family of related context types
+
+`setContextType` matches exact type IDs, so an allow-list of `['ProjectMaster']` rejects a
+`'Facility'` item even if that facility's [`ContextItemType.parentTypeIds`](data-model.md#contextitemtype-and-hierarchies)
+includes `'ProjectMaster'`. To accept a type *and* its declared children, widen validation
+instead of the allow-list:
+
+```ts
+enableContext(configurator, (builder) => {
+  const acceptedTypes = ['ProjectMaster'];
+
+  builder.setContextType(acceptedTypes);
+  builder.setValidateContext((item) => {
+    if (acceptedTypes.includes(item.type.id)) return true;
+    return Boolean(item.type.isChildType && item.type.parentTypeIds?.some((id) => acceptedTypes.includes(id)));
+  });
+});
+```
+
+This keeps `setContextType` as the source of truth for the query allow-list (so searches still
+scope to the right types server-side) while letting validation reason about the type hierarchy.
+
+## Skipping the default initial-context lookup
+
+By default, a newly initialized instance tries to resolve its context from the URL, then from
+its parent — see [Resolving the initial context](lifecycle.md#resolving-the-initial-context).
+An application that manages its own startup context entirely (e.g. from application state
+rather than the URL or a parent) can replace that lookup outright:
+
+```ts
+import { EMPTY } from 'rxjs';
+
+enableContext(configurator, (builder) => {
+  // never auto-resolve an initial context; the application sets one explicitly later
+  builder.setResolveInitialContext(() => EMPTY);
+});
+```
+
+## Custom search errors
+
+`FusionContextSearchError`, thrown from `setContextClient`'s `query`, lets an application
+surface a domain-specific search failure instead of a generic error — see the
+[app-react-context-custom-error](https://github.com/equinor/fusion-framework/tree/main/cookbooks/app-react-context-custom-error/src/config.ts)
+cookbook for a complete example.
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@equinor/fusion-framework-module-context",
-  "version": "8.0.3",
+  "version": "9.0.0-next.0",
   "description": "",
   "main": "./dist/esm/index.js",
   "exports": {
@@ -16,6 +16,14 @@
       "import": "./dist/esm/utils/index.js",
       "types": "./dist/types/utils/index.d.ts"
     },
+    "./mock": {
+      "import": "./dist/esm/mock/index.js",
+      "types": "./dist/types/mock/index.d.ts"
+    },
+    "./mock/fixtures": {
+      "import": "./dist/esm/mock/fixtures/index.js",
+      "types": "./dist/types/mock/fixtures/index.d.ts"
+    },
     "./package.json": "./package.json"
   },
   "types": "./dist/types/index.d.ts",
@@ -29,6 +37,12 @@
       ],
       "utils": [
         "dist/types/utils/index.d.ts"
+      ],
+      "mock": [
+        "dist/types/mock/index.d.ts"
+      ],
+      "mock/fixtures": [
+        "dist/types/mock/fixtures/index.d.ts"
       ]
     }
   },
@@ -45,25 +59,39 @@
   },
   "dependencies": {
     "fast-deep-equal": "^3.1.3",
-    "@equinor/fusion-query": "^7.0.3"
+    "@equinor/fusion-query": "^7.0.4-next.0"
   },
   "devDependencies": {
+    "@faker-js/faker": "^10.1.0",
     "rxjs": "^7.8.1",
     "typescript": "^7.0.2",
     "@types/semver": "^7.0.0",
     "semver": "^7.0.0",
-    "@equinor/fusion-framework-module-event": "^6.0.1",
-    "@equinor/fusion-framework-module-navigation": "^7.0.7",
-    "@equinor/fusion-framework-module": "^6.1.2",
-    "@equinor/fusion-framework-module-services": "^8.1.0"
+    "@equinor/fusion-framework-module": "^6.1.3-next.0",
+    "@equinor/fusion-framework-module-event": "^6.1.0-next.0",
+    "@equinor/fusion-framework-module-http": "^8.1.0-next.0",
+    "@equinor/fusion-framework-module-navigation": "^7.0.8-next.0",
+    "@equinor/fusion-framework-module-services": "^8.1.1-next.0",
+    "@equinor/fusion-framework-module-telemetry": "^8.0.0-next.0"
   },
   "peerDependencies": {
+    "@faker-js/faker": "^10.1.0",
     "@types/semver": "^7.0.0",
     "semver": "^7.0.0",
     "rxjs": "^7.0.0",
-    "@equinor/fusion-framework-module": "^6.1.2"
+    "@equinor/fusion-framework-module": "^6.1.3-next.0",
+    "@equinor/fusion-framework-module-telemetry": "^8.0.0-next.0"
+  },
+  "peerDependenciesMeta": {
+    "@equinor/fusion-framework-module-telemetry": {
+      "optional": true
+    },
+    "@faker-js/faker": {
+      "optional": true
+    }
   },
   "scripts": {
-    "build": "tsc -b"
+    "build": "tsc -b",
+    "test": "vitest run"
   }
 }