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

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

@@ -0,0 +1,57 @@
+import type { HistoryStack, Location, LocationState, To } from './types';
+/**
+ * Memory-based history stack implementation.
+ *
+ * Stores navigation state in memory instead of using browser APIs.
+ * Unlike BrowserHistoryStack, push/replace only update the current location
+ * (history entries are managed by the reducer, not the stack).
+ */
+export declare class MemoryHistoryStack implements HistoryStack {
+    #private;
+    /**
+     * Gets the origin of the history stack.
+     * Always returns 'memory://' for in-memory storage.
+     */
+    get origin(): string;
+    /**
+     * Gets the current location.
+     */
+    get current(): Location;
+    /**
+     * Creates a memory history stack instance.
+     *
+     * @param options - Configuration options
+     * @param options.initialLocation - Optional initial location (defaults to '/')
+     */
+    constructor(options?: {
+        initialLocation?: Location;
+    });
+    /**
+     * Pushes a new entry onto the history stack.
+     *
+     * Only updates the current location. History entries are managed by the reducer.
+     */
+    push(location: Location): void;
+    /**
+     * Replaces the current entry in the history stack.
+     *
+     * Only updates the current location. History entries are managed by the reducer.
+     */
+    replace(location: Location): void;
+    /**
+     * Navigates backward or forward in the history stack.
+     *
+     * Uses the history state to find the target location by index.
+     * Clamps to valid range (first or last entry if out of bounds).
+     *
+     * @param delta - Number of steps to move (negative for back, positive for forward)
+     * @param state - Current location state with history entries
+     */
+    go(delta: number, state: Readonly<LocationState>): void;
+    /**
+     * Creates a URL object for a given path.
+     *
+     * All URLs use the 'memory://' origin since this is in-memory storage.
+     */
+    createURL(to: To): URL;
+}

package/dist/types/lib/create-history.d.ts

@@ -0,0 +1,35 @@
+import { MemoryHistory, type MemoryHistoryOptions } from './MemoryHistory';
+import { BrowserHistory, type BrowserHistoryOptions } from './BrowserHistory';
+type HistoryCtorMap = {
+    memory: (options?: MemoryHistoryOptions) => MemoryHistory;
+    browser: (options?: Omit<BrowserHistoryOptions, 'stack'>) => BrowserHistory;
+    hash: (options?: Omit<BrowserHistoryOptions, 'stack'>) => BrowserHistory;
+};
+/**
+ * Creates a history instance based on the specified type.
+ *
+ * Factory function for creating different history implementations:
+ * - `'browser'`: Creates a {@link BrowserHistory} instance using regular routing (pathname-based)
+ * - `'hash'`: Creates a {@link BrowserHistory} instance using hash routing (hash-based)
+ * - `'memory'`: Creates a {@link MemoryHistory} instance for testing or SSR (in-memory)
+ *
+ * All returned instances are compatible with industry-standard routers (Remix/React Router).
+ *
+ * @param type - The type of history to create ('browser', 'hash', or 'memory')
+ * @param args - Optional arguments for the history type
+ * @returns A History instance compatible with industry-standard routers (Remix/React Router)
+ *
+ * @example
+ * ```ts
+ * // Regular browser routing
+ * const history = createHistory('browser');
+ *
+ * // Hash-based routing
+ * const hashHistory = createHistory('hash');
+ *
+ * // In-memory history for testing
+ * const memoryHistory = createHistory('memory', { initialLocation: { ... } });
+ * ```
+ */
+export declare const createHistory: <T extends keyof HistoryCtorMap>(type: T, ...args: Parameters<HistoryCtorMap[T]>) => ReturnType<HistoryCtorMap[T]>;
+export {};

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

@@ -1 +1,7 @@
-export * from './provider';
+export { BaseHistory } from './BaseHistory';
+export { BrowserHistory } from './BrowserHistory';
+export { MemoryHistory } from './MemoryHistory';
+export { BrowserHistoryStack } from './BrowserHistoryStack';
+export { BrowserHistoryHashStack as HashHistoryStack } from './BrowserHistoryHashStack';
+export { MemoryHistoryStack } from './MemoryStack';
+export type { Action, History, HistoryStack, Location, NavigateOptions, NavigationListener, NavigationUpdate, Path, To, } from './types';

package/dist/types/lib/state/history.actions.d.ts

@@ -0,0 +1,61 @@
+import type { ActionTypes } from '@equinor/fusion-observable/actions';
+import type { To, NavigateOptions, NavigationBlocker, NavigationUpdate } from '../types';
+/**
+ * Navigation actions for history state management.
+ */
+export declare const actions: {
+    navigate: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[to: To, options: NavigateOptions], {
+        to: To;
+        options: NavigateOptions;
+    }, "navigation/navigate::request", never, {
+        key: string;
+    }> & {
+        success: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[update: NavigationUpdate], {
+            update: NavigationUpdate;
+        }, "navigation/navigate::success", never, never>;
+        failure: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[error: Error], {
+            error: Error;
+        }, "navigation/navigate::failure", never, never>;
+    };
+    abortNavigate: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[reason?: string | undefined], {
+        reason: string | undefined;
+    }, "navigation/navigate::abort", never, never>;
+    go: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[delta: number], {
+        delta: number;
+    }, "navigation/go::request", never, never> & {
+        success: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[update: NavigationUpdate], {
+            update: NavigationUpdate;
+        }, "navigation/go::success", never, never>;
+        failure: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[error: Error], {
+            error: Error;
+        }, "navigation/go::failure", never, never>;
+    };
+    pop: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[update?: NavigationUpdate | undefined], {
+        update: NavigationUpdate | undefined;
+    }, "navigation/pop::request", never, never> & {
+        success: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[update: NavigationUpdate], {
+            update: NavigationUpdate;
+        }, "navigation/pop::success", never, never>;
+        failure: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[error: Error], {
+            error: Error;
+        }, "navigation/pop::failure", never, never>;
+    };
+    validateLocation: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[], {}, "navigation/navigationValidation::request", never, never> & {
+        success: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[update: NavigationUpdate], {
+            update: NavigationUpdate;
+        }, "navigation/navigationValidation::success", never, never>;
+        failure: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[error: Error], {
+            error: Error;
+        }, "navigation/navigationValidation::failure", never, never>;
+    };
+    addBlocker: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[blocker: NavigationBlocker], {
+        blocker: NavigationBlocker;
+    }, "navigation/addBlocker", never, never>;
+    removeBlocker: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[blocker: NavigationBlocker], {
+        blocker: NavigationBlocker;
+    }, "navigation/removeBlocker", never, never>;
+};
+/**
+ * Union type of all navigation actions.
+ */
+export type Actions = ActionTypes<typeof actions>;

package/dist/types/lib/state/history.flows.d.ts

@@ -0,0 +1,102 @@
+import type { Flow } from '@equinor/fusion-observable';
+import { type Actions } from './history.actions';
+import { type LocationState, type HistoryStack } from '../types';
+/**
+ * History flow for processing navigation actions.
+ */
+export type HistoryFlow = Flow<Actions, LocationState>;
+/**
+ * Factory function that creates a history flow from a stack.
+ */
+export type HistoryFlowCreator = (stack: HistoryStack) => HistoryFlow;
+/**
+ * Flow creator for handling navigate actions.
+ *
+ * Execution flow:
+ * 1. Filters for navigate actions
+ * 2. Resolves the target path from the action payload
+ * 3. Creates a location object with the resolved path, key (from action meta), and optional state
+ * 4. Checks if the new location is the same as current to prevent navigation loops
+ * 5. Updates the stack based on replace option (replace updates current, otherwise pushes new entry)
+ * 6. Returns success action with the new location and appropriate action type (PUSH/REPLACE)
+ */
+export declare const navigate: HistoryFlowCreator;
+/**
+ * Flow creator for handling go (back/forward) actions.
+ *
+ * Execution flow:
+ * 1. Filters for go actions
+ * 2. Combines with current state to get history entries
+ * 3. Moves the stack index by the specified delta (negative for back, positive for forward)
+ * 4. Returns success action with POP action type and the new current location
+ */
+export declare const go: HistoryFlowCreator;
+/**
+ * Flow creator for handling pop (browser back/forward) actions.
+ *
+ * Execution flow:
+ * 1. Filters for pop actions
+ * 2. Uses the location from the action payload or falls back to stack.current
+ * 3. Emits a success action with POP action type and the current location
+ * 4. Completes the observable immediately (synchronous operation)
+ */
+export declare const pop: HistoryFlowCreator;
+/**
+ * Flow creator for checking navigation blockers before processing actions.
+ *
+ * Execution flow:
+ * 1. Filters for navigation actions (navigate, go, pop, validateLocation)
+ * 2. Determines the action type (PUSH/REPLACE for navigate, POP for others)
+ * 3. Combines with current state to check for active blockers
+ * 4. If no blockers exist, passes the action through immediately
+ * 5. If blockers exist:
+ *    - Creates a transition object with action, location, and retry callback
+ *    - Calls each blocker asynchronously (wrapped in Promise to prevent blocking)
+ *    - Blockers can call retry() to allow navigation or prevent it by not calling retry()
+ *    - Waits for all blockers to complete before continuing
+ * 6. Returns the original action if navigation is allowed, or completes without emitting if blocked
+ */
+export declare const checkBlockers: HistoryFlowCreator;
+/**
+ * Flow creator for validating the current location against history state.
+ *
+ * Execution flow:
+ * 1. Filters for validateLocation actions
+ * 2. Combines with current state to access history entries
+ * 3. Gets the current location from the stack
+ * 4. Searches history for an entry matching the current location's key
+ * 5. Validates that:
+ *    - The location key exists in history (returns failure if not found)
+ *    - The location state matches the history entry state (returns failure if mismatch)
+ * 6. Returns success action with current location if validation passes, failure otherwise
+ */
+export declare const validateCurrentLocation: HistoryFlowCreator;
+/**
+ * Creates a combined history flow from multiple flow creators.
+ *
+ * Execution flow:
+ * 1. Creates a preprocessing step that applies blocker checking (unless skipped)
+ * 2. Initializes each flow creator with the stack to create individual flows
+ * 3. Merges all flows so they process actions in parallel
+ * 4. Returns a combined flow that:
+ *    - First applies preprocessing (blocker checking)
+ *    - Then processes actions through all merged flows
+ *    - Emits results from any flow that matches the action
+ *
+ * @param flowCreators - Array of flow creators to combine
+ * @param options - Optional configuration options
+ * @param options.skipBlockCheck - If true, skip blocker checking
+ * @returns A combined history flow creator
+ */
+export declare const createFlow: (flowCreators: HistoryFlowCreator[], options?: {
+    skipBlockCheck?: boolean;
+}) => HistoryFlowCreator;
+/**
+ * Collection of flow creators for history state management.
+ */
+export declare const flowCreators: {
+    navigate: HistoryFlowCreator;
+    go: HistoryFlowCreator;
+    pop: HistoryFlowCreator;
+    validateCurrentLocation: HistoryFlowCreator;
+};

package/dist/types/lib/state/history.reducer.d.ts

@@ -0,0 +1,85 @@
+import type { LocationState, NavigationUpdate } from '../types';
+/**
+ * Creates a reducer for history state management.
+ *
+ * @param initial - Initial navigation update or function that returns initial state
+ * @param options - Optional configuration options
+ * @param options.maxHistory - Maximum number of history entries to keep (default: 100)
+ * @returns A reducer for history state
+ */
+export declare const createHistoryReducer: (initial: NavigationUpdate | (() => LocationState), options?: {
+    maxHistory?: number;
+}) => import("@equinor/fusion-observable").ReducerWithInitialState<LocationState, import("@equinor/fusion-observable").PayloadAction<{
+    to: import("..").To;
+    options: import("..").NavigateOptions;
+}, "navigation/navigate::request", {
+    key: string;
+}, never> | {
+    payload: {
+        reason: string | undefined;
+    };
+    type: "navigation/navigate::abort";
+} | {
+    payload: {
+        delta: number;
+    };
+    type: "navigation/go::request";
+} | {
+    payload: {
+        update: NavigationUpdate | undefined;
+    };
+    type: "navigation/pop::request";
+} | {
+    payload: {};
+    type: "navigation/navigationValidation::request";
+} | {
+    payload: {
+        blocker: import("../types").NavigationBlocker;
+    };
+    type: "navigation/addBlocker";
+} | {
+    payload: {
+        blocker: import("../types").NavigationBlocker;
+    };
+    type: "navigation/removeBlocker";
+} | {
+    payload: {
+        update: NavigationUpdate;
+    };
+    type: "navigation/navigate::success";
+} | {
+    payload: {
+        error: Error;
+    };
+    type: "navigation/navigate::failure";
+} | {
+    payload: {
+        update: NavigationUpdate;
+    };
+    type: "navigation/go::success";
+} | {
+    payload: {
+        error: Error;
+    };
+    type: "navigation/go::failure";
+} | {
+    payload: {
+        update: NavigationUpdate;
+    };
+    type: "navigation/pop::success";
+} | {
+    payload: {
+        error: Error;
+    };
+    type: "navigation/pop::failure";
+} | {
+    payload: {
+        update: NavigationUpdate;
+    };
+    type: "navigation/navigationValidation::success";
+} | {
+    payload: {
+        error: Error;
+    };
+    type: "navigation/navigationValidation::failure";
+}>;

package/dist/types/lib/state/history.state.d.ts

@@ -0,0 +1,27 @@
+import { type FlowState, type ReducerWithInitialState } from '@equinor/fusion-observable';
+import { actions, type Actions } from './history.actions';
+import { type HistoryFlowCreator } from './history.flows';
+import type { HistoryStack, LocationState } from '../types';
+/**
+ * History state containing flow state and stack.
+ */
+export type HistoryState = FlowState<LocationState, typeof actions> & {
+    stack: HistoryStack;
+};
+/**
+ * Default flows for history state management.
+ */
+export declare const defaultFlows: HistoryFlowCreator[];
+/**
+ * Creates a history store with the specified stack and reducer.
+ *
+ * @param stack - The history stack implementation
+ * @param reducer - The reducer for history state
+ * @param options - Optional configuration options
+ * @returns A HistoryState instance
+ */
+export declare const createStore: (stack: HistoryStack, reducer: ReducerWithInitialState<LocationState, Actions>, options?: {
+    flows?: HistoryFlowCreator[];
+    skipBlockCheck?: boolean;
+    validateCurrentLocation?: boolean;
+}) => HistoryState;

package/dist/types/lib/state/index.d.ts

@@ -0,0 +1,3 @@
+export { createStore, type HistoryState } from './history.state';
+export { createHistoryReducer } from './history.reducer';
+export { actions, type Actions } from './history.actions';

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

@@ -0,0 +1,145 @@
+import type { Observable } from 'rxjs';
+import type { Actions } from './state/history.actions';
+/**
+ * Actions represent the type of change to a location value.
+ */
+export declare enum Action {
+    /**
+     * A POP indicates a change to an arbitrary index in the history stack, such
+     * as a back or forward navigation. It does not describe the direction of the
+     * navigation, only that the current index changed.
+     *
+     * Note: This is the default action for newly created history objects.
+     */
+    Pop = "POP",
+    /**
+     * A PUSH indicates a new entry being added to the history stack, such as when
+     * a link is clicked and a new page loads.
+     */
+    Push = "PUSH",
+    /**
+     * A REPLACE indicates the entry at the current index in the history stack
+     * being replaced by a new one.
+     */
+    Replace = "REPLACE"
+}
+/**
+ * Target path for navigation operations.
+ * Can be a string path or a Path object.
+ */
+export type To = string | Partial<Path>;
+/**
+ * Path object containing pathname, optional search, and optional hash.
+ */
+export type Path = {
+    pathname: string;
+    search: string;
+    hash: string;
+};
+/**
+ * Location object representing a navigation entry.
+ * Extends Path with state and a unique key.
+ */
+export type Location<T = any> = Path & {
+    state: T;
+    key: string;
+};
+/**
+ * Internal state for history management.
+ */
+export type LocationState = {
+    current: NavigationUpdate;
+    history: NavigationUpdate[];
+    blockers: NavigationBlocker[];
+};
+/**
+ * Callback function for listening to navigation changes.
+ */
+export type NavigationListener = (update: Readonly<NavigationUpdate>) => void;
+/**
+ * Navigation update event containing action and location.
+ */
+export type NavigationUpdate<A extends string = Action, T = unknown> = {
+    delta: number;
+    action: Readonly<A>;
+    location: Readonly<Location<T>>;
+};
+/**
+ * Navigation transition that was blocked.
+ * Provides a retry method to allow the navigation to proceed.
+ */
+export interface NavigationTransition extends NavigationUpdate {
+    /**
+     * Retries the navigation that was blocked.
+     */
+    retry(): void;
+}
+/**
+ * Callback function for blocking navigation attempts.
+ */
+export type NavigationBlocker = (transition: NavigationTransition) => void;
+/**
+ * Options for controlling navigation behavior.
+ *
+ * @interface NavigateOptions
+ *
+ * @property {boolean} [replace] - Determines the navigation action:
+ * - `false` (default): Pushes a new entry onto the history stack
+ * - `true`: Replaces the current entry in the history stack
+ *
+ * @property {unknown} [state] - Optional state object to associate with the navigation entry.
+ * This state can be accessed later when navigating back to this entry.
+ */
+export interface NavigateOptions {
+    replace?: boolean;
+    state?: unknown;
+}
+/**
+ * History interface for managing navigation state.
+ * Compatible with industry-standard routers (Remix/React Router) and provides observable state management.
+ */
+export interface History extends Disposable {
+    /** Observable stream of navigation state updates. */
+    readonly state$: Observable<NavigationUpdate>;
+    /** Observable stream of navigation actions. */
+    readonly action$: Observable<Actions>;
+    /** Current navigation action. */
+    readonly action: Action;
+    /** Current location in the history stack. */
+    readonly location: Location;
+    /** 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;
+    /** Pushes a new navigation entry onto the history stack. */
+    push(to: To, state?: unknown): void;
+    /** Replaces the current history entry with a new one. */
+    replace(to: To, state?: unknown): void;
+    /** Navigate to a location with explicit options. */
+    navigate(to: To, options?: NavigateOptions): void;
+    /** Navigates backward or forward in the history stack. */
+    go(delta: number): void;
+    /** Sets up a listener for navigation changes. */
+    listen(listener: NavigationListener): () => void;
+    /** Registers a blocker to intercept navigation attempts. */
+    block(blocker: NavigationBlocker): VoidFunction;
+}
+/**
+ * History stack interface for managing navigation entries.
+ */
+export interface HistoryStack {
+    /** Origin URL for the history stack. */
+    readonly origin: string;
+    /** Current location in the stack. */
+    readonly 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 backward or forward in the history stack. */
+    go(delta: number, state: Readonly<LocationState>): void;
+    /** Creates a URL object for a given path. */
+    createURL(to: To): URL;
+}

package/dist/types/lib/utils/encode-trailing-whitespace.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Encodes trailing whitespace in a string by replacing it with '%20'.
+ *
+ * @param input - The string to encode
+ * @returns The string with trailing whitespace encoded
+ *
+ * @example
+ * ```ts
+ * encodeTrailingWhitespace('hello ')
+ * // 'hello%20'
+ *
+ * encodeTrailingWhitespace('hello')
+ * // 'hello'
+ * ```
+ */
+export declare const encodeTrailingWhitespace: (input: string) => string;

package/dist/types/lib/utils/has-protocol.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Checks if a string has a protocol prefix.
+ *
+ * @param input - The string to check
+ * @returns True if the string starts with a protocol (e.g., 'http:', 'https:', 'file:')
+ *
+ * @example
+ * ```ts
+ * hasProtocol('https://example.com')
+ * // true
+ *
+ * hasProtocol('/users')
+ * // false
+ *
+ * hasProtocol('file:///path/to/file')
+ * // true
+ * ```
+ */
+export declare const hasProtocol: (input: string) => boolean;

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

@@ -0,0 +1,5 @@
+export { pathToString } from './path-to-string';
+export { pathToUrl } from './path-to-url';
+export { resolvePath } from './resolve-path';
+export { resolveWindowLocation } from './resolve-browser-location';
+export { resolveHashLocation } from './resolve-browser-location';

package/dist/types/lib/utils/path-to-string.d.ts

@@ -0,0 +1,17 @@
+import type { Path } from '../types';
+/**
+ * Converts a Partial<Path> object to a path string.
+ *
+ * @param to - The path object with optional pathname, search, and hash
+ * @returns A path string with properly formatted search and hash
+ *
+ * @example
+ * ```ts
+ * pathToString({ pathname: '/users', search: '?id=1', hash: '#section' })
+ * // '/users?id=1#section'
+ *
+ * pathToString({ pathname: '/users', search: 'id=1', hash: 'section' })
+ * // '/users?id=1#section'
+ * ```
+ */
+export declare const pathToString: (to: Partial<Path>) => string;

package/dist/types/lib/utils/path-to-url.d.ts

@@ -0,0 +1,32 @@
+import type { To } from '../types';
+/**
+ * Converts a path to a URL object.
+ *
+ * This utility handles various path formats and converts them to standard URL objects.
+ * It supports absolute URLs, relative paths, and path objects with pathname/search/hash.
+ *
+ * @param path - The target path (string, Path object, or Location object)
+ * @param origin - Optional origin URL. Defaults to `window.location.origin` in browser environments,
+ *                 or 'http://localhost' in Node.js environments
+ * @returns A URL object for the given path
+ *
+ * @example
+ * ```ts
+ * // Absolute URL with custom origin
+ * pathToUrl('/users?id=1', 'https://example.com')
+ * // URL { href: 'https://example.com/users?id=1', ... }
+ *
+ * // Complete URL with protocol
+ * pathToUrl('https://example.com/users')
+ * // URL { href: 'https://example.com/users', ... }
+ *
+ * // Path object
+ * pathToUrl({ pathname: '/users', search: '?id=1' })
+ * // URL { href: 'http://localhost/users?id=1', ... }
+ *
+ * // Browser environment (uses window.location.origin)
+ * pathToUrl('/dashboard')
+ * // URL { href: 'https://current-site.com/dashboard', ... }
+ * ```
+ */
+export declare const pathToUrl: (path: To, origin?: string) => URL;

package/dist/types/lib/utils/resolve-browser-location.d.ts

@@ -0,0 +1,42 @@
+import type { Location } from '../types';
+/**
+ * Resolves the current location from window.location.
+ *
+ * @param window - The window object to extract location from
+ * @param target - Optional target object with state
+ * @returns The current location with pathname, search, hash, state, and key
+ *
+ * @example
+ * ```ts
+ * // If window.location is 'https://example.com/users?id=1#section'
+ * resolveWindowLocation(window)
+ * // { pathname: '/users', search: '?id=1', hash: '#section', state: undefined, key: 'unknown' }
+ *
+ * resolveWindowLocation(window, { state: { userId: 123 } })
+ * // { pathname: '/users', search: '?id=1', hash: '#section', state: { userId: 123 }, key: 'abc123' }
+ * ```
+ */
+export declare const resolveWindowLocation: (window: Window, target?: {
+    state: unknown;
+}) => Location;
+/**
+ * Resolves the current location from window.location.hash.
+ *
+ * @param window - The window object to extract location from
+ * @param target - Optional target object with state
+ * @returns The current location with pathname, search, hash, state, and key
+ *
+ * @example
+ * ```ts
+ * // If window.location.hash is '#/users?id=1#section'
+ * resolveHashLocation(window)
+ * // { pathname: '/users', search: '?id=1', hash: '#section', state: undefined, key: 'unknown' }
+ *
+ * // If window.location.hash is '#/dashboard'
+ * resolveHashLocation(window)
+ * // { pathname: '/dashboard', search: '', hash: '', state: undefined, key: 'unknown' }
+ * ```
+ */
+export declare const resolveHashLocation: (window: Window, target?: {
+    state: unknown;
+}) => Location;