@equinor/fusion-framework-plugin-context-navigation 0.1.0 → 0.1.1

package/dist/types/create-context-navigation-plugin.d.ts

@@ -0,0 +1,58 @@
+import type { AppModuleProvider } from '@equinor/fusion-framework-module-app';
+import type { IContextProvider } from '@equinor/fusion-framework-module-context';
+import type { IEventModuleProvider } from '@equinor/fusion-framework-module-event';
+import type { INavigationProvider } from '@equinor/fusion-framework-module-navigation';
+import type { ContextNavigationConfig } from './types';
+/**
+ * Arguments required to initialize the context-navigation plugin.
+ *
+ * Consumers never construct this directly — it is assembled by the framework's
+ * plugin registration callback from the initialized module providers.
+ */
+export interface ContextNavigationPluginArgs {
+    /** Provides the currently active app and its resolved module instances. */
+    app: AppModuleProvider;
+    /** Provides browser navigation state and imperative navigation methods. */
+    navigation: INavigationProvider;
+    /** Provides the active context and mutation methods (e.g. setCurrentContextByIdAsync). */
+    context: IContextProvider;
+    /** Provides the cancelable event bus for dispatching plugin lifecycle events. */
+    event: IEventModuleProvider;
+    /** Fully resolved plugin configuration (adapters, sources, options). */
+    config: ContextNavigationConfig;
+}
+/** Event source token forwarded to all dispatched events. */
+declare const eventSource: {
+    name: string;
+    version: string;
+};
+/** The type of the event source token attached to all context-navigation events. */
+export type ContextNavigationEventSource = typeof eventSource;
+/**
+ * Creates the context-navigation plugin runtime.
+ *
+ * Sets up two subscriptions:
+ *
+ * **Reconciler** — watches the portal context and app switches via the configured
+ * source factory. On each emission it encodes the active context into the app URL
+ * using the first matching adapter.
+ *
+ * **URL guard** — watches browser navigation state and detects when the URL no
+ * longer reflects the active context. Behavior depends on `navigationOptions.replace`:
+ *
+ * - `replace: true` (default) — each context change replaces the current history entry,
+ *   so there is no meaningful back/forward stack within the context history. If the URL
+ *   diverges from the active context (e.g. an external redirect stripped the context
+ *   segment), the guard re-asserts the active context into the URL.
+ *
+ * - `replace: false` (push mode) — each context change pushes a new history entry, so
+ *   back/forward navigations legitimately land on URLs with different context IDs. The
+ *   guard detects this and drives context from the URL instead of overwriting it,
+ *   keeping the browser history and context state in sync.
+ *
+ * @param args - Initialized module providers and resolved plugin config.
+ * @returns A teardown function compatible with {@link FrameworkPluginTeardown}.
+ */
+export declare function createContextNavigationPlugin(args: ContextNavigationPluginArgs): () => void;
+export {};
+//# sourceMappingURL=create-context-navigation-plugin.d.ts.map

package/dist/types/create-context-navigation-plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-context-navigation-plugin.d.ts","sourceRoot":"","sources":["../../src/create-context-navigation-plugin.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sCAAsC,CAAC;AAC9E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0CAA0C,CAAC;AACjF,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,wCAAwC,CAAC;AACnF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6CAA6C,CAAC;AAEvF,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,SAAS,CAAC;AAcvD;;;;;GAKG;AACH,MAAM,WAAW,2BAA2B;IAC1C,2EAA2E;IAC3E,GAAG,EAAE,iBAAiB,CAAC;IACvB,2EAA2E;IAC3E,UAAU,EAAE,mBAAmB,CAAC;IAChC,0FAA0F;IAC1F,OAAO,EAAE,gBAAgB,CAAC;IAC1B,iFAAiF;IACjF,KAAK,EAAE,oBAAoB,CAAC;IAC5B,wEAAwE;IACxE,MAAM,EAAE,uBAAuB,CAAC;CACjC;AAED,6DAA6D;AAC7D,QAAA,MAAM,WAAW;;;CAAyC,CAAC;AAE3D,oFAAoF;AACpF,MAAM,MAAM,4BAA4B,GAAG,OAAO,WAAW,CAAC;AAI9D;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,6BAA6B,CAAC,IAAI,EAAE,2BAA2B,GAAG,MAAM,IAAI,CA4H3F"}

package/dist/types/enable-context-navigation.d.ts

@@ -0,0 +1,21 @@
+import type { IModulesConfigurator } from '@equinor/fusion-framework-module';
+import { ContextNavigationConfigurator } from './ContextNavigationConfigurator';
+export type ContextNavigationBuilder = (builder: ContextNavigationConfigurator) => void | Promise<void>;
+/**
+ * Registers the event-driven context-to-URL reconciler plugin for a portal.
+ *
+ * @example
+ * ```ts
+ * // Minimal — all defaults (built-in adapters: custom > query > path)
+ * enableContextNavigation(configurator);
+ *
+ * // With custom adapter
+ * enableContextNavigation(configurator, (builder) => {
+ *   builder.setPortalName('my-portal');
+ *   builder.setDebug(true);
+ *   builder.registerAdapter(myHashAdapter);
+ * });
+ * ```
+ */
+export declare const enableContextNavigation: (configurator: IModulesConfigurator<any, any>, builder?: ContextNavigationBuilder) => void;
+//# sourceMappingURL=enable-context-navigation.d.ts.map

package/dist/types/enable-context-navigation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enable-context-navigation.d.ts","sourceRoot":"","sources":["../../src/enable-context-navigation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kCAAkC,CAAC;AAM7E,OAAO,EAAE,6BAA6B,EAAE,MAAM,iCAAiC,CAAC;AAKhF,MAAM,MAAM,wBAAwB,GAAG,CACrC,OAAO,EAAE,6BAA6B,KACnC,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAE1B;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,uBAAuB,iBAEpB,oBAAoB,CAAC,GAAG,EAAE,GAAG,CAAC,YAClC,wBAAwB,KACjC,IAuBF,CAAC"}

package/dist/types/events.d.ts

@@ -0,0 +1,16 @@
+import type { FrameworkEvent, FrameworkEventInit } from '@equinor/fusion-framework-module-event';
+import type { ContextNavigationNavigateDetail, ContextNavigationNavigatedDetail, ContextNavigationAdapterResolvedDetail, ContextNavigationSkippedDetail } from './types';
+import type { ContextNavigationEventSource } from './create-context-navigation-plugin';
+declare module '@equinor/fusion-framework-module-event' {
+    interface FrameworkEventMap {
+        /** Fired before context navigation. Cancelable — call `event.preventDefault()` to block. */
+        onContextNavigationNavigate: FrameworkEvent<FrameworkEventInit<ContextNavigationNavigateDetail, ContextNavigationEventSource>>;
+        /** Fired after context navigation completes. */
+        onContextNavigationNavigated: FrameworkEvent<FrameworkEventInit<ContextNavigationNavigatedDetail, ContextNavigationEventSource>>;
+        /** Fired when an adapter is resolved for an app. */
+        onContextNavigationAdapterResolved: FrameworkEvent<FrameworkEventInit<ContextNavigationAdapterResolvedDetail, ContextNavigationEventSource>>;
+        /** Fired when navigation is skipped. */
+        onContextNavigationSkipped: FrameworkEvent<FrameworkEventInit<ContextNavigationSkippedDetail, ContextNavigationEventSource>>;
+    }
+}
+//# sourceMappingURL=events.d.ts.map

package/dist/types/events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../../src/events.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,wCAAwC,CAAC;AAEjG,OAAO,KAAK,EACV,+BAA+B,EAC/B,gCAAgC,EAChC,sCAAsC,EACtC,8BAA8B,EAC/B,MAAM,SAAS,CAAC;AAEjB,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,oCAAoC,CAAC;AAEvF,OAAO,QAAQ,wCAAwC,CAAC;IACtD,UAAU,iBAAiB;QACzB,4FAA4F;QAC5F,2BAA2B,EAAE,cAAc,CACzC,kBAAkB,CAAC,+BAA+B,EAAE,4BAA4B,CAAC,CAClF,CAAC;QACF,gDAAgD;QAChD,4BAA4B,EAAE,cAAc,CAC1C,kBAAkB,CAAC,gCAAgC,EAAE,4BAA4B,CAAC,CACnF,CAAC;QACF,oDAAoD;QACpD,kCAAkC,EAAE,cAAc,CAChD,kBAAkB,CAAC,sCAAsC,EAAE,4BAA4B,CAAC,CACzF,CAAC;QACF,wCAAwC;QACxC,0BAA0B,EAAE,cAAc,CACxC,kBAAkB,CAAC,8BAA8B,EAAE,4BAA4B,CAAC,CACjF,CAAC;KACH;CACF"}

package/dist/types/guard-handlers/consume-own-nav-token.d.ts

@@ -0,0 +1,21 @@
+import type { OwnNavigationTokens } from '../apply-navigation';
+/**
+ * Consume an own-navigation token if the current URL matches one previously
+ * navigated to by the plugin itself.
+ *
+ * Intent: prevent infinite loops between the reconciler and the guard.
+ * When the reconciler calls `applyNavigation`, it records the target path as a
+ * token. The next `navigation.state$` emission triggers the guard, which would
+ * otherwise see a "new" URL and try to reconcile again. By checking and consuming
+ * the token here, the guard knows this URL change was self-initiated and bails.
+ *
+ * Each token is consumed (deleted from the set) exactly once. This ensures that
+ * a subsequent user-initiated back/forward navigation to the same path IS
+ * processed by the guard, since the token will no longer be present.
+ *
+ * @param currentURL - The current browser URL to check against known tokens.
+ * @param ownNavTokens - The set of normalized paths the plugin has navigated to.
+ * @returns `true` if this navigation was plugin-initiated (caller should bail).
+ */
+export declare function consumeOwnNavToken(currentURL: URL, ownNavTokens: OwnNavigationTokens): boolean;
+//# sourceMappingURL=consume-own-nav-token.d.ts.map

package/dist/types/guard-handlers/consume-own-nav-token.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consume-own-nav-token.d.ts","sourceRoot":"","sources":["../../../src/guard-handlers/consume-own-nav-token.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAE/D;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,GAAG,EAAE,YAAY,EAAE,mBAAmB,GAAG,OAAO,CAS9F"}

package/dist/types/guard-handlers/guard-tick-deps.d.ts

@@ -0,0 +1,20 @@
+import type { IContextProvider } from '@equinor/fusion-framework-module-context';
+import type { ContextNavigationConfig } from '../types';
+import type { ApplyNavigationDeps, OwnNavigationTokens } from '../apply-navigation';
+/**
+ * Dependencies required by the URL guard handler functions.
+ *
+ * Extends {@link ApplyNavigationDeps} with the context provider needed
+ * to drive context from the URL in push mode.
+ */
+export interface GuardTickDeps extends ApplyNavigationDeps {
+    /** Resolved plugin configuration (adapters, navigation options). */
+    config: ContextNavigationConfig;
+    /** Context provider for setting context from URL-decoded IDs in push mode. */
+    context: IContextProvider;
+    /** Own-navigation token set (inherited from ApplyNavigationDeps). */
+    ownNavTokens: OwnNavigationTokens;
+    /** Conditional debug logger. */
+    log: (msg: string) => void;
+}
+//# sourceMappingURL=guard-tick-deps.d.ts.map

package/dist/types/guard-handlers/guard-tick-deps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"guard-tick-deps.d.ts","sourceRoot":"","sources":["../../../src/guard-handlers/guard-tick-deps.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0CAA0C,CAAC;AAEjF,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,UAAU,CAAC;AACxD,OAAO,KAAK,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAEpF;;;;;GAKG;AACH,MAAM,WAAW,aAAc,SAAQ,mBAAmB;IACxD,oEAAoE;IACpE,MAAM,EAAE,uBAAuB,CAAC;IAChC,8EAA8E;IAC9E,OAAO,EAAE,gBAAgB,CAAC;IAC1B,qEAAqE;IACrE,YAAY,EAAE,mBAAmB,CAAC;IAClC,gCAAgC;IAChC,GAAG,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;CAC5B"}

package/dist/types/guard-handlers/guard-tick-payload.d.ts

@@ -0,0 +1,15 @@
+import type { AppModulesInstance, FrameworkOptions } from '@equinor/fusion-framework-module-app';
+import type { ContextModule } from '@equinor/fusion-framework-module-context';
+/**
+ * Payload emitted on each URL guard tick, carrying the resolved app identity
+ * and its module instances so the guard can inspect app-level context state.
+ */
+export interface GuardTickPayload {
+    /** The currently active app's key (used for URL scope checks). */
+    appKey: string;
+    /** The app's resolved module instances (provides access to context provider). */
+    appModules: AppModulesInstance<[ContextModule]>;
+    /** Routing strategy declared in the app manifest's build options. */
+    routingStrategy?: FrameworkOptions['contextRouting'];
+}
+//# sourceMappingURL=guard-tick-payload.d.ts.map

package/dist/types/guard-handlers/guard-tick-payload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"guard-tick-payload.d.ts","sourceRoot":"","sources":["../../../src/guard-handlers/guard-tick-payload.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,sCAAsC,CAAC;AACjG,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0CAA0C,CAAC;AAE9E;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAC/B,kEAAkE;IAClE,MAAM,EAAE,MAAM,CAAC;IACf,iFAAiF;IACjF,UAAU,EAAE,kBAAkB,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC;IAChD,qEAAqE;IACrE,eAAe,CAAC,EAAE,gBAAgB,CAAC,gBAAgB,CAAC,CAAC;CACtD"}

package/dist/types/guard-handlers/handle-push-mode-guard.d.ts

@@ -0,0 +1,24 @@
+import type { GuardTickPayload } from './guard-tick-payload';
+import type { GuardTickDeps } from './guard-tick-deps';
+/**
+ * Handle a URL guard tick in **push mode** (`navigationOptions.replace: false`).
+ *
+ * Intent: keep browser history and context state bidirectionally in sync.
+ *
+ * In push mode, each context change pushes a new history entry, so back/forward
+ * navigations legitimately land on URLs with different context IDs. When the guard
+ * detects a URL containing a context ID that differs from the active context, it
+ * interprets this as the user having navigated through history and drives context
+ * FROM the URL (rather than overwriting the URL).
+ *
+ * If the URL's context ID can't be resolved (stale bookmark, deleted context),
+ * the function falls back to re-asserting the active context into the URL so the
+ * address bar isn't left pointing at a broken resource.
+ *
+ * @param urlContextId - The context ID decoded from the current URL by the adapter.
+ * @param payload - The active app key and resolved modules.
+ * @param currentURL - The current browser URL.
+ * @param deps - Shared plugin dependencies including the context provider.
+ */
+export declare function handlePushModeGuard(urlContextId: string, payload: GuardTickPayload, currentURL: URL, deps: GuardTickDeps): void;
+//# sourceMappingURL=handle-push-mode-guard.d.ts.map

package/dist/types/guard-handlers/handle-push-mode-guard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handle-push-mode-guard.d.ts","sourceRoot":"","sources":["../../../src/guard-handlers/handle-push-mode-guard.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAC7D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAEvD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,mBAAmB,CACjC,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,gBAAgB,EACzB,UAAU,EAAE,GAAG,EACf,IAAI,EAAE,aAAa,GAClB,IAAI,CA6BN"}

package/dist/types/guard-handlers/handle-replace-mode-guard.d.ts

@@ -0,0 +1,19 @@
+import type { GuardTickPayload } from './guard-tick-payload';
+import type { GuardTickDeps } from './guard-tick-deps';
+/**
+ * Handle a URL guard tick in **replace mode** (`navigationOptions.replace: true`, the default).
+ *
+ * Intent: correct URL drift caused by external interference.
+ *
+ * In replace mode, context changes replace the current history entry, so there is
+ * no meaningful back/forward stack within the context history. A URL mismatch
+ * therefore means something external mutated the URL (a redirect, a router
+ * guard stripping segments, etc.). The fix is to re-assert the active context
+ * back into the URL, restoring the canonical app path.
+ *
+ * @param payload - The active app key and resolved modules.
+ * @param currentURL - The current browser URL that diverged from the active context.
+ * @param deps - Shared plugin dependencies.
+ */
+export declare function handleReplaceModeGuard(payload: GuardTickPayload, currentURL: URL, deps: GuardTickDeps): void;
+//# sourceMappingURL=handle-replace-mode-guard.d.ts.map

package/dist/types/guard-handlers/handle-replace-mode-guard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handle-replace-mode-guard.d.ts","sourceRoot":"","sources":["../../../src/guard-handlers/handle-replace-mode-guard.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAC7D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAEvD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,gBAAgB,EACzB,UAAU,EAAE,GAAG,EACf,IAAI,EAAE,aAAa,GAClB,IAAI,CA6BN"}

package/dist/types/guard-handlers/index.d.ts

@@ -0,0 +1,7 @@
+export type { GuardTickPayload } from './guard-tick-payload';
+export type { GuardTickDeps } from './guard-tick-deps';
+export { isInAppScope } from './is-in-app-scope';
+export { consumeOwnNavToken } from './consume-own-nav-token';
+export { handlePushModeGuard } from './handle-push-mode-guard';
+export { handleReplaceModeGuard } from './handle-replace-mode-guard';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/guard-handlers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/guard-handlers/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAC7D,YAAY,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AACvD,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAC/D,OAAO,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC"}

package/dist/types/guard-handlers/is-in-app-scope.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Determine whether the current URL falls within the active app's path namespace.
+ *
+ * The plugin must only guard URLs that belong to its own app. Navigations to
+ * other apps or external paths should be ignored entirely — they are another
+ * app instance's responsibility.
+ *
+ * Convention: all app URLs live under `/apps/{appKey}` or `/apps/{appKey}/...`.
+ *
+ * @param currentURL - The current browser URL to check.
+ * @param appKey - The app key used to derive the expected base path.
+ * @returns `true` if the URL belongs to this app's scope.
+ */
+export declare function isInAppScope(currentURL: URL, appKey: string): boolean;
+//# sourceMappingURL=is-in-app-scope.d.ts.map

package/dist/types/guard-handlers/is-in-app-scope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-in-app-scope.d.ts","sourceRoot":"","sources":["../../../src/guard-handlers/is-in-app-scope.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,wBAAgB,YAAY,CAAC,UAAU,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAIrE"}

package/dist/types/helpers/get-current-url.d.ts

@@ -0,0 +1,10 @@
+import type { INavigationProvider } from '@equinor/fusion-framework-module-navigation';
+/**
+ * Construct the current browser URL from the navigation provider's state.
+ *
+ * @param navigation - The navigation provider (for reading pathname and search).
+ * @param origin - The origin used to construct an absolute URL.
+ * @returns An absolute URL representing the current browser location.
+ */
+export declare function getCurrentURL(navigation: INavigationProvider, origin: string): URL;
+//# sourceMappingURL=get-current-url.d.ts.map

package/dist/types/helpers/get-current-url.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-current-url.d.ts","sourceRoot":"","sources":["../../../src/helpers/get-current-url.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6CAA6C,CAAC;AAEvF;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,UAAU,EAAE,mBAAmB,EAAE,MAAM,EAAE,MAAM,GAAG,GAAG,CAElF"}

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

@@ -0,0 +1,6 @@
+export { normalizePathFromURL } from './normalize-path-from-url';
+export { normalizePath } from './normalize-path';
+export { getCurrentURL } from './get-current-url';
+export { resolveAdapter } from './resolve-adapter';
+export { stripQueryParams } from './strip-query-params';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/helpers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/helpers/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/types/helpers/normalize-path-from-url.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Normalize a URL to its path + search representation for comparison.
+ *
+ * Strips trailing slashes from the pathname so that `/apps/foo/` and
+ * `/apps/foo` compare as equal.
+ *
+ * @param url - The URL to normalize.
+ * @returns A string of the form `pathname + search` with trailing slash removed.
+ */
+export declare function normalizePathFromURL(url: URL): string;
+//# sourceMappingURL=normalize-path-from-url.d.ts.map

package/dist/types/helpers/normalize-path-from-url.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize-path-from-url.d.ts","sourceRoot":"","sources":["../../../src/helpers/normalize-path-from-url.ts"],"names":[],"mappings":"AACA;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,GAAG,GAAG,MAAM,CAErD"}

package/dist/types/helpers/normalize-path.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Normalizes a path string to ensure it is in a consistent format for comparison and processing.
+ *
+ * This function performs the following normalizations:
+ * - Ensures the path starts with a leading slash.
+ * - Removes any trailing slashes, except for the root path ("/").
+ * - Converts empty paths to the root path ("/").
+ * - Fixing multiple consecutive slashes to a single slash.
+ *
+ * @param path - The path string to normalize.
+ * @returns The normalized path string.
+ */
+export declare function normalizePath(path: string): string;
+//# sourceMappingURL=normalize-path.d.ts.map

package/dist/types/helpers/normalize-path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize-path.d.ts","sourceRoot":"","sources":["../../../src/helpers/normalize-path.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAoBlD"}

package/dist/types/helpers/resolve-adapter.d.ts

@@ -0,0 +1,14 @@
+import type { AdapterResolutionContext, ContextNavigationAdapter, ContextNavigationAdapterInput } from '../adapters/types';
+/**
+ * Iterate registered adapters and return the first one that can handle
+ * the given resolution context.
+ *
+ * - **Object adapters** are tested via `canHandle(ctx)`.
+ * - **Factory adapters** are invoked with `ctx`; a non-null return means match.
+ *
+ * @param ctx - The adapter resolution context (app key, app context, current URL).
+ * @param adapters - The registered adapters in evaluation order.
+ * @returns The first matching adapter, or `null` if none matched.
+ */
+export declare function resolveAdapter(ctx: AdapterResolutionContext, adapters: readonly ContextNavigationAdapterInput[]): ContextNavigationAdapter | null;
+//# sourceMappingURL=resolve-adapter.d.ts.map

package/dist/types/helpers/resolve-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-adapter.d.ts","sourceRoot":"","sources":["../../../src/helpers/resolve-adapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,wBAAwB,EACxB,wBAAwB,EACxB,6BAA6B,EAC9B,MAAM,mBAAmB,CAAC;AAE3B;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAC5B,GAAG,EAAE,wBAAwB,EAC7B,QAAQ,EAAE,SAAS,6BAA6B,EAAE,GACjD,wBAAwB,GAAG,IAAI,CAUjC"}

package/dist/types/helpers/strip-query-params.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Strip all query parameters from a URL.
+ *
+ * Used on app switches to give the adapter a clean URL. The adapter's
+ * `encode()` will add back whatever params it needs (e.g. `$contextId`
+ * for query-strategy apps). On context-only changes within the same app,
+ * this function is not called — query params survive naturally.
+ *
+ * @param url - The URL to strip (mutated in-place).
+ */
+export declare function stripQueryParams(url: URL): void;
+//# sourceMappingURL=strip-query-params.d.ts.map

package/dist/types/helpers/strip-query-params.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strip-query-params.d.ts","sourceRoot":"","sources":["../../../src/helpers/strip-query-params.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,GAAG,GAAG,IAAI,CAE/C"}

package/dist/types/index.d.ts

@@ -0,0 +1,9 @@
+export { createContextNavigationPlugin } from './create-context-navigation-plugin';
+export type { ContextNavigationPluginArgs, ContextNavigationEventSource, } from './create-context-navigation-plugin';
+export { ContextNavigationConfigurator } from './ContextNavigationConfigurator';
+export { enableContextNavigation } from './enable-context-navigation';
+export type { ContextNavigationConfig, ContextNavigationNavigateDetail, ContextNavigationNavigatedDetail, ContextNavigationAdapterResolvedDetail, ContextNavigationSkippedDetail, } from './types';
+export { legacyAppNavigationFix } from './utils/legacy-app-navigation-fix';
+import './events';
+export { version } from './version';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,6BAA6B,EAAE,MAAM,oCAAoC,CAAC;AACnF,YAAY,EACV,2BAA2B,EAC3B,4BAA4B,GAC7B,MAAM,oCAAoC,CAAC;AAG5C,OAAO,EAAE,6BAA6B,EAAE,MAAM,iCAAiC,CAAC;AAGhF,OAAO,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAC;AAGtE,YAAY,EACV,uBAAuB,EACvB,+BAA+B,EAC/B,gCAAgC,EAChC,sCAAsC,EACtC,8BAA8B,GAC/B,MAAM,SAAS,CAAC;AAGjB,OAAO,EAAE,sBAAsB,EAAE,MAAM,mCAAmC,CAAC;AAG3E,OAAO,UAAU,CAAC;AAGlB,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC"}

package/dist/types/operators/active-app-navigation-events.d.ts

@@ -0,0 +1,47 @@
+import { type Observable } from 'rxjs';
+import type { AppModuleProvider, AppModulesInstance, FrameworkOptions } from '@equinor/fusion-framework-module-app';
+import type { ContextModule } from '@equinor/fusion-framework-module-context';
+import type { INavigationProvider } from '@equinor/fusion-framework-module-navigation';
+/**
+ * Emission from the {@link activeAppNavigationEvents} stream.
+ *
+ * Represents the snapshot of the currently active app and its resolved modules
+ * at the moment a browser navigation state change occurred.
+ */
+export interface ActiveAppNavigationEvent {
+    /** The key identifying the currently active application. */
+    appKey: string;
+    /** The app's resolved module instances, guaranteed to include the context module. */
+    appModules: AppModulesInstance<[ContextModule]>;
+    /** Routing strategy declared in the app manifest's build options. */
+    routingStrategy?: FrameworkOptions['contextRouting'];
+}
+/**
+ * RxJS operator factory that produces an emission each time the browser
+ * navigation state changes while a fully resolved app is present.
+ *
+ * Intent: decouple the URL guard from the mechanics of observing app readiness.
+ * The guard only needs to know "an app is active and a navigation just happened" —
+ * this operator encapsulates the four-level observable plumbing required to
+ * produce that signal:
+ *
+ * 1. **App switch** — outer `switchMap` on `app.current$`. If the portal switches
+ *    to a different app (or clears the app), inner subscriptions auto-cancel.
+ * 2. **Module + manifest resolution** — middle `switchMap` on
+ *    `currentApp.instance$.pipe(combineLatestWith(currentApp.manifest$))`.
+ *    Waits until both the app's lazy modules and its manifest have resolved.
+ *    Emits EMPTY if modules are null.
+ * 3. **Routing strategy extraction** — `manifest.build.options.contextRouting`
+ *    is projected into the downstream payload so the guard can pass it to
+ *    adapter resolution without a separate manifest lookup.
+ * 4. **Navigation event** — inner `map` on `navigation.state$`. Each state change
+ *    (push, replace, popstate) triggers a downstream emission carrying the
+ *    resolved app key, modules, and routing strategy.
+ *
+ * @param app - The app module provider (source of `current$`).
+ * @param navigation - The navigation provider (source of `state$`).
+ * @returns An observable that emits `{ appKey, appModules }` on every navigation
+ *          event while an active app with resolved modules is present.
+ */
+export declare function activeAppNavigationEvents(app: AppModuleProvider, navigation: INavigationProvider): Observable<ActiveAppNavigationEvent>;
+//# sourceMappingURL=active-app-navigation-events.d.ts.map

package/dist/types/operators/active-app-navigation-events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"active-app-navigation-events.d.ts","sourceRoot":"","sources":["../../../src/operators/active-app-navigation-events.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,KAAK,UAAU,EAAqC,MAAM,MAAM,CAAC;AAEjF,OAAO,KAAK,EACV,iBAAiB,EACjB,kBAAkB,EAClB,gBAAgB,EACjB,MAAM,sCAAsC,CAAC;AAC9C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0CAA0C,CAAC;AAC9E,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6CAA6C,CAAC;AAEvF;;;;;GAKG;AACH,MAAM,WAAW,wBAAwB;IACvC,4DAA4D;IAC5D,MAAM,EAAE,MAAM,CAAC;IACf,qFAAqF;IACrF,UAAU,EAAE,kBAAkB,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC;IAChD,qEAAqE;IACrE,eAAe,CAAC,EAAE,gBAAgB,CAAC,gBAAgB,CAAC,CAAC;CACtD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,yBAAyB,CACvC,GAAG,EAAE,iBAAiB,EACtB,UAAU,EAAE,mBAAmB,GAC9B,UAAU,CAAC,wBAAwB,CAAC,CA8BtC"}

package/dist/types/reconcile.d.ts

@@ -0,0 +1,43 @@
+import type { IEventModuleProvider } from '@equinor/fusion-framework-module-event';
+import type { INavigationProvider } from '@equinor/fusion-framework-module-navigation';
+import type { ContextNavigationConfig } from './types';
+import type { ContextNavigationEventSource } from './create-context-navigation-plugin';
+import type { ReconcilerSourceEntry } from './sources/types';
+import { type ApplyNavigationDeps } from './apply-navigation';
+/** Dependencies required by {@link reconcile}. */
+export interface ReconcileDeps extends ApplyNavigationDeps {
+    event: IEventModuleProvider;
+    navigation: INavigationProvider;
+    config: ContextNavigationConfig;
+    eventSource: ContextNavigationEventSource;
+}
+/**
+ * Options that describe the trigger context for a reconciliation pass.
+ */
+export interface ReconcileOptions {
+    /**
+     * Whether this reconciliation was triggered by an app switch.
+     *
+     * When `true`, all query parameters are stripped from the current URL
+     * before the adapter encodes the new URL. The adapter adds back whatever
+     * it needs (e.g. `$contextId` for query-strategy apps).
+     *
+     * @default false
+     */
+    isAppSwitch?: boolean;
+}
+/**
+ * Reconcile a source entry: resolve an adapter and apply navigation
+ * for the given app/context combination.
+ *
+ * Handles three context states:
+ * - `undefined` — context not yet resolved, skip.
+ * - `null` — context cleared, navigate to `nullContextUrl` if configured.
+ * - `ContextItem` — active context, encode via adapter and navigate.
+ *
+ * @param entry - The reconciler source entry with app key, modules, and context state.
+ * @param deps - Shared plugin dependencies.
+ * @param options - Optional trigger context (e.g. whether this is an app switch).
+ */
+export declare function reconcile(entry: ReconcilerSourceEntry, deps: ReconcileDeps, options?: ReconcileOptions): void;
+//# sourceMappingURL=reconcile.d.ts.map

package/dist/types/reconcile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reconcile.d.ts","sourceRoot":"","sources":["../../src/reconcile.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,wCAAwC,CAAC;AACnF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6CAA6C,CAAC;AAEvF,OAAO,KAAK,EAEV,uBAAuB,EAExB,MAAM,SAAS,CAAC;AACjB,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,oCAAoC,CAAC;AACvF,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AAE7D,OAAO,EAAmB,KAAK,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAE/E,kDAAkD;AAClD,MAAM,WAAW,aAAc,SAAQ,mBAAmB;IACxD,KAAK,EAAE,oBAAoB,CAAC;IAC5B,UAAU,EAAE,mBAAmB,CAAC;IAChC,MAAM,EAAE,uBAAuB,CAAC;IAChC,WAAW,EAAE,4BAA4B,CAAC;CAC3C;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;;;;;;;OAQG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,SAAS,CACvB,KAAK,EAAE,qBAAqB,EAC5B,IAAI,EAAE,aAAa,EACnB,OAAO,GAAE,gBAAqB,GAC7B,IAAI,CA8EN"}

package/dist/types/sources/app-first-source.d.ts

@@ -0,0 +1,14 @@
+import { type ReconcilerSourceFactory } from './types';
+/**
+ * App-first source factory — app switches lead, context follows.
+ *
+ * Stream composition:
+ * ```
+ * app.current$ → combineLatest(instance$, manifest$) → combineLatestWith(context.currentContext$)
+ * ```
+ *
+ * Use this for **app-portal** where the active app determines the navigation
+ * context. Context changes are reconciled within the scope of the current app.
+ */
+export declare const appFirstSource: () => ReconcilerSourceFactory;
+//# sourceMappingURL=app-first-source.d.ts.map

package/dist/types/sources/app-first-source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"app-first-source.d.ts","sourceRoot":"","sources":["../../../src/sources/app-first-source.ts"],"names":[],"mappings":"AAKA,OAAO,EAAuB,KAAK,uBAAuB,EAAE,MAAM,SAAS,CAAC;AAE5E;;;;;;;;;;GAUG;AACH,eAAO,MAAM,cAAc,QAAO,uBAyCjC,CAAC"}

package/dist/types/sources/context-first-source.d.ts

@@ -0,0 +1,15 @@
+import { type ReconcilerSourceFactory } from './types';
+/**
+ * Context-first source factory — context changes lead, app follows.
+ *
+ * Stream composition:
+ * ```
+ * context.currentContext$ → combineLatestWith(app.current$ → combineLatest(instance$, manifest$))
+ * ```
+ *
+ * Use this for **context-portal** where the selected context drives all
+ * navigation. App switches are reconciled within the scope of the current
+ * context.
+ */
+export declare const contextFirstSource: () => ReconcilerSourceFactory;
+//# sourceMappingURL=context-first-source.d.ts.map

package/dist/types/sources/context-first-source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-first-source.d.ts","sourceRoot":"","sources":["../../../src/sources/context-first-source.ts"],"names":[],"mappings":"AAKA,OAAO,EAAuB,KAAK,uBAAuB,EAAE,MAAM,SAAS,CAAC;AAE5E;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,kBAAkB,QAAO,uBAiDrC,CAAC"}

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

@@ -0,0 +1,4 @@
+export { appFirstSource } from './app-first-source';
+export { contextFirstSource } from './context-first-source';
+export { contextStateChanged, type ContextState, type ReconcilerPhase, type ReconcilerSourceEntry, type ReconcilerSourceDeps, type ReconcilerSourceFactory, } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/sources/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/sources/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAE5D,OAAO,EACL,mBAAmB,EACnB,KAAK,YAAY,EACjB,KAAK,eAAe,EACpB,KAAK,qBAAqB,EAC1B,KAAK,oBAAoB,EACzB,KAAK,uBAAuB,GAC7B,MAAM,SAAS,CAAC"}

package/dist/types/sources/types.d.ts

@@ -0,0 +1,61 @@
+import type { Observable } from 'rxjs';
+import type { AppModuleProvider, AppModulesInstance, FrameworkOptions } from '@equinor/fusion-framework-module-app';
+import type { ContextModule, ContextItem, IContextProvider } from '@equinor/fusion-framework-module-context';
+import type { INavigationProvider } from '@equinor/fusion-framework-module-navigation';
+/**
+ * The reconciler's view of context state.
+ *
+ * - `undefined` — context not yet resolved (initializing)
+ * - `null` — context intentionally cleared
+ * - `ContextItem` — active context
+ */
+export type ContextState = ContextItem | null | undefined;
+export type ReconcilerPhase = 'idle' | 'active' | 'cleared';
+/**
+ * A single reconciliation entry emitted by the source factory.
+ *
+ * Contains everything the reconciler needs to decide whether and how
+ * to navigate.
+ */
+export interface ReconcilerSourceEntry {
+    /** Current app key. */
+    appKey: string;
+    /** The app's loaded module instances (must include context). */
+    appModules: AppModulesInstance<[ContextModule]>;
+    /** The portal-level context state driving reconciliation. */
+    contextState: ContextState;
+    /** Routing strategy declared in the app manifest's build options. */
+    routingStrategy?: FrameworkOptions['contextRouting'];
+}
+/**
+ * Dependencies injected into a source factory.
+ */
+export interface ReconcilerSourceDeps {
+    /** The app module provider (for watching app switches). */
+    app: AppModuleProvider;
+    /** The portal's context provider (for watching context changes). */
+    context: IContextProvider;
+    /** The navigation provider (for reading current URL). */
+    navigation: INavigationProvider;
+}
+/**
+ * A source factory produces the observable stream that drives the reconciler.
+ *
+ * The stream composition determines **what leads** — app switches or context
+ * changes — making it the primary extension point for portal-specific behavior.
+ *
+ * Built-in factories:
+ * - `createAppFirstSource` — app switches lead, context follows (app-portal)
+ * - `createContextFirstSource` — context changes lead, app follows (context-portal)
+ */
+export type ReconcilerSourceFactory = (deps: ReconcilerSourceDeps) => Observable<ReconcilerSourceEntry>;
+/**
+ * Equality comparator for `ContextState` values in `distinctUntilChanged`.
+ *
+ * Returns `true` when the two states represent the same context identity,
+ * preventing redundant reconciler emissions. Both `null` (cleared) and
+ * `undefined` (initializing) are compared by reference; active contexts
+ * are compared by `id`.
+ */
+export declare const contextStateChanged: (a: ContextState, b: ContextState) => boolean;
+//# sourceMappingURL=types.d.ts.map

package/dist/types/sources/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/sources/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,MAAM,CAAC;AAEvC,OAAO,KAAK,EACV,iBAAiB,EACjB,kBAAkB,EAClB,gBAAgB,EACjB,MAAM,sCAAsC,CAAC;AAC9C,OAAO,KAAK,EACV,aAAa,EACb,WAAW,EACX,gBAAgB,EACjB,MAAM,0CAA0C,CAAC;AAClD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6CAA6C,CAAC;AAIvF;;;;;;GAMG;AACH,MAAM,MAAM,YAAY,GAAG,WAAW,GAAG,IAAI,GAAG,SAAS,CAAC;AAI1D,MAAM,MAAM,eAAe,GAAG,MAAM,GAAG,QAAQ,GAAG,SAAS,CAAC;AAI5D;;;;;GAKG;AACH,MAAM,WAAW,qBAAqB;IACpC,uBAAuB;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,gEAAgE;IAChE,UAAU,EAAE,kBAAkB,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC;IAChD,6DAA6D;IAC7D,YAAY,EAAE,YAAY,CAAC;IAC3B,qEAAqE;IACrE,eAAe,CAAC,EAAE,gBAAgB,CAAC,gBAAgB,CAAC,CAAC;CACtD;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,2DAA2D;IAC3D,GAAG,EAAE,iBAAiB,CAAC;IACvB,oEAAoE;IACpE,OAAO,EAAE,gBAAgB,CAAC;IAC1B,yDAAyD;IACzD,UAAU,EAAE,mBAAmB,CAAC;CACjC;AAED;;;;;;;;;GASG;AACH,MAAM,MAAM,uBAAuB,GAAG,CACpC,IAAI,EAAE,oBAAoB,KACvB,UAAU,CAAC,qBAAqB,CAAC,CAAC;AAIvC;;;;;;;GAOG;AACH,eAAO,MAAM,mBAAmB,MAAO,YAAY,KAAK,YAAY,KAAG,OAItE,CAAC"}