@equinor/fusion-framework-module-navigation 6.0.1 → 7.0.0-next.2

package/dist/types/NavigationConfigurator.d.ts

@@ -0,0 +1,60 @@
+import { type ObservableInput } from 'rxjs';
+import { BaseConfigBuilder, type ConfigBuilderCallback, type ConfigBuilderCallbackArgs } from '@equinor/fusion-framework-module';
+import type { ITelemetryProvider } from '@equinor/fusion-framework-module-telemetry';
+import type { IEventModuleProvider } from '@equinor/fusion-framework-module-event';
+import type { INavigationConfigurator } from './NavigationConfigurator.interface';
+import type { History } from './lib/types';
+/**
+ * Configurator class for navigation module settings.
+ * Extends BaseConfigBuilder to provide fluent configuration API with Zod validation.
+ */
+export declare class NavigationConfigurator extends BaseConfigBuilder<INavigationConfigurator> {
+    constructor();
+    /**
+     * @deprecated Use `setBasename()` method instead
+     */
+    set basename(value: string | undefined);
+    /**
+     * @deprecated Use `setHistory()` method instead
+     */
+    set history(value: History | undefined);
+    /**
+     * Sets the basename for the application.
+     *
+     * @param basenameOrCallback - Basename string or configuration callback
+     * @returns The configurator instance for method chaining
+     */
+    setBasename(basenameOrCallback?: string | ConfigBuilderCallback<string>): this;
+    /**
+     * Sets a custom history instance for the navigation module.
+     *
+     * @param historyOrCallback - History instance or configuration callback
+     * @returns The configurator instance for method chaining
+     */
+    setHistory(historyOrCallback?: History | ConfigBuilderCallback<History>): this;
+    /**
+     * Sets telemetry configuration for navigation-specific events.
+     *
+     * @param telemetryOrCallback - Telemetry provider instance or configuration callback
+     * @returns The configurator instance for method chaining
+     */
+    setTelemetry(telemetryOrCallback: ITelemetryProvider | ConfigBuilderCallback<ITelemetryProvider>): this;
+    /**
+     * Sets event provider for dispatching navigation events.
+     *
+     * @param eventProviderOrCallback - Event provider instance or configuration callback
+     * @returns The configurator instance for method chaining
+     */
+    setEventProvider(eventProviderOrCallback: IEventModuleProvider | ConfigBuilderCallback<IEventModuleProvider>): this;
+    /**
+     * Processes and validates the configuration using Zod schema.
+     *
+     * @param config - Raw configuration object from builder
+     * @param _init - Configuration builder callback arguments (unused)
+     * @returns Observable that emits validated and processed configuration object
+     * @throws {z.ZodError} If the configuration is invalid
+     *
+     * @protected
+     */
+    protected _processConfig(config: Partial<INavigationConfigurator>, _init: ConfigBuilderCallbackArgs): ObservableInput<INavigationConfigurator>;
+}

package/dist/types/NavigationConfigurator.interface.d.ts

@@ -0,0 +1,17 @@
+import type { History } from './lib/types';
+import type { ITelemetryProvider } from '@equinor/fusion-framework-module-telemetry';
+import type { IEventModuleProvider } from '@equinor/fusion-framework-module-event';
+/**
+ * Configuration object for the navigation module.
+ * Provides options for customizing history, basename, telemetry, and event settings.
+ */
+export interface INavigationConfigurator {
+    /** Optional base pathname for the application (e.g., "/app") */
+    basename?: string;
+    /** Optional custom history instance (browser, hash, or memory). If not provided, defaults to browser history. */
+    history?: History;
+    /** Optional telemetry provider for tracking navigation events */
+    telemetry?: ITelemetryProvider;
+    /** Optional event provider for dispatching navigation events */
+    eventProvider?: IEventModuleProvider;
+}

package/dist/types/NavigationProvider.d.ts

@@ -0,0 +1,112 @@
+import { type AgnosticRouteObject } from '@remix-run/router';
+import type { Observable } from 'rxjs';
+import { BaseModuleProvider, type BaseModuleProviderCtorArgs } from '@equinor/fusion-framework-module/provider';
+import type { INavigationProvider } from './NavigationProvider.interface';
+import type { INavigationConfigurator } from './NavigationConfigurator.interface';
+import type { History, NavigateOptions, NavigationUpdate, Path, To } from './lib/types';
+/**
+ * Navigation provider implementation.
+ * Manages routing and navigation state with basename localization.
+ *
+ * @remarks
+ * This provider:
+ * - Wraps the Navigator to provide observable navigation state
+ * - Localizes paths by removing basename prefix
+ * - Creates routers compatible with industry-standard routers (Remix/React Router)
+ * - Handles navigation actions (push, replace, createHref, etc.)
+ *
+ * Path localization ensures that consumers receive paths relative to the basename,
+ * while internally we work with full paths including basename.
+ */
+export declare class NavigationProvider extends BaseModuleProvider<INavigationConfigurator> implements INavigationProvider {
+    #private;
+    /**
+     * Observable stream of navigation state updates.
+     * Emits localized paths (with basename removed) for consumers.
+     */
+    get state$(): Observable<NavigationUpdate>;
+    /**
+     * Gets the basename.
+     */
+    get basename(): string;
+    /**
+     * @deprecated Use `history` instead
+     */
+    get navigator(): History;
+    /**
+     * Gets the history instance.
+     */
+    get history(): History;
+    /**
+     * Gets the current localized path (basename removed).
+     */
+    get path(): Path;
+    /**
+     * @param args - Configuration arguments containing module config
+     * @throws {Error} If no history is provided in the configuration
+     */
+    constructor(args: BaseModuleProviderCtorArgs<INavigationConfigurator>);
+    /**
+     * Sets up navigation subscriptions for events and telemetry.
+     *
+     * Configures subscriptions for:
+     * - NavigatedEvent dispatching when navigation changes
+     * - Telemetry tracking for navigation actions and events
+     * - History disposal cleanup
+     */
+    protected _initialize(): void;
+    /**
+     * Creates a router instance from route configuration.
+     *
+     * @deprecated Use `@equinor/fusion-framework-react-router` instead
+     *
+     * @param routes - Route configuration objects compatible with industry-standard routers (Remix/React Router)
+     * @returns A configured and initialized router instance
+     */
+    createRouter(routes: AgnosticRouteObject[]): import("@remix-run/router").Router;
+    /**
+     * Creates a localized href string for navigation.
+     *
+     * @param to - Optional path or location (defaults to current path)
+     */
+    createHref(to?: To): string;
+    /**
+     * Creates a full URL object for navigation.
+     *
+     * @param to - Optional path or location (defaults to current path)
+     */
+    createURL(to?: To): URL;
+    /**
+     * Pushes a new navigation entry onto the history stack.
+     *
+     * @param to - Path or location to navigate to (relative to basename)
+     * @param state - Optional state to associate with the navigation
+     */
+    push(to: To, state?: unknown): void;
+    /**
+     * Replaces the current history entry with a new one.
+     *
+     * @param to - Path or location to navigate to (relative to basename)
+     * @param state - Optional state to associate with the navigation
+     */
+    replace(to: To, state?: unknown): void;
+    /**
+     * Navigate to a location with explicit options.
+     *
+     * @param to - Optional path or location (defaults to current path)
+     * @param options - Optional navigation options
+     */
+    navigate(to?: To, options?: Partial<NavigateOptions>): void;
+    /**
+     * Checks if a pathname is within the basename scope.
+     */
+    protected _isWithinBasenameScope(pathname: string): boolean;
+    /**
+     * Localizes a path by removing the basename prefix.
+     */
+    protected _localizePath(location: Path): Path;
+    /**
+     * Creates a full path object from a target location, adding basename prefix.
+     */
+    protected _createToPath(to: To): Partial<Path>;
+}

package/dist/types/NavigationProvider.interface.d.ts

@@ -0,0 +1,75 @@
+import type { AgnosticRouteObject, Router } from '@remix-run/router';
+import type { History, NavigateOptions } from './lib/types';
+import type { Action, Path, To } from './lib/types';
+import type { Observable } from 'rxjs';
+import type { IModuleProvider } from '@equinor/fusion-framework-module';
+/**
+ * Navigation provider interface.
+ * Provides routing and navigation capabilities with basename localization.
+ */
+export interface INavigationProvider extends IModuleProvider {
+    /**
+     * Observable stream of navigation state updates.
+     * Emits localized paths (with basename removed) for consumers.
+     */
+    readonly state$: Observable<{
+        action: Action;
+        location: Path;
+    }>;
+    /**
+     * Gets the basename.
+     */
+    readonly basename: string;
+    /**
+     * Gets the current localized path (basename removed).
+     */
+    readonly path: Path;
+    /**
+     * @deprecated Use `history` instead
+     */
+    readonly navigator: History;
+    /**
+     * Gets the history instance.
+     */
+    readonly history: History;
+    /**
+     * Creates a router instance from route configuration.
+     *
+     * @param routes - Route configuration objects compatible with industry-standard routers (Remix/React Router)
+     * @returns A configured and initialized router instance
+     */
+    createRouter(routes: AgnosticRouteObject[]): Router;
+    /**
+     * Creates a localized href string for navigation.
+     *
+     * @param to - Optional path or location (defaults to current path)
+     */
+    createHref(to?: To): string;
+    /**
+     * Creates a full URL object for navigation.
+     *
+     * @param to - Optional path or location (defaults to current path)
+     */
+    createURL(to?: To): URL;
+    /**
+     * Navigates to a location with explicit options.
+     *
+     * @param to - Optional path or location (defaults to current path)
+     * @param options - Optional navigation options
+     */
+    navigate(to?: To, options?: Partial<NavigateOptions>): void;
+    /**
+     * Pushes a new navigation entry onto the history stack.
+     *
+     * @param to - Path or location to navigate to (relative to basename)
+     * @param state - Optional state to associate with the navigation
+     */
+    push(to: To, state?: unknown): void;
+    /**
+     * Replaces the current history entry with a new one.
+     *
+     * @param to - Path or location to navigate to (relative to basename)
+     * @param state - Optional state to associate with the navigation
+     */
+    replace(to: To, state?: unknown): void;
+}

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

@@ -0,0 +1,40 @@
+import type { IModulesConfigurator, ModuleConfigType } from '@equinor/fusion-framework-module';
+import { type NavigationModule } from './module';
+/**
+ * Helper function to enable the navigation module.
+ *
+ * This is the main entry point for consumers to add navigation capabilities to their
+ * framework configuration. It registers the navigation module and allows configuration
+ * of basename and other navigation settings.
+ *
+ * The navigation module provides routing and navigation capabilities compatible with
+ * industry-standard routers (Remix/React Router), with support for browser history,
+ * hash routing, and memory history.
+ *
+ * @param configurator - The modules configurator to add navigation to
+ * @param basenameOrOptions - Optional basename string or configuration object
+ * @param basenameOrOptions.configure - Configuration callback for advanced setup
+ * @typeParam TRef - Reference type for module composition
+ *
+ * @example
+ * ```ts
+ * // Simple usage with basename
+ * enableNavigation(configurator, '/app');
+ *
+ * // Advanced configuration
+ * enableNavigation(configurator, {
+ *   configure(config, ref) {
+ *     config.setBasename('/app');
+ *     config.setHistory(createHistory('browser'));
+ *   }
+ * });
+ * ```
+ *
+ * @see {@link NavigationModule} - The navigation module type
+ * @see {@link INavigationConfigurator} - Configuration interface
+ * @see {@link INavigationProvider} - Provider interface for accessing navigation
+ */
+export declare const enableNavigation: <TRef = unknown>(configurator: IModulesConfigurator<any, any>, basenameOrOptions?: string | {
+    configure: (config: ModuleConfigType<NavigationModule>, ref: TRef) => void;
+}) => void;
+export default enableNavigation;

package/dist/types/events.d.ts

@@ -0,0 +1,48 @@
+import { FrameworkEvent, type FrameworkEventInit } from '@equinor/fusion-framework-module-event';
+import type { INavigationProvider } from './NavigationProvider.interface';
+import type { Action, NavigationUpdate, Path } from './lib/types';
+/**
+ * Event detail for navigation events (before navigation).
+ */
+export interface NavigateEventDetail {
+    /** The target path or location to navigate to */
+    location: NavigationUpdate;
+    /** Optional current location before navigation */
+    currentLocation?: Path;
+}
+/**
+ * Event emitted before navigation occurs.
+ * Can be canceled by calling `preventDefault()`.
+ */
+export declare class NavigateEvent extends FrameworkEvent<FrameworkEventInit<NavigateEventDetail, INavigationProvider>> {
+    constructor(detail: NavigateEventDetail, source: INavigationProvider);
+}
+/**
+ * Event detail for navigated events (after navigation).
+ */
+export interface NavigatedEventDetail {
+    /** The navigation action that occurred (PUSH, POP, REPLACE) */
+    action: Action;
+    /** The new location after navigation */
+    current: NavigationUpdate;
+    /** The previous location before navigation */
+    previous: NavigationUpdate;
+}
+/**
+ * Event emitted after navigation occurs.
+ * Contains the navigation action and location details.
+ */
+export declare class NavigatedEvent extends FrameworkEvent<FrameworkEventInit<NavigatedEventDetail, INavigationProvider>> {
+    constructor(detail: NavigatedEventDetail, source: INavigationProvider);
+}
+/**
+ * Declares navigation events in the FrameworkEventMap for type safety.
+ */
+declare module '@equinor/fusion-framework-module-event' {
+    interface FrameworkEventMap {
+        /** Event emitted before navigation occurs, can be canceled to prevent navigation */
+        onNavigate: NavigateEvent;
+        /** Event emitted after navigation occurs */
+        onNavigated: NavigatedEvent;
+    }
+}

package/dist/types/index.d.ts

@@ -1,6 +1,13 @@
-export type { Action, Path } from '@remix-run/router';
-export { INavigationConfigurator, NavigationConfigurator } from './configurator';
-export { NavigationModule, enableNavigation, module, moduleKey } from './module';
-export { createHistory } from './createHistory';
-export * from './lib';
-export * from './types';
+export type { INavigationConfigurator } from './NavigationConfigurator.interface';
+export { NavigationConfigurator } from './NavigationConfigurator';
+export { NavigationModule, module, moduleKey } from './module';
+export { enableNavigation } from './enable-navigation';
+export type { INavigationProvider } from './NavigationProvider.interface';
+export { NavigationProvider } from './NavigationProvider';
+export { createHistory } from './lib/create-history';
+export { NavigateEvent, NavigatedEvent, type NavigateEventDetail, type NavigatedEventDetail, } from './events';
+export type { Path, To, Location, History, NavigationBlocker, NavigationListener, } from './lib/types';
+/**
+ * @deprecated use History instead
+ */
+export type { History as INavigator } from './lib';

package/dist/types/lib/BaseHistory.d.ts

@@ -0,0 +1,122 @@
+import { Subscription } from 'rxjs';
+import type { Actions, HistoryState } from './state';
+import type { NavigateOptions, NavigationListener, Path, To, History, NavigationBlocker } from './types';
+/**
+ * Abstract base class for history implementations.
+ * Provides common state management and navigation logic that can be shared
+ * across different history implementations (browser, memory, etc.).
+ */
+export declare abstract class BaseHistory implements History {
+    #private;
+    /**
+     * Gets the current location.
+     */
+    get location(): History['location'];
+    /**
+     * Gets the current action.
+     */
+    get action(): History['action'];
+    /**
+     * Observable stream of navigation state changes.
+     * Emits on all navigation events (push, replace, pop).
+     */
+    get state$(): History['state$'];
+    /**
+     * Observable stream of navigation actions.
+     */
+    get action$(): History['action$'];
+    /**
+     * Checks if there are any active navigation blockers.
+     */
+    get hasBlockers(): boolean;
+    protected constructor(state: HistoryState);
+    /**
+     * Creates a valid href string for a given path.
+     */
+    createHref(to: To): string;
+    /**
+     * Creates a URL object for a given path.
+     */
+    createURL(to: To): URL;
+    /**
+     * Encodes a location by properly URL-encoding the pathname.
+     */
+    encodeLocation(to: To): Path;
+    /**
+     * Navigate to a location with explicit options.
+     *
+     * @param to - The target path (string, Path object, or Location object)
+     * @param options - Navigation options specifying action (PUSH/REPLACE) and optional state
+     */
+    navigate(to: To, options: NavigateOptions): void;
+    /**
+     * Pushes a new location onto the history stack.
+     */
+    push(to: To, state?: unknown): void;
+    /**
+     * Replaces the current location in the history stack.
+     */
+    replace(to: To, state?: unknown): void;
+    /**
+     * Navigates backward or forward in the history stack.
+     *
+     * @param delta - The number of steps to move (negative for backward, positive for forward)
+     */
+    go(delta: number): void;
+    /**
+     * Sets up a listener for navigation changes.
+     *
+     * Only listens for POP actions (browser back/forward navigation). PUSH/REPLACE
+     * actions are programmatic and synchronous - the caller already knows about them.
+     * POP actions come from browser events and are asynchronous, so we need to listen.
+     * This matches industry-standard router behavior (Remix/React Router).
+     *
+     * @param listener - Function to call on navigation changes
+     * @returns Function to unsubscribe the listener
+     */
+    listen(listener: NavigationListener): () => void;
+    /**
+     * Registers a blocker to intercept navigation attempts.
+     *
+     * @param blocker - Navigation blocker function to register
+     * @returns Function to unsubscribe the blocker
+     */
+    block(blocker: NavigationBlocker): VoidFunction;
+    pop(): void;
+    /**
+     * Disposes of the history instance and cleans up all subscriptions.
+     */
+    [Symbol.dispose](): void;
+    /**
+     * Dispatches an action to trigger state updates.
+     *
+     * Use this to dispatch actions when external events occur (e.g., browser popstate).
+     * The action will be processed by flows and update the history state.
+     *
+     * @param action - The action to dispatch
+     */
+    protected _dispatch(action: Actions): void;
+    /**
+     * Registers a cleanup function or subscription for automatic disposal.
+     *
+     * All teardowns are automatically cleaned up when the history instance is disposed.
+     * Use `executeOnRemove: true` if the teardown should run when manually removed.
+     *
+     * @param teardown - Function or subscription to clean up
+     * @param options - Optional configuration
+     * @param options.executeOnRemove - Execute teardown when removed (default: false)
+     * @returns Function to manually remove the teardown
+     */
+    protected _addTeardown(teardown: VoidFunction | Subscription, options?: {
+        executeOnRemove: boolean;
+    }): VoidFunction;
+    /**
+     * Removes a teardown from the cleanup collection.
+     *
+     * Typically called automatically by the function returned from `_addTeardown`.
+     * Only call directly if you need to remove a teardown without executing it.
+     *
+     * @param teardown - The teardown to remove
+     */
+    protected _removeTeardown(teardown: VoidFunction | Subscription): void;
+}

package/dist/types/lib/BrowserHistory.d.ts

@@ -0,0 +1,53 @@
+import { BaseHistory } from './BaseHistory';
+import { type HistoryStack, type NavigationBlocker } from './types';
+/**
+ * Constructor for a HistoryStack implementation.
+ *
+ * @param window - The window object to use for history operations
+ * @returns A new instance of the HistoryStack implementation
+ */
+export interface StackConstructor {
+    new (window: Window): HistoryStack;
+}
+/**
+ * Options for configuring a BrowserHistory instance.
+ */
+export type BrowserHistoryOptions = {
+    /** Optional window object (defaults to global window) */
+    window?: Window;
+    /** Optional stack constructor (defaults to BrowserHistoryStack, use BrowserHistoryHashStack for hash routing) */
+    stack?: StackConstructor;
+};
+/**
+ * Browser history implementation using native browser APIs.
+ *
+ * Uses the browser's History API (pushState/replaceState) for navigation.
+ * Automatically listens for popstate/hashchange events to detect browser back/forward navigation.
+ * Compatible with industry-standard routers (Remix/React Router).
+ */
+export declare class BrowserHistory extends BaseHistory {
+    #private;
+    /**
+     * Creates a browser history instance.
+     *
+     * Initializes with the current window location and sets up listeners for
+     * browser navigation events (popstate for regular routing, hashchange for hash routing).
+     *
+     * @param options - Configuration options
+     * @param options.window - Window object to use (defaults to global window)
+     * @param options.stack - Stack implementation (defaults to BrowserHistoryStack, use BrowserHistoryHashStack for hash routing)
+     * @throws {Error} If window is not available
+     */
+    constructor(options?: BrowserHistoryOptions);
+    /**
+     * Registers a blocker to intercept navigation attempts.
+     *
+     * Adds a beforeunload event listener when blockers are active to prevent
+     * page unload (e.g., when user tries to close the tab). This provides
+     * browser-level protection in addition to in-app navigation blocking.
+     *
+     * @param blocker - Navigation blocker function to register
+     * @returns Function to unsubscribe the blocker
+     */
+    block(blocker: NavigationBlocker): VoidFunction;
+}

package/dist/types/lib/BrowserHistoryHashStack.d.ts

@@ -0,0 +1,41 @@
+import { BrowserHistoryStack } from './BrowserHistoryStack';
+import type { Location, To } from './types';
+/**
+ * Browser history hash stack implementation using hash-based routing.
+ *
+ * Uses URL hash fragment (#) instead of pathname. The hash is not sent to the server,
+ * allowing routing without server configuration.
+ *
+ * @example
+ * ```ts
+ * // Regular routing: https://example.com/users
+ * // Hash routing: https://example.com/#/users
+ * const stack = new BrowserHistoryHashStack(window);
+ * ```
+ */
+export declare class BrowserHistoryHashStack extends BrowserHistoryStack {
+    /**
+     * Gets the current location from window.location.hash.
+     */
+    get current(): Readonly<Location>;
+    /**
+     * Creates a URL object for a given path with hash-based routing.
+     *
+     * Uses the current window location as the base and only modifies the hash fragment.
+     * The path is normalized to ensure it starts with '#' if not already present.
+     *
+     * @param to - The target path (string, Path object, or Location object)
+     * @returns A URL object with the path in the hash fragment
+     *
+     * @example
+     * ```ts
+     * // If current URL is 'https://example.com/app'
+     * createURL('/users?id=1')
+     * // URL { href: 'https://example.com/app#/users?id=1', ... }
+     *
+     * createURL({ pathname: '/dashboard', search: '?tab=settings' })
+     * // URL { href: 'https://example.com/app#/dashboard?tab=settings', ... }
+     * ```
+     */
+    createURL(to: To): URL;
+}

package/dist/types/lib/BrowserHistoryStack.d.ts

@@ -0,0 +1,51 @@
+import type { HistoryStack, Location, To } from './types';
+/**
+ * Browser history stack implementation using native browser APIs.
+ *
+ * Manages navigation state using the browser's History API (pushState/replaceState).
+ * Stores location state in history.state and uses relative paths for navigation.
+ * This is the base implementation for regular (non-hash) routing.
+ *
+ * @example
+ * ```ts
+ * const stack = new BrowserHistoryStack(window);
+ * stack.push({ pathname: '/users', key: 'abc123', state: { userId: 1 } });
+ * // Updates URL to /users and adds entry to history
+ * ```
+ */
+export declare class BrowserHistoryStack implements HistoryStack {
+    protected readonly _window: Window;
+    /**
+     * @param _window - The window object to use for history operations
+     */
+    constructor(_window: Window);
+    /**
+     * Gets the origin of the history stack.
+     */
+    get origin(): string;
+    /**
+     * Gets the current location.
+     */
+    get current(): Location;
+    /**
+     * Pushes a new entry onto the history stack.
+     */
+    push(location: Location): void;
+    /**
+     * Replaces the current entry in the history stack.
+     */
+    replace(location: Location): void;
+    /**
+     * Navigates to a location with the specified action.
+     */
+    navigate(location: Location, action: 'PUSH' | 'REPLACE'): void;
+    /**
+     * Navigates backward or forward in the history stack.
+     */
+    go(delta: number): void;
+    /**
+     * Creates a URL object for a given path.
+     */
+    createURL(to: To): URL;
+    protected _createRelativePath(to: To): string;
+}

package/dist/types/lib/MemoryHistory.d.ts

@@ -0,0 +1,27 @@
+import { type To, type NavigationUpdate } from './types';
+import { BaseHistory } from './BaseHistory';
+/**
+ * Options for configuring a MemoryHistory instance.
+ */
+export type MemoryHistoryOptions = {
+    /** Optional initial location */
+    initialLocation?: NavigationUpdate;
+    /** Optional initial history entries */
+    initialHistory?: NavigationUpdate[];
+};
+/**
+ * Memory history implementation using in-memory storage.
+ *
+ * Useful for:
+ * - Testing: Control navigation state in tests without browser APIs
+ * - SSR: Server-side rendering where window is not available
+ * - Widgets: Serving applications as widgets without affecting the main browser history
+ * - Node.js environments: Environments without browser APIs
+ */
+export declare class MemoryHistory extends BaseHistory {
+    constructor(options?: MemoryHistoryOptions);
+    /**
+     * Creates a URL object for a given path using memory:// origin.
+     */
+    createURL(to: To): URL;
+}