@equinor/fusion-framework-module-context 4.0.0-next.8 → 4.0.0

package/dist/types/ContextConfigBuilder.d.ts

@@ -15,7 +15,7 @@ export declare class ContextConfigBuilder<TModules extends Array<AnyModule> = []
     setContextParameterFn(fn: ContextModuleConfig['contextParameterFn']): void;
     setValidateContext(fn: ContextModuleConfig['validateContext']): void;
     setResolveContext(fn: ContextModuleConfig['resolveContext']): void;
-    setSkipInitialContext(skip: ContextModuleConfig['skipInitialContext']): void;
+    setResolveInitialContext(fn: ContextModuleConfig['resolveInitialContext']): void;
     setContextClient(client: {
         get: QueryFn<ContextItem, GetContextParameters> | QueryCtorOptions<ContextItem, GetContextParameters>;
         query: QueryFn<ContextItem[], QueryContextParameters> | QueryCtorOptions<ContextItem[], QueryContextParameters>;

package/dist/types/ContextProvider.d.ts

@@ -8,8 +8,8 @@ import Query from '@equinor/fusion-query';
 export interface IContextProvider {
     readonly contextClient: ContextClient;
     readonly queryClient: Query<ContextItem[], QueryContextParameters>;
-    readonly currentContext$: Observable<ContextItem | undefined>;
-    currentContext: ContextItem | undefined;
+    readonly currentContext$: Observable<ContextItem | null | undefined>;
+    currentContext: ContextItem | null | undefined;
     queryContext(search: string): Observable<Array<ContextItem>>;
     queryContextAsync(search: string): Promise<Array<ContextItem>>;
     validateContext(item: ContextItem<Record<string, unknown>>): boolean;
@@ -20,40 +20,40 @@ export interface IContextProvider {
     clearCurrentContext: VoidFunction;
     setCurrentContextById(id: string): Observable<ContextItem<Record<string, unknown>>>;
     setCurrentContextByIdAsync(id: string): Promise<ContextItem<Record<string, unknown>>>;
-    setCurrentContext(context: ContextItem<Record<string, unknown>>, opt?: {
+    setCurrentContext(context: ContextItem<Record<string, unknown>> | null, opt?: {
         validate?: boolean;
         resolve?: boolean;
-    }): Observable<ContextItem<Record<string, unknown>>>;
-    setCurrentContextAsync(context: ContextItem<Record<string, unknown>>, opt?: {
+    }): Observable<ContextItem<Record<string, unknown>> | null>;
+    setCurrentContextAsync(context: ContextItem<Record<string, unknown>> | null, opt?: {
         validate?: boolean;
         resolve?: boolean;
-    }): Promise<ContextItem<Record<string, unknown>>>;
+    }): Promise<ContextItem<Record<string, unknown>> | null>;
 }
 export declare class ContextProvider implements IContextProvider {
     #private;
     get contextClient(): ContextClient;
     get queryClient(): Query<ContextItem<Record<string, unknown>>[], QueryContextParameters>;
-    get currentContext$(): Observable<ContextItem | undefined>;
-    get currentContext(): ContextItem | undefined;
-    set currentContext(context: ContextItem | undefined);
+    get currentContext$(): Observable<ContextItem | null | undefined>;
+    get currentContext(): ContextItem | undefined | null;
+    set currentContext(context: ContextItem | null | undefined);
     constructor(args: {
         config: ContextModuleConfig;
         event?: ModuleType<EventModule>;
         parentContext?: IContextProvider;
     });
-    connectParentContextAsync(provider: IContextProvider, opt?: {
-        setCurrent?: boolean;
-    }): Promise<Subscription>;
+    connectParentContext(provider: IContextProvider, opt?: {
+        skipFirst: boolean;
+    }): Subscription;
     setCurrentContextById(id: string): Observable<ContextItem<Record<string, unknown>>>;
     setCurrentContextByIdAsync(id: string): Promise<ContextItem<Record<string, unknown>>>;
-    setCurrentContext(context: ContextItem<Record<string, unknown>>, opt?: {
+    setCurrentContext<T extends ContextItem<Record<string, unknown>> | null>(context: T, opt?: {
         validate?: boolean;
         resolve?: boolean;
-    }): Observable<ContextItem<Record<string, unknown>>>;
-    setCurrentContextAsync(context: ContextItem<Record<string, unknown>>, opt?: {
+    }): Observable<T>;
+    setCurrentContextAsync<T extends ContextItem<Record<string, unknown>> | null>(context: T, opt?: {
         validate?: boolean;
         resolve?: boolean;
-    }): Promise<ContextItem<Record<string, unknown>>>;
+    }): Promise<T>;
     queryContext(search: string): Observable<Array<ContextItem>>;
     queryContextAsync(search: string): Promise<Array<ContextItem>>;
     validateContext(item: ContextItem<Record<string, unknown>>): boolean;
@@ -68,14 +68,14 @@ export default ContextProvider;
 declare module '@equinor/fusion-framework-module-event' {
     interface FrameworkEventMap {
         onCurrentContextChange: FrameworkEvent<FrameworkEventInit<{
-            context: ContextItem | undefined;
+            context: ContextItem | null;
         }, IContextProvider>>;
         onCurrentContextChanged: FrameworkEvent<FrameworkEventInit<{
-            next: ContextItem | undefined;
-            previous: ContextItem | undefined;
+            next: ContextItem | null;
+            previous?: ContextItem | null;
         }, IContextProvider>>;
         onParentContextChanged: FrameworkEvent<FrameworkEventInit<{
-            context: ContextItem | undefined;
+            context: ContextItem | null;
         }, IContextProvider>>;
         onSetContextResolve: FrameworkEvent<FrameworkEventInit<{
             context: ContextItem;

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

@@ -4,16 +4,19 @@ import { ContextItem } from '../types';
 export type GetContextParameters = {
     id: string;
 };
-export declare class ContextClient extends Observable<ContextItem> {
+export declare class ContextClient extends Observable<ContextItem | null> {
     #private;
-    get currentContext(): ContextItem | undefined;
-    get currentContext$(): Observable<ContextItem | undefined>;
+    get currentContext(): ContextItem | null | undefined;
+    get currentContext$(): Observable<ContextItem | null | undefined>;
     get client(): Query<ContextItem, {
         id: string;
     }>;
     constructor(options: QueryCtorOptions<ContextItem, GetContextParameters>);
-    setCurrentContext(idOrItem?: string | ContextItem): void;
+    setCurrentContext(idOrItem?: string | ContextItem | null): void;
     resolveContext(id: string): Observable<ContextItem>;
+    resolveContextAsync(id: string, opt?: {
+        awaitResolve: boolean;
+    }): Promise<ContextItem>;
     dispose(): void;
 }
 export default ContextClient;

package/dist/types/configurator.d.ts

@@ -1,10 +1,12 @@
-import { ModuleInitializerArgs } from '@equinor/fusion-framework-module';
+import { ObservableInput } from 'rxjs';
+import { AnyModuleInstance, ModuleInitializerArgs, ModuleInstance } from '@equinor/fusion-framework-module';
 import { ServicesModule, IApiProvider } from '@equinor/fusion-framework-module-services';
+import { NavigationModule } from '@equinor/fusion-framework-module-navigation';
 import { QueryCtorOptions } from '@equinor/fusion-query';
 import { ContextFilterFn, ContextItem, QueryContextParameters, RelatedContextParameters } from './types';
 import { GetContextParameters } from './client/ContextClient';
 import { ContextConfigBuilderCallback } from './ContextConfigBuilder';
-import { IContextProvider } from 'ContextProvider';
+import { type IContextProvider } from './ContextProvider';
 export interface ContextModuleConfig {
     client: {
         get: QueryCtorOptions<ContextItem, GetContextParameters>;
@@ -20,6 +22,10 @@ export interface ContextModuleConfig {
     }) => string | QueryContextParameters;
     resolveContext?: (this: IContextProvider, item: ContextItem | null) => ReturnType<IContextProvider['resolveContext']>;
     validateContext?: (this: IContextProvider, item: ContextItem | null) => ReturnType<IContextProvider['validateContext']>;
+    resolveInitialContext?: (args: {
+        ref?: AnyModuleInstance | any;
+        modules: ModuleInstance;
+    }) => ObservableInput<ContextItem | void>;
 }
 export interface IContextModuleConfigurator {
     addConfigBuilder: (init: ContextConfigBuilderCallback) => void;
@@ -29,6 +35,6 @@ export declare class ContextModuleConfigurator implements IContextModuleConfigur
     defaultExpireTime: number;
     addConfigBuilder(init: ContextConfigBuilderCallback): void;
     protected _getServiceProvider(init: ModuleInitializerArgs<IContextModuleConfigurator, [ServicesModule]>): Promise<IApiProvider>;
-    createConfig(init: ModuleInitializerArgs<IContextModuleConfigurator, [ServicesModule]>): Promise<ContextModuleConfig>;
+    createConfig(init: ModuleInitializerArgs<IContextModuleConfigurator, [ServicesModule, NavigationModule]>): Promise<ContextModuleConfig>;
 }
 export default ContextModuleConfigurator;

package/dist/types/index.d.ts

@@ -1,5 +1,5 @@
 export { ContextModuleConfigurator, IContextModuleConfigurator, ContextModuleConfig, } from './configurator';
 export { IContextProvider, ContextProvider } from './ContextProvider';
 export { default, ContextModule, module as contextModule, moduleKey as contextModuleKey, } from './module';
-export { enableContext } from './enable-context';
+export { enableContext } from './utils/enable-context';
 export * from './types';

package/dist/types/module.d.ts

@@ -1,13 +1,15 @@
 import { Module } from '@equinor/fusion-framework-module';
 import { EventModule } from '@equinor/fusion-framework-module-event';
 import { ServicesModule } from '@equinor/fusion-framework-module-services';
+import { NavigationModule } from '@equinor/fusion-framework-module-navigation';
 import { IContextModuleConfigurator } from './configurator';
 import { IContextProvider } from './ContextProvider';
 export type ContextModuleKey = 'context';
 export declare const moduleKey: ContextModuleKey;
 export type ContextModule = Module<ContextModuleKey, IContextProvider, IContextModuleConfigurator, [
     ServicesModule,
-    EventModule
+    EventModule,
+    NavigationModule
 ]>;
 export declare const module: ContextModule;
 declare module '@equinor/fusion-framework-module' {

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

@@ -1,4 +1,4 @@
 import type { IModulesConfigurator, AnyModule, ModuleInitializerArgs } from '@equinor/fusion-framework-module';
-import type { IContextModuleConfigurator } from './configurator';
-import type { ContextConfigBuilder } from './ContextConfigBuilder';
+import type { IContextModuleConfigurator } from '../configurator';
+import type { ContextConfigBuilder } from '../ContextConfigBuilder';
 export declare const enableContext: (configurator: IModulesConfigurator<any, any>, builder?: (<TDeps extends AnyModule[] = []>(builder: ContextConfigBuilder<TDeps, ModuleInitializerArgs<IContextModuleConfigurator, TDeps>>) => void | Promise<void>) | undefined) => void;

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

@@ -0,0 +1,2 @@
+export { enableContext } from './enable-context';
+export { resolveInitialContext } from './resolve-initial-context';

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

@@ -0,0 +1,8 @@
+import { ModuleType } from '@equinor/fusion-framework-module';
+import { type ContextModule } from '../module';
+export type ContextPathResolveArgs = {
+    extract?: (path: string) => string | undefined;
+    validate?: (contextId: string) => boolean;
+};
+export declare const resolveContextFromPath: (context: ModuleType<ContextModule>, args?: ContextPathResolveArgs) => (path: string) => import("rxjs").Observable<import("..").ContextItem<Record<string, unknown>>>;
+export default resolveContextFromPath;

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

@@ -0,0 +1,7 @@
+import { type ContextModuleConfig } from '../configurator';
+import { ContextPathResolveArgs } from './resolve-context-from-path';
+export declare const resolveContextFromParent: ContextModuleConfig['resolveInitialContext'];
+export declare const resolveInitialContext: (options?: {
+    path?: ContextPathResolveArgs;
+}) => Required<ContextModuleConfig>['resolveInitialContext'];
+export default resolveInitialContext;

package/package.json

@@ -1,17 +1,21 @@
 {
     "name": "@equinor/fusion-framework-module-context",
-    "version": "4.0.0-next.8",
+    "version": "4.0.0",
     "description": "",
     "main": "./dist/esm/index.js",
     "exports": {
         ".": "./dist/esm/index.js",
-        "./package.json": "./package.json"
+        "./package.json": "./package.json",
+        "./utils": "./dist/esm/utils/index.js"
     },
     "types": "index.d.ts",
     "typesVersions": {
         ">=4.2": {
             "*": [
                 "dist/types/*"
+            ],
+            "utils": [
+                "dist/types/utils/index.d.ts"
             ]
         }
     },
@@ -31,18 +35,19 @@
         "directory": "packages/modules/context"
     },
     "dependencies": {
-        "@equinor/fusion-query": "^3.0.0",
+        "@equinor/fusion-query": "^3.0.1",
         "fast-deep-equal": "^3.1.3"
     },
     "devDependencies": {
-        "@equinor/fusion-framework-module": "^3.0.0",
-        "@equinor/fusion-framework-module-event": "^3.0.0",
-        "@equinor/fusion-framework-module-services": "^3.1.0-next.0",
+        "@equinor/fusion-framework-module": "^4.0.0",
+        "@equinor/fusion-framework-module-event": "^4.0.0",
+        "@equinor/fusion-framework-module-navigation": "^2.1.0",
+        "@equinor/fusion-framework-module-services": "^3.1.0",
         "rxjs": "^7.5.7"
     },
     "peerDependencies": {
         "@equinor/fusion-framework-module": ">=1.2.5",
         "rxjs": "^7.5.7"
     },
-    "gitHead": "3a5344ee1e18a35158681004cb154b2522e659ed"
+    "gitHead": "851d70038b9b015663981a9456247f3d5dd0c3a2"
 }

package/src/ContextConfigBuilder.ts

@@ -65,8 +65,8 @@ export class ContextConfigBuilder<
         this.config.resolveContext = fn;
     }
 
-    setSkipInitialContext(skip: ContextModuleConfig['skipInitialContext']) {
-        this.config.skipInitialContext = skip;
+    setResolveInitialContext(fn: ContextModuleConfig['resolveInitialContext']) {
+        this.config.resolveInitialContext = fn;
     }
 
     setContextClient(

package/src/ContextProvider.ts

@@ -31,8 +31,8 @@ export interface IContextProvider {
     /** DANGER */
     readonly queryClient: Query<ContextItem[], QueryContextParameters>;
 
-    readonly currentContext$: Observable<ContextItem | undefined>;
-    currentContext: ContextItem | undefined;
+    readonly currentContext$: Observable<ContextItem | null | undefined>;
+    currentContext: ContextItem | null | undefined;
     queryContext(search: string): Observable<Array<ContextItem>>;
     queryContextAsync(search: string): Promise<Array<ContextItem>>;
     validateContext(item: ContextItem<Record<string, unknown>>): boolean;
@@ -50,14 +50,14 @@ export interface IContextProvider {
     setCurrentContextByIdAsync(id: string): Promise<ContextItem<Record<string, unknown>>>;
 
     setCurrentContext(
-        context: ContextItem<Record<string, unknown>>,
+        context: ContextItem<Record<string, unknown>> | null,
         opt?: { validate?: boolean; resolve?: boolean }
-    ): Observable<ContextItem<Record<string, unknown>>>;
+    ): Observable<ContextItem<Record<string, unknown>> | null>;
 
     setCurrentContextAsync(
-        context: ContextItem<Record<string, unknown>>,
+        context: ContextItem<Record<string, unknown>> | null,
         opt?: { validate?: boolean; resolve?: boolean }
-    ): Promise<ContextItem<Record<string, unknown>>>;
+    ): Promise<ContextItem<Record<string, unknown>> | null>;
 }
 
 export class ContextProvider implements IContextProvider {
@@ -81,22 +81,25 @@ export class ContextProvider implements IContextProvider {
         return this.#contextQuery;
     }
 
-    get currentContext$(): Observable<ContextItem | undefined> {
+    get currentContext$(): Observable<ContextItem | null | undefined> {
         return this.#contextClient.currentContext$;
     }
 
-    get currentContext(): ContextItem | undefined {
+    get currentContext(): ContextItem | undefined | null {
         return this.#contextClient.currentContext;
     }
 
     /** @deprecated do not use, will be removed */
-    set currentContext(context: ContextItem | undefined) {
+    set currentContext(context: ContextItem | null | undefined) {
         console.warn(
             '@deprecated',
             'ContextProvider.currentContext',
             'use setCurrentContextById|setCurrentContext|clearCurrentContext'
         );
-        context ? this.setCurrentContextAsync(context) : this.clearCurrentContext();
+        if (context === undefined) {
+            throw Error('not allowed to set current context as undefined undefined!');
+        }
+        this.setCurrentContextAsync(context);
     }
 
     constructor(args: {
@@ -150,20 +153,30 @@ export class ContextProvider implements IContextProvider {
                 /** observe event from child modules */
                 this.#event.addEventListener('onCurrentContextChanged', (e) => {
                     /** loop prevention */
-                    if (e.source !== this) {
-                        this.currentContext = e.detail.next;
+                    if (e.source !== this && e.detail.next !== undefined) {
+                        this.setCurrentContext(e.detail.next);
                     }
                 })
             );
         }
     }
 
-    public async connectParentContextAsync(
+    public connectParentContext(
         provider: IContextProvider,
-        opt?: { setCurrent?: boolean }
-    ): Promise<Subscription> {
+        opt?: { skipFirst: boolean }
+    ): Subscription {
         const parentContext$ = provider.currentContext$.pipe(
-            filter((next) => this.currentContext !== next),
+            filter((next, index) => {
+                if (opt?.skipFirst && index <= 1) {
+                    console.debug(
+                        'ContextProvider::connectParentContext',
+                        'skipping first item',
+                        next
+                    );
+                    return false;
+                }
+                return this.currentContext !== next;
+            }),
             switchMap(async (next) => {
                 if (next) {
                     const onParentContextChanged = await this.#event?.dispatchEvent(
@@ -206,29 +219,7 @@ export class ContextProvider implements IContextProvider {
 
         const subscription = parentContext$.subscribe();
         this.#subscriptions.add(subscription);
-
-        return new Promise((resolve, reject) => {
-            if (opt?.setCurrent && provider.currentContext) {
-                subscription.add(reject);
-                subscription.add(
-                    this.setCurrentContext(provider.currentContext, {
-                        validate: true,
-                        resolve: true,
-                    }).subscribe({
-                        error: (err) => {
-                            subscription.remove(reject);
-                            reject(err);
-                        },
-                        complete: () => {
-                            subscription.remove(reject);
-                            resolve(subscription);
-                        },
-                    })
-                );
-            } else {
-                return resolve(subscription);
-            }
-        });
+        return subscription;
     }
 
     public setCurrentContextById(id: string): Observable<ContextItem<Record<string, unknown>>> {
@@ -236,7 +227,10 @@ export class ContextProvider implements IContextProvider {
             try {
                 this.#contextClient
                     .resolveContext(id)
-                    .pipe(switchMap((item) => this.setCurrentContext(item)))
+                    .pipe(
+                        filter((item): item is ContextItem => !!item),
+                        switchMap((item) => this.setCurrentContext(item))
+                    )
                     .subscribe(subscriber);
             } catch (err) {
                 subscriber.error(err);
@@ -248,16 +242,16 @@ export class ContextProvider implements IContextProvider {
         return firstValueFrom(this.setCurrentContextById(id));
     }
 
-    public setCurrentContext(
-        context: ContextItem<Record<string, unknown>>,
+    public setCurrentContext<T extends ContextItem<Record<string, unknown>> | null>(
+        context: T,
         opt?: { validate?: boolean; resolve?: boolean }
-    ): Observable<ContextItem<Record<string, unknown>>> {
+    ): Observable<T> {
         return new Observable((subscriber) => {
             if (context === this.currentContext) {
                 subscriber.next(context);
                 return subscriber.complete();
             }
-            if (opt?.validate && !this.validateContext(context)) {
+            if (context && opt?.validate && !this.validateContext(context)) {
                 if (!opt.resolve) {
                     /** cannot resolve context, and provided is invalid  */
                     this.#event?.dispatchEvent('onSetContextValidationFailed', {
@@ -309,7 +303,9 @@ export class ContextProvider implements IContextProvider {
                                 return resolved;
                             }),
                             /** recursive set current context without validation and resolve */
-                            switchMap((resolved) => this.setCurrentContext(resolved))
+                            switchMap((resolved) =>
+                                this.setCurrentContext(resolved as unknown as T)
+                            )
                         )
                         .subscribe(subscriber);
                 }
@@ -333,17 +329,17 @@ export class ContextProvider implements IContextProvider {
                     })
                 )
                 .subscribe((context) => {
-                    this.#contextClient.setCurrentContext(context);
+                    this.#contextClient.setCurrentContext(context ?? null);
                     subscriber.next(context);
                     subscriber.complete();
                 });
         });
     }
 
-    public async setCurrentContextAsync(
-        context: ContextItem<Record<string, unknown>>,
+    public async setCurrentContextAsync<T extends ContextItem<Record<string, unknown>> | null>(
+        context: T,
         opt?: { validate?: boolean; resolve?: boolean }
-    ): Promise<ContextItem<Record<string, unknown>>> {
+    ): Promise<T> {
         return firstValueFrom(this.setCurrentContext(context, opt));
     }
 
@@ -407,7 +403,15 @@ export class ContextProvider implements IContextProvider {
                 )
             );
         }
-        return this.#contextRelated.query(args).pipe(map(({ value }) => value));
+        return this.#contextRelated.query(args).pipe(
+            map(({ value }) => value),
+            catchError((err) => {
+                if (err.cause) {
+                    throw err.cause;
+                }
+                throw err;
+            })
+        );
     }
 
     public relatedContextsAsync(
@@ -417,7 +421,7 @@ export class ContextProvider implements IContextProvider {
     }
 
     public clearCurrentContext() {
-        this.#contextClient.setCurrentContext(undefined);
+        this.setCurrentContextAsync(null);
     }
 
     dispose() {
@@ -434,7 +438,7 @@ declare module '@equinor/fusion-framework-module-event' {
         onCurrentContextChange: FrameworkEvent<
             FrameworkEventInit<
                 {
-                    context: ContextItem | undefined;
+                    context: ContextItem | null;
                 },
                 IContextProvider
             >
@@ -443,8 +447,8 @@ declare module '@equinor/fusion-framework-module-event' {
         onCurrentContextChanged: FrameworkEvent<
             FrameworkEventInit<
                 {
-                    next: ContextItem | undefined;
-                    previous: ContextItem | undefined;
+                    next: ContextItem | null;
+                    previous?: ContextItem | null;
                 },
                 IContextProvider
             >
@@ -452,7 +456,7 @@ declare module '@equinor/fusion-framework-module-event' {
         onParentContextChanged: FrameworkEvent<
             FrameworkEventInit<
                 {
-                    context: ContextItem | undefined;
+                    context: ContextItem | null;
                 },
                 IContextProvider
             >

package/src/client/ContextClient.ts

@@ -1,4 +1,4 @@
-import { Observable, BehaviorSubject, EMPTY } from 'rxjs';
+import { Observable, BehaviorSubject, EMPTY, lastValueFrom, firstValueFrom } from 'rxjs';
 import { catchError, map } from 'rxjs/operators';
 
 import equal from 'fast-deep-equal';
@@ -9,16 +9,16 @@ import { ContextItem } from '../types';
 
 export type GetContextParameters = { id: string };
 
-export class ContextClient extends Observable<ContextItem> {
+export class ContextClient extends Observable<ContextItem | null> {
     #client: Query<ContextItem, { id: string }>;
     /** might change to reactive state, for comparing state with reducer */
-    #currentContext$: BehaviorSubject<ContextItem | undefined>;
+    #currentContext$: BehaviorSubject<ContextItem | null | undefined>;
 
-    get currentContext(): ContextItem | undefined {
+    get currentContext(): ContextItem | null | undefined {
         return this.#currentContext$.value;
     }
 
-    get currentContext$(): Observable<ContextItem | undefined> {
+    get currentContext$(): Observable<ContextItem | null | undefined> {
         return this.#currentContext$.asObservable();
     }
 
@@ -29,13 +29,14 @@ export class ContextClient extends Observable<ContextItem> {
     constructor(options: QueryCtorOptions<ContextItem, GetContextParameters>) {
         super((observer) => this.#currentContext$.subscribe(observer));
         this.#client = new Query(options);
-        this.#currentContext$ = new BehaviorSubject<ContextItem | undefined>(undefined);
+        this.#currentContext$ = new BehaviorSubject<ContextItem | null | undefined>(undefined);
     }
 
-    public setCurrentContext(idOrItem?: string | ContextItem) {
+    public setCurrentContext(idOrItem?: string | ContextItem | null) {
         if (typeof idOrItem === 'string') {
             // TODO - compare context
             this.resolveContext(idOrItem)
+                // TODO should this catch error?
                 .pipe(catchError(() => EMPTY))
                 .subscribe((value) => this.setCurrentContext(value));
             /** only add context if not match */
@@ -45,7 +46,21 @@ export class ContextClient extends Observable<ContextItem> {
     }
 
     public resolveContext(id: string): Observable<ContextItem> {
-        return this.#client.query({ id }).pipe(map((x) => x.value));
+        return this.#client.query({ id }).pipe(
+            map((x) => x.value),
+            // unwrap error
+            catchError((err) => {
+                if (err.cause) {
+                    throw err.cause;
+                }
+                throw err;
+            })
+        );
+    }
+
+    public resolveContextAsync(id: string, opt?: { awaitResolve: boolean }): Promise<ContextItem> {
+        const fn = opt?.awaitResolve ? lastValueFrom : firstValueFrom;
+        return fn(this.resolveContext(id));
     }
 
     public dispose(): void {

package/src/configurator.ts

@@ -1,5 +1,13 @@
-import { ModuleInitializerArgs, ModulesInstanceType } from '@equinor/fusion-framework-module';
+import { ObservableInput } from 'rxjs';
+
+import {
+    AnyModuleInstance,
+    ModuleInitializerArgs,
+    ModuleInstance,
+    ModulesInstanceType,
+} from '@equinor/fusion-framework-module';
 import { ServicesModule, IApiProvider } from '@equinor/fusion-framework-module-services';
+import { NavigationModule } from '@equinor/fusion-framework-module-navigation';
 import { getContextSelector, queryContextSelector, relatedContextSelector } from './selectors';
 import { QueryCtorOptions } from '@equinor/fusion-query';
 import {
@@ -10,7 +18,8 @@ import {
 } from './types';
 import { GetContextParameters } from './client/ContextClient';
 import { ContextConfigBuilder, ContextConfigBuilderCallback } from './ContextConfigBuilder';
-import { IContextProvider } from 'ContextProvider';
+import { type IContextProvider } from './ContextProvider';
+import resolveInitialContext from './utils/resolve-initial-context';
 
 export interface ContextModuleConfig {
     client: {
@@ -41,6 +50,14 @@ export interface ContextModuleConfig {
         this: IContextProvider,
         item: ContextItem | null
     ) => ReturnType<IContextProvider['validateContext']>;
+
+    resolveInitialContext?: (
+        args: {
+            ref?: AnyModuleInstance | any;
+            modules: ModuleInstance;
+        }
+        // ...args: Parameters<ContextModule['postInitialize']>
+    ) => ObservableInput<ContextItem | void>;
 }
 
 export interface IContextModuleConfigurator {
@@ -72,7 +89,7 @@ export class ContextModuleConfigurator implements IContextModuleConfigurator {
     }
 
     public async createConfig(
-        init: ModuleInitializerArgs<IContextModuleConfigurator, [ServicesModule]>
+        init: ModuleInitializerArgs<IContextModuleConfigurator, [ServicesModule, NavigationModule]>
     ): Promise<ContextModuleConfig> {
         const config = await this.#configBuilders.reduce(async (cur, cb) => {
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -81,6 +98,8 @@ export class ContextModuleConfigurator implements IContextModuleConfigurator {
             return Object.assign(cur, builder.config);
         }, Promise.resolve({} as Partial<ContextModuleConfig>));
 
+        config.resolveInitialContext ??= resolveInitialContext();
+
         // TODO - make less lazy
         config.client ??= await (async (): Promise<ContextModuleConfig['client']> => {
             const apiProvider = await this._getServiceProvider(init);

package/src/index.ts

@@ -13,6 +13,6 @@ export {
     moduleKey as contextModuleKey,
 } from './module';
 
-export { enableContext } from './enable-context';
+export { enableContext } from './utils/enable-context';
 
 export * from './types';