@equinor/fusion-framework-module-navigation 0.0.0-next-20230915185612

package/src/module.ts

@@ -0,0 +1,64 @@
+import {
+    IModuleConfigurator,
+    IModulesConfigurator,
+    Module,
+    ModuleConfigType,
+    ModuleInstance,
+    SemanticVersion,
+} from '@equinor/fusion-framework-module';
+import { type INavigationConfigurator, NavigationConfigurator } from './configurator';
+import { createHistory } from './createHistory';
+import { type INavigationProvider, NavigationProvider } from './lib';
+
+import { version } from './version';
+
+export const moduleKey = 'navigation';
+
+export type NavigationModule = Module<
+    typeof moduleKey,
+    INavigationProvider,
+    INavigationConfigurator
+>;
+
+export const module: NavigationModule = {
+    version: new SemanticVersion(version),
+    name: moduleKey,
+    configure: (ref?: unknown) => {
+        const configurator = new NavigationConfigurator();
+        if (ref) {
+            configurator.history = (ref as ModuleInstance).navigation.navigator;
+        }
+        return configurator;
+    },
+    initialize: ({ config }) => {
+        config.history ??= createHistory();
+        return new NavigationProvider({ version, config });
+    },
+    dispose({ instance }) {
+        instance.dispose();
+    },
+};
+
+export const enableNavigation = <TRef = unknown>(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    configurator: IModulesConfigurator<any, any>,
+    basenameOrOptions?: string | Omit<IModuleConfigurator<NavigationModule, TRef>, 'module'>,
+): void => {
+    const options =
+        typeof basenameOrOptions === 'string'
+            ? {
+                  configure: (config: ModuleConfigType<NavigationModule>) => {
+                      config.basename = basenameOrOptions;
+                  },
+              }
+            : basenameOrOptions;
+    configurator.addConfig({ module, ...options });
+};
+
+export default module;
+
+declare module '@equinor/fusion-framework-module' {
+    interface Modules {
+        navigation: NavigationModule;
+    }
+}

package/src/navigator.ts

@@ -0,0 +1,123 @@
+import type { History, To, Path } from '@remix-run/router';
+import { BehaviorSubject, Observable, skip, Subscription } from 'rxjs';
+
+import type { NavigationUpdate, NavigationListener } from './types';
+
+export interface INavigator<T extends NavigationUpdate = NavigationUpdate>
+    extends Observable<T>,
+        History {
+    readonly basename?: string;
+    readonly origin?: string;
+    readonly value: NavigationUpdate;
+    readonly location: NavigationUpdate['location'];
+    dispose: VoidFunction;
+}
+
+export class Navigator<T extends NavigationUpdate = NavigationUpdate>
+    extends Observable<T>
+    implements INavigator<T>
+{
+    #history: History;
+    #baseName?: string;
+    #origin?: string = window.location.origin;
+    #subscriptions = new Subscription();
+    #state: BehaviorSubject<T>;
+
+    #logger: typeof console;
+
+    get basename(): string | undefined {
+        return this.#baseName;
+    }
+    get origin(): string | undefined {
+        return this.#origin;
+    }
+
+    get state(): Observable<T> {
+        return this.#state.asObservable();
+    }
+
+    get value(): T {
+        return this.#state.value;
+    }
+
+    get location(): T['location'] {
+        return this.value.location;
+    }
+
+    get action(): T['action'] {
+        return this.value.action;
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    constructor(args: { basename?: string; history: History; logger?: any }) {
+        super((subscriber) => this.#state.subscribe(subscriber));
+        const { basename, history } = args;
+        this.#logger = args.logger || console;
+        this.#baseName = basename;
+        this.#history = history;
+        this.#state = new BehaviorSubject<T>({
+            action: this.#history.action,
+            location: this.#history.location,
+            delta: null,
+        } as T);
+        this.#subscriptions.add(
+            this.#history.listen((update) => {
+                if (update.location.key !== this.#state.value.location.key) {
+                    this.#logger.debug(
+                        'Navigator::constructor',
+                        'history changed',
+                        update,
+                        this.#state.value,
+                    );
+                    this.#state.next(update as T);
+                }
+            }),
+        );
+    }
+
+    public encodeLocation(to: To): Path {
+        return this.#history.encodeLocation(to);
+    }
+
+    public listen(listener: NavigationListener): VoidFunction {
+        this.#logger.debug('Navigator::listen', listener);
+        const subscription = this.#state
+            .pipe(
+                /** skip the first, since we only want up-coming events  */
+                skip(1),
+                // TODO filter only locations within this basename
+            )
+            .subscribe((x) => {
+                this.#logger.debug('Navigator::listen[onchange]');
+                listener(x);
+            });
+        return () => {
+            this.#logger.debug('Navigator::listen[unsubscribe]');
+            return subscription.unsubscribe();
+        };
+    }
+
+    public createHref(to: To): string {
+        return this.#history.createHref(to);
+    }
+
+    public go(delta: number): void {
+        this.#history.go(delta);
+    }
+
+    public push(to: To, state?: unknown): void {
+        return this.#history.push(to, state);
+    }
+
+    public replace(to: To, state?: unknown): void {
+        return this.#history.replace(to, state);
+    }
+
+    public createURL(to: To): URL {
+        return this.#history.createURL(to);
+    }
+
+    dispose() {
+        this.#subscriptions.unsubscribe();
+    }
+}

package/src/types.ts

@@ -0,0 +1,4 @@
+import type { History } from '@remix-run/router';
+
+export type NavigationListener = Parameters<History['listen']>[0];
+export type NavigationUpdate = Parameters<NavigationListener>[0];

package/src/version.ts

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

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "extends": "../../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "dist/esm",
+    "rootDir": "src",
+    "declarationDir": "./dist/types",
+  },
+  "references": [
+    {
+      "path": "../module"
+    }
+  ],
+  "include": [
+    "src/**/*",
+  ],
+  "exclude": [
+    "node_modules",
+    "lib"
+  ]
+}