import { e as RouteObject, f as History, g as MaybePromise, c as RouterContextProvider, h as MapRoutePropertiesFunction, i as Action, L as Location, D as DataRouteMatch, j as Submission, k as RouteData, l as DataStrategyFunction, m as PatchRoutesOnNavigationFunction, n as DataRouteObject, U as UIMatch, T as To, o as HTMLFormMethod, F as FormEncType, p as Path, q as LoaderFunctionArgs, r as MiddlewareEnabled, s as AppLoadContext } from './routeModules-CA7kSxJJ.js'; /** * A Router instance manages all navigation and data loading/mutations */ interface Router { /** * @private * PRIVATE - DO NOT USE * * Return the basename for the router */ get basename(): RouterInit["basename"]; /** * @private * PRIVATE - DO NOT USE * * Return the future config for the router */ get future(): FutureConfig; /** * @private * PRIVATE - DO NOT USE * * Return the current state of the router */ get state(): RouterState; /** * @private * PRIVATE - DO NOT USE * * Return the routes for this router instance */ get routes(): DataRouteObject[]; /** * @private * PRIVATE - DO NOT USE * * Return the window associated with the router */ get window(): RouterInit["window"]; /** * @private * PRIVATE - DO NOT USE * * Initialize the router, including adding history listeners and kicking off * initial data fetches. Returns a function to cleanup listeners and abort * any in-progress loads */ initialize(): Router; /** * @private * PRIVATE - DO NOT USE * * Subscribe to router.state updates * * @param fn function to call with the new state */ subscribe(fn: RouterSubscriber): () => void; /** * @private * PRIVATE - DO NOT USE * * Enable scroll restoration behavior in the router * * @param savedScrollPositions Object that will manage positions, in case * it's being restored from sessionStorage * @param getScrollPosition Function to get the active Y scroll position * @param getKey Function to get the key to use for restoration */ enableScrollRestoration(savedScrollPositions: Record<string, number>, getScrollPosition: GetScrollPositionFunction, getKey?: GetScrollRestorationKeyFunction): () => void; /** * @private * PRIVATE - DO NOT USE * * Navigate forward/backward in the history stack * @param to Delta to move in the history stack */ navigate(to: number): Promise<void>; /** * Navigate to the given path * @param to Path to navigate to * @param opts Navigation options (method, submission, etc.) */ navigate(to: To | null, opts?: RouterNavigateOptions): Promise<void>; /** * @private * PRIVATE - DO NOT USE * * Trigger a fetcher load/submission * * @param key Fetcher key * @param routeId Route that owns the fetcher * @param href href to fetch * @param opts Fetcher options, (method, submission, etc.) */ fetch(key: string, routeId: string, href: string | null, opts?: RouterFetchOptions): Promise<void>; /** * @private * PRIVATE - DO NOT USE * * Trigger a revalidation of all current route loaders and fetcher loads */ revalidate(): Promise<void>; /** * @private * PRIVATE - DO NOT USE * * Utility function to create an href for the given location * @param location */ createHref(location: Location | URL): string; /** * @private * PRIVATE - DO NOT USE * * Utility function to URL encode a destination path according to the internal * history implementation * @param to */ encodeLocation(to: To): Path; /** * @private * PRIVATE - DO NOT USE * * Get/create a fetcher for the given key * @param key */ getFetcher<TData = any>(key: string): Fetcher<TData>; /** * @internal * PRIVATE - DO NOT USE * * Reset the fetcher for a given key * @param key */ resetFetcher(key: string, opts?: { reason?: unknown; }): void; /** * @private * PRIVATE - DO NOT USE * * Delete the fetcher for a given key * @param key */ deleteFetcher(key: string): void; /** * @private * PRIVATE - DO NOT USE * * Cleanup listeners and abort any in-progress loads */ dispose(): void; /** * @private * PRIVATE - DO NOT USE * * Get a navigation blocker * @param key The identifier for the blocker * @param fn The blocker function implementation */ getBlocker(key: string, fn: BlockerFunction): Blocker; /** * @private * PRIVATE - DO NOT USE * * Delete a navigation blocker * @param key The identifier for the blocker */ deleteBlocker(key: string): void; /** * @private * PRIVATE DO NOT USE * * Patch additional children routes into an existing parent route * @param routeId The parent route id or a callback function accepting `patch` * to perform batch patching * @param children The additional children routes * @param unstable_allowElementMutations Allow mutation or route elements on * existing routes. Intended for RSC-usage * only. */ patchRoutes(routeId: string | null, children: RouteObject[], unstable_allowElementMutations?: boolean): void; /** * @private * PRIVATE - DO NOT USE * * HMR needs to pass in-flight route updates to React Router * TODO: Replace this with granular route update APIs (addRoute, updateRoute, deleteRoute) */ _internalSetRoutes(routes: RouteObject[]): void; /** * @private * PRIVATE - DO NOT USE * * Cause subscribers to re-render. This is used to force a re-render. */ _internalSetStateDoNotUseOrYouWillBreakYourApp(state: Partial<RouterState>): void; /** * @private * PRIVATE - DO NOT USE * * Internal fetch AbortControllers accessed by unit tests */ _internalFetchControllers: Map<string, AbortController>; } /** * State maintained internally by the router. During a navigation, all states * reflect the "old" location unless otherwise noted. */ interface RouterState { /** * The action of the most recent navigation */ historyAction: Action; /** * The current location reflected by the router */ location: Location; /** * The current set of route matches */ matches: DataRouteMatch[]; /** * Tracks whether we've completed our initial data load */ initialized: boolean; /** * Tracks whether we should be rendering a HydrateFallback during hydration */ renderFallback: boolean; /** * Current scroll position we should start at for a new view * - number -> scroll position to restore to * - false -> do not restore scroll at all (used during submissions/revalidations) * - null -> don't have a saved position, scroll to hash or top of page */ restoreScrollPosition: number | false | null; /** * Indicate whether this navigation should skip resetting the scroll position * if we are unable to restore the scroll position */ preventScrollReset: boolean; /** * Tracks the state of the current navigation */ navigation: Navigation; /** * Tracks any in-progress revalidations */ revalidation: RevalidationState; /** * Data from the loaders for the current matches */ loaderData: RouteData; /** * Data from the action for the current matches */ actionData: RouteData | null; /** * Errors caught from loaders for the current matches */ errors: RouteData | null; /** * Map of current fetchers */ fetchers: Map<string, Fetcher>; /** * Map of current blockers */ blockers: Map<string, Blocker>; } /** * Data that can be passed into hydrate a Router from SSR */ type HydrationState = Partial<Pick<RouterState, "loaderData" | "actionData" | "errors">>; /** * Future flags to toggle new feature behavior */ interface FutureConfig { unstable_passThroughRequests: boolean; } /** * Initialization options for createRouter */ interface RouterInit { routes: RouteObject[]; history: History; basename?: string; getContext?: () => MaybePromise<RouterContextProvider>; unstable_instrumentations?: unstable_ClientInstrumentation[]; mapRouteProperties?: MapRoutePropertiesFunction; future?: Partial<FutureConfig>; hydrationRouteProperties?: string[]; hydrationData?: HydrationState; window?: Window; dataStrategy?: DataStrategyFunction; patchRoutesOnNavigation?: PatchRoutesOnNavigationFunction; } /** * State returned from a server-side query() call */ interface StaticHandlerContext { basename: Router["basename"]; location: RouterState["location"]; matches: RouterState["matches"]; loaderData: RouterState["loaderData"]; actionData: RouterState["actionData"]; errors: RouterState["errors"]; statusCode: number; loaderHeaders: Record<string, Headers>; actionHeaders: Record<string, Headers>; _deepestRenderedBoundaryId?: string | null; } /** * A StaticHandler instance manages a singular SSR navigation/fetch event */ interface StaticHandler { dataRoutes: DataRouteObject[]; query(request: Request, opts?: { requestContext?: unknown; filterMatchesToLoad?: (match: DataRouteMatch) => boolean; skipLoaderErrorBubbling?: boolean; skipRevalidation?: boolean; dataStrategy?: DataStrategyFunction<unknown>; generateMiddlewareResponse?: (query: (r: Request, args?: { filterMatchesToLoad?: (match: DataRouteMatch) => boolean; }) => Promise<StaticHandlerContext | Response>) => MaybePromise<Response>; unstable_normalizePath?: (request: Request) => Path; }): Promise<StaticHandlerContext | Response>; queryRoute(request: Request, opts?: { routeId?: string; requestContext?: unknown; dataStrategy?: DataStrategyFunction<unknown>; generateMiddlewareResponse?: (queryRoute: (r: Request) => Promise<Response>) => MaybePromise<Response>; unstable_normalizePath?: (request: Request) => Path; }): Promise<any>; } type ViewTransitionOpts = { currentLocation: Location; nextLocation: Location; }; /** * Subscriber function signature for changes to router state */ interface RouterSubscriber { (state: RouterState, opts: { deletedFetchers: string[]; newErrors: RouteData | null; viewTransitionOpts?: ViewTransitionOpts; flushSync: boolean; }): void; } /** * Function signature for determining the key to be used in scroll restoration * for a given location */ interface GetScrollRestorationKeyFunction { (location: Location, matches: UIMatch[]): string | null; } /** * Function signature for determining the current scroll position */ interface GetScrollPositionFunction { (): number; } /** * - "route": relative to the route hierarchy so `..` means remove all segments * of the current route even if it has many. For example, a `route("posts/:id")` * would have both `:id` and `posts` removed from the url. * - "path": relative to the pathname so `..` means remove one segment of the * pathname. For example, a `route("posts/:id")` would have only `:id` removed * from the url. */ type RelativeRoutingType = "route" | "path"; type BaseNavigateOrFetchOptions = { preventScrollReset?: boolean; relative?: RelativeRoutingType; flushSync?: boolean; unstable_defaultShouldRevalidate?: boolean; }; type BaseNavigateOptions = BaseNavigateOrFetchOptions & { replace?: boolean; state?: any; fromRouteId?: string; viewTransition?: boolean; unstable_mask?: To; }; type BaseSubmissionOptions = { formMethod?: HTMLFormMethod; formEncType?: FormEncType; } & ({ formData: FormData; body?: undefined; } | { formData?: undefined; body: any; }); /** * Options for a navigate() call for a normal (non-submission) navigation */ type LinkNavigateOptions = BaseNavigateOptions; /** * Options for a navigate() call for a submission navigation */ type SubmissionNavigateOptions = BaseNavigateOptions & BaseSubmissionOptions; /** * Options to pass to navigate() for a navigation */ type RouterNavigateOptions = LinkNavigateOptions | SubmissionNavigateOptions; /** * Options for a fetch() load */ type LoadFetchOptions = BaseNavigateOrFetchOptions; /** * Options for a fetch() submission */ type SubmitFetchOptions = BaseNavigateOrFetchOptions & BaseSubmissionOptions; /** * Options to pass to fetch() */ type RouterFetchOptions = LoadFetchOptions | SubmitFetchOptions; /** * Potential states for state.navigation */ type NavigationStates = { Idle: { state: "idle"; location: undefined; formMethod: undefined; formAction: undefined; formEncType: undefined; formData: undefined; json: undefined; text: undefined; }; Loading: { state: "loading"; location: Location; formMethod: Submission["formMethod"] | undefined; formAction: Submission["formAction"] | undefined; formEncType: Submission["formEncType"] | undefined; formData: Submission["formData"] | undefined; json: Submission["json"] | undefined; text: Submission["text"] | undefined; }; Submitting: { state: "submitting"; location: Location; formMethod: Submission["formMethod"]; formAction: Submission["formAction"]; formEncType: Submission["formEncType"]; formData: Submission["formData"]; json: Submission["json"]; text: Submission["text"]; }; }; type Navigation = NavigationStates[keyof NavigationStates]; type RevalidationState = "idle" | "loading"; /** * Potential states for fetchers */ type FetcherStates<TData = any> = { /** * The fetcher is not calling a loader or action * * ```tsx * fetcher.state === "idle" * ``` */ Idle: { state: "idle"; formMethod: undefined; formAction: undefined; formEncType: undefined; text: undefined; formData: undefined; json: undefined; /** * If the fetcher has never been called, this will be undefined. */ data: TData | undefined; }; /** * The fetcher is loading data from a {@link LoaderFunction | loader} from a * call to {@link FetcherWithComponents.load | `fetcher.load`}. * * ```tsx * // somewhere * <button onClick={() => fetcher.load("/some/route") }>Load</button> * * // the state will update * fetcher.state === "loading" * ``` */ Loading: { state: "loading"; formMethod: Submission["formMethod"] | undefined; formAction: Submission["formAction"] | undefined; formEncType: Submission["formEncType"] | undefined; text: Submission["text"] | undefined; formData: Submission["formData"] | undefined; json: Submission["json"] | undefined; data: TData | undefined; }; /** The fetcher is submitting to a {@link LoaderFunction} (GET) or {@link ActionFunction} (POST) from a {@link FetcherWithComponents.Form | `fetcher.Form`} or {@link FetcherWithComponents.submit | `fetcher.submit`}. ```tsx // somewhere <input onChange={e => { fetcher.submit(event.currentTarget.form, { method: "post" }); }} /> // the state will update fetcher.state === "submitting" // and formData will be available fetcher.formData ``` */ Submitting: { state: "submitting"; formMethod: Submission["formMethod"]; formAction: Submission["formAction"]; formEncType: Submission["formEncType"]; text: Submission["text"]; formData: Submission["formData"]; json: Submission["json"]; data: TData | undefined; }; }; type Fetcher<TData = any> = FetcherStates<TData>[keyof FetcherStates<TData>]; interface BlockerBlocked { state: "blocked"; reset: () => void; proceed: () => void; location: Location; } interface BlockerUnblocked { state: "unblocked"; reset: undefined; proceed: undefined; location: undefined; } interface BlockerProceeding { state: "proceeding"; reset: undefined; proceed: undefined; location: Location; } type Blocker = BlockerUnblocked | BlockerBlocked | BlockerProceeding; type BlockerFunction = (args: { currentLocation: Location; nextLocation: Location; historyAction: Action; }) => boolean; declare const IDLE_NAVIGATION: NavigationStates["Idle"]; declare const IDLE_FETCHER: FetcherStates["Idle"]; declare const IDLE_BLOCKER: BlockerUnblocked; /** * Create a router and listen to history POP navigations */ declare function createRouter(init: RouterInit): Router; interface CreateStaticHandlerOptions { basename?: string; mapRouteProperties?: MapRoutePropertiesFunction; unstable_instrumentations?: Pick<unstable_ServerInstrumentation, "route">[]; future?: Partial<FutureConfig>; } type unstable_ServerInstrumentation = { handler?: unstable_InstrumentRequestHandlerFunction; route?: unstable_InstrumentRouteFunction; }; type unstable_ClientInstrumentation = { router?: unstable_InstrumentRouterFunction; route?: unstable_InstrumentRouteFunction; }; type unstable_InstrumentRequestHandlerFunction = (handler: InstrumentableRequestHandler) => void; type unstable_InstrumentRouterFunction = (router: InstrumentableRouter) => void; type unstable_InstrumentRouteFunction = (route: InstrumentableRoute) => void; type unstable_InstrumentationHandlerResult = { status: "success"; error: undefined; } | { status: "error"; error: Error; }; type InstrumentFunction<T> = (handler: () => Promise<unstable_InstrumentationHandlerResult>, info: T) => Promise<void>; type ReadonlyRequest = { method: string; url: string; headers: Pick<Headers, "get">; }; type ReadonlyContext = MiddlewareEnabled extends true ? Pick<RouterContextProvider, "get"> : Readonly<AppLoadContext>; type InstrumentableRoute = { id: string; index: boolean | undefined; path: string | undefined; instrument(instrumentations: RouteInstrumentations): void; }; type RouteInstrumentations = { lazy?: InstrumentFunction<RouteLazyInstrumentationInfo>; "lazy.loader"?: InstrumentFunction<RouteLazyInstrumentationInfo>; "lazy.action"?: InstrumentFunction<RouteLazyInstrumentationInfo>; "lazy.middleware"?: InstrumentFunction<RouteLazyInstrumentationInfo>; middleware?: InstrumentFunction<RouteHandlerInstrumentationInfo>; loader?: InstrumentFunction<RouteHandlerInstrumentationInfo>; action?: InstrumentFunction<RouteHandlerInstrumentationInfo>; }; type RouteLazyInstrumentationInfo = undefined; type RouteHandlerInstrumentationInfo = Readonly<{ request: ReadonlyRequest; params: LoaderFunctionArgs["params"]; unstable_pattern: string; context: ReadonlyContext; }>; type InstrumentableRouter = { instrument(instrumentations: RouterInstrumentations): void; }; type RouterInstrumentations = { navigate?: InstrumentFunction<RouterNavigationInstrumentationInfo>; fetch?: InstrumentFunction<RouterFetchInstrumentationInfo>; }; type RouterNavigationInstrumentationInfo = Readonly<{ to: string | number; currentUrl: string; formMethod?: HTMLFormMethod; formEncType?: FormEncType; formData?: FormData; body?: any; }>; type RouterFetchInstrumentationInfo = Readonly<{ href: string; currentUrl: string; fetcherKey: string; formMethod?: HTMLFormMethod; formEncType?: FormEncType; formData?: FormData; body?: any; }>; type InstrumentableRequestHandler = { instrument(instrumentations: RequestHandlerInstrumentations): void; }; type RequestHandlerInstrumentations = { request?: InstrumentFunction<RequestHandlerInstrumentationInfo>; }; type RequestHandlerInstrumentationInfo = Readonly<{ request: ReadonlyRequest; context: ReadonlyContext | undefined; }>; export { type BlockerFunction as B, type CreateStaticHandlerOptions as C, type Fetcher as F, type GetScrollPositionFunction as G, type HydrationState as H, IDLE_NAVIGATION as I, type Navigation as N, type RouterInit as R, type StaticHandler as S, type Router as a, type Blocker as b, type RelativeRoutingType as c, type RouterState as d, type GetScrollRestorationKeyFunction as e, type StaticHandlerContext as f, type NavigationStates as g, type RouterSubscriber as h, type RouterNavigateOptions as i, type RouterFetchOptions as j, type RevalidationState as k, type unstable_ServerInstrumentation as l, type unstable_InstrumentRequestHandlerFunction as m, type unstable_InstrumentRouterFunction as n, type unstable_InstrumentRouteFunction as o, type unstable_InstrumentationHandlerResult as p, IDLE_FETCHER as q, IDLE_BLOCKER as r, createRouter as s, type FutureConfig as t, type unstable_ClientInstrumentation as u };