@equinor/fusion-framework-module-context 4.1.1 → 4.2.0

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

@@ -1,2 +1,3 @@
 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

@@ -1,8 +1,17 @@
-import { ModuleType } from '@equinor/fusion-framework-module';
+import { Observable } from 'rxjs';
+import { type ModuleType } from '@equinor/fusion-framework-module';
 import { type ContextModule } from '../module';
+import { type ContextItem } from '../types';
 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>;
+export declare const extractContextIdFromPath: (path: string, matcher?: RegExp) => string | undefined;
+export interface resolveContextFromPath {
+    (context: ModuleType<ContextModule>): (path: string) => Observable<ContextItem>;
+}
+export interface resolveContextFromPath {
+    (context: ModuleType<ContextModule>, args: ContextPathResolveArgs): (path: string) => Observable<ContextItem>;
+}
+export declare function resolveContextFromPath(context: ModuleType<ContextModule>, args?: ContextPathResolveArgs): (path: string) => Observable<ContextItem>;
 export default resolveContextFromPath;

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

@@ -1,5 +1,5 @@
 import { type ContextModuleConfig } from '../configurator';
-import { ContextPathResolveArgs } from './resolve-context-from-path';
+import { type ContextPathResolveArgs } from './resolve-context-from-path';
 export declare const resolveContextFromParent: ContextModuleConfig['resolveInitialContext'];
 export declare const resolveInitialContext: (options?: {
     path?: ContextPathResolveArgs;

package/dist/types/version.d.ts

@@ -1 +1 @@
-export declare const version = "4.1.1";
+export declare const version = "4.2.0";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@equinor/fusion-framework-module-context",
-  "version": "4.1.1",
+  "version": "4.2.0",
   "description": "",
   "main": "./dist/esm/index.js",
   "exports": {
@@ -51,8 +51,8 @@
     "rxjs": "^7.8.1",
     "typescript": "^5.1.3",
     "@equinor/fusion-framework-module": "^4.2.7",
-    "@equinor/fusion-framework-module-navigation": "^3.1.4",
     "@equinor/fusion-framework-module-event": "^4.0.8",
+    "@equinor/fusion-framework-module-navigation": "^3.1.4",
     "@equinor/fusion-framework-module-services": "^3.2.4"
   },
   "peerDependencies": {

package/src/utils/index.ts

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

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

@@ -1,24 +1,116 @@
-import { EMPTY } from 'rxjs';
+import { EMPTY, Observable } from 'rxjs';
 
-import { ModuleType } from '@equinor/fusion-framework-module';
+import { type ModuleType } from '@equinor/fusion-framework-module';
 
 import { type ContextModule } from '../module';
+import { type ContextItem } from '../types';
 
+/**
+ * Arguments for resolving a context from a path.
+ */
 export type ContextPathResolveArgs = {
+    /**
+     * Callback to extract a context id from a path.
+     * @param path string - the path to extract the context id from
+     * @returns string | undefined - the context id or undefined
+     */
     extract?: (path: string) => string | undefined;
+    /**
+     * Callback to validate a context id.
+     * @param contextId string - the context id to validate
+     * @returns boolean - true if the context id is valid
+     */
     validate?: (contextId: string) => boolean;
 };
 
+// GUID pattern
 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();
+/**
+ * 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 const extractContextIdFromPath = (
+    path: string,
+    matcher: RegExp = matchGUID,
+): string | undefined =>
+    path
+        // remove leading slashes
+        .replace(/^\/+/, '')
+        // split path by slashes
+        .split('/')
+        // find the first path fragment that matches the matcher
+        .find((x) => x.match(matcher));
 
 const validateContextId = (contextId: string): boolean => !!contextId.match(matchGUID);
 
-export const resolveContextFromPath =
-    (context: ModuleType<ContextModule>, args?: ContextPathResolveArgs) => (path: string) => {
+/**
+ * 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.
+ * The method will use the context module to resolve the context.
+ * The method will use the extract and validate methods from the args to extract and validate the context id.
+ * If the context id is not valid, the method will throw an error.
+ * If the context id is valid, the method will return an observable of the resolved context.
+ * If the context id is not found, the method will return an empty observable.
+ *
+ * @example
+ * ```ts
+ * const resolve = resolveContextFromPath(modules.context);
+ * resolve(
+ *  '/apps/context/7fd97952-7fe6-409b-a6dc-292dbf0e50d7?foobar#example'
+ * ).subscribe(console.log);
+ * ```
+ *
+ * @param context The context module.
+ * @returns A function that takes a path and returns an Observable of the resolved context item.
+ */
+export interface resolveContextFromPath {
+    (context: ModuleType<ContextModule>): (path: string) => Observable<ContextItem>;
+}
+
+/**
+ *
+ * @example
+ * ```ts
+ * const resolve = resolveContextFromPath(
+ *      modules.context,
+ *       {
+ *          extract: (path) => path.find(extractingContextFromPath),
+ *          validate: (id) => isValidContextId(id)
+ * });
+ * resolve(
+ *      '/apps/context/7fd97952-7fe6-409b-a6dc-292dbf0e50d7?foobar#example'
+ * ).subscribe(console.log);
+ * ```
+ *
+ * @param context The context module.
+ * @param args The arguments for resolving the path.
+ * @returns A function that takes a path and returns an Observable of the resolved context item.
+ */
+export interface resolveContextFromPath {
+    (
+        context: ModuleType<ContextModule>,
+        args: ContextPathResolveArgs,
+    ): (path: string) => Observable<ContextItem>;
+}
+
+export function resolveContextFromPath(
+    context: ModuleType<ContextModule>,
+    args?: ContextPathResolveArgs,
+) {
+    return (path: string) => {
         const { extract = extractContextIdFromPath, validate = validateContextId } = args ?? {};
         const contextId = extract(path);
         if (!contextId) {
@@ -30,5 +122,6 @@ export const resolveContextFromPath =
 
         throw Error(`Failed to validate context [${contextId}] from path [${path}]`);
     };
+}
 
 export default resolveContextFromPath;

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

@@ -1,27 +1,50 @@
-import { ModulesInstance } from '@equinor/fusion-framework-module';
-import { ContextModule } from '../module';
+import { type ModulesInstance } from '@equinor/fusion-framework-module';
+import { type ContextModule } from '../module';
 import { type ContextModuleConfig } from '../configurator';
 import { concat, EMPTY, first, of } from 'rxjs';
 
-import { ContextPathResolveArgs, resolveContextFromPath } from './resolve-context-from-path';
+import { type ContextPathResolveArgs, resolveContextFromPath } from './resolve-context-from-path';
+import { type NavigationModule } from '@equinor/fusion-framework-module-navigation';
 
+/**
+ * Resolves the initial context from the parent module.
+ *
+ * @param ref - parent modules.
+ * @returns An Observable of the resolved initial context.
+ */
 export const resolveContextFromParent: ContextModuleConfig['resolveInitialContext'] = ({ ref }) => {
     const parentContext = (ref as ModulesInstance<[ContextModule]>)?.context;
+    // check if the parent has context module
     if (!parentContext) {
         throw Error(['resolveContextFromNavigation', 'ref does not support context!'].join('\n'));
     }
+    // return the current context from the parent or empty if the parent does not have a context
     return parentContext.currentContext ? of(parentContext.currentContext) : EMPTY;
 };
 
+/**
+ * Resolves the initial context for a Fusion Framework context module.
+ *
+ * will try to resolve the initial context from the path, and if that fails, it will try to resolve the context from the parent.
+ *
+ * @param options - Optional configuration for resolving the context path.
+ * @returns A function that accepts the module's reference and modules, and returns an Observable of the resolved initial context.
+ */
 export const resolveInitialContext =
     (options?: {
         path?: ContextPathResolveArgs;
     }): Required<ContextModuleConfig>['resolveInitialContext'] =>
     ({ ref, modules }) => {
         const { context, navigation } = modules;
+        // create a path resolver from the context module
         const pathResolver = resolveContextFromPath(context, options?.path);
+        // use the path from the navigation module, or the path from the parent navigation module
+        const pathname =
+            navigation?.path.pathname ??
+            (ref as Partial<ModulesInstance<[NavigationModule]>>).navigation?.path.pathname;
+        // try to resolve the context from the path, and if that fails, try to resolve the context from the parent
         return concat(
-            navigation ? pathResolver(navigation.path.pathname) : EMPTY,
+            pathname ? pathResolver(pathname) : EMPTY,
             resolveContextFromParent({ ref, modules }),
         ).pipe(first());
     };

package/src/version.ts

@@ -1,2 +1,2 @@
 // Generated by genversion.
-export const version = '4.1.1';
+export const version = '4.2.0';