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

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

@@ -41,9 +41,9 @@ export declare class ContextProvider implements IContextProvider {
         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?: {

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.11",
+    "version": "4.0.0-next.12",
     "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.1-next.2",
+        "@equinor/fusion-query": "^3.0.1-next.3",
         "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.3",
+        "@equinor/fusion-framework-module": "^4.0.0-next.0",
+        "@equinor/fusion-framework-module-event": "^4.0.0-next.0",
+        "@equinor/fusion-framework-module-navigation": "^2.1.0-next.0",
+        "@equinor/fusion-framework-module-services": "^3.1.0-next.4",
         "rxjs": "^7.5.7"
     },
     "peerDependencies": {
         "@equinor/fusion-framework-module": ">=1.2.5",
         "rxjs": "^7.5.7"
     },
-    "gitHead": "278330e42e38f94327a98c0fc6121efe87a63b00"
+    "gitHead": "a2d5050515d375c7546b321aba27d11239869d97"
 }

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

@@ -158,12 +158,22 @@ export class ContextProvider implements IContextProvider {
         }
     }
 
-    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 +216,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>>> {

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';

package/src/module.ts

@@ -2,9 +2,12 @@ import { Module, ModulesInstance } 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, ContextModuleConfigurator } from './configurator';
 import { IContextProvider, ContextProvider } from './ContextProvider';
+import { catchError, EMPTY, from, Observable, switchMap, filter, Subscription } from 'rxjs';
+import { ContextItem } from 'types';
 
 export type ContextModuleKey = 'context';
 
@@ -14,34 +17,84 @@ export type ContextModule = Module<
     ContextModuleKey,
     IContextProvider,
     IContextModuleConfigurator,
-    [ServicesModule, EventModule]
+    [ServicesModule, EventModule, NavigationModule]
 >;
 
 export const module: ContextModule = {
     name: moduleKey,
     configure: () => new ContextModuleConfigurator(),
-    initialize: async (args) => {
+    initialize: async function (args) {
         const config = await (args.config as ContextModuleConfigurator).createConfig(args);
         const event = args.hasModule('event') ? await args.requireInstance('event') : undefined;
         const parentProvider = (args.ref as ModulesInstance<[ContextModule]>)?.context;
         const provider = new ContextProvider({ config, event, parentContext: parentProvider });
 
-        // TODO add option for skipping this step
-        if (parentProvider) {
-            try {
-                await provider.connectParentContextAsync(parentProvider, {
-                    setCurrent: !config.skipInitialContext,
-                });
-            } catch (err) {
-                console.warn('provider.connectParentContext', 'failed to set parent context', err);
-            }
-        }
+        const subscription = new Subscription(() => provider.dispose());
 
-        return provider;
-    },
+        this.postInitialize = (args) =>
+            new Observable((subscriber) => {
+                const resolveInitialContext$ = config.resolveInitialContext
+                    ? from(config.resolveInitialContext(args)).pipe(
+                          filter((item): item is ContextItem => !!item),
+                          switchMap((item) =>
+                              args.modules.context.setCurrentContext(item, {
+                                  validate: true,
+                                  resolve: true,
+                              })
+                          )
+                      )
+                    : EMPTY;
+
+                subscriber.add(
+                    resolveInitialContext$
+                        .pipe(
+                            catchError((err) => {
+                                console.warn(
+                                    'ContextModule.postInitialize',
+                                    'failed to resolve initial context',
+                                    err
+                                );
+                                return EMPTY;
+                            })
+                        )
+                        .subscribe({
+                            next: (item) => {
+                                console.debug(
+                                    'ContextModule.postInitialize',
+                                    `initial context was resolved to [${item.id}]`,
+                                    item
+                                );
+                            },
+                            complete: () => {
+                                provider.connectParentContext(parentProvider, { skipFirst: true });
+                                subscriber.complete();
+                            },
+                        })
+                );
 
-    dispose: (args) => {
-        (args.instance as ContextProvider).dispose();
+                if (args.modules.navigation) {
+                    subscription.add(
+                        provider.currentContext$.subscribe((item) => {
+                            if (!item) {
+                                return args.modules.navigation.replace('/');
+                            }
+                            const { path } = args.modules.navigation;
+                            const partial = path.pathname.split('/') ?? [];
+                            if (partial[0] !== item.id) {
+                                partial[0] = item?.id;
+                                args.modules.navigation.replace({
+                                    ...path,
+                                    pathname: partial.join('/'),
+                                });
+                            }
+                        })
+                    );
+                }
+            });
+
+        this.dispose = () => subscription.unsubscribe();
+
+        return provider;
     },
 };
 

package/src/{enable-context.ts → utils/enable-context.ts}

@@ -3,10 +3,10 @@ import type {
     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';
 
-import { module } from './module';
+import { module } from '../module';
 
 /**
  * Method for enabling the Service module

package/src/utils/index.ts

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

package/src/utils/resolve-context-from-path.ts

@@ -0,0 +1,33 @@
+import { EMPTY } from 'rxjs';
+
+import { ModuleType } from '@equinor/fusion-framework-module';
+
+import { type ContextModule } from '../module';
+
+export type ContextPathResolveArgs = {
+    extract?: (path: string) => string | undefined;
+    validate?: (contextId: string) => boolean;
+};
+
+const matchGUID =
+    /^(?:(?:[0-9a-fA-F]){8}-(?:[0-9a-fA-F]){4}-(?:[0-9a-fA-F]){4}-(?:[0-9a-fA-F]){4}-(?:[0-9a-fA-F]){12})$/;
+
+const extractContextIdFromPath = (path: string): string | undefined => path.split('/')[0];
+
+const validateContextId = (contextId: string): boolean => !!contextId.match(matchGUID);
+
+export const resolveContextFromPath =
+    (context: ModuleType<ContextModule>, args?: ContextPathResolveArgs) => (path: string) => {
+        const { extract = extractContextIdFromPath, validate = validateContextId } = args ?? {};
+        const contextId = extract(path);
+        if (!contextId) {
+            return EMPTY;
+        }
+        if (validate(contextId)) {
+            return context.contextClient.resolveContext(contextId);
+        }
+
+        throw Error(`Failed to validate context [${contextId}] from path [${path}]`);
+    };
+
+export default resolveContextFromPath;

package/src/utils/resolve-initial-context.ts

@@ -0,0 +1,29 @@
+import { ModulesInstance } from '@equinor/fusion-framework-module';
+import { ContextModule } from '../module';
+import { type ContextModuleConfig } from '../configurator';
+import { concat, EMPTY, first, of } from 'rxjs';
+
+import { ContextPathResolveArgs, resolveContextFromPath } from './resolve-context-from-path';
+
+export const resolveContextFromParent: ContextModuleConfig['resolveInitialContext'] = ({ ref }) => {
+    const parentContext = (ref as ModulesInstance<[ContextModule]>)?.context;
+    if (!parentContext) {
+        throw Error(['resolveContextFromNavigation', 'ref does not support context!'].join('\n'));
+    }
+    return parentContext.currentContext ? of(parentContext.currentContext) : EMPTY;
+};
+
+export const resolveInitialContext =
+    (options?: {
+        path?: ContextPathResolveArgs;
+    }): Required<ContextModuleConfig>['resolveInitialContext'] =>
+    ({ ref, modules }) => {
+        const { context, navigation } = modules;
+        const pathResolver = resolveContextFromPath(context, options?.path);
+        return concat(
+            navigation ? pathResolver(navigation.path.pathname) : EMPTY,
+            resolveContextFromParent(ref)
+        ).pipe(first());
+    };
+
+export default resolveInitialContext;

package/tsconfig.json

@@ -14,11 +14,14 @@
       "path": "../module"
     },
     {
-      "path": "../services"
+      "path": "../navigation"
     },
     {
       "path": "../event"
-    }
+    },
+    {
+      "path": "../services"
+    },
   ],
   "include": [
     "src/**/*",

package/dist/esm/enable-context.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"enable-context.js","sourceRoot":"","sources":["../../src/enable-context.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAMlC,MAAM,CAAC,MAAM,aAAa,GAAG,CAEzB,YAA4C,EAC5C,OAKyB,EACrB,EAAE;IACN,YAAY,CAAC,SAAS,CAAC;QACnB,MAAM;QACN,SAAS,EAAE,CAAC,mBAAmB,EAAE,EAAE;YAC/B,OAAO,IAAI,mBAAmB,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC;QAC7D,CAAC;KACJ,CAAC,CAAC;AACP,CAAC,CAAC"}