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

package/src/module.ts

@@ -1,10 +1,14 @@
+import { catchError, EMPTY, from, Observable, switchMap, filter, Subscription } from 'rxjs';
+
 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 { ContextItem } from 'types';
 
 export type ContextModuleKey = 'context';
 
@@ -14,34 +18,65 @@ 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;
 
-    dispose: (args) => {
-        (args.instance as ContextProvider).dispose();
+                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 ? item.id : 'none'}]`,
+                                    item
+                                );
+                            },
+                            complete: () => {
+                                provider.connectParentContext(parentProvider, { skipFirst: true });
+                                subscriber.complete();
+                            },
+                        })
+                );
+            });
+
+        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,34 @@
+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.replace(/^\/+/, '').split('/').shift();
+
+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, modules })
+        ).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"}