@equinor/fusion-framework-module-context 7.0.4-next.0 → 8.0.1

package/dist/types/ContextConfigBuilder.d.ts

@@ -3,6 +3,14 @@ import type { QueryCtorOptions, QueryFn } from '@equinor/fusion-query';
 import type { GetContextParameters } from './client/ContextClient';
 import type { ContextModuleConfig, ContextModuleConfigurator, IContextModuleConfigurator } from './configurator';
 import type { ContextItem, QueryContextParameters, RelatedContextParameters } from './types';
+/**
+ * Callback passed to {@link IContextModuleConfigurator.addConfigBuilder}.
+ *
+ * Receives a {@link ContextConfigBuilder} and may use its setter methods
+ * to populate the context module configuration. The callback may be async.
+ *
+ * @typeParam TDeps - Module dependency array inferred from the configurator.
+ */
 export type ContextConfigBuilderCallback = <TDeps extends Array<AnyModule> = []>(builder: ContextConfigBuilder<TDeps, ModuleInitializerArgs<IContextModuleConfigurator, TDeps>>) => void | Promise<void>;
 /**
  * A builder class for configuring and customizing context module behavior within the Fusion Framework.
@@ -27,7 +35,7 @@ export type ContextConfigBuilderCallback = <TDeps extends Array<AnyModule> = []>
  * - The builder pattern allows chaining configuration methods for clarity and convenience.
  * - The `requireInstance` method enables asynchronous retrieval of module instances by name.
  *
- * @todo - this should extend the BaseConfigBuilder
+ * @todo(#5120) - this should extend the BaseConfigBuilder
  *
  * @see ContextModuleConfig
  * @see ModuleInitializerArgs
@@ -35,8 +43,23 @@ export type ContextConfigBuilderCallback = <TDeps extends Array<AnyModule> = []>
 export declare class ContextConfigBuilder<TModules extends Array<AnyModule> = [], TInit extends ModuleInitializerArgs<any, any> = ModuleInitializerArgs<ContextModuleConfigurator, TModules>> {
     #private;
     config: Partial<ContextModuleConfig>;
+    /**
+     * Creates a new `ContextConfigBuilder`.
+     * @param init - Module initializer arguments used to resolve module instances.
+     * @param config - The partial context module config to build upon.
+     */
     constructor(init: TInit, config?: Partial<ContextModuleConfig>);
+    /**
+     * Requires a module instance by its registered key.
+     * @param module - The key of the module to resolve.
+     * @returns A promise that resolves to the requested module instance.
+     */
     requireInstance<TKey extends string = Extract<keyof Modules, string>>(module: TKey): Promise<ModuleType<Modules[TKey]>>;
+    /**
+     * Requires a module instance by name.
+     * @param module - The name of the module to resolve.
+     * @returns A promise that resolves to the requested module instance.
+     */
     requireInstance<T>(module: string): Promise<T>;
     /**
      * Sets the context type for the current configuration.
@@ -87,6 +110,13 @@ export declare class ContextConfigBuilder<TModules extends Array<AnyModule> = []
      * @param fn - A function that takes a context and generates a corresponding path.
      */
     setContextPathGenerator(fn: ContextModuleConfig['generatePathFromContext']): void;
+    /**
+     * Sets the function used to resolve the initial context during module post-initialization.
+     *
+     * @param fn - A function that returns an observable input emitting the initial context item.
+     *             The default resolver extracts a context ID from the navigation path, falling
+     *             back to the parent provider's current context.
+     */
     setResolveInitialContext(fn: ContextModuleConfig['resolveInitialContext']): void;
     /**
      * Sets the context client configuration for fetching context items.

package/dist/types/ContextProvider.d.ts

@@ -290,12 +290,40 @@ export interface IContextProvider {
  */
 export declare class ContextProvider extends BaseModuleProvider<ContextModuleConfig> implements IContextProvider {
     #private;
+    /**
+     * The underlying context client used to resolve and hold the current context item.
+     * @returns The internal {@link ContextClient} instance.
+     */
     get contextClient(): ContextClient;
+    /**
+     * The query client used to search for context items.
+     * @returns The internal `Query` instance used by {@link queryContext}.
+     */
     get queryClient(): Query<ContextItem[], QueryContextParameters>;
+    /**
+     * Observable stream emitting the current context item.
+     * @returns Observable that emits the current `ContextItem`, `null`, or `undefined`.
+     */
     get currentContext$(): Observable<ContextItem | null | undefined>;
+    /**
+     * Snapshot of the current context item.
+     * @returns The current `ContextItem`, or `null`/`undefined` if not set.
+     */
     get currentContext(): ContextItem | undefined | null;
-    /** @deprecated do not use, will be removed */
+    /**
+     * Sets the current context item.
+     * @deprecated do not use, will be removed
+     * @param context - The context item to set as current. Must not be `undefined`.
+     * @throws Error if `context` is `undefined`.
+     */
     set currentContext(context: ContextItem | null | undefined);
+    /**
+     * Creates a new instance of `ContextProvider`.
+     * @param args - Constructor arguments.
+     * @param args.config - The context module configuration.
+     * @param args.event - Optional event module instance for dispatching context change events.
+     * @param args.parentContext - Optional parent context provider. Deprecated, use {@link connectParentContext}.
+     */
     constructor(args: {
         config: ContextModuleConfig;
         event?: ModuleType<EventModule>;
@@ -357,6 +385,11 @@ export declare class ContextProvider extends BaseModuleProvider<ContextModuleCon
      * If the observable is subscribe, unsubscribing __WILL__ abort the task and remove it from queue
      *
      * @param context context item which would be queue to set as current
+     * @param opt Optional settings.
+     * @param opt.validate Whether to validate the context item before setting it.
+     * @param opt.resolve Whether to attempt to resolve the context item if validation fails.
+     * @template T The type of the context item, which extends `ContextItem<Record<string, unknown>>` or can be `null`.
+     * @returns An observable that emits the context item once the queued task completes.
      */
     setCurrentContext<T extends ContextItem<Record<string, unknown>> | null>(context: T, opt?: {
         validate?: boolean;
@@ -391,7 +424,7 @@ export declare class ContextProvider extends BaseModuleProvider<ContextModuleCon
      *    - Emit the context and complete the observable.
      *
      * @protected
-     * @typeParam T - The type of the context item, which extends `ContextItem<Record<string, unknown>>` or can be `null`.
+     * @template T - The type of the context item, which extends `ContextItem<Record<string, unknown>>` or can be `null`.
      * @param context - The new context to set.
      * @param opt - Optional settings:
      *   - `validate`: Whether to validate the context before setting.
@@ -412,7 +445,7 @@ export declare class ContextProvider extends BaseModuleProvider<ContextModuleCon
      *
      * @see {@link setCurrentContext} for more details.
      *
-     * @typeParam T - The type of the context item, which extends `ContextItem<Record<string, unknown>>` or can be `null`.
+     * @template T - The type of the context item, which extends `ContextItem<Record<string, unknown>>` or can be `null`.
      * @param context - The context item to set as the current context, or `null` to clear it.
      * @param opt - Optional settings for context handling.
      * @param opt.validate - If `true`, validates the context before setting it.
@@ -433,6 +466,7 @@ export declare class ContextProvider extends BaseModuleProvider<ContextModuleCon
      *
      * @param search - The search string to filter context items.
      * @returns An Observable that emits an array of `ContextItem` objects matching the search criteria.
+     * @throws Re-throws the underlying cause of a `QueryClientError`, otherwise re-throws the original error.
      */
     queryContext(search: string): Observable<Array<ContextItem>>;
     /**
@@ -514,26 +548,63 @@ export declare class ContextProvider extends BaseModuleProvider<ContextModuleCon
 export default ContextProvider;
 declare module '@equinor/fusion-framework-module-event' {
     interface FrameworkEventMap {
+        /**
+         * Dispatched **before** the current context is changed.
+         *
+         * The event is cancelable — calling `event.preventDefault()` in a
+         * listener will abort the context change.
+         */
         onCurrentContextChange: FrameworkEvent<FrameworkEventInit<{
             context: ContextItem | null;
         }, IContextProvider>>;
+        /**
+         * Dispatched **after** the current context has changed.
+         *
+         * Contains both the previous and next context items, enabling
+         * listeners to react to transitions.
+         */
         onCurrentContextChanged: FrameworkEvent<FrameworkEventInit<{
             next: ContextItem | null;
             previous?: ContextItem | null;
         }, IContextProvider>>;
+        /**
+         * Dispatched **before** a parent context change is applied locally.
+         *
+         * Cancelable — prevents the parent context from being mirrored into
+         * this provider.
+         */
         onParentContextChanged: FrameworkEvent<FrameworkEventInit<{
             context: ContextItem | null;
         }, IContextProvider>>;
+        /**
+         * Dispatched **before** context resolution begins (when validation
+         * fails and the caller requested resolution).
+         *
+         * Cancelable — aborting prevents the resolution attempt.
+         */
         onSetContextResolve: FrameworkEvent<FrameworkEventInit<{
             context: ContextItem;
         }, IContextProvider>>;
+        /**
+         * Dispatched **after** the context has been resolved to a new item.
+         *
+         * Cancelable — aborting prevents the resolved item from being
+         * set as the current context.
+         */
         onSetContextResolved: FrameworkEvent<FrameworkEventInit<{
             context: ContextItem;
             resolved?: ContextItem | null;
         }, IContextProvider>>;
+        /**
+         * Dispatched when context validation fails and resolution is not
+         * enabled.
+         */
         onSetContextValidationFailed: FrameworkEvent<FrameworkEventInit<{
             context: ContextItem;
         }, IContextProvider>>;
+        /**
+         * Dispatched when context resolution fails with an error.
+         */
         onSetContextResolveFailed: FrameworkEvent<FrameworkEventInit<{
             context: ContextItem;
             error: unknown;

package/dist/types/client/ContextClient.d.ts

@@ -20,7 +20,7 @@ export type GetContextParameters = {
  * @template ContextItem The type of the context item managed by the client.
  * @extends Observable<ContextItem | null | undefined>
  *
- * @todo - should this have `undefined` as a valid value?
+ * @todo(#5116) - should this have `undefined` as a valid value?
  *
  * @example
  * ```typescript
@@ -55,6 +55,10 @@ export declare class ContextClient extends Observable<ContextItem | null | undef
     get client(): Query<ContextItem, {
         id: string;
     }>;
+    /**
+     * Creates a new `ContextClient`.
+     * @param options - Query constructor options used to fetch a `ContextItem` by its ID.
+     */
     constructor(options: QueryCtorOptions<ContextItem, GetContextParameters>);
     /**
      * Sets the current context based on the provided identifier or context item.
@@ -85,6 +89,9 @@ export declare class ContextClient extends Observable<ContextItem | null | undef
     resolveContextAsync(id: string, opt?: {
         awaitResolve: boolean;
     }): Promise<ContextItem>;
+    /**
+     * Disposes of the client, completing the internal current-context subject.
+     */
     dispose(): void;
 }
 export default ContextClient;

package/dist/types/configurator.d.ts

@@ -7,46 +7,176 @@ import type { ContextFilterFn, ContextItem, QueryContextParameters, RelatedConte
 import type { GetContextParameters } from './client/ContextClient';
 import { type ContextConfigBuilderCallback } from './ContextConfigBuilder';
 import type { IContextProvider } from './ContextProvider';
+/**
+ * Resolved configuration for the context module.
+ *
+ * Holds query clients, type filters, parent-connection settings, and
+ * optional callbacks for validation, resolution, and path integration.
+ * Produced by {@link ContextModuleConfigurator.createConfig} after all
+ * {@link ContextConfigBuilder} callbacks have run.
+ *
+ * @see ContextConfigBuilder — fluent API for populating this config.
+ * @see ContextProvider — runtime consumer of this config.
+ */
 export interface ContextModuleConfig {
+    /**
+     * Query client options used to fetch, search, and resolve related context items.
+     *
+     * - `get` — retrieves a single context item by ID.
+     * - `query` — searches context items by text and optional type filter.
+     * - `related` — fetches context items related to a given item (used during resolution).
+     */
     client: {
         get: QueryCtorOptions<ContextItem, GetContextParameters>;
         query: QueryCtorOptions<ContextItem[], QueryContextParameters>;
         related?: QueryCtorOptions<ContextItem[], RelatedContextParameters>;
     };
+    /**
+     * Allowed context type IDs (e.g. `['ProjectMaster', 'Facility']`).
+     *
+     * When set, {@link ContextProvider.validateContext} only accepts items
+     * whose `type.id` matches one of these values (case-insensitive).
+     */
     contextType?: string[];
+    /**
+     * Optional post-query filter applied to the result set returned by
+     * {@link ContextProvider.queryContext}.
+     */
     contextFilter?: ContextFilterFn;
     /**
-     * connect context module to paren context module.
+     * Whether to connect the context module to a parent context module.
+     *
+     * When `true` (the default), the provider subscribes to the parent's
+     * `currentContext$` and mirrors changes into its own state.
      *
-     * _default: `true`_
+     * @defaultValue `true`
      */
     connectParentContext?: boolean;
-    /** set initial context from parent, will await resolve */
+    /**
+     * When `true`, skips resolving an initial context from the path or parent
+     * during module post-initialization.
+     */
     skipInitialContext?: boolean;
+    /**
+     * Extracts a context ID from a URL path segment.
+     *
+     * Used during initial context resolution and deep-link support.
+     * If not provided, the default GUID-based extractor is used.
+     *
+     * @param path - The URL path to inspect.
+     * @returns The extracted context ID, or `undefined` if none is found.
+     */
     extractContextIdFromPath?: (path: string) => string | undefined;
+    /**
+     * Generates a URL path that embeds the given context item's ID.
+     *
+     * Used by navigation integrations to update the browser URL when
+     * the context changes.
+     *
+     * @param context - The active context item.
+     * @param path - The current URL path.
+     * @returns The updated path, or `undefined` to leave it unchanged.
+     */
     generatePathFromContext?: (context: ContextItem, path: string) => string | undefined;
     /**
-     * Method for generating context query parameters.
+     * Transforms a user search string and the configured context type into
+     * the query parameters sent to the context API.
+     *
+     * Override this to customise how free-text searches are mapped to the
+     * backend query contract.
      */
     contextParameterFn?: (args: {
         search: string;
         type: ContextModuleConfig['contextType'];
     }) => string | QueryContextParameters;
+    /**
+     * Custom context resolution strategy.
+     *
+     * Called with `this` bound to the {@link IContextProvider} when a context
+     * item fails validation and the caller requests resolution.
+     *
+     * @param item - The context item to resolve, or `null`.
+     * @returns An observable emitting the resolved context item.
+     */
     resolveContext?: (this: IContextProvider, item: ContextItem | null) => ReturnType<IContextProvider['resolveContext']>;
+    /**
+     * Custom context validation strategy.
+     *
+     * Called with `this` bound to the {@link IContextProvider} to decide
+     * whether a candidate context item is acceptable.
+     *
+     * @param item - The context item to validate, or `null`.
+     * @returns `true` if the item is valid.
+     */
     validateContext?: (this: IContextProvider, item: ContextItem | null) => ReturnType<IContextProvider['validateContext']>;
+    /**
+     * Resolves the initial context during module post-initialization.
+     *
+     * The default implementation tries to extract a context ID from the
+     * current navigation path, falling back to the parent provider's context.
+     *
+     * @param args - Module reference and instance map.
+     * @returns An observable input emitting the initial context item, or void.
+     */
     resolveInitialContext?: (args: {
         ref?: AnyModuleInstance | any;
         modules: ModuleInstance;
     }) => ObservableInput<ContextItem | void>;
 }
+/**
+ * Public configurator contract for the context module.
+ *
+ * Consumers call {@link addConfigBuilder} to register one or more
+ * {@link ContextConfigBuilderCallback} functions that will run during
+ * module initialization to populate the {@link ContextModuleConfig}.
+ */
 export interface IContextModuleConfigurator {
+    /**
+     * Registers a configuration callback that receives a {@link ContextConfigBuilder}.
+     *
+     * Multiple builders can be added; they execute sequentially and merge
+     * their results into a single {@link ContextModuleConfig}.
+     *
+     * @param init - Builder callback invoked during module initialization.
+     */
     addConfigBuilder: (init: ContextConfigBuilderCallback) => void;
 }
+/**
+ * Default implementation of {@link IContextModuleConfigurator}.
+ *
+ * Collects {@link ContextConfigBuilderCallback} registrations and, when
+ * {@link createConfig} is called, runs them in order against a
+ * {@link ContextConfigBuilder} to produce the final {@link ContextModuleConfig}.
+ *
+ * If no custom client is configured, the configurator falls back to
+ * creating one from the {@link ServicesModule} API provider.
+ */
 export declare class ContextModuleConfigurator implements IContextModuleConfigurator {
     #private;
+    /** Default cache TTL (in ms) for context query results. */
     defaultExpireTime: number;
+    /** @inheritdoc */
     addConfigBuilder(init: ContextConfigBuilderCallback): void;
+    /**
+     * Resolves the services API provider, preferring the local module
+     * instance and falling back to the parent module.
+     *
+     * @param init - Module initializer arguments.
+     * @returns The resolved API provider.
+     * @throws Error if no services module is available.
+     */
     protected _getServiceProvider(init: ModuleInitializerArgs<IContextModuleConfigurator, [ServicesModule]>): Promise<IApiProvider>;
+    /**
+     * Runs all registered config builders and produces the final
+     * {@link ContextModuleConfig}.
+     *
+     * If no `resolveInitialContext` was set, the default path + parent
+     * resolver is used. If no `client` was set, one is created from the
+     * {@link ServicesModule} API provider.
+     *
+     * @param init - Module initializer arguments including dependency instances.
+     * @returns The fully resolved context module configuration.
+     */
     createConfig(init: ModuleInitializerArgs<IContextModuleConfigurator, [ServicesModule, NavigationModule]>): Promise<ContextModuleConfig>;
 }
 export default ContextModuleConfigurator;

package/dist/types/{errors.d.ts → errors/FusionContextSearchError.d.ts}

@@ -16,10 +16,12 @@ export declare class FusionContextSearchError extends Error {
     #private;
     /**
      * The title of the error.
+     * @returns The error title.
      */
     get title(): string;
     /**
      * The description of the error, if available.
+     * @returns The error description, or `undefined` if none was provided.
      */
     get description(): string | undefined;
     /**

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

@@ -0,0 +1 @@
+export * from './FusionContextSearchError';

package/dist/types/get-context-selector.d.ts

@@ -0,0 +1,9 @@
+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/index.d.ts

@@ -1,3 +1,15 @@
+/**
+ * Context module for the Fusion Framework.
+ *
+ * Provides context management for Fusion-based applications and portals,
+ * including setting, querying, validating, and resolving context items.
+ *
+ * Use {@link enableContext} to register the module in a configurator,
+ * then access the {@link IContextProvider} from the module instance
+ * to interact with context state.
+ *
+ * @packageDocumentation
+ */
 export { ContextModuleConfigurator, IContextModuleConfigurator, ContextModuleConfig, } from './configurator';
 export { IContextProvider, ContextProvider } from './ContextProvider';
 export { default, ContextModule, module as contextModule, moduleKey as contextModuleKey, } from './module';

package/dist/types/module.d.ts

@@ -4,7 +4,18 @@ 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 IContextProvider } from './ContextProvider';
+/**
+ * Literal type identifying the context module within the Fusion Framework module system.
+ *
+ * Used as the key when registering or looking up the module in a `Modules` map.
+ */
 export type ContextModuleKey = 'context';
+/**
+ * Module registration key for the context module.
+ *
+ * Pass this value—or reference it as `contextModuleKey`—when you need to
+ * identify the context module by name at runtime (e.g., `hasModule(contextModuleKey)`).
+ */
 export declare const moduleKey: ContextModuleKey;
 /**
  * Represents a module for managing context within the framework.

package/dist/types/parse-context-item.d.ts

@@ -0,0 +1,8 @@
+import type { ApiVersion, ApiContextEntity } from '@equinor/fusion-framework-module-services/context';
+import type { ContextItem } from './types';
+/**
+ * Parses an ApiContextEntity object into a ContextItem object.
+ * @param item The ApiContextEntity object to parse.
+ * @returns The parsed ContextItem object.
+ */
+export declare const parseContextItem: (item: ApiContextEntity<ApiVersion.v1>) => ContextItem;

package/dist/types/query-context-selector.d.ts

@@ -0,0 +1,7 @@
+import type { ContextItem } from './types';
+/**
+ * Parse the response from the QueryContext API into an array of context items.
+ * @param response The response object.
+ * @returns A promise that resolves to an array of context items.
+ */
+export declare const queryContextSelector: (response: Response) => Promise<ContextItem[]>;

package/dist/types/related-context-selector.d.ts

@@ -0,0 +1,7 @@
+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.
+ * @returns A promise that resolves to an array of ContextItem objects.
+ */
+export declare const relatedContextSelector: (response: Response) => Promise<ContextItem[]>;

package/dist/types/types.d.ts

@@ -16,7 +16,7 @@
  * @property graphic - Optional graphical representation, either as a string or an object containing type and content.
  * @property meta - Optional meta information, either as a string or an object containing type and content.
  *
- * @todo - convert to Zod schema for validation and type safety.
+ * @todo(#5122) - convert to Zod schema for validation and type safety.
  */
 export type ContextItem<TType extends Record<string, unknown> = Record<string, unknown>> = {
     id: string;
@@ -39,11 +39,33 @@ export type ContextItem<TType extends Record<string, unknown> = Record<string, u
         content: string;
     };
 };
+/**
+ * Describes the type classification of a {@link ContextItem}.
+ *
+ * Every context item carries a `type` that identifies what kind of
+ * entity it represents (e.g. `ProjectMaster`, `Facility`, `Contract`).
+ * The optional hierarchy fields indicate parent–child relationships
+ * between context types.
+ */
 export interface ContextItemType {
+    /** Unique identifier for the context type (e.g. `'ProjectMaster'`). */
     id: string;
+    /** Whether this type is a child of another context type. */
     isChildType?: boolean;
+    /** IDs of parent context types, when `isChildType` is `true`. */
     parentTypeIds?: string[];
 }
+/**
+ * Parameters for querying context items from the context API.
+ *
+ * Used by {@link ContextProvider.queryContext} and the underlying
+ * query client to search and filter context results.
+ *
+ * @property search - Free-text search term.
+ * @property filter - Optional structured filters.
+ * @property filter.type - Restrict results to specific context type IDs.
+ * @property filter.externalId - Filter by an external system identifier.
+ */
 export type QueryContextParameters = {
     search?: string;
     filter?: {

package/dist/types/utils/extract-context-id-from-path.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Method will try to extract a context id from a path.
+ * The default matcher is a GUID pattern.
+ * Will iterate over the path and return the first match.
+ *
+ * @example
+ * ```ts
+ * const path = '/apps/context/7fd97952-7fe6-409b-a6dc-292dbf0e50d7?dsadasdas#example';
+ * const contextId = extractContextIdFromPath(path); // '7fd97952-7fe6-409b-a6dc-292dbf0e50d7'
+ * ```
+ *
+ * @param path string - the path to extract the context id from
+ * @param matcher RegExp - the pattern to match against
+ * @returns string | undefined - the context id or undefined
+ */
+export declare const extractContextIdFromPath: (path: string, matcher?: RegExp) => string | undefined;

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

@@ -1,3 +1,13 @@
+/**
+ * Utility functions for context module configuration and initialization.
+ *
+ * - {@link enableContext} — register the context module on a configurator.
+ * - {@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.
+ *
+ * @packageDocumentation
+ */
 export { enableContext } from './enable-context';
 export { resolveInitialContext } from './resolve-initial-context';
 export { extractContextIdFromPath, resolveContextFromPath } from './resolve-context-from-path';

package/dist/types/utils/resolve-context-from-path.d.ts

@@ -2,6 +2,7 @@ import { type Observable } from 'rxjs';
 import type { ModuleType } from '@equinor/fusion-framework-module';
 import type { ContextModule } from '../module';
 import type { ContextItem } from '../types';
+export { extractContextIdFromPath } from './extract-context-id-from-path';
 /**
  * Arguments for resolving a context from a path.
  */
@@ -19,22 +20,6 @@ export type ContextPathResolveArgs = {
      */
     validate?: (contextId: string) => boolean;
 };
-/**
- * Method will try to extract a context id from a path.
- * The default matcher is a GUID pattern.
- * Will iterate over the path and return the first match.
- *
- * @example
- * ```ts
- * const path = '/apps/context/7fd97952-7fe6-409b-a6dc-292dbf0e50d7?dsadasdas#example';
- * const contextId = extractContextIdFromPath(path); // '7fd97952-7fe6-409b-a6dc-292dbf0e50d7'
- * ```
- *
- * @param path string - the path to extract the context id from
- * @param matcher RegExp - the pattern to match against
- * @returns string | undefined - the context id or undefined
- */
-export declare const extractContextIdFromPath: (path: string, matcher?: RegExp) => string | undefined;
 /**
  * Method will try to resolve a context from a path.
  * The method will return a function that takes a path and returns an observable of the resolved context.

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

@@ -17,5 +17,5 @@ export declare const resolveContextFromParent: ContextModuleConfig['resolveIniti
  */
 export declare const resolveInitialContext: (options?: {
     path?: ContextPathResolveArgs;
-}) => Required<ContextModuleConfig>["resolveInitialContext"];
+}) => Required<ContextModuleConfig>['resolveInitialContext'];
 export default resolveInitialContext;

package/dist/types/version.d.ts

@@ -1 +1 @@
-export declare const version = "7.0.4-next.0";
+export declare const version = "8.0.1";