# All files / router/src types.ts

0% Statements 0/0
0% Branches 1/1
0% Functions 1/1
0% Lines 0/0

Press n or j to go to the next uncovered block, b, p or k for the previous block.

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118

     import { ReadonlySignal } from "@preact/signals";

    export type NavigationState = Record<string, unknown>;

    export interface QueryParams {
      [key: string]: string
    }

    /**
     * Interface for NavigationHistoryEntry based on the Navigation API
     */
    export interface NavigationHistoryEntry {
        url: string;
        key: string;
        id: string;
        index: number;
        sameDocument: boolean;
        // State storage for entries
        // eslint-disable-next-line @typescript-eslint/no-explicit-any
        state?: any;
        hash: string;
      }

    /**
       * Interface for NavigationResult based on the Navigation API
       */
    export interface NavigationResult {
        committed: Promise<NavigationHistoryEntry>;
        finished: Promise<NavigationHistoryEntry>;
      }

    /**
       * Simplified NavigateEvent interface based on the Navigation API
       */
    export interface NavigateEvent extends Event {
        destination: NavigationHistoryEntry;
        canIntercept: boolean;
        intercept: (options?: { handler?: () => Promise<void> | void }) => void;
        scroll: () => void;
      }

    /**
       * NavigationOptions interface based on the Navigation API
       */
    export interface NavigationOptions {
        state?: unknown;
        info?: unknown;
    }

    export interface HashNavigation {
      // Public signals
      currentEntry: ReadonlySignal<NavigationHistoryEntry>;
      entries: ReadonlySignal<NavigationHistoryEntry[]>;
      canGoBack: ReadonlySignal<boolean>;
      canGoForward: ReadonlySignal<boolean>;

      // Navigation methods
      navigate: (hash: string, options?: NavigationOptions) => NavigationResult;
      traverseTo: (key: string, options?: NavigationOptions) => NavigationResult | null;
      back: (options?: NavigationOptions) => NavigationResult | null;
      forward: (options?: NavigationOptions) => NavigationResult | null;
      reload: (options?: NavigationOptions) => NavigationResult;
      updateCurrentEntry: (options?: NavigationOptions, hash?: string) => void;

      // Subscription method
      subscribe: (
        callback: (
          entry: NavigationHistoryEntry,
          prevEntry: NavigationHistoryEntry | null,
          hash: string
        ) => void
      ) => VoidFunction;

      // Init
      create: () => void;
      // Cleanup
      destroy: () => void;

      updateCurrentEntryHash: (hash: string) => void;
    }

    /**
     * router interfaces
     */
    export interface InitializeRouterConfig {
      homeUrl: string;
      routeNames: string[];
    }

    export interface SubscribeChangeConfig {
      onChange: (loc: NavigationHistoryEntry) => void;
      config: InitializeRouterConfig;
    }

    export interface RouterHistoryEntry extends NavigationHistoryEntry {
      pattern?: string;
      getParams: <T extends Record<string, string> = Record<string, string>>() => T;
      getQuery : <T extends QueryParams>() => T,
    }

    export interface HashRouter extends Pick<HashNavigation, 'entries' | 'canGoBack' | 'canGoForward'> {
      _navigation: HashNavigation;
      currentEntry: ReadonlySignal<RouterHistoryEntry>;
      state: ReadonlySignal<NavigationState>;
      hash: ReadonlySignal<string>;
      create: (config: SubscribeChangeConfig) => VoidFunction;
      subscribe: (callback: (update: NavigationHistoryEntry, prevLocation?: NavigationHistoryEntry | null) => void) => VoidFunction;
      navigate: (hash: string, state?: Record<string, unknown>) => NavigationResult;
      replaceState : (config?: {state?: Record<string, unknown>; hash?: string;}) => void;
      goBack: VoidFunction;
      goToPrev: VoidFunction;
      getHash: () => string;
      getState: () => NavigationState | undefined;
      hasPage: (hash?: string) => boolean;
      destroy: VoidFunction;
      getConfig: () => InitializeRouterConfig | null;
    }