react-router-dom
Advanced tools
Comparing version 0.0.0-experimental-4a8a492a to 0.0.0-experimental-4ed3f5da9
@@ -1,278 +0,6 @@ | ||
| /** | ||
| * NOTE: If you refactor this to split up the modules into separate files, | ||
| * you'll need to update the rollup config for react-router-dom-v5-compat. | ||
| */ | ||
| import * as React from "react"; | ||
| import type { FutureConfig, NavigateOptions, RelativeRoutingType, RouteObject, To } from "react-router"; | ||
| import type { Fetcher, FormEncType, FormMethod, FutureConfig as RouterFutureConfig, GetScrollRestorationKeyFunction, History, HTMLFormMethod, HydrationState, Router as RemixRouter, V7_FormMethod } from "@remix-run/router"; | ||
| import type { SubmitOptions, ParamKeyValuePair, URLSearchParamsInit, SubmitTarget } from "./dom"; | ||
| import { createSearchParams } from "./dom"; | ||
| export type { FormEncType, FormMethod, GetScrollRestorationKeyFunction, ParamKeyValuePair, SubmitOptions, URLSearchParamsInit, V7_FormMethod, }; | ||
| export { createSearchParams }; | ||
| export type { ActionFunction, ActionFunctionArgs, AwaitProps, unstable_Blocker, unstable_BlockerFunction, DataRouteMatch, DataRouteObject, ErrorResponse, Fetcher, Hash, IndexRouteObject, IndexRouteProps, JsonFunction, LazyRouteFunction, LayoutRouteProps, LoaderFunction, LoaderFunctionArgs, Location, MemoryRouterProps, NavigateFunction, NavigateOptions, NavigateProps, Navigation, Navigator, NonIndexRouteObject, OutletProps, Params, ParamParseKey, Path, PathMatch, Pathname, PathPattern, PathRouteProps, RedirectFunction, RelativeRoutingType, RouteMatch, RouteObject, RouteProps, RouterProps, RouterProviderProps, RoutesProps, Search, ShouldRevalidateFunction, ShouldRevalidateFunctionArgs, To, UIMatch, } from "react-router"; | ||
| export { AbortedDeferredError, Await, MemoryRouter, Navigate, NavigationType, Outlet, Route, Router, RouterProvider, Routes, createMemoryRouter, createPath, createRoutesFromChildren, createRoutesFromElements, defer, isRouteErrorResponse, generatePath, json, matchPath, matchRoutes, parsePath, redirect, redirectDocument, renderMatches, resolvePath, useActionData, useAsyncError, useAsyncValue, unstable_useBlocker, useHref, useInRouterContext, useLoaderData, useLocation, useMatch, useMatches, useNavigate, useNavigation, useNavigationType, useOutlet, useOutletContext, useParams, useResolvedPath, useRevalidator, useRouteError, useRouteLoaderData, useRoutes, } from "react-router"; | ||
| export type { ActionFunction, ActionFunctionArgs, AwaitProps, DataRouteMatch, DataRouteObject, unstable_DataStrategyFunction, unstable_DataStrategyFunctionArgs, unstable_DataStrategyMatch, ErrorResponse, Fetcher, FutureConfig, Hash, IndexRouteObject, IndexRouteProps, JsonFunction, LayoutRouteProps, LazyRouteFunction, LoaderFunction, LoaderFunctionArgs, Location, MemoryRouterProps, NavigateFunction, NavigateOptions, NavigateProps, Navigation, Navigator, NonIndexRouteObject, OutletProps, ParamParseKey, Params, Path, PathMatch, PathParam, PathPattern, PathRouteProps, Pathname, RedirectFunction, RelativeRoutingType, RouteMatch, RouteObject, RouteProps, RouterProps, RouterProviderProps, RoutesProps, Search, ShouldRevalidateFunction, ShouldRevalidateFunctionArgs, To, UIMatch, Blocker, BlockerFunction, unstable_HandlerResult, AgnosticDataIndexRouteObject, AgnosticDataNonIndexRouteObject, AgnosticDataRouteMatch, AgnosticDataRouteObject, AgnosticIndexRouteObject, AgnosticNonIndexRouteObject, AgnosticRouteMatch, AgnosticRouteObject, HydrationState, InitialEntry, StaticHandler, TrackedPromise, UNSAFE_DeferredData, FormEncType, FormMethod, GetScrollRestorationKeyFunction, StaticHandlerContext, V7_FormMethod, BrowserRouterProps, HashRouterProps, HistoryRouterProps, LinkProps, NavLinkProps, FetcherFormProps, FormProps, ScrollRestorationProps, SetURLSearchParams, SubmitFunction, FetcherSubmitFunction, FetcherWithComponents, ParamKeyValuePair, SubmitOptions, URLSearchParamsInit, StaticRouterProps, StaticRouterProviderProps, HtmlLinkDescriptor, ClientActionFunction, ClientActionFunctionArgs, ClientLoaderFunction, ClientLoaderFunctionArgs, MetaArgs, MetaDescriptor, MetaFunction, RemixServerProps, RemixStubProps, } from "react-router"; | ||
| export { AbortedDeferredError, Await, MemoryRouter, Navigate, NavigationType, Outlet, Route, Router, RouterProvider, Routes, createMemoryRouter, createPath, createRoutesFromChildren, createRoutesFromChildren as createRoutesFromElements, defer, generatePath, isRouteErrorResponse, json, matchPath, matchRoutes, parsePath, redirect, redirectDocument, renderMatches, resolvePath, useBlocker, useActionData, useAsyncError, useAsyncValue, useHref, useInRouterContext, useLoaderData, useLocation, useMatch, useMatches, useNavigate, useNavigation, useNavigationType, useOutlet, useOutletContext, useParams, useResolvedPath, useRevalidator, useRouteError, useRouteLoaderData, useRoutes, getStaticContextFromError, stripBasename, UNSAFE_DEFERRED_SYMBOL, UNSAFE_convertRoutesToDataRoutes, createBrowserRouter, createHashRouter, BrowserRouter, HashRouter, Link, UNSAFE_ViewTransitionContext, UNSAFE_FetchersContext, unstable_HistoryRouter, NavLink, Form, ScrollRestoration, useLinkClickHandler, useSearchParams, useSubmit, useFormAction, useFetcher, useFetchers, UNSAFE_useScrollRestoration, useBeforeUnload, unstable_usePrompt, unstable_useViewTransitionState, createSearchParams, createStaticHandler, createStaticRouter, StaticRouter, StaticRouterProvider, HydratedRouter, Meta, Links, Scripts, PrefetchPageLinks, RemixServer, createRemixStub, } from "react-router"; | ||
| /** @internal */ | ||
| export { UNSAFE_DataRouterContext, UNSAFE_DataRouterStateContext, UNSAFE_NavigationContext, UNSAFE_LocationContext, UNSAFE_RouteContext, UNSAFE_ViewTransitionContext, UNSAFE_useRouteId, } from "react-router"; | ||
| declare global { | ||
| var __staticRouterHydrationData: HydrationState | undefined; | ||
| } | ||
| interface DOMRouterOpts { | ||
| basename?: string; | ||
| future?: Partial<Omit<RouterFutureConfig, "v7_prependBasename">>; | ||
| hydrationData?: HydrationState; | ||
| window?: Window; | ||
| } | ||
| export declare function createBrowserRouter(routes: RouteObject[], opts?: DOMRouterOpts): RemixRouter; | ||
| export declare function createHashRouter(routes: RouteObject[], opts?: DOMRouterOpts): RemixRouter; | ||
| export interface BrowserRouterProps { | ||
| basename?: string; | ||
| children?: React.ReactNode; | ||
| future?: FutureConfig; | ||
| window?: Window; | ||
| } | ||
| /** | ||
| * A `<Router>` for use in web browsers. Provides the cleanest URLs. | ||
| */ | ||
| export declare function BrowserRouter({ basename, children, future, window, }: BrowserRouterProps): React.JSX.Element; | ||
| export interface HashRouterProps { | ||
| basename?: string; | ||
| children?: React.ReactNode; | ||
| future?: FutureConfig; | ||
| window?: Window; | ||
| } | ||
| /** | ||
| * A `<Router>` for use in web browsers. Stores the location in the hash | ||
| * portion of the URL so it is not sent to the server. | ||
| */ | ||
| export declare function HashRouter({ basename, children, future, window, }: HashRouterProps): React.JSX.Element; | ||
| export interface HistoryRouterProps { | ||
| basename?: string; | ||
| children?: React.ReactNode; | ||
| future?: FutureConfig; | ||
| history: History; | ||
| } | ||
| /** | ||
| * A `<Router>` that accepts a pre-instantiated history object. It's important | ||
| * to note that using your own history object is highly discouraged and may add | ||
| * two versions of the history library to your bundles unless you use the same | ||
| * version of the history library that React Router uses internally. | ||
| */ | ||
| declare function HistoryRouter({ basename, children, future, history, }: HistoryRouterProps): React.JSX.Element; | ||
| declare namespace HistoryRouter { | ||
| var displayName: string; | ||
| } | ||
| export { HistoryRouter as unstable_HistoryRouter }; | ||
| export interface LinkProps extends Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>, "href"> { | ||
| reloadDocument?: boolean; | ||
| replace?: boolean; | ||
| state?: any; | ||
| preventScrollReset?: boolean; | ||
| relative?: RelativeRoutingType; | ||
| to: To; | ||
| unstable_viewTransition?: boolean; | ||
| } | ||
| /** | ||
| * The public API for rendering a history-aware `<a>`. | ||
| */ | ||
| export declare const Link: React.ForwardRefExoticComponent<LinkProps & React.RefAttributes<HTMLAnchorElement>>; | ||
| type NavLinkRenderProps = { | ||
| isActive: boolean; | ||
| isPending: boolean; | ||
| isTransitioning: boolean; | ||
| }; | ||
| export interface NavLinkProps extends Omit<LinkProps, "className" | "style" | "children"> { | ||
| children?: React.ReactNode | ((props: NavLinkRenderProps) => React.ReactNode); | ||
| caseSensitive?: boolean; | ||
| className?: string | ((props: NavLinkRenderProps) => string | undefined); | ||
| end?: boolean; | ||
| style?: React.CSSProperties | ((props: NavLinkRenderProps) => React.CSSProperties | undefined); | ||
| unstable_viewTransition?: boolean; | ||
| } | ||
| /** | ||
| * A `<Link>` wrapper that knows if it's "active" or not. | ||
| */ | ||
| export declare const NavLink: React.ForwardRefExoticComponent<NavLinkProps & React.RefAttributes<HTMLAnchorElement>>; | ||
| export interface FetcherFormProps extends React.FormHTMLAttributes<HTMLFormElement> { | ||
| /** | ||
| * The HTTP verb to use when the form is submit. Supports "get", "post", | ||
| * "put", "delete", "patch". | ||
| */ | ||
| method?: HTMLFormMethod; | ||
| /** | ||
| * `<form encType>` - enhancing beyond the normal string type and limiting | ||
| * to the built-in browser supported values | ||
| */ | ||
| encType?: "application/x-www-form-urlencoded" | "multipart/form-data" | "text/plain"; | ||
| /** | ||
| * Normal `<form action>` but supports React Router's relative paths. | ||
| */ | ||
| action?: string; | ||
| /** | ||
| * Determines whether the form action is relative to the route hierarchy or | ||
| * the pathname. Use this if you want to opt out of navigating the route | ||
| * hierarchy and want to instead route based on /-delimited URL segments | ||
| */ | ||
| relative?: RelativeRoutingType; | ||
| /** | ||
| * Prevent the scroll position from resetting to the top of the viewport on | ||
| * completion of the navigation when using the <ScrollRestoration> component | ||
| */ | ||
| preventScrollReset?: boolean; | ||
| /** | ||
| * A function to call when the form is submitted. If you call | ||
| * `event.preventDefault()` then this form will not do anything. | ||
| */ | ||
| onSubmit?: React.FormEventHandler<HTMLFormElement>; | ||
| } | ||
| export interface FormProps extends FetcherFormProps { | ||
| /** | ||
| * Forces a full document navigation instead of a fetch. | ||
| */ | ||
| reloadDocument?: boolean; | ||
| /** | ||
| * Replaces the current entry in the browser history stack when the form | ||
| * navigates. Use this if you don't want the user to be able to click "back" | ||
| * to the page with the form on it. | ||
| */ | ||
| replace?: boolean; | ||
| /** | ||
| * State object to add to the history stack entry for this navigation | ||
| */ | ||
| state?: any; | ||
| /** | ||
| * Enable view transitions on this Form navigation | ||
| */ | ||
| unstable_viewTransition?: boolean; | ||
| } | ||
| /** | ||
| * A `@remix-run/router`-aware `<form>`. It behaves like a normal form except | ||
| * that the interaction with the server is with `fetch` instead of new document | ||
| * requests, allowing components to add nicer UX to the page as the form is | ||
| * submitted and returns with data. | ||
| */ | ||
| export declare const Form: React.ForwardRefExoticComponent<FormProps & React.RefAttributes<HTMLFormElement>>; | ||
| export interface ScrollRestorationProps { | ||
| getKey?: GetScrollRestorationKeyFunction; | ||
| storageKey?: string; | ||
| } | ||
| /** | ||
| * This component will emulate the browser's scroll restoration on location | ||
| * changes. | ||
| */ | ||
| export declare function ScrollRestoration({ getKey, storageKey, }: ScrollRestorationProps): null; | ||
| export declare namespace ScrollRestoration { | ||
| var displayName: string; | ||
| } | ||
| /** | ||
| * Handles the click behavior for router `<Link>` components. This is useful if | ||
| * you need to create custom `<Link>` components with the same click behavior we | ||
| * use in our exported `<Link>`. | ||
| */ | ||
| export declare function useLinkClickHandler<E extends Element = HTMLAnchorElement>(to: To, { target, replace: replaceProp, state, preventScrollReset, relative, unstable_viewTransition, }?: { | ||
| target?: React.HTMLAttributeAnchorTarget; | ||
| replace?: boolean; | ||
| state?: any; | ||
| preventScrollReset?: boolean; | ||
| relative?: RelativeRoutingType; | ||
| unstable_viewTransition?: boolean; | ||
| }): (event: React.MouseEvent<E, MouseEvent>) => void; | ||
| /** | ||
| * A convenient wrapper for reading and writing search parameters via the | ||
| * URLSearchParams interface. | ||
| */ | ||
| export declare function useSearchParams(defaultInit?: URLSearchParamsInit): [URLSearchParams, SetURLSearchParams]; | ||
| export type SetURLSearchParams = (nextInit?: URLSearchParamsInit | ((prev: URLSearchParams) => URLSearchParamsInit), navigateOpts?: NavigateOptions) => void; | ||
| /** | ||
| * Submits a HTML `<form>` to the server without reloading the page. | ||
| */ | ||
| export interface SubmitFunction { | ||
| ( | ||
| /** | ||
| * Specifies the `<form>` to be submitted to the server, a specific | ||
| * `<button>` or `<input type="submit">` to use to submit the form, or some | ||
| * arbitrary data to submit. | ||
| * | ||
| * Note: When using a `<button>` its `name` and `value` will also be | ||
| * included in the form data that is submitted. | ||
| */ | ||
| target: SubmitTarget, | ||
| /** | ||
| * Options that override the `<form>`'s own attributes. Required when | ||
| * submitting arbitrary data without a backing `<form>`. | ||
| */ | ||
| options?: SubmitOptions): void; | ||
| } | ||
| /** | ||
| * Submits a fetcher `<form>` to the server without reloading the page. | ||
| */ | ||
| export interface FetcherSubmitFunction { | ||
| (target: SubmitTarget, options?: Omit<SubmitOptions, "replace" | "state">): void; | ||
| } | ||
| /** | ||
| * Returns a function that may be used to programmatically submit a form (or | ||
| * some arbitrary data) to the server. | ||
| */ | ||
| export declare function useSubmit(): SubmitFunction; | ||
| export declare function useFormAction(action?: string, { relative }?: { | ||
| relative?: RelativeRoutingType; | ||
| }): string; | ||
| declare function createFetcherForm(fetcherKey: string, routeId: string): React.ForwardRefExoticComponent<FetcherFormProps & React.RefAttributes<HTMLFormElement>>; | ||
| export type FetcherWithComponents<TData> = Fetcher<TData> & { | ||
| Form: ReturnType<typeof createFetcherForm>; | ||
| submit: FetcherSubmitFunction; | ||
| load: (href: string) => void; | ||
| }; | ||
| /** | ||
| * Interacts with route loaders and actions without causing a navigation. Great | ||
| * for any interaction that stays on the same page. | ||
| */ | ||
| export declare function useFetcher<TData = any>(): FetcherWithComponents<TData>; | ||
| /** | ||
| * Provides all fetchers currently on the page. Useful for layouts and parent | ||
| * routes that need to provide pending/optimistic UI regarding the fetch. | ||
| */ | ||
| export declare function useFetchers(): Fetcher[]; | ||
| /** | ||
| * When rendered inside a RouterProvider, will restore scroll positions on navigations | ||
| */ | ||
| declare function useScrollRestoration({ getKey, storageKey, }?: { | ||
| getKey?: GetScrollRestorationKeyFunction; | ||
| storageKey?: string; | ||
| }): void; | ||
| export { useScrollRestoration as UNSAFE_useScrollRestoration }; | ||
| /** | ||
| * Setup a callback to be fired on the window's `beforeunload` event. This is | ||
| * useful for saving some data to `window.localStorage` just before the page | ||
| * refreshes. | ||
| * | ||
| * Note: The `callback` argument should be a function created with | ||
| * `React.useCallback()`. | ||
| */ | ||
| export declare function useBeforeUnload(callback: (event: BeforeUnloadEvent) => any, options?: { | ||
| capture?: boolean; | ||
| }): void; | ||
| /** | ||
| * Wrapper around useBlocker to show a window.confirm prompt to users instead | ||
| * of building a custom UI with useBlocker. | ||
| * | ||
| * Warning: This has *a lot of rough edges* and behaves very differently (and | ||
| * very incorrectly in some cases) across browsers if user click addition | ||
| * back/forward navigations while the confirm is open. Use at your own risk. | ||
| */ | ||
| declare function usePrompt({ when, message }: { | ||
| when: boolean; | ||
| message: string; | ||
| }): void; | ||
| export { usePrompt as unstable_usePrompt }; | ||
| /** | ||
| * Return a boolean indicating if there is an active view transition to the | ||
| * given href. You can use this value to render CSS classes or viewTransitionName | ||
| * styles onto your elements | ||
| * | ||
| * @param href The destination href | ||
| * @param [opts.relative] Relative routing type ("route" | "path") | ||
| */ | ||
| declare function useViewTransitionState(to: To, opts?: { | ||
| relative?: RelativeRoutingType; | ||
| }): boolean; | ||
| export { useViewTransitionState as unstable_useViewTransitionState }; | ||
| export type { UNSAFE_RouteModules, UNSAFE_FutureConfig, UNSAFE_AssetsManifest, UNSAFE_RemixContextObject, UNSAFE_EntryRoute, UNSAFE_RouteManifest, UNSAFE_SingleFetchRedirectResult, UNSAFE_SingleFetchResult, UNSAFE_SingleFetchResults, } from "react-router"; | ||
| /** @internal */ | ||
| export { UNSAFE_DataRouterContext, UNSAFE_DataRouterStateContext, UNSAFE_LocationContext, UNSAFE_NavigationContext, UNSAFE_RouteContext, UNSAFE_mapRouteProperties, UNSAFE_useRouteId, UNSAFE_useRoutesImpl, UNSAFE_ErrorResponseImpl, UNSAFE_RemixContext, UNSAFE_decodeViaTurboStream, UNSAFE_SingleFetchRedirectSymbol, } from "react-router"; |
1129
dist/index.js
| /** | ||
| * React Router DOM v0.0.0-experimental-4a8a492a | ||
| * React Router DOM v0.0.0-experimental-4ed3f5da9 | ||
| * | ||
@@ -11,1126 +11,9 @@ * Copyright (c) Remix Software Inc. | ||
| */ | ||
| import * as React from 'react'; | ||
| import { UNSAFE_mapRouteProperties, Router, UNSAFE_NavigationContext, useHref, useResolvedPath, useLocation, UNSAFE_DataRouterStateContext, useNavigate, createPath, UNSAFE_useRouteId, UNSAFE_RouteContext, useMatches, useNavigation, unstable_useBlocker, UNSAFE_ViewTransitionContext, UNSAFE_DataRouterContext } from 'react-router'; | ||
| export { AbortedDeferredError, Await, MemoryRouter, Navigate, NavigationType, Outlet, Route, Router, RouterProvider, Routes, UNSAFE_DataRouterContext, UNSAFE_DataRouterStateContext, UNSAFE_LocationContext, UNSAFE_NavigationContext, UNSAFE_RouteContext, UNSAFE_ViewTransitionContext, UNSAFE_useRouteId, createMemoryRouter, createPath, createRoutesFromChildren, createRoutesFromElements, defer, generatePath, isRouteErrorResponse, json, matchPath, matchRoutes, parsePath, redirect, redirectDocument, renderMatches, resolvePath, unstable_useBlocker, useActionData, useAsyncError, useAsyncValue, useHref, useInRouterContext, useLoaderData, useLocation, useMatch, useMatches, useNavigate, useNavigation, useNavigationType, useOutlet, useOutletContext, useParams, useResolvedPath, useRevalidator, useRouteError, useRouteLoaderData, useRoutes } from 'react-router'; | ||
| import { stripBasename, UNSAFE_warning, createRouter, createBrowserHistory, createHashHistory, UNSAFE_ErrorResponseImpl, UNSAFE_invariant, joinPaths, matchPath } from '@remix-run/router'; | ||
| export { AbortedDeferredError, Await, BrowserRouter, Form, HashRouter, HydratedRouter, Link, Links, MemoryRouter, Meta, NavLink, Navigate, NavigationType, Outlet, PrefetchPageLinks, RemixServer, Route, Router, RouterProvider, Routes, Scripts, ScrollRestoration, StaticRouter, StaticRouterProvider, UNSAFE_DEFERRED_SYMBOL, UNSAFE_DataRouterContext, UNSAFE_DataRouterStateContext, UNSAFE_ErrorResponseImpl, UNSAFE_FetchersContext, UNSAFE_LocationContext, UNSAFE_NavigationContext, UNSAFE_RemixContext, UNSAFE_RouteContext, UNSAFE_SingleFetchRedirectSymbol, UNSAFE_ViewTransitionContext, UNSAFE_convertRoutesToDataRoutes, UNSAFE_decodeViaTurboStream, UNSAFE_mapRouteProperties, UNSAFE_useRouteId, UNSAFE_useRoutesImpl, UNSAFE_useScrollRestoration, createBrowserRouter, createHashRouter, createMemoryRouter, createPath, createRemixStub, createRoutesFromChildren, createRoutesFromChildren as createRoutesFromElements, createSearchParams, createStaticHandler, createStaticRouter, defer, generatePath, getStaticContextFromError, isRouteErrorResponse, json, matchPath, matchRoutes, parsePath, redirect, redirectDocument, renderMatches, resolvePath, stripBasename, unstable_HistoryRouter, unstable_usePrompt, unstable_useViewTransitionState, useActionData, useAsyncError, useAsyncValue, useBeforeUnload, useBlocker, useFetcher, useFetchers, useFormAction, useHref, useInRouterContext, useLinkClickHandler, useLoaderData, useLocation, useMatch, useMatches, useNavigate, useNavigation, useNavigationType, useOutlet, useOutletContext, useParams, useResolvedPath, useRevalidator, useRouteError, useRouteLoaderData, useRoutes, useSearchParams, useSubmit } from 'react-router'; | ||
| function _extends() { | ||
| _extends = Object.assign ? Object.assign.bind() : function (target) { | ||
| for (var i = 1; i < arguments.length; i++) { | ||
| var source = arguments[i]; | ||
| for (var key in source) { | ||
| if (Object.prototype.hasOwnProperty.call(source, key)) { | ||
| target[key] = source[key]; | ||
| } | ||
| } | ||
| } | ||
| return target; | ||
| }; | ||
| return _extends.apply(this, arguments); | ||
| let alreadyWarned = false; | ||
| if (!alreadyWarned && typeof console !== "undefined") { | ||
| alreadyWarned = true; | ||
| console.warn("The `react-router-dom` package is deprecated in v7, you can change all " + "of your imports to load directly from the `react-router` package."); | ||
| } | ||
| function _objectWithoutPropertiesLoose(source, excluded) { | ||
| if (source == null) return {}; | ||
| var target = {}; | ||
| var sourceKeys = Object.keys(source); | ||
| var key, i; | ||
| for (i = 0; i < sourceKeys.length; i++) { | ||
| key = sourceKeys[i]; | ||
| if (excluded.indexOf(key) >= 0) continue; | ||
| target[key] = source[key]; | ||
| } | ||
| return target; | ||
| } | ||
| const defaultMethod = "get"; | ||
| const defaultEncType = "application/x-www-form-urlencoded"; | ||
| function isHtmlElement(object) { | ||
| return object != null && typeof object.tagName === "string"; | ||
| } | ||
| function isButtonElement(object) { | ||
| return isHtmlElement(object) && object.tagName.toLowerCase() === "button"; | ||
| } | ||
| function isFormElement(object) { | ||
| return isHtmlElement(object) && object.tagName.toLowerCase() === "form"; | ||
| } | ||
| function isInputElement(object) { | ||
| return isHtmlElement(object) && object.tagName.toLowerCase() === "input"; | ||
| } | ||
| function isModifiedEvent(event) { | ||
| return !!(event.metaKey || event.altKey || event.ctrlKey || event.shiftKey); | ||
| } | ||
| function shouldProcessLinkClick(event, target) { | ||
| return event.button === 0 && ( | ||
| // Ignore everything but left clicks | ||
| !target || target === "_self") && | ||
| // Let browser handle "target=_blank" etc. | ||
| !isModifiedEvent(event) // Ignore clicks with modifier keys | ||
| ; | ||
| } | ||
| /** | ||
| * Creates a URLSearchParams object using the given initializer. | ||
| * | ||
| * This is identical to `new URLSearchParams(init)` except it also | ||
| * supports arrays as values in the object form of the initializer | ||
| * instead of just strings. This is convenient when you need multiple | ||
| * values for a given key, but don't want to use an array initializer. | ||
| * | ||
| * For example, instead of: | ||
| * | ||
| * let searchParams = new URLSearchParams([ | ||
| * ['sort', 'name'], | ||
| * ['sort', 'price'] | ||
| * ]); | ||
| * | ||
| * you can do: | ||
| * | ||
| * let searchParams = createSearchParams({ | ||
| * sort: ['name', 'price'] | ||
| * }); | ||
| */ | ||
| function createSearchParams(init) { | ||
| if (init === void 0) { | ||
| init = ""; | ||
| } | ||
| return new URLSearchParams(typeof init === "string" || Array.isArray(init) || init instanceof URLSearchParams ? init : Object.keys(init).reduce((memo, key) => { | ||
| let value = init[key]; | ||
| return memo.concat(Array.isArray(value) ? value.map(v => [key, v]) : [[key, value]]); | ||
| }, [])); | ||
| } | ||
| function getSearchParamsForLocation(locationSearch, defaultSearchParams) { | ||
| let searchParams = createSearchParams(locationSearch); | ||
| if (defaultSearchParams) { | ||
| // Use `defaultSearchParams.forEach(...)` here instead of iterating of | ||
| // `defaultSearchParams.keys()` to work-around a bug in Firefox related to | ||
| // web extensions. Relevant Bugzilla tickets: | ||
| // https://bugzilla.mozilla.org/show_bug.cgi?id=1414602 | ||
| // https://bugzilla.mozilla.org/show_bug.cgi?id=1023984 | ||
| defaultSearchParams.forEach((_, key) => { | ||
| if (!searchParams.has(key)) { | ||
| defaultSearchParams.getAll(key).forEach(value => { | ||
| searchParams.append(key, value); | ||
| }); | ||
| } | ||
| }); | ||
| } | ||
| return searchParams; | ||
| } | ||
| // One-time check for submitter support | ||
| let _formDataSupportsSubmitter = null; | ||
| function isFormDataSubmitterSupported() { | ||
| if (_formDataSupportsSubmitter === null) { | ||
| try { | ||
| new FormData(document.createElement("form"), | ||
| // @ts-expect-error if FormData supports the submitter parameter, this will throw | ||
| 0); | ||
| _formDataSupportsSubmitter = false; | ||
| } catch (e) { | ||
| _formDataSupportsSubmitter = true; | ||
| } | ||
| } | ||
| return _formDataSupportsSubmitter; | ||
| } | ||
| const supportedFormEncTypes = new Set(["application/x-www-form-urlencoded", "multipart/form-data", "text/plain"]); | ||
| function getFormEncType(encType) { | ||
| if (encType != null && !supportedFormEncTypes.has(encType)) { | ||
| process.env.NODE_ENV !== "production" ? UNSAFE_warning(false, "\"" + encType + "\" is not a valid `encType` for `<Form>`/`<fetcher.Form>` " + ("and will default to \"" + defaultEncType + "\"")) : void 0; | ||
| return null; | ||
| } | ||
| return encType; | ||
| } | ||
| function getFormSubmissionInfo(target, basename) { | ||
| let method; | ||
| let action; | ||
| let encType; | ||
| let formData; | ||
| let body; | ||
| if (isFormElement(target)) { | ||
| // When grabbing the action from the element, it will have had the basename | ||
| // prefixed to ensure non-JS scenarios work, so strip it since we'll | ||
| // re-prefix in the router | ||
| let attr = target.getAttribute("action"); | ||
| action = attr ? stripBasename(attr, basename) : null; | ||
| method = target.getAttribute("method") || defaultMethod; | ||
| encType = getFormEncType(target.getAttribute("enctype")) || defaultEncType; | ||
| formData = new FormData(target); | ||
| } else if (isButtonElement(target) || isInputElement(target) && (target.type === "submit" || target.type === "image")) { | ||
| let form = target.form; | ||
| if (form == null) { | ||
| throw new Error("Cannot submit a <button> or <input type=\"submit\"> without a <form>"); | ||
| } | ||
| // <button>/<input type="submit"> may override attributes of <form> | ||
| // When grabbing the action from the element, it will have had the basename | ||
| // prefixed to ensure non-JS scenarios work, so strip it since we'll | ||
| // re-prefix in the router | ||
| let attr = target.getAttribute("formaction") || form.getAttribute("action"); | ||
| action = attr ? stripBasename(attr, basename) : null; | ||
| method = target.getAttribute("formmethod") || form.getAttribute("method") || defaultMethod; | ||
| encType = getFormEncType(target.getAttribute("formenctype")) || getFormEncType(form.getAttribute("enctype")) || defaultEncType; | ||
| // Build a FormData object populated from a form and submitter | ||
| formData = new FormData(form, target); | ||
| // If this browser doesn't support the `FormData(el, submitter)` format, | ||
| // then tack on the submitter value at the end. This is a lightweight | ||
| // solution that is not 100% spec compliant. For complete support in older | ||
| // browsers, consider using the `formdata-submitter-polyfill` package | ||
| if (!isFormDataSubmitterSupported()) { | ||
| let { | ||
| name, | ||
| type, | ||
| value | ||
| } = target; | ||
| if (type === "image") { | ||
| let prefix = name ? name + "." : ""; | ||
| formData.append(prefix + "x", "0"); | ||
| formData.append(prefix + "y", "0"); | ||
| } else if (name) { | ||
| formData.append(name, value); | ||
| } | ||
| } | ||
| } else if (isHtmlElement(target)) { | ||
| throw new Error("Cannot submit element that is not <form>, <button>, or " + "<input type=\"submit|image\">"); | ||
| } else { | ||
| method = defaultMethod; | ||
| action = null; | ||
| encType = defaultEncType; | ||
| body = target; | ||
| } | ||
| // Send body for <Form encType="text/plain" so we encode it into text | ||
| if (formData && encType === "text/plain") { | ||
| body = formData; | ||
| formData = undefined; | ||
| } | ||
| return { | ||
| action, | ||
| method: method.toLowerCase(), | ||
| encType, | ||
| formData, | ||
| body | ||
| }; | ||
| } | ||
| const _excluded = ["onClick", "relative", "reloadDocument", "replace", "state", "target", "to", "preventScrollReset", "unstable_viewTransition"], | ||
| _excluded2 = ["aria-current", "caseSensitive", "className", "end", "style", "to", "unstable_viewTransition", "children"], | ||
| _excluded3 = ["reloadDocument", "replace", "state", "method", "action", "onSubmit", "submit", "relative", "preventScrollReset", "unstable_viewTransition"]; | ||
| function createBrowserRouter(routes, opts) { | ||
| return createRouter({ | ||
| basename: opts == null ? void 0 : opts.basename, | ||
| future: _extends({}, opts == null ? void 0 : opts.future, { | ||
| v7_prependBasename: true | ||
| }), | ||
| history: createBrowserHistory({ | ||
| window: opts == null ? void 0 : opts.window | ||
| }), | ||
| hydrationData: (opts == null ? void 0 : opts.hydrationData) || parseHydrationData(), | ||
| routes, | ||
| mapRouteProperties: UNSAFE_mapRouteProperties | ||
| }).initialize(); | ||
| } | ||
| function createHashRouter(routes, opts) { | ||
| return createRouter({ | ||
| basename: opts == null ? void 0 : opts.basename, | ||
| future: _extends({}, opts == null ? void 0 : opts.future, { | ||
| v7_prependBasename: true | ||
| }), | ||
| history: createHashHistory({ | ||
| window: opts == null ? void 0 : opts.window | ||
| }), | ||
| hydrationData: (opts == null ? void 0 : opts.hydrationData) || parseHydrationData(), | ||
| routes, | ||
| mapRouteProperties: UNSAFE_mapRouteProperties | ||
| }).initialize(); | ||
| } | ||
| function parseHydrationData() { | ||
| var _window; | ||
| let state = (_window = window) == null ? void 0 : _window.__staticRouterHydrationData; | ||
| if (state && state.errors) { | ||
| state = _extends({}, state, { | ||
| errors: deserializeErrors(state.errors) | ||
| }); | ||
| } | ||
| return state; | ||
| } | ||
| function deserializeErrors(errors) { | ||
| if (!errors) return null; | ||
| let entries = Object.entries(errors); | ||
| let serialized = {}; | ||
| for (let [key, val] of entries) { | ||
| // Hey you! If you change this, please change the corresponding logic in | ||
| // serializeErrors in react-router-dom/server.tsx :) | ||
| if (val && val.__type === "RouteErrorResponse") { | ||
| serialized[key] = new UNSAFE_ErrorResponseImpl(val.status, val.statusText, val.data, val.internal === true); | ||
| } else if (val && val.__type === "Error") { | ||
| // Attempt to reconstruct the right type of Error (i.e., ReferenceError) | ||
| if (val.__subType) { | ||
| let ErrorConstructor = window[val.__subType]; | ||
| if (typeof ErrorConstructor === "function") { | ||
| try { | ||
| // @ts-expect-error | ||
| let error = new ErrorConstructor(val.message); | ||
| // Wipe away the client-side stack trace. Nothing to fill it in with | ||
| // because we don't serialize SSR stack traces for security reasons | ||
| error.stack = ""; | ||
| serialized[key] = error; | ||
| } catch (e) { | ||
| // no-op - fall through and create a normal Error | ||
| } | ||
| } | ||
| } | ||
| if (serialized[key] == null) { | ||
| let error = new Error(val.message); | ||
| // Wipe away the client-side stack trace. Nothing to fill it in with | ||
| // because we don't serialize SSR stack traces for security reasons | ||
| error.stack = ""; | ||
| serialized[key] = error; | ||
| } | ||
| } else { | ||
| serialized[key] = val; | ||
| } | ||
| } | ||
| return serialized; | ||
| } | ||
| //#endregion | ||
| //////////////////////////////////////////////////////////////////////////////// | ||
| //#region Components | ||
| //////////////////////////////////////////////////////////////////////////////// | ||
| /** | ||
| Webpack + React 17 fails to compile on any of the following because webpack | ||
| complains that `startTransition` doesn't exist in `React`: | ||
| * import { startTransition } from "react" | ||
| * import * as React from from "react"; | ||
| "startTransition" in React ? React.startTransition(() => setState()) : setState() | ||
| * import * as React from from "react"; | ||
| "startTransition" in React ? React["startTransition"](() => setState()) : setState() | ||
| Moving it to a constant such as the following solves the Webpack/React 17 issue: | ||
| * import * as React from from "react"; | ||
| const START_TRANSITION = "startTransition"; | ||
| START_TRANSITION in React ? React[START_TRANSITION](() => setState()) : setState() | ||
| However, that introduces webpack/terser minification issues in production builds | ||
| in React 18 where minification/obfuscation ends up removing the call of | ||
| React.startTransition entirely from the first half of the ternary. Grabbing | ||
| this exported reference once up front resolves that issue. | ||
| See https://github.com/remix-run/react-router/issues/10579 | ||
| */ | ||
| const START_TRANSITION = "startTransition"; | ||
| const startTransitionImpl = React[START_TRANSITION]; | ||
| /** | ||
| * A `<Router>` for use in web browsers. Provides the cleanest URLs. | ||
| */ | ||
| function BrowserRouter(_ref) { | ||
| let { | ||
| basename, | ||
| children, | ||
| future, | ||
| window | ||
| } = _ref; | ||
| let historyRef = React.useRef(); | ||
| if (historyRef.current == null) { | ||
| historyRef.current = createBrowserHistory({ | ||
| window, | ||
| v5Compat: true | ||
| }); | ||
| } | ||
| let history = historyRef.current; | ||
| let [state, setStateImpl] = React.useState({ | ||
| action: history.action, | ||
| location: history.location | ||
| }); | ||
| let { | ||
| v7_startTransition | ||
| } = future || {}; | ||
| let setState = React.useCallback(newState => { | ||
| v7_startTransition && startTransitionImpl ? startTransitionImpl(() => setStateImpl(newState)) : setStateImpl(newState); | ||
| }, [setStateImpl, v7_startTransition]); | ||
| React.useLayoutEffect(() => history.listen(setState), [history, setState]); | ||
| return /*#__PURE__*/React.createElement(Router, { | ||
| basename: basename, | ||
| children: children, | ||
| location: state.location, | ||
| navigationType: state.action, | ||
| navigator: history | ||
| }); | ||
| } | ||
| /** | ||
| * A `<Router>` for use in web browsers. Stores the location in the hash | ||
| * portion of the URL so it is not sent to the server. | ||
| */ | ||
| function HashRouter(_ref2) { | ||
| let { | ||
| basename, | ||
| children, | ||
| future, | ||
| window | ||
| } = _ref2; | ||
| let historyRef = React.useRef(); | ||
| if (historyRef.current == null) { | ||
| historyRef.current = createHashHistory({ | ||
| window, | ||
| v5Compat: true | ||
| }); | ||
| } | ||
| let history = historyRef.current; | ||
| let [state, setStateImpl] = React.useState({ | ||
| action: history.action, | ||
| location: history.location | ||
| }); | ||
| let { | ||
| v7_startTransition | ||
| } = future || {}; | ||
| let setState = React.useCallback(newState => { | ||
| v7_startTransition && startTransitionImpl ? startTransitionImpl(() => setStateImpl(newState)) : setStateImpl(newState); | ||
| }, [setStateImpl, v7_startTransition]); | ||
| React.useLayoutEffect(() => history.listen(setState), [history, setState]); | ||
| return /*#__PURE__*/React.createElement(Router, { | ||
| basename: basename, | ||
| children: children, | ||
| location: state.location, | ||
| navigationType: state.action, | ||
| navigator: history | ||
| }); | ||
| } | ||
| /** | ||
| * A `<Router>` that accepts a pre-instantiated history object. It's important | ||
| * to note that using your own history object is highly discouraged and may add | ||
| * two versions of the history library to your bundles unless you use the same | ||
| * version of the history library that React Router uses internally. | ||
| */ | ||
| function HistoryRouter(_ref3) { | ||
| let { | ||
| basename, | ||
| children, | ||
| future, | ||
| history | ||
| } = _ref3; | ||
| let [state, setStateImpl] = React.useState({ | ||
| action: history.action, | ||
| location: history.location | ||
| }); | ||
| let { | ||
| v7_startTransition | ||
| } = future || {}; | ||
| let setState = React.useCallback(newState => { | ||
| v7_startTransition && startTransitionImpl ? startTransitionImpl(() => setStateImpl(newState)) : setStateImpl(newState); | ||
| }, [setStateImpl, v7_startTransition]); | ||
| React.useLayoutEffect(() => history.listen(setState), [history, setState]); | ||
| return /*#__PURE__*/React.createElement(Router, { | ||
| basename: basename, | ||
| children: children, | ||
| location: state.location, | ||
| navigationType: state.action, | ||
| navigator: history | ||
| }); | ||
| } | ||
| if (process.env.NODE_ENV !== "production") { | ||
| HistoryRouter.displayName = "unstable_HistoryRouter"; | ||
| } | ||
| const isBrowser = typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement !== "undefined"; | ||
| const ABSOLUTE_URL_REGEX = /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i; | ||
| /** | ||
| * The public API for rendering a history-aware `<a>`. | ||
| */ | ||
| const Link = /*#__PURE__*/React.forwardRef(function LinkWithRef(_ref4, ref) { | ||
| let { | ||
| onClick, | ||
| relative, | ||
| reloadDocument, | ||
| replace, | ||
| state, | ||
| target, | ||
| to, | ||
| preventScrollReset, | ||
| unstable_viewTransition | ||
| } = _ref4, | ||
| rest = _objectWithoutPropertiesLoose(_ref4, _excluded); | ||
| let { | ||
| basename | ||
| } = React.useContext(UNSAFE_NavigationContext); | ||
| // Rendered into <a href> for absolute URLs | ||
| let absoluteHref; | ||
| let isExternal = false; | ||
| if (typeof to === "string" && ABSOLUTE_URL_REGEX.test(to)) { | ||
| // Render the absolute href server- and client-side | ||
| absoluteHref = to; | ||
| // Only check for external origins client-side | ||
| if (isBrowser) { | ||
| try { | ||
| let currentUrl = new URL(window.location.href); | ||
| let targetUrl = to.startsWith("//") ? new URL(currentUrl.protocol + to) : new URL(to); | ||
| let path = stripBasename(targetUrl.pathname, basename); | ||
| if (targetUrl.origin === currentUrl.origin && path != null) { | ||
| // Strip the protocol/origin/basename for same-origin absolute URLs | ||
| to = path + targetUrl.search + targetUrl.hash; | ||
| } else { | ||
| isExternal = true; | ||
| } | ||
| } catch (e) { | ||
| // We can't do external URL detection without a valid URL | ||
| process.env.NODE_ENV !== "production" ? UNSAFE_warning(false, "<Link to=\"" + to + "\"> contains an invalid URL which will probably break " + "when clicked - please update to a valid URL path.") : void 0; | ||
| } | ||
| } | ||
| } | ||
| // Rendered into <a href> for relative URLs | ||
| let href = useHref(to, { | ||
| relative | ||
| }); | ||
| let internalOnClick = useLinkClickHandler(to, { | ||
| replace, | ||
| state, | ||
| target, | ||
| preventScrollReset, | ||
| relative, | ||
| unstable_viewTransition | ||
| }); | ||
| function handleClick(event) { | ||
| if (onClick) onClick(event); | ||
| if (!event.defaultPrevented) { | ||
| internalOnClick(event); | ||
| } | ||
| } | ||
| return ( | ||
| /*#__PURE__*/ | ||
| // eslint-disable-next-line jsx-a11y/anchor-has-content | ||
| React.createElement("a", _extends({}, rest, { | ||
| href: absoluteHref || href, | ||
| onClick: isExternal || reloadDocument ? onClick : handleClick, | ||
| ref: ref, | ||
| target: target | ||
| })) | ||
| ); | ||
| }); | ||
| if (process.env.NODE_ENV !== "production") { | ||
| Link.displayName = "Link"; | ||
| } | ||
| /** | ||
| * A `<Link>` wrapper that knows if it's "active" or not. | ||
| */ | ||
| const NavLink = /*#__PURE__*/React.forwardRef(function NavLinkWithRef(_ref5, ref) { | ||
| let { | ||
| "aria-current": ariaCurrentProp = "page", | ||
| caseSensitive = false, | ||
| className: classNameProp = "", | ||
| end = false, | ||
| style: styleProp, | ||
| to, | ||
| unstable_viewTransition, | ||
| children | ||
| } = _ref5, | ||
| rest = _objectWithoutPropertiesLoose(_ref5, _excluded2); | ||
| let path = useResolvedPath(to, { | ||
| relative: rest.relative | ||
| }); | ||
| let location = useLocation(); | ||
| let routerState = React.useContext(UNSAFE_DataRouterStateContext); | ||
| let { | ||
| navigator | ||
| } = React.useContext(UNSAFE_NavigationContext); | ||
| let isTransitioning = useViewTransitionState(path) && unstable_viewTransition === true; | ||
| let toPathname = navigator.encodeLocation ? navigator.encodeLocation(path).pathname : path.pathname; | ||
| let locationPathname = location.pathname; | ||
| let nextLocationPathname = routerState && routerState.navigation && routerState.navigation.location ? routerState.navigation.location.pathname : null; | ||
| if (!caseSensitive) { | ||
| locationPathname = locationPathname.toLowerCase(); | ||
| nextLocationPathname = nextLocationPathname ? nextLocationPathname.toLowerCase() : null; | ||
| toPathname = toPathname.toLowerCase(); | ||
| } | ||
| let isActive = locationPathname === toPathname || !end && locationPathname.startsWith(toPathname) && locationPathname.charAt(toPathname.length) === "/"; | ||
| let isPending = nextLocationPathname != null && (nextLocationPathname === toPathname || !end && nextLocationPathname.startsWith(toPathname) && nextLocationPathname.charAt(toPathname.length) === "/"); | ||
| let renderProps = { | ||
| isActive, | ||
| isPending, | ||
| isTransitioning | ||
| }; | ||
| let ariaCurrent = isActive ? ariaCurrentProp : undefined; | ||
| let className; | ||
| if (typeof classNameProp === "function") { | ||
| className = classNameProp(renderProps); | ||
| } else { | ||
| // If the className prop is not a function, we use a default `active` | ||
| // class for <NavLink />s that are active. In v5 `active` was the default | ||
| // value for `activeClassName`, but we are removing that API and can still | ||
| // use the old default behavior for a cleaner upgrade path and keep the | ||
| // simple styling rules working as they currently do. | ||
| className = [classNameProp, isActive ? "active" : null, isPending ? "pending" : null, isTransitioning ? "transitioning" : null].filter(Boolean).join(" "); | ||
| } | ||
| let style = typeof styleProp === "function" ? styleProp(renderProps) : styleProp; | ||
| return /*#__PURE__*/React.createElement(Link, _extends({}, rest, { | ||
| "aria-current": ariaCurrent, | ||
| className: className, | ||
| ref: ref, | ||
| style: style, | ||
| to: to, | ||
| unstable_viewTransition: unstable_viewTransition | ||
| }), typeof children === "function" ? children(renderProps) : children); | ||
| }); | ||
| if (process.env.NODE_ENV !== "production") { | ||
| NavLink.displayName = "NavLink"; | ||
| } | ||
| /** | ||
| * A `@remix-run/router`-aware `<form>`. It behaves like a normal form except | ||
| * that the interaction with the server is with `fetch` instead of new document | ||
| * requests, allowing components to add nicer UX to the page as the form is | ||
| * submitted and returns with data. | ||
| */ | ||
| const Form = /*#__PURE__*/React.forwardRef((props, ref) => { | ||
| let submit = useSubmit(); | ||
| return /*#__PURE__*/React.createElement(FormImpl, _extends({}, props, { | ||
| submit: submit, | ||
| ref: ref | ||
| })); | ||
| }); | ||
| if (process.env.NODE_ENV !== "production") { | ||
| Form.displayName = "Form"; | ||
| } | ||
| const FormImpl = /*#__PURE__*/React.forwardRef((_ref6, forwardedRef) => { | ||
| let { | ||
| reloadDocument, | ||
| replace, | ||
| state, | ||
| method = defaultMethod, | ||
| action, | ||
| onSubmit, | ||
| submit, | ||
| relative, | ||
| preventScrollReset, | ||
| unstable_viewTransition | ||
| } = _ref6, | ||
| props = _objectWithoutPropertiesLoose(_ref6, _excluded3); | ||
| let formMethod = method.toLowerCase() === "get" ? "get" : "post"; | ||
| let formAction = useFormAction(action, { | ||
| relative | ||
| }); | ||
| let submitHandler = event => { | ||
| onSubmit && onSubmit(event); | ||
| if (event.defaultPrevented) return; | ||
| event.preventDefault(); | ||
| let submitter = event.nativeEvent.submitter; | ||
| let submitMethod = (submitter == null ? void 0 : submitter.getAttribute("formmethod")) || method; | ||
| submit(submitter || event.currentTarget, { | ||
| method: submitMethod, | ||
| replace, | ||
| state, | ||
| relative, | ||
| preventScrollReset, | ||
| unstable_viewTransition | ||
| }); | ||
| }; | ||
| return /*#__PURE__*/React.createElement("form", _extends({ | ||
| ref: forwardedRef, | ||
| method: formMethod, | ||
| action: formAction, | ||
| onSubmit: reloadDocument ? onSubmit : submitHandler | ||
| }, props)); | ||
| }); | ||
| if (process.env.NODE_ENV !== "production") { | ||
| FormImpl.displayName = "FormImpl"; | ||
| } | ||
| /** | ||
| * This component will emulate the browser's scroll restoration on location | ||
| * changes. | ||
| */ | ||
| function ScrollRestoration(_ref7) { | ||
| let { | ||
| getKey, | ||
| storageKey | ||
| } = _ref7; | ||
| useScrollRestoration({ | ||
| getKey, | ||
| storageKey | ||
| }); | ||
| return null; | ||
| } | ||
| if (process.env.NODE_ENV !== "production") { | ||
| ScrollRestoration.displayName = "ScrollRestoration"; | ||
| } | ||
| //#endregion | ||
| //////////////////////////////////////////////////////////////////////////////// | ||
| //#region Hooks | ||
| //////////////////////////////////////////////////////////////////////////////// | ||
| var DataRouterHook; | ||
| (function (DataRouterHook) { | ||
| DataRouterHook["UseScrollRestoration"] = "useScrollRestoration"; | ||
| DataRouterHook["UseSubmit"] = "useSubmit"; | ||
| DataRouterHook["UseSubmitFetcher"] = "useSubmitFetcher"; | ||
| DataRouterHook["UseFetcher"] = "useFetcher"; | ||
| DataRouterHook["useViewTransitionStates"] = "useViewTransitionStates"; | ||
| DataRouterHook["useViewTransitionState"] = "useViewTransitionState"; | ||
| })(DataRouterHook || (DataRouterHook = {})); | ||
| var DataRouterStateHook; | ||
| (function (DataRouterStateHook) { | ||
| DataRouterStateHook["UseFetchers"] = "useFetchers"; | ||
| DataRouterStateHook["UseScrollRestoration"] = "useScrollRestoration"; | ||
| })(DataRouterStateHook || (DataRouterStateHook = {})); | ||
| function getDataRouterConsoleError(hookName) { | ||
| return hookName + " must be used within a data router. See https://reactrouter.com/routers/picking-a-router."; | ||
| } | ||
| function useDataRouterContext(hookName) { | ||
| let ctx = React.useContext(UNSAFE_DataRouterContext); | ||
| !ctx ? process.env.NODE_ENV !== "production" ? UNSAFE_invariant(false, getDataRouterConsoleError(hookName)) : UNSAFE_invariant(false) : void 0; | ||
| return ctx; | ||
| } | ||
| function useDataRouterState(hookName) { | ||
| let state = React.useContext(UNSAFE_DataRouterStateContext); | ||
| !state ? process.env.NODE_ENV !== "production" ? UNSAFE_invariant(false, getDataRouterConsoleError(hookName)) : UNSAFE_invariant(false) : void 0; | ||
| return state; | ||
| } | ||
| /** | ||
| * Handles the click behavior for router `<Link>` components. This is useful if | ||
| * you need to create custom `<Link>` components with the same click behavior we | ||
| * use in our exported `<Link>`. | ||
| */ | ||
| function useLinkClickHandler(to, _temp) { | ||
| let { | ||
| target, | ||
| replace: replaceProp, | ||
| state, | ||
| preventScrollReset, | ||
| relative, | ||
| unstable_viewTransition | ||
| } = _temp === void 0 ? {} : _temp; | ||
| let navigate = useNavigate(); | ||
| let location = useLocation(); | ||
| let path = useResolvedPath(to, { | ||
| relative | ||
| }); | ||
| return React.useCallback(event => { | ||
| if (shouldProcessLinkClick(event, target)) { | ||
| event.preventDefault(); | ||
| // If the URL hasn't changed, a regular <a> will do a replace instead of | ||
| // a push, so do the same here unless the replace prop is explicitly set | ||
| let replace = replaceProp !== undefined ? replaceProp : createPath(location) === createPath(path); | ||
| navigate(to, { | ||
| replace, | ||
| state, | ||
| preventScrollReset, | ||
| relative, | ||
| unstable_viewTransition | ||
| }); | ||
| } | ||
| }, [location, navigate, path, replaceProp, state, target, to, preventScrollReset, relative, unstable_viewTransition]); | ||
| } | ||
| /** | ||
| * A convenient wrapper for reading and writing search parameters via the | ||
| * URLSearchParams interface. | ||
| */ | ||
| function useSearchParams(defaultInit) { | ||
| process.env.NODE_ENV !== "production" ? UNSAFE_warning(typeof URLSearchParams !== "undefined", "You cannot use the `useSearchParams` hook in a browser that does not " + "support the URLSearchParams API. If you need to support Internet " + "Explorer 11, we recommend you load a polyfill such as " + "https://github.com/ungap/url-search-params\n\n" + "If you're unsure how to load polyfills, we recommend you check out " + "https://polyfill.io/v3/ which provides some recommendations about how " + "to load polyfills only for users that need them, instead of for every " + "user.") : void 0; | ||
| let defaultSearchParamsRef = React.useRef(createSearchParams(defaultInit)); | ||
| let hasSetSearchParamsRef = React.useRef(false); | ||
| let location = useLocation(); | ||
| let searchParams = React.useMemo(() => | ||
| // Only merge in the defaults if we haven't yet called setSearchParams. | ||
| // Once we call that we want those to take precedence, otherwise you can't | ||
| // remove a param with setSearchParams({}) if it has an initial value | ||
| getSearchParamsForLocation(location.search, hasSetSearchParamsRef.current ? null : defaultSearchParamsRef.current), [location.search]); | ||
| let navigate = useNavigate(); | ||
| let setSearchParams = React.useCallback((nextInit, navigateOptions) => { | ||
| const newSearchParams = createSearchParams(typeof nextInit === "function" ? nextInit(searchParams) : nextInit); | ||
| hasSetSearchParamsRef.current = true; | ||
| navigate("?" + newSearchParams, navigateOptions); | ||
| }, [navigate, searchParams]); | ||
| return [searchParams, setSearchParams]; | ||
| } | ||
| function validateClientSideSubmission() { | ||
| if (typeof document === "undefined") { | ||
| throw new Error("You are calling submit during the server render. " + "Try calling submit within a `useEffect` or callback instead."); | ||
| } | ||
| } | ||
| /** | ||
| * Returns a function that may be used to programmatically submit a form (or | ||
| * some arbitrary data) to the server. | ||
| */ | ||
| function useSubmit() { | ||
| let { | ||
| router | ||
| } = useDataRouterContext(DataRouterHook.UseSubmit); | ||
| let { | ||
| basename | ||
| } = React.useContext(UNSAFE_NavigationContext); | ||
| let currentRouteId = UNSAFE_useRouteId(); | ||
| return React.useCallback(function (target, options) { | ||
| if (options === void 0) { | ||
| options = {}; | ||
| } | ||
| validateClientSideSubmission(); | ||
| let { | ||
| action, | ||
| method, | ||
| encType, | ||
| formData, | ||
| body | ||
| } = getFormSubmissionInfo(target, basename); | ||
| router.navigate(options.action || action, { | ||
| preventScrollReset: options.preventScrollReset, | ||
| formData, | ||
| body, | ||
| formMethod: options.method || method, | ||
| formEncType: options.encType || encType, | ||
| replace: options.replace, | ||
| state: options.state, | ||
| fromRouteId: currentRouteId, | ||
| unstable_viewTransition: options.unstable_viewTransition | ||
| }); | ||
| }, [router, basename, currentRouteId]); | ||
| } | ||
| /** | ||
| * Returns the implementation for fetcher.submit | ||
| */ | ||
| function useSubmitFetcher(fetcherKey, fetcherRouteId) { | ||
| let { | ||
| router | ||
| } = useDataRouterContext(DataRouterHook.UseSubmitFetcher); | ||
| let { | ||
| basename | ||
| } = React.useContext(UNSAFE_NavigationContext); | ||
| return React.useCallback(function (target, options) { | ||
| if (options === void 0) { | ||
| options = {}; | ||
| } | ||
| validateClientSideSubmission(); | ||
| let { | ||
| action, | ||
| method, | ||
| encType, | ||
| formData, | ||
| body | ||
| } = getFormSubmissionInfo(target, basename); | ||
| !(fetcherRouteId != null) ? process.env.NODE_ENV !== "production" ? UNSAFE_invariant(false, "No routeId available for useFetcher()") : UNSAFE_invariant(false) : void 0; | ||
| router.fetch(fetcherKey, fetcherRouteId, options.action || action, { | ||
| preventScrollReset: options.preventScrollReset, | ||
| formData, | ||
| body, | ||
| formMethod: options.method || method, | ||
| formEncType: options.encType || encType | ||
| }); | ||
| }, [router, basename, fetcherKey, fetcherRouteId]); | ||
| } | ||
| // v7: Eventually we should deprecate this entirely in favor of using the | ||
| // router method directly? | ||
| function useFormAction(action, _temp2) { | ||
| let { | ||
| relative | ||
| } = _temp2 === void 0 ? {} : _temp2; | ||
| let { | ||
| basename | ||
| } = React.useContext(UNSAFE_NavigationContext); | ||
| let routeContext = React.useContext(UNSAFE_RouteContext); | ||
| !routeContext ? process.env.NODE_ENV !== "production" ? UNSAFE_invariant(false, "useFormAction must be used inside a RouteContext") : UNSAFE_invariant(false) : void 0; | ||
| let [match] = routeContext.matches.slice(-1); | ||
| // Shallow clone path so we can modify it below, otherwise we modify the | ||
| // object referenced by useMemo inside useResolvedPath | ||
| let path = _extends({}, useResolvedPath(action ? action : ".", { | ||
| relative | ||
| })); | ||
| // Previously we set the default action to ".". The problem with this is that | ||
| // `useResolvedPath(".")` excludes search params of the resolved URL. This is | ||
| // the intended behavior of when "." is specifically provided as | ||
| // the form action, but inconsistent w/ browsers when the action is omitted. | ||
| // https://github.com/remix-run/remix/issues/927 | ||
| let location = useLocation(); | ||
| if (action == null) { | ||
| // Safe to write to this directly here since if action was undefined, we | ||
| // would have called useResolvedPath(".") which will never include a search | ||
| path.search = location.search; | ||
| // When grabbing search params from the URL, remove the automatically | ||
| // inserted ?index param so we match the useResolvedPath search behavior | ||
| // which would not include ?index | ||
| if (match.route.index) { | ||
| let params = new URLSearchParams(path.search); | ||
| params.delete("index"); | ||
| path.search = params.toString() ? "?" + params.toString() : ""; | ||
| } | ||
| } | ||
| if ((!action || action === ".") && match.route.index) { | ||
| path.search = path.search ? path.search.replace(/^\?/, "?index&") : "?index"; | ||
| } | ||
| // If we're operating within a basename, prepend it to the pathname prior | ||
| // to creating the form action. If this is a root navigation, then just use | ||
| // the raw basename which allows the basename to have full control over the | ||
| // presence of a trailing slash on root actions | ||
| if (basename !== "/") { | ||
| path.pathname = path.pathname === "/" ? basename : joinPaths([basename, path.pathname]); | ||
| } | ||
| return createPath(path); | ||
| } | ||
| function createFetcherForm(fetcherKey, routeId) { | ||
| let FetcherForm = /*#__PURE__*/React.forwardRef((props, ref) => { | ||
| let submit = useSubmitFetcher(fetcherKey, routeId); | ||
| return /*#__PURE__*/React.createElement(FormImpl, _extends({}, props, { | ||
| ref: ref, | ||
| submit: submit | ||
| })); | ||
| }); | ||
| if (process.env.NODE_ENV !== "production") { | ||
| FetcherForm.displayName = "fetcher.Form"; | ||
| } | ||
| return FetcherForm; | ||
| } | ||
| let fetcherId = 0; | ||
| // TODO: (v7) Change the useFetcher generic default from `any` to `unknown` | ||
| /** | ||
| * Interacts with route loaders and actions without causing a navigation. Great | ||
| * for any interaction that stays on the same page. | ||
| */ | ||
| function useFetcher() { | ||
| var _route$matches; | ||
| let { | ||
| router | ||
| } = useDataRouterContext(DataRouterHook.UseFetcher); | ||
| let route = React.useContext(UNSAFE_RouteContext); | ||
| !route ? process.env.NODE_ENV !== "production" ? UNSAFE_invariant(false, "useFetcher must be used inside a RouteContext") : UNSAFE_invariant(false) : void 0; | ||
| let routeId = (_route$matches = route.matches[route.matches.length - 1]) == null ? void 0 : _route$matches.route.id; | ||
| !(routeId != null) ? process.env.NODE_ENV !== "production" ? UNSAFE_invariant(false, "useFetcher can only be used on routes that contain a unique \"id\"") : UNSAFE_invariant(false) : void 0; | ||
| let [fetcherKey] = React.useState(() => String(++fetcherId)); | ||
| let [Form] = React.useState(() => { | ||
| !routeId ? process.env.NODE_ENV !== "production" ? UNSAFE_invariant(false, "No routeId available for fetcher.Form()") : UNSAFE_invariant(false) : void 0; | ||
| return createFetcherForm(fetcherKey, routeId); | ||
| }); | ||
| let [load] = React.useState(() => href => { | ||
| !router ? process.env.NODE_ENV !== "production" ? UNSAFE_invariant(false, "No router available for fetcher.load()") : UNSAFE_invariant(false) : void 0; | ||
| !routeId ? process.env.NODE_ENV !== "production" ? UNSAFE_invariant(false, "No routeId available for fetcher.load()") : UNSAFE_invariant(false) : void 0; | ||
| router.fetch(fetcherKey, routeId, href); | ||
| }); | ||
| let submit = useSubmitFetcher(fetcherKey, routeId); | ||
| let fetcher = router.getFetcher(fetcherKey); | ||
| let fetcherWithComponents = React.useMemo(() => _extends({ | ||
| Form, | ||
| submit, | ||
| load | ||
| }, fetcher), [fetcher, Form, submit, load]); | ||
| React.useEffect(() => { | ||
| // Is this busted when the React team gets real weird and calls effects | ||
| // twice on mount? We really just need to garbage collect here when this | ||
| // fetcher is no longer around. | ||
| return () => { | ||
| if (!router) { | ||
| console.warn("No router available to clean up from useFetcher()"); | ||
| return; | ||
| } | ||
| router.deleteFetcher(fetcherKey); | ||
| }; | ||
| }, [router, fetcherKey]); | ||
| return fetcherWithComponents; | ||
| } | ||
| /** | ||
| * Provides all fetchers currently on the page. Useful for layouts and parent | ||
| * routes that need to provide pending/optimistic UI regarding the fetch. | ||
| */ | ||
| function useFetchers() { | ||
| let state = useDataRouterState(DataRouterStateHook.UseFetchers); | ||
| return [...state.fetchers.values()]; | ||
| } | ||
| const SCROLL_RESTORATION_STORAGE_KEY = "react-router-scroll-positions"; | ||
| let savedScrollPositions = {}; | ||
| /** | ||
| * When rendered inside a RouterProvider, will restore scroll positions on navigations | ||
| */ | ||
| function useScrollRestoration(_temp3) { | ||
| let { | ||
| getKey, | ||
| storageKey | ||
| } = _temp3 === void 0 ? {} : _temp3; | ||
| let { | ||
| router | ||
| } = useDataRouterContext(DataRouterHook.UseScrollRestoration); | ||
| let { | ||
| restoreScrollPosition, | ||
| preventScrollReset | ||
| } = useDataRouterState(DataRouterStateHook.UseScrollRestoration); | ||
| let { | ||
| basename | ||
| } = React.useContext(UNSAFE_NavigationContext); | ||
| let location = useLocation(); | ||
| let matches = useMatches(); | ||
| let navigation = useNavigation(); | ||
| // Trigger manual scroll restoration while we're active | ||
| React.useEffect(() => { | ||
| window.history.scrollRestoration = "manual"; | ||
| return () => { | ||
| window.history.scrollRestoration = "auto"; | ||
| }; | ||
| }, []); | ||
| // Save positions on pagehide | ||
| usePageHide(React.useCallback(() => { | ||
| if (navigation.state === "idle") { | ||
| let key = (getKey ? getKey(location, matches) : null) || location.key; | ||
| savedScrollPositions[key] = window.scrollY; | ||
| } | ||
| try { | ||
| sessionStorage.setItem(storageKey || SCROLL_RESTORATION_STORAGE_KEY, JSON.stringify(savedScrollPositions)); | ||
| } catch (error) { | ||
| process.env.NODE_ENV !== "production" ? UNSAFE_warning(false, "Failed to save scroll positions in sessionStorage, <ScrollRestoration /> will not work properly (" + error + ").") : void 0; | ||
| } | ||
| window.history.scrollRestoration = "auto"; | ||
| }, [storageKey, getKey, navigation.state, location, matches])); | ||
| // Read in any saved scroll locations | ||
| if (typeof document !== "undefined") { | ||
| // eslint-disable-next-line react-hooks/rules-of-hooks | ||
| React.useLayoutEffect(() => { | ||
| try { | ||
| let sessionPositions = sessionStorage.getItem(storageKey || SCROLL_RESTORATION_STORAGE_KEY); | ||
| if (sessionPositions) { | ||
| savedScrollPositions = JSON.parse(sessionPositions); | ||
| } | ||
| } catch (e) { | ||
| // no-op, use default empty object | ||
| } | ||
| }, [storageKey]); | ||
| // Enable scroll restoration in the router | ||
| // eslint-disable-next-line react-hooks/rules-of-hooks | ||
| React.useLayoutEffect(() => { | ||
| let getKeyWithoutBasename = getKey && basename !== "/" ? (location, matches) => getKey( // Strip the basename to match useLocation() | ||
| _extends({}, location, { | ||
| pathname: stripBasename(location.pathname, basename) || location.pathname | ||
| }), matches) : getKey; | ||
| let disableScrollRestoration = router == null ? void 0 : router.enableScrollRestoration(savedScrollPositions, () => window.scrollY, getKeyWithoutBasename); | ||
| return () => disableScrollRestoration && disableScrollRestoration(); | ||
| }, [router, basename, getKey]); | ||
| // Restore scrolling when state.restoreScrollPosition changes | ||
| // eslint-disable-next-line react-hooks/rules-of-hooks | ||
| React.useLayoutEffect(() => { | ||
| // Explicit false means don't do anything (used for submissions) | ||
| if (restoreScrollPosition === false) { | ||
| return; | ||
| } | ||
| // been here before, scroll to it | ||
| if (typeof restoreScrollPosition === "number") { | ||
| window.scrollTo(0, restoreScrollPosition); | ||
| return; | ||
| } | ||
| // try to scroll to the hash | ||
| if (location.hash) { | ||
| let el = document.getElementById(decodeURIComponent(location.hash.slice(1))); | ||
| if (el) { | ||
| el.scrollIntoView(); | ||
| return; | ||
| } | ||
| } | ||
| // Don't reset if this navigation opted out | ||
| if (preventScrollReset === true) { | ||
| return; | ||
| } | ||
| // otherwise go to the top on new locations | ||
| window.scrollTo(0, 0); | ||
| }, [location, restoreScrollPosition, preventScrollReset]); | ||
| } | ||
| } | ||
| /** | ||
| * Setup a callback to be fired on the window's `beforeunload` event. This is | ||
| * useful for saving some data to `window.localStorage` just before the page | ||
| * refreshes. | ||
| * | ||
| * Note: The `callback` argument should be a function created with | ||
| * `React.useCallback()`. | ||
| */ | ||
| function useBeforeUnload(callback, options) { | ||
| let { | ||
| capture | ||
| } = options || {}; | ||
| React.useEffect(() => { | ||
| let opts = capture != null ? { | ||
| capture | ||
| } : undefined; | ||
| window.addEventListener("beforeunload", callback, opts); | ||
| return () => { | ||
| window.removeEventListener("beforeunload", callback, opts); | ||
| }; | ||
| }, [callback, capture]); | ||
| } | ||
| /** | ||
| * Setup a callback to be fired on the window's `pagehide` event. This is | ||
| * useful for saving some data to `window.localStorage` just before the page | ||
| * refreshes. This event is better supported than beforeunload across browsers. | ||
| * | ||
| * Note: The `callback` argument should be a function created with | ||
| * `React.useCallback()`. | ||
| */ | ||
| function usePageHide(callback, options) { | ||
| let { | ||
| capture | ||
| } = options || {}; | ||
| React.useEffect(() => { | ||
| let opts = capture != null ? { | ||
| capture | ||
| } : undefined; | ||
| window.addEventListener("pagehide", callback, opts); | ||
| return () => { | ||
| window.removeEventListener("pagehide", callback, opts); | ||
| }; | ||
| }, [callback, capture]); | ||
| } | ||
| /** | ||
| * Wrapper around useBlocker to show a window.confirm prompt to users instead | ||
| * of building a custom UI with useBlocker. | ||
| * | ||
| * Warning: This has *a lot of rough edges* and behaves very differently (and | ||
| * very incorrectly in some cases) across browsers if user click addition | ||
| * back/forward navigations while the confirm is open. Use at your own risk. | ||
| */ | ||
| function usePrompt(_ref8) { | ||
| let { | ||
| when, | ||
| message | ||
| } = _ref8; | ||
| let blocker = unstable_useBlocker(when); | ||
| React.useEffect(() => { | ||
| if (blocker.state === "blocked") { | ||
| let proceed = window.confirm(message); | ||
| if (proceed) { | ||
| // This timeout is needed to avoid a weird "race" on POP navigations | ||
| // between the `window.history` revert navigation and the result of | ||
| // `window.confirm` | ||
| setTimeout(blocker.proceed, 0); | ||
| } else { | ||
| blocker.reset(); | ||
| } | ||
| } | ||
| }, [blocker, message]); | ||
| React.useEffect(() => { | ||
| if (blocker.state === "blocked" && !when) { | ||
| blocker.reset(); | ||
| } | ||
| }, [blocker, when]); | ||
| } | ||
| /** | ||
| * Return a boolean indicating if there is an active view transition to the | ||
| * given href. You can use this value to render CSS classes or viewTransitionName | ||
| * styles onto your elements | ||
| * | ||
| * @param href The destination href | ||
| * @param [opts.relative] Relative routing type ("route" | "path") | ||
| */ | ||
| function useViewTransitionState(to, opts) { | ||
| if (opts === void 0) { | ||
| opts = {}; | ||
| } | ||
| let vtContext = React.useContext(UNSAFE_ViewTransitionContext); | ||
| let { | ||
| basename | ||
| } = useDataRouterContext(DataRouterHook.useViewTransitionState); | ||
| let path = useResolvedPath(to, { | ||
| relative: opts.relative | ||
| }); | ||
| if (vtContext.isTransitioning) { | ||
| let currentPath = stripBasename(vtContext.currentLocation.pathname, basename) || vtContext.currentLocation.pathname; | ||
| let nextPath = stripBasename(vtContext.nextLocation.pathname, basename) || vtContext.nextLocation.pathname; | ||
| // Transition is active if we're going to or coming from the indicated | ||
| // destination. This ensures that other PUSH navigations that reverse | ||
| // an indicated transition apply. I.e., on the list view you have: | ||
| // | ||
| // <NavLink to="/details/1" unstable_viewTransition> | ||
| // | ||
| // If you click the breadcrumb back to the list view: | ||
| // | ||
| // <NavLink to="/list" unstable_viewTransition> | ||
| // | ||
| // We should apply the transition because it's indicated as active going | ||
| // from /list -> /details/1 and therefore should be active on the reverse | ||
| // (even though this isn't strictly a POP reverse) | ||
| return matchPath(path.pathname, nextPath) != null || matchPath(path.pathname, currentPath) != null; | ||
| } | ||
| return false; | ||
| } | ||
| //#endregion | ||
| export { BrowserRouter, Form, HashRouter, Link, NavLink, ScrollRestoration, useScrollRestoration as UNSAFE_useScrollRestoration, createBrowserRouter, createHashRouter, createSearchParams, HistoryRouter as unstable_HistoryRouter, usePrompt as unstable_usePrompt, useViewTransitionState as unstable_useViewTransitionState, useBeforeUnload, useFetcher, useFetchers, useFormAction, useLinkClickHandler, useSearchParams, useSubmit }; | ||
| //# sourceMappingURL=index.js.map |
| /** | ||
| * React Router DOM v0.0.0-experimental-4a8a492a | ||
| * React Router DOM v0.0.0-experimental-4ed3f5da9 | ||
| * | ||
@@ -4,0 +4,0 @@ * Copyright (c) Remix Software Inc. |
| /** | ||
| * React Router DOM v0.0.0-experimental-4a8a492a | ||
| * React Router DOM v0.0.0-experimental-4ed3f5da9 | ||
| * | ||
@@ -11,1140 +11,9 @@ * Copyright (c) Remix Software Inc. | ||
| */ | ||
| import * as React from 'react'; | ||
| import { UNSAFE_mapRouteProperties, Router, UNSAFE_NavigationContext, useHref, useResolvedPath, useLocation, UNSAFE_DataRouterStateContext, useNavigate, createPath, UNSAFE_useRouteId, UNSAFE_RouteContext, useMatches, useNavigation, unstable_useBlocker, UNSAFE_ViewTransitionContext, UNSAFE_DataRouterContext } from 'react-router'; | ||
| export { AbortedDeferredError, Await, MemoryRouter, Navigate, NavigationType, Outlet, Route, Router, RouterProvider, Routes, UNSAFE_DataRouterContext, UNSAFE_DataRouterStateContext, UNSAFE_LocationContext, UNSAFE_NavigationContext, UNSAFE_RouteContext, UNSAFE_ViewTransitionContext, UNSAFE_useRouteId, createMemoryRouter, createPath, createRoutesFromChildren, createRoutesFromElements, defer, generatePath, isRouteErrorResponse, json, matchPath, matchRoutes, parsePath, redirect, redirectDocument, renderMatches, resolvePath, unstable_useBlocker, useActionData, useAsyncError, useAsyncValue, useHref, useInRouterContext, useLoaderData, useLocation, useMatch, useMatches, useNavigate, useNavigation, useNavigationType, useOutlet, useOutletContext, useParams, useResolvedPath, useRevalidator, useRouteError, useRouteLoaderData, useRoutes } from 'react-router'; | ||
| import { stripBasename, UNSAFE_warning, createRouter, createBrowserHistory, createHashHistory, UNSAFE_ErrorResponseImpl, UNSAFE_invariant, joinPaths, matchPath } from '@remix-run/router'; | ||
| export { AbortedDeferredError, Await, BrowserRouter, Form, HashRouter, HydratedRouter, Link, Links, MemoryRouter, Meta, NavLink, Navigate, NavigationType, Outlet, PrefetchPageLinks, RemixServer, Route, Router, RouterProvider, Routes, Scripts, ScrollRestoration, StaticRouter, StaticRouterProvider, UNSAFE_DEFERRED_SYMBOL, UNSAFE_DataRouterContext, UNSAFE_DataRouterStateContext, UNSAFE_ErrorResponseImpl, UNSAFE_FetchersContext, UNSAFE_LocationContext, UNSAFE_NavigationContext, UNSAFE_RemixContext, UNSAFE_RouteContext, UNSAFE_SingleFetchRedirectSymbol, UNSAFE_ViewTransitionContext, UNSAFE_convertRoutesToDataRoutes, UNSAFE_decodeViaTurboStream, UNSAFE_mapRouteProperties, UNSAFE_useRouteId, UNSAFE_useRoutesImpl, UNSAFE_useScrollRestoration, createBrowserRouter, createHashRouter, createMemoryRouter, createPath, createRemixStub, createRoutesFromChildren, createRoutesFromChildren as createRoutesFromElements, createSearchParams, createStaticHandler, createStaticRouter, defer, generatePath, getStaticContextFromError, isRouteErrorResponse, json, matchPath, matchRoutes, parsePath, redirect, redirectDocument, renderMatches, resolvePath, stripBasename, unstable_HistoryRouter, unstable_usePrompt, unstable_useViewTransitionState, useActionData, useAsyncError, useAsyncValue, useBeforeUnload, useBlocker, useFetcher, useFetchers, useFormAction, useHref, useInRouterContext, useLinkClickHandler, useLoaderData, useLocation, useMatch, useMatches, useNavigate, useNavigation, useNavigationType, useOutlet, useOutletContext, useParams, useResolvedPath, useRevalidator, useRouteError, useRouteLoaderData, useRoutes, useSearchParams, useSubmit } from 'react-router'; | ||
| const defaultMethod = "get"; | ||
| const defaultEncType = "application/x-www-form-urlencoded"; | ||
| function isHtmlElement(object) { | ||
| return object != null && typeof object.tagName === "string"; | ||
| let alreadyWarned = false; | ||
| if (!alreadyWarned && typeof console !== "undefined") { | ||
| alreadyWarned = true; | ||
| console.warn("The `react-router-dom` package is deprecated in v7, you can change all " + "of your imports to load directly from the `react-router` package."); | ||
| } | ||
| function isButtonElement(object) { | ||
| return isHtmlElement(object) && object.tagName.toLowerCase() === "button"; | ||
| } | ||
| function isFormElement(object) { | ||
| return isHtmlElement(object) && object.tagName.toLowerCase() === "form"; | ||
| } | ||
| function isInputElement(object) { | ||
| return isHtmlElement(object) && object.tagName.toLowerCase() === "input"; | ||
| } | ||
| function isModifiedEvent(event) { | ||
| return !!(event.metaKey || event.altKey || event.ctrlKey || event.shiftKey); | ||
| } | ||
| function shouldProcessLinkClick(event, target) { | ||
| return event.button === 0 && ( | ||
| // Ignore everything but left clicks | ||
| !target || target === "_self") && | ||
| // Let browser handle "target=_blank" etc. | ||
| !isModifiedEvent(event) // Ignore clicks with modifier keys | ||
| ; | ||
| } | ||
| /** | ||
| * Creates a URLSearchParams object using the given initializer. | ||
| * | ||
| * This is identical to `new URLSearchParams(init)` except it also | ||
| * supports arrays as values in the object form of the initializer | ||
| * instead of just strings. This is convenient when you need multiple | ||
| * values for a given key, but don't want to use an array initializer. | ||
| * | ||
| * For example, instead of: | ||
| * | ||
| * let searchParams = new URLSearchParams([ | ||
| * ['sort', 'name'], | ||
| * ['sort', 'price'] | ||
| * ]); | ||
| * | ||
| * you can do: | ||
| * | ||
| * let searchParams = createSearchParams({ | ||
| * sort: ['name', 'price'] | ||
| * }); | ||
| */ | ||
| function createSearchParams(init = "") { | ||
| return new URLSearchParams(typeof init === "string" || Array.isArray(init) || init instanceof URLSearchParams ? init : Object.keys(init).reduce((memo, key) => { | ||
| let value = init[key]; | ||
| return memo.concat(Array.isArray(value) ? value.map(v => [key, v]) : [[key, value]]); | ||
| }, [])); | ||
| } | ||
| function getSearchParamsForLocation(locationSearch, defaultSearchParams) { | ||
| let searchParams = createSearchParams(locationSearch); | ||
| if (defaultSearchParams) { | ||
| // Use `defaultSearchParams.forEach(...)` here instead of iterating of | ||
| // `defaultSearchParams.keys()` to work-around a bug in Firefox related to | ||
| // web extensions. Relevant Bugzilla tickets: | ||
| // https://bugzilla.mozilla.org/show_bug.cgi?id=1414602 | ||
| // https://bugzilla.mozilla.org/show_bug.cgi?id=1023984 | ||
| defaultSearchParams.forEach((_, key) => { | ||
| if (!searchParams.has(key)) { | ||
| defaultSearchParams.getAll(key).forEach(value => { | ||
| searchParams.append(key, value); | ||
| }); | ||
| } | ||
| }); | ||
| } | ||
| return searchParams; | ||
| } | ||
| // Thanks https://github.com/sindresorhus/type-fest! | ||
| // One-time check for submitter support | ||
| let _formDataSupportsSubmitter = null; | ||
| function isFormDataSubmitterSupported() { | ||
| if (_formDataSupportsSubmitter === null) { | ||
| try { | ||
| new FormData(document.createElement("form"), | ||
| // @ts-expect-error if FormData supports the submitter parameter, this will throw | ||
| 0); | ||
| _formDataSupportsSubmitter = false; | ||
| } catch (e) { | ||
| _formDataSupportsSubmitter = true; | ||
| } | ||
| } | ||
| return _formDataSupportsSubmitter; | ||
| } | ||
| const supportedFormEncTypes = new Set(["application/x-www-form-urlencoded", "multipart/form-data", "text/plain"]); | ||
| function getFormEncType(encType) { | ||
| if (encType != null && !supportedFormEncTypes.has(encType)) { | ||
| UNSAFE_warning(false, `"${encType}" is not a valid \`encType\` for \`<Form>\`/\`<fetcher.Form>\` ` + `and will default to "${defaultEncType}"`) ; | ||
| return null; | ||
| } | ||
| return encType; | ||
| } | ||
| function getFormSubmissionInfo(target, basename) { | ||
| let method; | ||
| let action; | ||
| let encType; | ||
| let formData; | ||
| let body; | ||
| if (isFormElement(target)) { | ||
| // When grabbing the action from the element, it will have had the basename | ||
| // prefixed to ensure non-JS scenarios work, so strip it since we'll | ||
| // re-prefix in the router | ||
| let attr = target.getAttribute("action"); | ||
| action = attr ? stripBasename(attr, basename) : null; | ||
| method = target.getAttribute("method") || defaultMethod; | ||
| encType = getFormEncType(target.getAttribute("enctype")) || defaultEncType; | ||
| formData = new FormData(target); | ||
| } else if (isButtonElement(target) || isInputElement(target) && (target.type === "submit" || target.type === "image")) { | ||
| let form = target.form; | ||
| if (form == null) { | ||
| throw new Error(`Cannot submit a <button> or <input type="submit"> without a <form>`); | ||
| } | ||
| // <button>/<input type="submit"> may override attributes of <form> | ||
| // When grabbing the action from the element, it will have had the basename | ||
| // prefixed to ensure non-JS scenarios work, so strip it since we'll | ||
| // re-prefix in the router | ||
| let attr = target.getAttribute("formaction") || form.getAttribute("action"); | ||
| action = attr ? stripBasename(attr, basename) : null; | ||
| method = target.getAttribute("formmethod") || form.getAttribute("method") || defaultMethod; | ||
| encType = getFormEncType(target.getAttribute("formenctype")) || getFormEncType(form.getAttribute("enctype")) || defaultEncType; | ||
| // Build a FormData object populated from a form and submitter | ||
| formData = new FormData(form, target); | ||
| // If this browser doesn't support the `FormData(el, submitter)` format, | ||
| // then tack on the submitter value at the end. This is a lightweight | ||
| // solution that is not 100% spec compliant. For complete support in older | ||
| // browsers, consider using the `formdata-submitter-polyfill` package | ||
| if (!isFormDataSubmitterSupported()) { | ||
| let { | ||
| name, | ||
| type, | ||
| value | ||
| } = target; | ||
| if (type === "image") { | ||
| let prefix = name ? `${name}.` : ""; | ||
| formData.append(`${prefix}x`, "0"); | ||
| formData.append(`${prefix}y`, "0"); | ||
| } else if (name) { | ||
| formData.append(name, value); | ||
| } | ||
| } | ||
| } else if (isHtmlElement(target)) { | ||
| throw new Error(`Cannot submit element that is not <form>, <button>, or ` + `<input type="submit|image">`); | ||
| } else { | ||
| method = defaultMethod; | ||
| action = null; | ||
| encType = defaultEncType; | ||
| body = target; | ||
| } | ||
| // Send body for <Form encType="text/plain" so we encode it into text | ||
| if (formData && encType === "text/plain") { | ||
| body = formData; | ||
| formData = undefined; | ||
| } | ||
| return { | ||
| action, | ||
| method: method.toLowerCase(), | ||
| encType, | ||
| formData, | ||
| body | ||
| }; | ||
| } | ||
| /** | ||
| * NOTE: If you refactor this to split up the modules into separate files, | ||
| * you'll need to update the rollup config for react-router-dom-v5-compat. | ||
| */ | ||
| //#endregion | ||
| //////////////////////////////////////////////////////////////////////////////// | ||
| //#region Routers | ||
| //////////////////////////////////////////////////////////////////////////////// | ||
| function createBrowserRouter(routes, opts) { | ||
| return createRouter({ | ||
| basename: opts?.basename, | ||
| future: { | ||
| ...opts?.future, | ||
| v7_prependBasename: true | ||
| }, | ||
| history: createBrowserHistory({ | ||
| window: opts?.window | ||
| }), | ||
| hydrationData: opts?.hydrationData || parseHydrationData(), | ||
| routes, | ||
| mapRouteProperties: UNSAFE_mapRouteProperties | ||
| }).initialize(); | ||
| } | ||
| function createHashRouter(routes, opts) { | ||
| return createRouter({ | ||
| basename: opts?.basename, | ||
| future: { | ||
| ...opts?.future, | ||
| v7_prependBasename: true | ||
| }, | ||
| history: createHashHistory({ | ||
| window: opts?.window | ||
| }), | ||
| hydrationData: opts?.hydrationData || parseHydrationData(), | ||
| routes, | ||
| mapRouteProperties: UNSAFE_mapRouteProperties | ||
| }).initialize(); | ||
| } | ||
| function parseHydrationData() { | ||
| let state = window?.__staticRouterHydrationData; | ||
| if (state && state.errors) { | ||
| state = { | ||
| ...state, | ||
| errors: deserializeErrors(state.errors) | ||
| }; | ||
| } | ||
| return state; | ||
| } | ||
| function deserializeErrors(errors) { | ||
| if (!errors) return null; | ||
| let entries = Object.entries(errors); | ||
| let serialized = {}; | ||
| for (let [key, val] of entries) { | ||
| // Hey you! If you change this, please change the corresponding logic in | ||
| // serializeErrors in react-router-dom/server.tsx :) | ||
| if (val && val.__type === "RouteErrorResponse") { | ||
| serialized[key] = new UNSAFE_ErrorResponseImpl(val.status, val.statusText, val.data, val.internal === true); | ||
| } else if (val && val.__type === "Error") { | ||
| // Attempt to reconstruct the right type of Error (i.e., ReferenceError) | ||
| if (val.__subType) { | ||
| let ErrorConstructor = window[val.__subType]; | ||
| if (typeof ErrorConstructor === "function") { | ||
| try { | ||
| // @ts-expect-error | ||
| let error = new ErrorConstructor(val.message); | ||
| // Wipe away the client-side stack trace. Nothing to fill it in with | ||
| // because we don't serialize SSR stack traces for security reasons | ||
| error.stack = ""; | ||
| serialized[key] = error; | ||
| } catch (e) { | ||
| // no-op - fall through and create a normal Error | ||
| } | ||
| } | ||
| } | ||
| if (serialized[key] == null) { | ||
| let error = new Error(val.message); | ||
| // Wipe away the client-side stack trace. Nothing to fill it in with | ||
| // because we don't serialize SSR stack traces for security reasons | ||
| error.stack = ""; | ||
| serialized[key] = error; | ||
| } | ||
| } else { | ||
| serialized[key] = val; | ||
| } | ||
| } | ||
| return serialized; | ||
| } | ||
| //#endregion | ||
| //////////////////////////////////////////////////////////////////////////////// | ||
| //#region Components | ||
| //////////////////////////////////////////////////////////////////////////////// | ||
| /** | ||
| Webpack + React 17 fails to compile on any of the following because webpack | ||
| complains that `startTransition` doesn't exist in `React`: | ||
| * import { startTransition } from "react" | ||
| * import * as React from from "react"; | ||
| "startTransition" in React ? React.startTransition(() => setState()) : setState() | ||
| * import * as React from from "react"; | ||
| "startTransition" in React ? React["startTransition"](() => setState()) : setState() | ||
| Moving it to a constant such as the following solves the Webpack/React 17 issue: | ||
| * import * as React from from "react"; | ||
| const START_TRANSITION = "startTransition"; | ||
| START_TRANSITION in React ? React[START_TRANSITION](() => setState()) : setState() | ||
| However, that introduces webpack/terser minification issues in production builds | ||
| in React 18 where minification/obfuscation ends up removing the call of | ||
| React.startTransition entirely from the first half of the ternary. Grabbing | ||
| this exported reference once up front resolves that issue. | ||
| See https://github.com/remix-run/react-router/issues/10579 | ||
| */ | ||
| const START_TRANSITION = "startTransition"; | ||
| const startTransitionImpl = React[START_TRANSITION]; | ||
| /** | ||
| * A `<Router>` for use in web browsers. Provides the cleanest URLs. | ||
| */ | ||
| function BrowserRouter({ | ||
| basename, | ||
| children, | ||
| future, | ||
| window | ||
| }) { | ||
| let historyRef = React.useRef(); | ||
| if (historyRef.current == null) { | ||
| historyRef.current = createBrowserHistory({ | ||
| window, | ||
| v5Compat: true | ||
| }); | ||
| } | ||
| let history = historyRef.current; | ||
| let [state, setStateImpl] = React.useState({ | ||
| action: history.action, | ||
| location: history.location | ||
| }); | ||
| let { | ||
| v7_startTransition | ||
| } = future || {}; | ||
| let setState = React.useCallback(newState => { | ||
| v7_startTransition && startTransitionImpl ? startTransitionImpl(() => setStateImpl(newState)) : setStateImpl(newState); | ||
| }, [setStateImpl, v7_startTransition]); | ||
| React.useLayoutEffect(() => history.listen(setState), [history, setState]); | ||
| return /*#__PURE__*/React.createElement(Router, { | ||
| basename: basename, | ||
| children: children, | ||
| location: state.location, | ||
| navigationType: state.action, | ||
| navigator: history | ||
| }); | ||
| } | ||
| /** | ||
| * A `<Router>` for use in web browsers. Stores the location in the hash | ||
| * portion of the URL so it is not sent to the server. | ||
| */ | ||
| function HashRouter({ | ||
| basename, | ||
| children, | ||
| future, | ||
| window | ||
| }) { | ||
| let historyRef = React.useRef(); | ||
| if (historyRef.current == null) { | ||
| historyRef.current = createHashHistory({ | ||
| window, | ||
| v5Compat: true | ||
| }); | ||
| } | ||
| let history = historyRef.current; | ||
| let [state, setStateImpl] = React.useState({ | ||
| action: history.action, | ||
| location: history.location | ||
| }); | ||
| let { | ||
| v7_startTransition | ||
| } = future || {}; | ||
| let setState = React.useCallback(newState => { | ||
| v7_startTransition && startTransitionImpl ? startTransitionImpl(() => setStateImpl(newState)) : setStateImpl(newState); | ||
| }, [setStateImpl, v7_startTransition]); | ||
| React.useLayoutEffect(() => history.listen(setState), [history, setState]); | ||
| return /*#__PURE__*/React.createElement(Router, { | ||
| basename: basename, | ||
| children: children, | ||
| location: state.location, | ||
| navigationType: state.action, | ||
| navigator: history | ||
| }); | ||
| } | ||
| /** | ||
| * A `<Router>` that accepts a pre-instantiated history object. It's important | ||
| * to note that using your own history object is highly discouraged and may add | ||
| * two versions of the history library to your bundles unless you use the same | ||
| * version of the history library that React Router uses internally. | ||
| */ | ||
| function HistoryRouter({ | ||
| basename, | ||
| children, | ||
| future, | ||
| history | ||
| }) { | ||
| let [state, setStateImpl] = React.useState({ | ||
| action: history.action, | ||
| location: history.location | ||
| }); | ||
| let { | ||
| v7_startTransition | ||
| } = future || {}; | ||
| let setState = React.useCallback(newState => { | ||
| v7_startTransition && startTransitionImpl ? startTransitionImpl(() => setStateImpl(newState)) : setStateImpl(newState); | ||
| }, [setStateImpl, v7_startTransition]); | ||
| React.useLayoutEffect(() => history.listen(setState), [history, setState]); | ||
| return /*#__PURE__*/React.createElement(Router, { | ||
| basename: basename, | ||
| children: children, | ||
| location: state.location, | ||
| navigationType: state.action, | ||
| navigator: history | ||
| }); | ||
| } | ||
| { | ||
| HistoryRouter.displayName = "unstable_HistoryRouter"; | ||
| } | ||
| const isBrowser = typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement !== "undefined"; | ||
| const ABSOLUTE_URL_REGEX = /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i; | ||
| /** | ||
| * The public API for rendering a history-aware `<a>`. | ||
| */ | ||
| const Link = /*#__PURE__*/React.forwardRef(function LinkWithRef({ | ||
| onClick, | ||
| relative, | ||
| reloadDocument, | ||
| replace, | ||
| state, | ||
| target, | ||
| to, | ||
| preventScrollReset, | ||
| unstable_viewTransition, | ||
| ...rest | ||
| }, ref) { | ||
| let { | ||
| basename | ||
| } = React.useContext(UNSAFE_NavigationContext); | ||
| // Rendered into <a href> for absolute URLs | ||
| let absoluteHref; | ||
| let isExternal = false; | ||
| if (typeof to === "string" && ABSOLUTE_URL_REGEX.test(to)) { | ||
| // Render the absolute href server- and client-side | ||
| absoluteHref = to; | ||
| // Only check for external origins client-side | ||
| if (isBrowser) { | ||
| try { | ||
| let currentUrl = new URL(window.location.href); | ||
| let targetUrl = to.startsWith("//") ? new URL(currentUrl.protocol + to) : new URL(to); | ||
| let path = stripBasename(targetUrl.pathname, basename); | ||
| if (targetUrl.origin === currentUrl.origin && path != null) { | ||
| // Strip the protocol/origin/basename for same-origin absolute URLs | ||
| to = path + targetUrl.search + targetUrl.hash; | ||
| } else { | ||
| isExternal = true; | ||
| } | ||
| } catch (e) { | ||
| // We can't do external URL detection without a valid URL | ||
| UNSAFE_warning(false, `<Link to="${to}"> contains an invalid URL which will probably break ` + `when clicked - please update to a valid URL path.`) ; | ||
| } | ||
| } | ||
| } | ||
| // Rendered into <a href> for relative URLs | ||
| let href = useHref(to, { | ||
| relative | ||
| }); | ||
| let internalOnClick = useLinkClickHandler(to, { | ||
| replace, | ||
| state, | ||
| target, | ||
| preventScrollReset, | ||
| relative, | ||
| unstable_viewTransition | ||
| }); | ||
| function handleClick(event) { | ||
| if (onClick) onClick(event); | ||
| if (!event.defaultPrevented) { | ||
| internalOnClick(event); | ||
| } | ||
| } | ||
| return ( | ||
| /*#__PURE__*/ | ||
| // eslint-disable-next-line jsx-a11y/anchor-has-content | ||
| React.createElement("a", Object.assign({}, rest, { | ||
| href: absoluteHref || href, | ||
| onClick: isExternal || reloadDocument ? onClick : handleClick, | ||
| ref: ref, | ||
| target: target | ||
| })) | ||
| ); | ||
| }); | ||
| { | ||
| Link.displayName = "Link"; | ||
| } | ||
| /** | ||
| * A `<Link>` wrapper that knows if it's "active" or not. | ||
| */ | ||
| const NavLink = /*#__PURE__*/React.forwardRef(function NavLinkWithRef({ | ||
| "aria-current": ariaCurrentProp = "page", | ||
| caseSensitive = false, | ||
| className: classNameProp = "", | ||
| end = false, | ||
| style: styleProp, | ||
| to, | ||
| unstable_viewTransition, | ||
| children, | ||
| ...rest | ||
| }, ref) { | ||
| let path = useResolvedPath(to, { | ||
| relative: rest.relative | ||
| }); | ||
| let location = useLocation(); | ||
| let routerState = React.useContext(UNSAFE_DataRouterStateContext); | ||
| let { | ||
| navigator | ||
| } = React.useContext(UNSAFE_NavigationContext); | ||
| let isTransitioning = useViewTransitionState(path) && unstable_viewTransition === true; | ||
| let toPathname = navigator.encodeLocation ? navigator.encodeLocation(path).pathname : path.pathname; | ||
| let locationPathname = location.pathname; | ||
| let nextLocationPathname = routerState && routerState.navigation && routerState.navigation.location ? routerState.navigation.location.pathname : null; | ||
| if (!caseSensitive) { | ||
| locationPathname = locationPathname.toLowerCase(); | ||
| nextLocationPathname = nextLocationPathname ? nextLocationPathname.toLowerCase() : null; | ||
| toPathname = toPathname.toLowerCase(); | ||
| } | ||
| let isActive = locationPathname === toPathname || !end && locationPathname.startsWith(toPathname) && locationPathname.charAt(toPathname.length) === "/"; | ||
| let isPending = nextLocationPathname != null && (nextLocationPathname === toPathname || !end && nextLocationPathname.startsWith(toPathname) && nextLocationPathname.charAt(toPathname.length) === "/"); | ||
| let renderProps = { | ||
| isActive, | ||
| isPending, | ||
| isTransitioning | ||
| }; | ||
| let ariaCurrent = isActive ? ariaCurrentProp : undefined; | ||
| let className; | ||
| if (typeof classNameProp === "function") { | ||
| className = classNameProp(renderProps); | ||
| } else { | ||
| // If the className prop is not a function, we use a default `active` | ||
| // class for <NavLink />s that are active. In v5 `active` was the default | ||
| // value for `activeClassName`, but we are removing that API and can still | ||
| // use the old default behavior for a cleaner upgrade path and keep the | ||
| // simple styling rules working as they currently do. | ||
| className = [classNameProp, isActive ? "active" : null, isPending ? "pending" : null, isTransitioning ? "transitioning" : null].filter(Boolean).join(" "); | ||
| } | ||
| let style = typeof styleProp === "function" ? styleProp(renderProps) : styleProp; | ||
| return /*#__PURE__*/React.createElement(Link, Object.assign({}, rest, { | ||
| "aria-current": ariaCurrent, | ||
| className: className, | ||
| ref: ref, | ||
| style: style, | ||
| to: to, | ||
| unstable_viewTransition: unstable_viewTransition | ||
| }), typeof children === "function" ? children(renderProps) : children); | ||
| }); | ||
| { | ||
| NavLink.displayName = "NavLink"; | ||
| } | ||
| /** | ||
| * A `@remix-run/router`-aware `<form>`. It behaves like a normal form except | ||
| * that the interaction with the server is with `fetch` instead of new document | ||
| * requests, allowing components to add nicer UX to the page as the form is | ||
| * submitted and returns with data. | ||
| */ | ||
| const Form = /*#__PURE__*/React.forwardRef((props, ref) => { | ||
| let submit = useSubmit(); | ||
| return /*#__PURE__*/React.createElement(FormImpl, Object.assign({}, props, { | ||
| submit: submit, | ||
| ref: ref | ||
| })); | ||
| }); | ||
| { | ||
| Form.displayName = "Form"; | ||
| } | ||
| const FormImpl = /*#__PURE__*/React.forwardRef(({ | ||
| reloadDocument, | ||
| replace, | ||
| state, | ||
| method: _method = defaultMethod, | ||
| action, | ||
| onSubmit, | ||
| submit, | ||
| relative, | ||
| preventScrollReset, | ||
| unstable_viewTransition, | ||
| ...props | ||
| }, forwardedRef) => { | ||
| let formMethod = _method.toLowerCase() === "get" ? "get" : "post"; | ||
| let formAction = useFormAction(action, { | ||
| relative | ||
| }); | ||
| let submitHandler = event => { | ||
| onSubmit && onSubmit(event); | ||
| if (event.defaultPrevented) return; | ||
| event.preventDefault(); | ||
| let submitter = event.nativeEvent.submitter; | ||
| let submitMethod = submitter?.getAttribute("formmethod") || _method; | ||
| submit(submitter || event.currentTarget, { | ||
| method: submitMethod, | ||
| replace, | ||
| state, | ||
| relative, | ||
| preventScrollReset, | ||
| unstable_viewTransition | ||
| }); | ||
| }; | ||
| return /*#__PURE__*/React.createElement("form", Object.assign({ | ||
| ref: forwardedRef, | ||
| method: formMethod, | ||
| action: formAction, | ||
| onSubmit: reloadDocument ? onSubmit : submitHandler | ||
| }, props)); | ||
| }); | ||
| { | ||
| FormImpl.displayName = "FormImpl"; | ||
| } | ||
| /** | ||
| * This component will emulate the browser's scroll restoration on location | ||
| * changes. | ||
| */ | ||
| function ScrollRestoration({ | ||
| getKey, | ||
| storageKey | ||
| }) { | ||
| useScrollRestoration({ | ||
| getKey, | ||
| storageKey | ||
| }); | ||
| return null; | ||
| } | ||
| { | ||
| ScrollRestoration.displayName = "ScrollRestoration"; | ||
| } | ||
| //#endregion | ||
| //////////////////////////////////////////////////////////////////////////////// | ||
| //#region Hooks | ||
| //////////////////////////////////////////////////////////////////////////////// | ||
| var DataRouterHook = /*#__PURE__*/function (DataRouterHook) { | ||
| DataRouterHook["UseScrollRestoration"] = "useScrollRestoration"; | ||
| DataRouterHook["UseSubmit"] = "useSubmit"; | ||
| DataRouterHook["UseSubmitFetcher"] = "useSubmitFetcher"; | ||
| DataRouterHook["UseFetcher"] = "useFetcher"; | ||
| DataRouterHook["useViewTransitionStates"] = "useViewTransitionStates"; | ||
| DataRouterHook["useViewTransitionState"] = "useViewTransitionState"; | ||
| return DataRouterHook; | ||
| }(DataRouterHook || {}); | ||
| var DataRouterStateHook = /*#__PURE__*/function (DataRouterStateHook) { | ||
| DataRouterStateHook["UseFetchers"] = "useFetchers"; | ||
| DataRouterStateHook["UseScrollRestoration"] = "useScrollRestoration"; | ||
| return DataRouterStateHook; | ||
| }(DataRouterStateHook || {}); | ||
| function getDataRouterConsoleError(hookName) { | ||
| return `${hookName} must be used within a data router. See https://reactrouter.com/routers/picking-a-router.`; | ||
| } | ||
| function useDataRouterContext(hookName) { | ||
| let ctx = React.useContext(UNSAFE_DataRouterContext); | ||
| !ctx ? UNSAFE_invariant(false, getDataRouterConsoleError(hookName)) : void 0; | ||
| return ctx; | ||
| } | ||
| function useDataRouterState(hookName) { | ||
| let state = React.useContext(UNSAFE_DataRouterStateContext); | ||
| !state ? UNSAFE_invariant(false, getDataRouterConsoleError(hookName)) : void 0; | ||
| return state; | ||
| } | ||
| /** | ||
| * Handles the click behavior for router `<Link>` components. This is useful if | ||
| * you need to create custom `<Link>` components with the same click behavior we | ||
| * use in our exported `<Link>`. | ||
| */ | ||
| function useLinkClickHandler(to, { | ||
| target, | ||
| replace: replaceProp, | ||
| state, | ||
| preventScrollReset, | ||
| relative, | ||
| unstable_viewTransition | ||
| } = {}) { | ||
| let navigate = useNavigate(); | ||
| let location = useLocation(); | ||
| let path = useResolvedPath(to, { | ||
| relative | ||
| }); | ||
| return React.useCallback(event => { | ||
| if (shouldProcessLinkClick(event, target)) { | ||
| event.preventDefault(); | ||
| // If the URL hasn't changed, a regular <a> will do a replace instead of | ||
| // a push, so do the same here unless the replace prop is explicitly set | ||
| let replace = replaceProp !== undefined ? replaceProp : createPath(location) === createPath(path); | ||
| navigate(to, { | ||
| replace, | ||
| state, | ||
| preventScrollReset, | ||
| relative, | ||
| unstable_viewTransition | ||
| }); | ||
| } | ||
| }, [location, navigate, path, replaceProp, state, target, to, preventScrollReset, relative, unstable_viewTransition]); | ||
| } | ||
| /** | ||
| * A convenient wrapper for reading and writing search parameters via the | ||
| * URLSearchParams interface. | ||
| */ | ||
| function useSearchParams(defaultInit) { | ||
| UNSAFE_warning(typeof URLSearchParams !== "undefined", `You cannot use the \`useSearchParams\` hook in a browser that does not ` + `support the URLSearchParams API. If you need to support Internet ` + `Explorer 11, we recommend you load a polyfill such as ` + `https://github.com/ungap/url-search-params\n\n` + `If you're unsure how to load polyfills, we recommend you check out ` + `https://polyfill.io/v3/ which provides some recommendations about how ` + `to load polyfills only for users that need them, instead of for every ` + `user.`) ; | ||
| let defaultSearchParamsRef = React.useRef(createSearchParams(defaultInit)); | ||
| let hasSetSearchParamsRef = React.useRef(false); | ||
| let location = useLocation(); | ||
| let searchParams = React.useMemo(() => | ||
| // Only merge in the defaults if we haven't yet called setSearchParams. | ||
| // Once we call that we want those to take precedence, otherwise you can't | ||
| // remove a param with setSearchParams({}) if it has an initial value | ||
| getSearchParamsForLocation(location.search, hasSetSearchParamsRef.current ? null : defaultSearchParamsRef.current), [location.search]); | ||
| let navigate = useNavigate(); | ||
| let setSearchParams = React.useCallback((nextInit, navigateOptions) => { | ||
| const newSearchParams = createSearchParams(typeof nextInit === "function" ? nextInit(searchParams) : nextInit); | ||
| hasSetSearchParamsRef.current = true; | ||
| navigate("?" + newSearchParams, navigateOptions); | ||
| }, [navigate, searchParams]); | ||
| return [searchParams, setSearchParams]; | ||
| } | ||
| /** | ||
| * Submits a HTML `<form>` to the server without reloading the page. | ||
| */ | ||
| /** | ||
| * Submits a fetcher `<form>` to the server without reloading the page. | ||
| */ | ||
| function validateClientSideSubmission() { | ||
| if (typeof document === "undefined") { | ||
| throw new Error("You are calling submit during the server render. " + "Try calling submit within a `useEffect` or callback instead."); | ||
| } | ||
| } | ||
| /** | ||
| * Returns a function that may be used to programmatically submit a form (or | ||
| * some arbitrary data) to the server. | ||
| */ | ||
| function useSubmit() { | ||
| let { | ||
| router | ||
| } = useDataRouterContext(DataRouterHook.UseSubmit); | ||
| let { | ||
| basename | ||
| } = React.useContext(UNSAFE_NavigationContext); | ||
| let currentRouteId = UNSAFE_useRouteId(); | ||
| return React.useCallback((target, options = {}) => { | ||
| validateClientSideSubmission(); | ||
| let { | ||
| action, | ||
| method, | ||
| encType, | ||
| formData, | ||
| body | ||
| } = getFormSubmissionInfo(target, basename); | ||
| router.navigate(options.action || action, { | ||
| preventScrollReset: options.preventScrollReset, | ||
| formData, | ||
| body, | ||
| formMethod: options.method || method, | ||
| formEncType: options.encType || encType, | ||
| replace: options.replace, | ||
| state: options.state, | ||
| fromRouteId: currentRouteId, | ||
| unstable_viewTransition: options.unstable_viewTransition | ||
| }); | ||
| }, [router, basename, currentRouteId]); | ||
| } | ||
| /** | ||
| * Returns the implementation for fetcher.submit | ||
| */ | ||
| function useSubmitFetcher(fetcherKey, fetcherRouteId) { | ||
| let { | ||
| router | ||
| } = useDataRouterContext(DataRouterHook.UseSubmitFetcher); | ||
| let { | ||
| basename | ||
| } = React.useContext(UNSAFE_NavigationContext); | ||
| return React.useCallback((target, options = {}) => { | ||
| validateClientSideSubmission(); | ||
| let { | ||
| action, | ||
| method, | ||
| encType, | ||
| formData, | ||
| body | ||
| } = getFormSubmissionInfo(target, basename); | ||
| !(fetcherRouteId != null) ? UNSAFE_invariant(false, "No routeId available for useFetcher()") : void 0; | ||
| router.fetch(fetcherKey, fetcherRouteId, options.action || action, { | ||
| preventScrollReset: options.preventScrollReset, | ||
| formData, | ||
| body, | ||
| formMethod: options.method || method, | ||
| formEncType: options.encType || encType | ||
| }); | ||
| }, [router, basename, fetcherKey, fetcherRouteId]); | ||
| } | ||
| // v7: Eventually we should deprecate this entirely in favor of using the | ||
| // router method directly? | ||
| function useFormAction(action, { | ||
| relative | ||
| } = {}) { | ||
| let { | ||
| basename | ||
| } = React.useContext(UNSAFE_NavigationContext); | ||
| let routeContext = React.useContext(UNSAFE_RouteContext); | ||
| !routeContext ? UNSAFE_invariant(false, "useFormAction must be used inside a RouteContext") : void 0; | ||
| let [match] = routeContext.matches.slice(-1); | ||
| // Shallow clone path so we can modify it below, otherwise we modify the | ||
| // object referenced by useMemo inside useResolvedPath | ||
| let path = { | ||
| ...useResolvedPath(action ? action : ".", { | ||
| relative | ||
| }) | ||
| }; | ||
| // Previously we set the default action to ".". The problem with this is that | ||
| // `useResolvedPath(".")` excludes search params of the resolved URL. This is | ||
| // the intended behavior of when "." is specifically provided as | ||
| // the form action, but inconsistent w/ browsers when the action is omitted. | ||
| // https://github.com/remix-run/remix/issues/927 | ||
| let location = useLocation(); | ||
| if (action == null) { | ||
| // Safe to write to this directly here since if action was undefined, we | ||
| // would have called useResolvedPath(".") which will never include a search | ||
| path.search = location.search; | ||
| // When grabbing search params from the URL, remove the automatically | ||
| // inserted ?index param so we match the useResolvedPath search behavior | ||
| // which would not include ?index | ||
| if (match.route.index) { | ||
| let params = new URLSearchParams(path.search); | ||
| params.delete("index"); | ||
| path.search = params.toString() ? `?${params.toString()}` : ""; | ||
| } | ||
| } | ||
| if ((!action || action === ".") && match.route.index) { | ||
| path.search = path.search ? path.search.replace(/^\?/, "?index&") : "?index"; | ||
| } | ||
| // If we're operating within a basename, prepend it to the pathname prior | ||
| // to creating the form action. If this is a root navigation, then just use | ||
| // the raw basename which allows the basename to have full control over the | ||
| // presence of a trailing slash on root actions | ||
| if (basename !== "/") { | ||
| path.pathname = path.pathname === "/" ? basename : joinPaths([basename, path.pathname]); | ||
| } | ||
| return createPath(path); | ||
| } | ||
| function createFetcherForm(fetcherKey, routeId) { | ||
| let FetcherForm = /*#__PURE__*/React.forwardRef((props, ref) => { | ||
| let submit = useSubmitFetcher(fetcherKey, routeId); | ||
| return /*#__PURE__*/React.createElement(FormImpl, Object.assign({}, props, { | ||
| ref: ref, | ||
| submit: submit | ||
| })); | ||
| }); | ||
| { | ||
| FetcherForm.displayName = "fetcher.Form"; | ||
| } | ||
| return FetcherForm; | ||
| } | ||
| let fetcherId = 0; | ||
| // TODO: (v7) Change the useFetcher generic default from `any` to `unknown` | ||
| /** | ||
| * Interacts with route loaders and actions without causing a navigation. Great | ||
| * for any interaction that stays on the same page. | ||
| */ | ||
| function useFetcher() { | ||
| let { | ||
| router | ||
| } = useDataRouterContext(DataRouterHook.UseFetcher); | ||
| let route = React.useContext(UNSAFE_RouteContext); | ||
| !route ? UNSAFE_invariant(false, `useFetcher must be used inside a RouteContext`) : void 0; | ||
| let routeId = route.matches[route.matches.length - 1]?.route.id; | ||
| !(routeId != null) ? UNSAFE_invariant(false, `useFetcher can only be used on routes that contain a unique "id"`) : void 0; | ||
| let [fetcherKey] = React.useState(() => String(++fetcherId)); | ||
| let [Form] = React.useState(() => { | ||
| !routeId ? UNSAFE_invariant(false, `No routeId available for fetcher.Form()`) : void 0; | ||
| return createFetcherForm(fetcherKey, routeId); | ||
| }); | ||
| let [load] = React.useState(() => href => { | ||
| !router ? UNSAFE_invariant(false, "No router available for fetcher.load()") : void 0; | ||
| !routeId ? UNSAFE_invariant(false, "No routeId available for fetcher.load()") : void 0; | ||
| router.fetch(fetcherKey, routeId, href); | ||
| }); | ||
| let submit = useSubmitFetcher(fetcherKey, routeId); | ||
| let fetcher = router.getFetcher(fetcherKey); | ||
| let fetcherWithComponents = React.useMemo(() => ({ | ||
| Form, | ||
| submit, | ||
| load, | ||
| ...fetcher | ||
| }), [fetcher, Form, submit, load]); | ||
| React.useEffect(() => { | ||
| // Is this busted when the React team gets real weird and calls effects | ||
| // twice on mount? We really just need to garbage collect here when this | ||
| // fetcher is no longer around. | ||
| return () => { | ||
| if (!router) { | ||
| console.warn(`No router available to clean up from useFetcher()`); | ||
| return; | ||
| } | ||
| router.deleteFetcher(fetcherKey); | ||
| }; | ||
| }, [router, fetcherKey]); | ||
| return fetcherWithComponents; | ||
| } | ||
| /** | ||
| * Provides all fetchers currently on the page. Useful for layouts and parent | ||
| * routes that need to provide pending/optimistic UI regarding the fetch. | ||
| */ | ||
| function useFetchers() { | ||
| let state = useDataRouterState(DataRouterStateHook.UseFetchers); | ||
| return [...state.fetchers.values()]; | ||
| } | ||
| const SCROLL_RESTORATION_STORAGE_KEY = "react-router-scroll-positions"; | ||
| let savedScrollPositions = {}; | ||
| /** | ||
| * When rendered inside a RouterProvider, will restore scroll positions on navigations | ||
| */ | ||
| function useScrollRestoration({ | ||
| getKey, | ||
| storageKey | ||
| } = {}) { | ||
| let { | ||
| router | ||
| } = useDataRouterContext(DataRouterHook.UseScrollRestoration); | ||
| let { | ||
| restoreScrollPosition, | ||
| preventScrollReset | ||
| } = useDataRouterState(DataRouterStateHook.UseScrollRestoration); | ||
| let { | ||
| basename | ||
| } = React.useContext(UNSAFE_NavigationContext); | ||
| let location = useLocation(); | ||
| let matches = useMatches(); | ||
| let navigation = useNavigation(); | ||
| // Trigger manual scroll restoration while we're active | ||
| React.useEffect(() => { | ||
| window.history.scrollRestoration = "manual"; | ||
| return () => { | ||
| window.history.scrollRestoration = "auto"; | ||
| }; | ||
| }, []); | ||
| // Save positions on pagehide | ||
| usePageHide(React.useCallback(() => { | ||
| if (navigation.state === "idle") { | ||
| let key = (getKey ? getKey(location, matches) : null) || location.key; | ||
| savedScrollPositions[key] = window.scrollY; | ||
| } | ||
| try { | ||
| sessionStorage.setItem(storageKey || SCROLL_RESTORATION_STORAGE_KEY, JSON.stringify(savedScrollPositions)); | ||
| } catch (error) { | ||
| UNSAFE_warning(false, `Failed to save scroll positions in sessionStorage, <ScrollRestoration /> will not work properly (${error}).`) ; | ||
| } | ||
| window.history.scrollRestoration = "auto"; | ||
| }, [storageKey, getKey, navigation.state, location, matches])); | ||
| // Read in any saved scroll locations | ||
| if (typeof document !== "undefined") { | ||
| // eslint-disable-next-line react-hooks/rules-of-hooks | ||
| React.useLayoutEffect(() => { | ||
| try { | ||
| let sessionPositions = sessionStorage.getItem(storageKey || SCROLL_RESTORATION_STORAGE_KEY); | ||
| if (sessionPositions) { | ||
| savedScrollPositions = JSON.parse(sessionPositions); | ||
| } | ||
| } catch (e) { | ||
| // no-op, use default empty object | ||
| } | ||
| }, [storageKey]); | ||
| // Enable scroll restoration in the router | ||
| // eslint-disable-next-line react-hooks/rules-of-hooks | ||
| React.useLayoutEffect(() => { | ||
| let getKeyWithoutBasename = getKey && basename !== "/" ? (location, matches) => getKey( | ||
| // Strip the basename to match useLocation() | ||
| { | ||
| ...location, | ||
| pathname: stripBasename(location.pathname, basename) || location.pathname | ||
| }, matches) : getKey; | ||
| let disableScrollRestoration = router?.enableScrollRestoration(savedScrollPositions, () => window.scrollY, getKeyWithoutBasename); | ||
| return () => disableScrollRestoration && disableScrollRestoration(); | ||
| }, [router, basename, getKey]); | ||
| // Restore scrolling when state.restoreScrollPosition changes | ||
| // eslint-disable-next-line react-hooks/rules-of-hooks | ||
| React.useLayoutEffect(() => { | ||
| // Explicit false means don't do anything (used for submissions) | ||
| if (restoreScrollPosition === false) { | ||
| return; | ||
| } | ||
| // been here before, scroll to it | ||
| if (typeof restoreScrollPosition === "number") { | ||
| window.scrollTo(0, restoreScrollPosition); | ||
| return; | ||
| } | ||
| // try to scroll to the hash | ||
| if (location.hash) { | ||
| let el = document.getElementById(decodeURIComponent(location.hash.slice(1))); | ||
| if (el) { | ||
| el.scrollIntoView(); | ||
| return; | ||
| } | ||
| } | ||
| // Don't reset if this navigation opted out | ||
| if (preventScrollReset === true) { | ||
| return; | ||
| } | ||
| // otherwise go to the top on new locations | ||
| window.scrollTo(0, 0); | ||
| }, [location, restoreScrollPosition, preventScrollReset]); | ||
| } | ||
| } | ||
| /** | ||
| * Setup a callback to be fired on the window's `beforeunload` event. This is | ||
| * useful for saving some data to `window.localStorage` just before the page | ||
| * refreshes. | ||
| * | ||
| * Note: The `callback` argument should be a function created with | ||
| * `React.useCallback()`. | ||
| */ | ||
| function useBeforeUnload(callback, options) { | ||
| let { | ||
| capture | ||
| } = options || {}; | ||
| React.useEffect(() => { | ||
| let opts = capture != null ? { | ||
| capture | ||
| } : undefined; | ||
| window.addEventListener("beforeunload", callback, opts); | ||
| return () => { | ||
| window.removeEventListener("beforeunload", callback, opts); | ||
| }; | ||
| }, [callback, capture]); | ||
| } | ||
| /** | ||
| * Setup a callback to be fired on the window's `pagehide` event. This is | ||
| * useful for saving some data to `window.localStorage` just before the page | ||
| * refreshes. This event is better supported than beforeunload across browsers. | ||
| * | ||
| * Note: The `callback` argument should be a function created with | ||
| * `React.useCallback()`. | ||
| */ | ||
| function usePageHide(callback, options) { | ||
| let { | ||
| capture | ||
| } = options || {}; | ||
| React.useEffect(() => { | ||
| let opts = capture != null ? { | ||
| capture | ||
| } : undefined; | ||
| window.addEventListener("pagehide", callback, opts); | ||
| return () => { | ||
| window.removeEventListener("pagehide", callback, opts); | ||
| }; | ||
| }, [callback, capture]); | ||
| } | ||
| /** | ||
| * Wrapper around useBlocker to show a window.confirm prompt to users instead | ||
| * of building a custom UI with useBlocker. | ||
| * | ||
| * Warning: This has *a lot of rough edges* and behaves very differently (and | ||
| * very incorrectly in some cases) across browsers if user click addition | ||
| * back/forward navigations while the confirm is open. Use at your own risk. | ||
| */ | ||
| function usePrompt({ | ||
| when, | ||
| message | ||
| }) { | ||
| let blocker = unstable_useBlocker(when); | ||
| React.useEffect(() => { | ||
| if (blocker.state === "blocked") { | ||
| let proceed = window.confirm(message); | ||
| if (proceed) { | ||
| // This timeout is needed to avoid a weird "race" on POP navigations | ||
| // between the `window.history` revert navigation and the result of | ||
| // `window.confirm` | ||
| setTimeout(blocker.proceed, 0); | ||
| } else { | ||
| blocker.reset(); | ||
| } | ||
| } | ||
| }, [blocker, message]); | ||
| React.useEffect(() => { | ||
| if (blocker.state === "blocked" && !when) { | ||
| blocker.reset(); | ||
| } | ||
| }, [blocker, when]); | ||
| } | ||
| /** | ||
| * Return a boolean indicating if there is an active view transition to the | ||
| * given href. You can use this value to render CSS classes or viewTransitionName | ||
| * styles onto your elements | ||
| * | ||
| * @param href The destination href | ||
| * @param [opts.relative] Relative routing type ("route" | "path") | ||
| */ | ||
| function useViewTransitionState(to, opts = {}) { | ||
| let vtContext = React.useContext(UNSAFE_ViewTransitionContext); | ||
| let { | ||
| basename | ||
| } = useDataRouterContext(DataRouterHook.useViewTransitionState); | ||
| let path = useResolvedPath(to, { | ||
| relative: opts.relative | ||
| }); | ||
| if (vtContext.isTransitioning) { | ||
| let currentPath = stripBasename(vtContext.currentLocation.pathname, basename) || vtContext.currentLocation.pathname; | ||
| let nextPath = stripBasename(vtContext.nextLocation.pathname, basename) || vtContext.nextLocation.pathname; | ||
| // Transition is active if we're going to or coming from the indicated | ||
| // destination. This ensures that other PUSH navigations that reverse | ||
| // an indicated transition apply. I.e., on the list view you have: | ||
| // | ||
| // <NavLink to="/details/1" unstable_viewTransition> | ||
| // | ||
| // If you click the breadcrumb back to the list view: | ||
| // | ||
| // <NavLink to="/list" unstable_viewTransition> | ||
| // | ||
| // We should apply the transition because it's indicated as active going | ||
| // from /list -> /details/1 and therefore should be active on the reverse | ||
| // (even though this isn't strictly a POP reverse) | ||
| return matchPath(path.pathname, nextPath) != null || matchPath(path.pathname, currentPath) != null; | ||
| } | ||
| return false; | ||
| } | ||
| //#endregion | ||
| export { BrowserRouter, Form, HashRouter, Link, NavLink, ScrollRestoration, useScrollRestoration as UNSAFE_useScrollRestoration, createBrowserRouter, createHashRouter, createSearchParams, HistoryRouter as unstable_HistoryRouter, usePrompt as unstable_usePrompt, useViewTransitionState as unstable_useViewTransitionState, useBeforeUnload, useFetcher, useFetchers, useFormAction, useLinkClickHandler, useSearchParams, useSubmit }; | ||
| //# sourceMappingURL=react-router-dom.development.js.map |
| /** | ||
| * React Router DOM v0.0.0-experimental-4a8a492a | ||
| * React Router DOM v0.0.0-experimental-4ed3f5da9 | ||
| * | ||
@@ -11,3 +11,3 @@ * Copyright (c) Remix Software Inc. | ||
| */ | ||
| import*as e from"react";import{UNSAFE_mapRouteProperties as t,Router as n,UNSAFE_NavigationContext as r,useHref as a,useResolvedPath as o,useLocation as i,UNSAFE_DataRouterStateContext as s,useNavigate as u,createPath as l,UNSAFE_useRouteId as c,UNSAFE_RouteContext as f,useMatches as m,useNavigation as d,unstable_useBlocker as p,UNSAFE_ViewTransitionContext as h,UNSAFE_DataRouterContext as w}from"react-router";export{AbortedDeferredError,Await,MemoryRouter,Navigate,NavigationType,Outlet,Route,Router,RouterProvider,Routes,UNSAFE_DataRouterContext,UNSAFE_DataRouterStateContext,UNSAFE_LocationContext,UNSAFE_NavigationContext,UNSAFE_RouteContext,UNSAFE_ViewTransitionContext,UNSAFE_useRouteId,createMemoryRouter,createPath,createRoutesFromChildren,createRoutesFromElements,defer,generatePath,isRouteErrorResponse,json,matchPath,matchRoutes,parsePath,redirect,redirectDocument,renderMatches,resolvePath,unstable_useBlocker,useActionData,useAsyncError,useAsyncValue,useHref,useInRouterContext,useLoaderData,useLocation,useMatch,useMatches,useNavigate,useNavigation,useNavigationType,useOutlet,useOutletContext,useParams,useResolvedPath,useRevalidator,useRouteError,useRouteLoaderData,useRoutes}from"react-router";import{stripBasename as b,createRouter as v,createBrowserHistory as y,createHashHistory as g,UNSAFE_ErrorResponseImpl as R,UNSAFE_invariant as S,joinPaths as E,matchPath as C}from"@remix-run/router";const T="application/x-www-form-urlencoded";function _(e){return null!=e&&"string"==typeof e.tagName}function x(e=""){return new URLSearchParams("string"==typeof e||Array.isArray(e)||e instanceof URLSearchParams?e:Object.keys(e).reduce(((t,n)=>{let r=e[n];return t.concat(Array.isArray(r)?r.map((e=>[n,e])):[[n,r]])}),[]))}let L=null;const A=new Set(["application/x-www-form-urlencoded","multipart/form-data","text/plain"]);function U(e){return null==e||A.has(e)?e:null}function F(e,t){let n,r,a,o,i;if(_(s=e)&&"form"===s.tagName.toLowerCase()){let i=e.getAttribute("action");r=i?b(i,t):null,n=e.getAttribute("method")||"get",a=U(e.getAttribute("enctype"))||T,o=new FormData(e)}else if(function(e){return _(e)&&"button"===e.tagName.toLowerCase()}(e)||function(e){return _(e)&&"input"===e.tagName.toLowerCase()}(e)&&("submit"===e.type||"image"===e.type)){let i=e.form;if(null==i)throw new Error('Cannot submit a <button> or <input type="submit"> without a <form>');let s=e.getAttribute("formaction")||i.getAttribute("action");if(r=s?b(s,t):null,n=e.getAttribute("formmethod")||i.getAttribute("method")||"get",a=U(e.getAttribute("formenctype"))||U(i.getAttribute("enctype"))||T,o=new FormData(i,e),!function(){if(null===L)try{new FormData(document.createElement("form"),0),L=!1}catch(e){L=!0}return L}()){let{name:t,type:n,value:r}=e;if("image"===n){let e=t?`${t}.`:"";o.append(`${e}x`,"0"),o.append(`${e}y`,"0")}else t&&o.append(t,r)}}else{if(_(e))throw new Error('Cannot submit element that is not <form>, <button>, or <input type="submit|image">');n="get",r=null,a=T,i=e}var s;return o&&"text/plain"===a&&(i=o,o=void 0),{action:r,method:n.toLowerCase(),encType:a,formData:o,body:i}}function D(e,n){return v({basename:n?.basename,future:{...n?.future,v7_prependBasename:!0},history:y({window:n?.window}),hydrationData:n?.hydrationData||k(),routes:e,mapRouteProperties:t}).initialize()}function N(e,n){return v({basename:n?.basename,future:{...n?.future,v7_prependBasename:!0},history:g({window:n?.window}),hydrationData:n?.hydrationData||k(),routes:e,mapRouteProperties:t}).initialize()}function k(){let e=window?.__staticRouterHydrationData;return e&&e.errors&&(e={...e,errors:P(e.errors)}),e}function P(e){if(!e)return null;let t=Object.entries(e),n={};for(let[a,o]of t)if(o&&"RouteErrorResponse"===o.__type)n[a]=new R(o.status,o.statusText,o.data,!0===o.internal);else if(o&&"Error"===o.__type){if(o.__subType){let e=window[o.__subType];if("function"==typeof e)try{let t=new e(o.message);t.stack="",n[a]=t}catch(r){}}if(null==n[a]){let e=new Error(o.message);e.stack="",n[a]=e}}else n[a]=o;return n}const O=e.startTransition;function K({basename:t,children:r,future:a,window:o}){let i=e.useRef();null==i.current&&(i.current=y({window:o,v5Compat:!0}));let s=i.current,[u,l]=e.useState({action:s.action,location:s.location}),{v7_startTransition:c}=a||{},f=e.useCallback((e=>{c&&O?O((()=>l(e))):l(e)}),[l,c]);return e.useLayoutEffect((()=>s.listen(f)),[s,f]),e.createElement(n,{basename:t,children:r,location:u.location,navigationType:u.action,navigator:s})}function j({basename:t,children:r,future:a,window:o}){let i=e.useRef();null==i.current&&(i.current=g({window:o,v5Compat:!0}));let s=i.current,[u,l]=e.useState({action:s.action,location:s.location}),{v7_startTransition:c}=a||{},f=e.useCallback((e=>{c&&O?O((()=>l(e))):l(e)}),[l,c]);return e.useLayoutEffect((()=>s.listen(f)),[s,f]),e.createElement(n,{basename:t,children:r,location:u.location,navigationType:u.action,navigator:s})}function M({basename:t,children:r,future:a,history:o}){let[i,s]=e.useState({action:o.action,location:o.location}),{v7_startTransition:u}=a||{},l=e.useCallback((e=>{u&&O?O((()=>s(e))):s(e)}),[s,u]);return e.useLayoutEffect((()=>o.listen(l)),[o,l]),e.createElement(n,{basename:t,children:r,location:i.location,navigationType:i.action,navigator:o})}const V="undefined"!=typeof window&&void 0!==window.document&&void 0!==window.document.createElement,I=/^(?:[a-z][a-z0-9+.-]*:|\/\/)/i,B=e.forwardRef((function({onClick:t,relative:n,reloadDocument:o,replace:i,state:s,target:u,to:l,preventScrollReset:c,unstable_viewTransition:f,...m},d){let p,{basename:h}=e.useContext(r),w=!1;if("string"==typeof l&&I.test(l)&&(p=l,V))try{let e=new URL(window.location.href),t=l.startsWith("//")?new URL(e.protocol+l):new URL(l),n=b(t.pathname,h);t.origin===e.origin&&null!=n?l=n+t.search+t.hash:w=!0}catch(g){}let v=a(l,{relative:n}),y=Q(l,{replace:i,state:s,target:u,preventScrollReset:c,relative:n,unstable_viewTransition:f});return e.createElement("a",Object.assign({},m,{href:p||v,onClick:w||o?t:function(e){t&&t(e),e.defaultPrevented||y(e)},ref:d,target:u}))})),z=e.forwardRef((function({"aria-current":t="page",caseSensitive:n=!1,className:a="",end:u=!1,style:l,to:c,unstable_viewTransition:f,children:m,...d},p){let h=o(c,{relative:d.relative}),w=i(),b=e.useContext(s),{navigator:v}=e.useContext(r),y=ce(h)&&!0===f,g=v.encodeLocation?v.encodeLocation(h).pathname:h.pathname,R=w.pathname,S=b&&b.navigation&&b.navigation.location?b.navigation.location.pathname:null;n||(R=R.toLowerCase(),S=S?S.toLowerCase():null,g=g.toLowerCase());let E,C=R===g||!u&&R.startsWith(g)&&"/"===R.charAt(g.length),T=null!=S&&(S===g||!u&&S.startsWith(g)&&"/"===S.charAt(g.length)),_={isActive:C,isPending:T,isTransitioning:y},x=C?t:void 0;E="function"==typeof a?a(_):[a,C?"active":null,T?"pending":null,y?"transitioning":null].filter(Boolean).join(" ");let L="function"==typeof l?l(_):l;return e.createElement(B,Object.assign({},d,{"aria-current":x,className:E,ref:p,style:L,to:c,unstable_viewTransition:f}),"function"==typeof m?m(_):m)})),$=e.forwardRef(((t,n)=>{let r=ee();return e.createElement(H,Object.assign({},t,{submit:r,ref:n}))})),H=e.forwardRef((({reloadDocument:t,replace:n,state:r,method:a="get",action:o,onSubmit:i,submit:s,relative:u,preventScrollReset:l,unstable_viewTransition:c,...f},m)=>{let d="get"===a.toLowerCase()?"get":"post",p=ne(o,{relative:u});return e.createElement("form",Object.assign({ref:m,method:d,action:p,onSubmit:t?i:e=>{if(i&&i(e),e.defaultPrevented)return;e.preventDefault();let t=e.nativeEvent.submitter,o=t?.getAttribute("formmethod")||a;s(t||e.currentTarget,{method:o,replace:n,state:r,relative:u,preventScrollReset:l,unstable_viewTransition:c})}},f))}));function W({getKey:e,storageKey:t}){return se({getKey:e,storageKey:t}),null}var Y=function(e){return e.UseScrollRestoration="useScrollRestoration",e.UseSubmit="useSubmit",e.UseSubmitFetcher="useSubmitFetcher",e.UseFetcher="useFetcher",e.useViewTransitionStates="useViewTransitionStates",e.useViewTransitionState="useViewTransitionState",e}(Y||{}),J=function(e){return e.UseFetchers="useFetchers",e.UseScrollRestoration="useScrollRestoration",e}(J||{});function q(t){let n=e.useContext(w);return n||S(!1),n}function G(t){let n=e.useContext(s);return n||S(!1),n}function Q(t,{target:n,replace:r,state:a,preventScrollReset:s,relative:c,unstable_viewTransition:f}={}){let m=u(),d=i(),p=o(t,{relative:c});return e.useCallback((e=>{if(function(e,t){return!(0!==e.button||t&&"_self"!==t||function(e){return!!(e.metaKey||e.altKey||e.ctrlKey||e.shiftKey)}(e))}(e,n)){e.preventDefault();let n=void 0!==r?r:l(d)===l(p);m(t,{replace:n,state:a,preventScrollReset:s,relative:c,unstable_viewTransition:f})}}),[d,m,p,r,a,n,t,s,c,f])}function X(t){let n=e.useRef(x(t)),r=e.useRef(!1),a=i(),o=e.useMemo((()=>function(e,t){let n=x(e);return t&&t.forEach(((e,r)=>{n.has(r)||t.getAll(r).forEach((e=>{n.append(r,e)}))})),n}(a.search,r.current?null:n.current)),[a.search]),s=u(),l=e.useCallback(((e,t)=>{const n=x("function"==typeof e?e(o):e);r.current=!0,s("?"+n,t)}),[s,o]);return[o,l]}function Z(){if("undefined"==typeof document)throw new Error("You are calling submit during the server render. Try calling submit within a `useEffect` or callback instead.")}function ee(){let{router:t}=q(Y.UseSubmit),{basename:n}=e.useContext(r),a=c();return e.useCallback(((e,r={})=>{Z();let{action:o,method:i,encType:s,formData:u,body:l}=F(e,n);t.navigate(r.action||o,{preventScrollReset:r.preventScrollReset,formData:u,body:l,formMethod:r.method||i,formEncType:r.encType||s,replace:r.replace,state:r.state,fromRouteId:a,unstable_viewTransition:r.unstable_viewTransition})}),[t,n,a])}function te(t,n){let{router:a}=q(Y.UseSubmitFetcher),{basename:o}=e.useContext(r);return e.useCallback(((e,r={})=>{Z();let{action:i,method:s,encType:u,formData:l,body:c}=F(e,o);null==n&&S(!1),a.fetch(t,n,r.action||i,{preventScrollReset:r.preventScrollReset,formData:l,body:c,formMethod:r.method||s,formEncType:r.encType||u})}),[a,o,t,n])}function ne(t,{relative:n}={}){let{basename:a}=e.useContext(r),s=e.useContext(f);s||S(!1);let[u]=s.matches.slice(-1),c={...o(t||".",{relative:n})},m=i();if(null==t&&(c.search=m.search,u.route.index)){let e=new URLSearchParams(c.search);e.delete("index"),c.search=e.toString()?`?${e.toString()}`:""}return t&&"."!==t||!u.route.index||(c.search=c.search?c.search.replace(/^\?/,"?index&"):"?index"),"/"!==a&&(c.pathname="/"===c.pathname?a:E([a,c.pathname])),l(c)}let re=0;function ae(){let{router:t}=q(Y.UseFetcher),n=e.useContext(f);n||S(!1);let r=n.matches[n.matches.length-1]?.route.id;null==r&&S(!1);let[a]=e.useState((()=>String(++re))),[o]=e.useState((()=>(r||S(!1),function(t,n){return e.forwardRef(((r,a)=>{let o=te(t,n);return e.createElement(H,Object.assign({},r,{ref:a,submit:o}))}))}(a,r)))),[i]=e.useState((()=>e=>{t||S(!1),r||S(!1),t.fetch(a,r,e)})),s=te(a,r),u=t.getFetcher(a),l=e.useMemo((()=>({Form:o,submit:s,load:i,...u})),[u,o,s,i]);return e.useEffect((()=>()=>{t?t.deleteFetcher(a):console.warn("No router available to clean up from useFetcher()")}),[t,a]),l}function oe(){return[...G(J.UseFetchers).fetchers.values()]}let ie={};function se({getKey:t,storageKey:n}={}){let{router:a}=q(Y.UseScrollRestoration),{restoreScrollPosition:o,preventScrollReset:s}=G(J.UseScrollRestoration),{basename:u}=e.useContext(r),l=i(),c=m(),f=d();e.useEffect((()=>(window.history.scrollRestoration="manual",()=>{window.history.scrollRestoration="auto"})),[]),function(t,n){let{capture:r}=n||{};e.useEffect((()=>{let e=null!=r?{capture:r}:void 0;return window.addEventListener("pagehide",t,e),()=>{window.removeEventListener("pagehide",t,e)}}),[t,r])}(e.useCallback((()=>{if("idle"===f.state){let e=(t?t(l,c):null)||l.key;ie[e]=window.scrollY}try{sessionStorage.setItem(n||"react-router-scroll-positions",JSON.stringify(ie))}catch(e){}window.history.scrollRestoration="auto"}),[n,t,f.state,l,c])),"undefined"!=typeof document&&(e.useLayoutEffect((()=>{try{let e=sessionStorage.getItem(n||"react-router-scroll-positions");e&&(ie=JSON.parse(e))}catch(e){}}),[n]),e.useLayoutEffect((()=>{let e=t&&"/"!==u?(e,n)=>t({...e,pathname:b(e.pathname,u)||e.pathname},n):t,n=a?.enableScrollRestoration(ie,(()=>window.scrollY),e);return()=>n&&n()}),[a,u,t]),e.useLayoutEffect((()=>{if(!1!==o)if("number"!=typeof o){if(l.hash){let e=document.getElementById(decodeURIComponent(l.hash.slice(1)));if(e)return void e.scrollIntoView()}!0!==s&&window.scrollTo(0,0)}else window.scrollTo(0,o)}),[l,o,s]))}function ue(t,n){let{capture:r}=n||{};e.useEffect((()=>{let e=null!=r?{capture:r}:void 0;return window.addEventListener("beforeunload",t,e),()=>{window.removeEventListener("beforeunload",t,e)}}),[t,r])}function le({when:t,message:n}){let r=p(t);e.useEffect((()=>{if("blocked"===r.state){window.confirm(n)?setTimeout(r.proceed,0):r.reset()}}),[r,n]),e.useEffect((()=>{"blocked"!==r.state||t||r.reset()}),[r,t])}function ce(t,n={}){let r=e.useContext(h),{basename:a}=q(Y.useViewTransitionState),i=o(t,{relative:n.relative});if(r.isTransitioning){let e=b(r.currentLocation.pathname,a)||r.currentLocation.pathname,t=b(r.nextLocation.pathname,a)||r.nextLocation.pathname;return null!=C(i.pathname,t)||null!=C(i.pathname,e)}return!1}export{K as BrowserRouter,$ as Form,j as HashRouter,B as Link,z as NavLink,W as ScrollRestoration,se as UNSAFE_useScrollRestoration,D as createBrowserRouter,N as createHashRouter,x as createSearchParams,M as unstable_HistoryRouter,le as unstable_usePrompt,ce as unstable_useViewTransitionState,ue as useBeforeUnload,ae as useFetcher,oe as useFetchers,ne as useFormAction,Q as useLinkClickHandler,X as useSearchParams,ee as useSubmit}; | ||
| export{AbortedDeferredError,Await,BrowserRouter,Form,HashRouter,HydratedRouter,Link,Links,MemoryRouter,Meta,NavLink,Navigate,NavigationType,Outlet,PrefetchPageLinks,RemixServer,Route,Router,RouterProvider,Routes,Scripts,ScrollRestoration,StaticRouter,StaticRouterProvider,UNSAFE_DEFERRED_SYMBOL,UNSAFE_DataRouterContext,UNSAFE_DataRouterStateContext,UNSAFE_ErrorResponseImpl,UNSAFE_FetchersContext,UNSAFE_LocationContext,UNSAFE_NavigationContext,UNSAFE_RemixContext,UNSAFE_RouteContext,UNSAFE_SingleFetchRedirectSymbol,UNSAFE_ViewTransitionContext,UNSAFE_convertRoutesToDataRoutes,UNSAFE_decodeViaTurboStream,UNSAFE_mapRouteProperties,UNSAFE_useRouteId,UNSAFE_useRoutesImpl,UNSAFE_useScrollRestoration,createBrowserRouter,createHashRouter,createMemoryRouter,createPath,createRemixStub,createRoutesFromChildren,createRoutesFromChildren as createRoutesFromElements,createSearchParams,createStaticHandler,createStaticRouter,defer,generatePath,getStaticContextFromError,isRouteErrorResponse,json,matchPath,matchRoutes,parsePath,redirect,redirectDocument,renderMatches,resolvePath,stripBasename,unstable_HistoryRouter,unstable_usePrompt,unstable_useViewTransitionState,useActionData,useAsyncError,useAsyncValue,useBeforeUnload,useBlocker,useFetcher,useFetchers,useFormAction,useHref,useInRouterContext,useLinkClickHandler,useLoaderData,useLocation,useMatch,useMatches,useNavigate,useNavigation,useNavigationType,useOutlet,useOutletContext,useParams,useResolvedPath,useRevalidator,useRouteError,useRouteLoaderData,useRoutes,useSearchParams,useSubmit}from"react-router";let e=!1;e||"undefined"==typeof console||(e=!0,console.warn("The `react-router-dom` package is deprecated in v7, you can change all of your imports to load directly from the `react-router` package.")); | ||
| //# sourceMappingURL=react-router-dom.production.min.js.map |
| /** | ||
| * React Router DOM v0.0.0-experimental-4a8a492a | ||
| * React Router DOM v0.0.0-experimental-4ed3f5da9 | ||
| * | ||
@@ -12,1202 +12,13 @@ * Copyright (c) Remix Software Inc. | ||
| (function (global, factory) { | ||
| typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react'), require('react-router'), require('@remix-run/router')) : | ||
| typeof define === 'function' && define.amd ? define(['exports', 'react', 'react-router', '@remix-run/router'], factory) : | ||
| (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.ReactRouterDOM = {}, global.React, global.ReactRouter, global.RemixRouter)); | ||
| })(this, (function (exports, React, reactRouter, router) { 'use strict'; | ||
| typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react-router')) : | ||
| typeof define === 'function' && define.amd ? define(['exports', 'react-router'], factory) : | ||
| (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.ReactRouterDOM = {}, global.ReactRouter)); | ||
| })(this, (function (exports, reactRouter) { 'use strict'; | ||
| function _interopNamespace(e) { | ||
| if (e && e.__esModule) return e; | ||
| var n = Object.create(null); | ||
| if (e) { | ||
| Object.keys(e).forEach(function (k) { | ||
| if (k !== 'default') { | ||
| var d = Object.getOwnPropertyDescriptor(e, k); | ||
| Object.defineProperty(n, k, d.get ? d : { | ||
| enumerable: true, | ||
| get: function () { return e[k]; } | ||
| }); | ||
| } | ||
| }); | ||
| } | ||
| n["default"] = e; | ||
| return Object.freeze(n); | ||
| let alreadyWarned = false; | ||
| if (!alreadyWarned && typeof console !== "undefined") { | ||
| alreadyWarned = true; | ||
| console.warn("The `react-router-dom` package is deprecated in v7, you can change all " + "of your imports to load directly from the `react-router` package."); | ||
| } | ||
| var React__namespace = /*#__PURE__*/_interopNamespace(React); | ||
| function _extends() { | ||
| _extends = Object.assign ? Object.assign.bind() : function (target) { | ||
| for (var i = 1; i < arguments.length; i++) { | ||
| var source = arguments[i]; | ||
| for (var key in source) { | ||
| if (Object.prototype.hasOwnProperty.call(source, key)) { | ||
| target[key] = source[key]; | ||
| } | ||
| } | ||
| } | ||
| return target; | ||
| }; | ||
| return _extends.apply(this, arguments); | ||
| } | ||
| function _objectWithoutPropertiesLoose(source, excluded) { | ||
| if (source == null) return {}; | ||
| var target = {}; | ||
| var sourceKeys = Object.keys(source); | ||
| var key, i; | ||
| for (i = 0; i < sourceKeys.length; i++) { | ||
| key = sourceKeys[i]; | ||
| if (excluded.indexOf(key) >= 0) continue; | ||
| target[key] = source[key]; | ||
| } | ||
| return target; | ||
| } | ||
| const defaultMethod = "get"; | ||
| const defaultEncType = "application/x-www-form-urlencoded"; | ||
| function isHtmlElement(object) { | ||
| return object != null && typeof object.tagName === "string"; | ||
| } | ||
| function isButtonElement(object) { | ||
| return isHtmlElement(object) && object.tagName.toLowerCase() === "button"; | ||
| } | ||
| function isFormElement(object) { | ||
| return isHtmlElement(object) && object.tagName.toLowerCase() === "form"; | ||
| } | ||
| function isInputElement(object) { | ||
| return isHtmlElement(object) && object.tagName.toLowerCase() === "input"; | ||
| } | ||
| function isModifiedEvent(event) { | ||
| return !!(event.metaKey || event.altKey || event.ctrlKey || event.shiftKey); | ||
| } | ||
| function shouldProcessLinkClick(event, target) { | ||
| return event.button === 0 && ( | ||
| // Ignore everything but left clicks | ||
| !target || target === "_self") && | ||
| // Let browser handle "target=_blank" etc. | ||
| !isModifiedEvent(event) // Ignore clicks with modifier keys | ||
| ; | ||
| } | ||
| /** | ||
| * Creates a URLSearchParams object using the given initializer. | ||
| * | ||
| * This is identical to `new URLSearchParams(init)` except it also | ||
| * supports arrays as values in the object form of the initializer | ||
| * instead of just strings. This is convenient when you need multiple | ||
| * values for a given key, but don't want to use an array initializer. | ||
| * | ||
| * For example, instead of: | ||
| * | ||
| * let searchParams = new URLSearchParams([ | ||
| * ['sort', 'name'], | ||
| * ['sort', 'price'] | ||
| * ]); | ||
| * | ||
| * you can do: | ||
| * | ||
| * let searchParams = createSearchParams({ | ||
| * sort: ['name', 'price'] | ||
| * }); | ||
| */ | ||
| function createSearchParams(init) { | ||
| if (init === void 0) { | ||
| init = ""; | ||
| } | ||
| return new URLSearchParams(typeof init === "string" || Array.isArray(init) || init instanceof URLSearchParams ? init : Object.keys(init).reduce((memo, key) => { | ||
| let value = init[key]; | ||
| return memo.concat(Array.isArray(value) ? value.map(v => [key, v]) : [[key, value]]); | ||
| }, [])); | ||
| } | ||
| function getSearchParamsForLocation(locationSearch, defaultSearchParams) { | ||
| let searchParams = createSearchParams(locationSearch); | ||
| if (defaultSearchParams) { | ||
| // Use `defaultSearchParams.forEach(...)` here instead of iterating of | ||
| // `defaultSearchParams.keys()` to work-around a bug in Firefox related to | ||
| // web extensions. Relevant Bugzilla tickets: | ||
| // https://bugzilla.mozilla.org/show_bug.cgi?id=1414602 | ||
| // https://bugzilla.mozilla.org/show_bug.cgi?id=1023984 | ||
| defaultSearchParams.forEach((_, key) => { | ||
| if (!searchParams.has(key)) { | ||
| defaultSearchParams.getAll(key).forEach(value => { | ||
| searchParams.append(key, value); | ||
| }); | ||
| } | ||
| }); | ||
| } | ||
| return searchParams; | ||
| } | ||
| // Thanks https://github.com/sindresorhus/type-fest! | ||
| // One-time check for submitter support | ||
| let _formDataSupportsSubmitter = null; | ||
| function isFormDataSubmitterSupported() { | ||
| if (_formDataSupportsSubmitter === null) { | ||
| try { | ||
| new FormData(document.createElement("form"), | ||
| // @ts-expect-error if FormData supports the submitter parameter, this will throw | ||
| 0); | ||
| _formDataSupportsSubmitter = false; | ||
| } catch (e) { | ||
| _formDataSupportsSubmitter = true; | ||
| } | ||
| } | ||
| return _formDataSupportsSubmitter; | ||
| } | ||
| const supportedFormEncTypes = new Set(["application/x-www-form-urlencoded", "multipart/form-data", "text/plain"]); | ||
| function getFormEncType(encType) { | ||
| if (encType != null && !supportedFormEncTypes.has(encType)) { | ||
| router.UNSAFE_warning(false, "\"" + encType + "\" is not a valid `encType` for `<Form>`/`<fetcher.Form>` " + ("and will default to \"" + defaultEncType + "\"")) ; | ||
| return null; | ||
| } | ||
| return encType; | ||
| } | ||
| function getFormSubmissionInfo(target, basename) { | ||
| let method; | ||
| let action; | ||
| let encType; | ||
| let formData; | ||
| let body; | ||
| if (isFormElement(target)) { | ||
| // When grabbing the action from the element, it will have had the basename | ||
| // prefixed to ensure non-JS scenarios work, so strip it since we'll | ||
| // re-prefix in the router | ||
| let attr = target.getAttribute("action"); | ||
| action = attr ? router.stripBasename(attr, basename) : null; | ||
| method = target.getAttribute("method") || defaultMethod; | ||
| encType = getFormEncType(target.getAttribute("enctype")) || defaultEncType; | ||
| formData = new FormData(target); | ||
| } else if (isButtonElement(target) || isInputElement(target) && (target.type === "submit" || target.type === "image")) { | ||
| let form = target.form; | ||
| if (form == null) { | ||
| throw new Error("Cannot submit a <button> or <input type=\"submit\"> without a <form>"); | ||
| } | ||
| // <button>/<input type="submit"> may override attributes of <form> | ||
| // When grabbing the action from the element, it will have had the basename | ||
| // prefixed to ensure non-JS scenarios work, so strip it since we'll | ||
| // re-prefix in the router | ||
| let attr = target.getAttribute("formaction") || form.getAttribute("action"); | ||
| action = attr ? router.stripBasename(attr, basename) : null; | ||
| method = target.getAttribute("formmethod") || form.getAttribute("method") || defaultMethod; | ||
| encType = getFormEncType(target.getAttribute("formenctype")) || getFormEncType(form.getAttribute("enctype")) || defaultEncType; | ||
| // Build a FormData object populated from a form and submitter | ||
| formData = new FormData(form, target); | ||
| // If this browser doesn't support the `FormData(el, submitter)` format, | ||
| // then tack on the submitter value at the end. This is a lightweight | ||
| // solution that is not 100% spec compliant. For complete support in older | ||
| // browsers, consider using the `formdata-submitter-polyfill` package | ||
| if (!isFormDataSubmitterSupported()) { | ||
| let { | ||
| name, | ||
| type, | ||
| value | ||
| } = target; | ||
| if (type === "image") { | ||
| let prefix = name ? name + "." : ""; | ||
| formData.append(prefix + "x", "0"); | ||
| formData.append(prefix + "y", "0"); | ||
| } else if (name) { | ||
| formData.append(name, value); | ||
| } | ||
| } | ||
| } else if (isHtmlElement(target)) { | ||
| throw new Error("Cannot submit element that is not <form>, <button>, or " + "<input type=\"submit|image\">"); | ||
| } else { | ||
| method = defaultMethod; | ||
| action = null; | ||
| encType = defaultEncType; | ||
| body = target; | ||
| } | ||
| // Send body for <Form encType="text/plain" so we encode it into text | ||
| if (formData && encType === "text/plain") { | ||
| body = formData; | ||
| formData = undefined; | ||
| } | ||
| return { | ||
| action, | ||
| method: method.toLowerCase(), | ||
| encType, | ||
| formData, | ||
| body | ||
| }; | ||
| } | ||
| const _excluded = ["onClick", "relative", "reloadDocument", "replace", "state", "target", "to", "preventScrollReset", "unstable_viewTransition"], | ||
| _excluded2 = ["aria-current", "caseSensitive", "className", "end", "style", "to", "unstable_viewTransition", "children"], | ||
| _excluded3 = ["reloadDocument", "replace", "state", "method", "action", "onSubmit", "submit", "relative", "preventScrollReset", "unstable_viewTransition"]; | ||
| //#endregion | ||
| //////////////////////////////////////////////////////////////////////////////// | ||
| //#region Routers | ||
| //////////////////////////////////////////////////////////////////////////////// | ||
| function createBrowserRouter(routes, opts) { | ||
| return router.createRouter({ | ||
| basename: opts == null ? void 0 : opts.basename, | ||
| future: _extends({}, opts == null ? void 0 : opts.future, { | ||
| v7_prependBasename: true | ||
| }), | ||
| history: router.createBrowserHistory({ | ||
| window: opts == null ? void 0 : opts.window | ||
| }), | ||
| hydrationData: (opts == null ? void 0 : opts.hydrationData) || parseHydrationData(), | ||
| routes, | ||
| mapRouteProperties: reactRouter.UNSAFE_mapRouteProperties | ||
| }).initialize(); | ||
| } | ||
| function createHashRouter(routes, opts) { | ||
| return router.createRouter({ | ||
| basename: opts == null ? void 0 : opts.basename, | ||
| future: _extends({}, opts == null ? void 0 : opts.future, { | ||
| v7_prependBasename: true | ||
| }), | ||
| history: router.createHashHistory({ | ||
| window: opts == null ? void 0 : opts.window | ||
| }), | ||
| hydrationData: (opts == null ? void 0 : opts.hydrationData) || parseHydrationData(), | ||
| routes, | ||
| mapRouteProperties: reactRouter.UNSAFE_mapRouteProperties | ||
| }).initialize(); | ||
| } | ||
| function parseHydrationData() { | ||
| var _window; | ||
| let state = (_window = window) == null ? void 0 : _window.__staticRouterHydrationData; | ||
| if (state && state.errors) { | ||
| state = _extends({}, state, { | ||
| errors: deserializeErrors(state.errors) | ||
| }); | ||
| } | ||
| return state; | ||
| } | ||
| function deserializeErrors(errors) { | ||
| if (!errors) return null; | ||
| let entries = Object.entries(errors); | ||
| let serialized = {}; | ||
| for (let [key, val] of entries) { | ||
| // Hey you! If you change this, please change the corresponding logic in | ||
| // serializeErrors in react-router-dom/server.tsx :) | ||
| if (val && val.__type === "RouteErrorResponse") { | ||
| serialized[key] = new router.UNSAFE_ErrorResponseImpl(val.status, val.statusText, val.data, val.internal === true); | ||
| } else if (val && val.__type === "Error") { | ||
| // Attempt to reconstruct the right type of Error (i.e., ReferenceError) | ||
| if (val.__subType) { | ||
| let ErrorConstructor = window[val.__subType]; | ||
| if (typeof ErrorConstructor === "function") { | ||
| try { | ||
| // @ts-expect-error | ||
| let error = new ErrorConstructor(val.message); | ||
| // Wipe away the client-side stack trace. Nothing to fill it in with | ||
| // because we don't serialize SSR stack traces for security reasons | ||
| error.stack = ""; | ||
| serialized[key] = error; | ||
| } catch (e) { | ||
| // no-op - fall through and create a normal Error | ||
| } | ||
| } | ||
| } | ||
| if (serialized[key] == null) { | ||
| let error = new Error(val.message); | ||
| // Wipe away the client-side stack trace. Nothing to fill it in with | ||
| // because we don't serialize SSR stack traces for security reasons | ||
| error.stack = ""; | ||
| serialized[key] = error; | ||
| } | ||
| } else { | ||
| serialized[key] = val; | ||
| } | ||
| } | ||
| return serialized; | ||
| } | ||
| //#endregion | ||
| //////////////////////////////////////////////////////////////////////////////// | ||
| //#region Components | ||
| //////////////////////////////////////////////////////////////////////////////// | ||
| /** | ||
| Webpack + React 17 fails to compile on any of the following because webpack | ||
| complains that `startTransition` doesn't exist in `React`: | ||
| * import { startTransition } from "react" | ||
| * import * as React from from "react"; | ||
| "startTransition" in React ? React.startTransition(() => setState()) : setState() | ||
| * import * as React from from "react"; | ||
| "startTransition" in React ? React["startTransition"](() => setState()) : setState() | ||
| Moving it to a constant such as the following solves the Webpack/React 17 issue: | ||
| * import * as React from from "react"; | ||
| const START_TRANSITION = "startTransition"; | ||
| START_TRANSITION in React ? React[START_TRANSITION](() => setState()) : setState() | ||
| However, that introduces webpack/terser minification issues in production builds | ||
| in React 18 where minification/obfuscation ends up removing the call of | ||
| React.startTransition entirely from the first half of the ternary. Grabbing | ||
| this exported reference once up front resolves that issue. | ||
| See https://github.com/remix-run/react-router/issues/10579 | ||
| */ | ||
| const START_TRANSITION = "startTransition"; | ||
| const startTransitionImpl = React__namespace[START_TRANSITION]; | ||
| /** | ||
| * A `<Router>` for use in web browsers. Provides the cleanest URLs. | ||
| */ | ||
| function BrowserRouter(_ref) { | ||
| let { | ||
| basename, | ||
| children, | ||
| future, | ||
| window | ||
| } = _ref; | ||
| let historyRef = React__namespace.useRef(); | ||
| if (historyRef.current == null) { | ||
| historyRef.current = router.createBrowserHistory({ | ||
| window, | ||
| v5Compat: true | ||
| }); | ||
| } | ||
| let history = historyRef.current; | ||
| let [state, setStateImpl] = React__namespace.useState({ | ||
| action: history.action, | ||
| location: history.location | ||
| }); | ||
| let { | ||
| v7_startTransition | ||
| } = future || {}; | ||
| let setState = React__namespace.useCallback(newState => { | ||
| v7_startTransition && startTransitionImpl ? startTransitionImpl(() => setStateImpl(newState)) : setStateImpl(newState); | ||
| }, [setStateImpl, v7_startTransition]); | ||
| React__namespace.useLayoutEffect(() => history.listen(setState), [history, setState]); | ||
| return /*#__PURE__*/React__namespace.createElement(reactRouter.Router, { | ||
| basename: basename, | ||
| children: children, | ||
| location: state.location, | ||
| navigationType: state.action, | ||
| navigator: history | ||
| }); | ||
| } | ||
| /** | ||
| * A `<Router>` for use in web browsers. Stores the location in the hash | ||
| * portion of the URL so it is not sent to the server. | ||
| */ | ||
| function HashRouter(_ref2) { | ||
| let { | ||
| basename, | ||
| children, | ||
| future, | ||
| window | ||
| } = _ref2; | ||
| let historyRef = React__namespace.useRef(); | ||
| if (historyRef.current == null) { | ||
| historyRef.current = router.createHashHistory({ | ||
| window, | ||
| v5Compat: true | ||
| }); | ||
| } | ||
| let history = historyRef.current; | ||
| let [state, setStateImpl] = React__namespace.useState({ | ||
| action: history.action, | ||
| location: history.location | ||
| }); | ||
| let { | ||
| v7_startTransition | ||
| } = future || {}; | ||
| let setState = React__namespace.useCallback(newState => { | ||
| v7_startTransition && startTransitionImpl ? startTransitionImpl(() => setStateImpl(newState)) : setStateImpl(newState); | ||
| }, [setStateImpl, v7_startTransition]); | ||
| React__namespace.useLayoutEffect(() => history.listen(setState), [history, setState]); | ||
| return /*#__PURE__*/React__namespace.createElement(reactRouter.Router, { | ||
| basename: basename, | ||
| children: children, | ||
| location: state.location, | ||
| navigationType: state.action, | ||
| navigator: history | ||
| }); | ||
| } | ||
| /** | ||
| * A `<Router>` that accepts a pre-instantiated history object. It's important | ||
| * to note that using your own history object is highly discouraged and may add | ||
| * two versions of the history library to your bundles unless you use the same | ||
| * version of the history library that React Router uses internally. | ||
| */ | ||
| function HistoryRouter(_ref3) { | ||
| let { | ||
| basename, | ||
| children, | ||
| future, | ||
| history | ||
| } = _ref3; | ||
| let [state, setStateImpl] = React__namespace.useState({ | ||
| action: history.action, | ||
| location: history.location | ||
| }); | ||
| let { | ||
| v7_startTransition | ||
| } = future || {}; | ||
| let setState = React__namespace.useCallback(newState => { | ||
| v7_startTransition && startTransitionImpl ? startTransitionImpl(() => setStateImpl(newState)) : setStateImpl(newState); | ||
| }, [setStateImpl, v7_startTransition]); | ||
| React__namespace.useLayoutEffect(() => history.listen(setState), [history, setState]); | ||
| return /*#__PURE__*/React__namespace.createElement(reactRouter.Router, { | ||
| basename: basename, | ||
| children: children, | ||
| location: state.location, | ||
| navigationType: state.action, | ||
| navigator: history | ||
| }); | ||
| } | ||
| { | ||
| HistoryRouter.displayName = "unstable_HistoryRouter"; | ||
| } | ||
| const isBrowser = typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement !== "undefined"; | ||
| const ABSOLUTE_URL_REGEX = /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i; | ||
| /** | ||
| * The public API for rendering a history-aware `<a>`. | ||
| */ | ||
| const Link = /*#__PURE__*/React__namespace.forwardRef(function LinkWithRef(_ref4, ref) { | ||
| let { | ||
| onClick, | ||
| relative, | ||
| reloadDocument, | ||
| replace, | ||
| state, | ||
| target, | ||
| to, | ||
| preventScrollReset, | ||
| unstable_viewTransition | ||
| } = _ref4, | ||
| rest = _objectWithoutPropertiesLoose(_ref4, _excluded); | ||
| let { | ||
| basename | ||
| } = React__namespace.useContext(reactRouter.UNSAFE_NavigationContext); | ||
| // Rendered into <a href> for absolute URLs | ||
| let absoluteHref; | ||
| let isExternal = false; | ||
| if (typeof to === "string" && ABSOLUTE_URL_REGEX.test(to)) { | ||
| // Render the absolute href server- and client-side | ||
| absoluteHref = to; | ||
| // Only check for external origins client-side | ||
| if (isBrowser) { | ||
| try { | ||
| let currentUrl = new URL(window.location.href); | ||
| let targetUrl = to.startsWith("//") ? new URL(currentUrl.protocol + to) : new URL(to); | ||
| let path = router.stripBasename(targetUrl.pathname, basename); | ||
| if (targetUrl.origin === currentUrl.origin && path != null) { | ||
| // Strip the protocol/origin/basename for same-origin absolute URLs | ||
| to = path + targetUrl.search + targetUrl.hash; | ||
| } else { | ||
| isExternal = true; | ||
| } | ||
| } catch (e) { | ||
| // We can't do external URL detection without a valid URL | ||
| router.UNSAFE_warning(false, "<Link to=\"" + to + "\"> contains an invalid URL which will probably break " + "when clicked - please update to a valid URL path.") ; | ||
| } | ||
| } | ||
| } | ||
| // Rendered into <a href> for relative URLs | ||
| let href = reactRouter.useHref(to, { | ||
| relative | ||
| }); | ||
| let internalOnClick = useLinkClickHandler(to, { | ||
| replace, | ||
| state, | ||
| target, | ||
| preventScrollReset, | ||
| relative, | ||
| unstable_viewTransition | ||
| }); | ||
| function handleClick(event) { | ||
| if (onClick) onClick(event); | ||
| if (!event.defaultPrevented) { | ||
| internalOnClick(event); | ||
| } | ||
| } | ||
| return ( | ||
| /*#__PURE__*/ | ||
| // eslint-disable-next-line jsx-a11y/anchor-has-content | ||
| React__namespace.createElement("a", _extends({}, rest, { | ||
| href: absoluteHref || href, | ||
| onClick: isExternal || reloadDocument ? onClick : handleClick, | ||
| ref: ref, | ||
| target: target | ||
| })) | ||
| ); | ||
| }); | ||
| { | ||
| Link.displayName = "Link"; | ||
| } | ||
| /** | ||
| * A `<Link>` wrapper that knows if it's "active" or not. | ||
| */ | ||
| const NavLink = /*#__PURE__*/React__namespace.forwardRef(function NavLinkWithRef(_ref5, ref) { | ||
| let { | ||
| "aria-current": ariaCurrentProp = "page", | ||
| caseSensitive = false, | ||
| className: classNameProp = "", | ||
| end = false, | ||
| style: styleProp, | ||
| to, | ||
| unstable_viewTransition, | ||
| children | ||
| } = _ref5, | ||
| rest = _objectWithoutPropertiesLoose(_ref5, _excluded2); | ||
| let path = reactRouter.useResolvedPath(to, { | ||
| relative: rest.relative | ||
| }); | ||
| let location = reactRouter.useLocation(); | ||
| let routerState = React__namespace.useContext(reactRouter.UNSAFE_DataRouterStateContext); | ||
| let { | ||
| navigator | ||
| } = React__namespace.useContext(reactRouter.UNSAFE_NavigationContext); | ||
| let isTransitioning = useViewTransitionState(path) && unstable_viewTransition === true; | ||
| let toPathname = navigator.encodeLocation ? navigator.encodeLocation(path).pathname : path.pathname; | ||
| let locationPathname = location.pathname; | ||
| let nextLocationPathname = routerState && routerState.navigation && routerState.navigation.location ? routerState.navigation.location.pathname : null; | ||
| if (!caseSensitive) { | ||
| locationPathname = locationPathname.toLowerCase(); | ||
| nextLocationPathname = nextLocationPathname ? nextLocationPathname.toLowerCase() : null; | ||
| toPathname = toPathname.toLowerCase(); | ||
| } | ||
| let isActive = locationPathname === toPathname || !end && locationPathname.startsWith(toPathname) && locationPathname.charAt(toPathname.length) === "/"; | ||
| let isPending = nextLocationPathname != null && (nextLocationPathname === toPathname || !end && nextLocationPathname.startsWith(toPathname) && nextLocationPathname.charAt(toPathname.length) === "/"); | ||
| let renderProps = { | ||
| isActive, | ||
| isPending, | ||
| isTransitioning | ||
| }; | ||
| let ariaCurrent = isActive ? ariaCurrentProp : undefined; | ||
| let className; | ||
| if (typeof classNameProp === "function") { | ||
| className = classNameProp(renderProps); | ||
| } else { | ||
| // If the className prop is not a function, we use a default `active` | ||
| // class for <NavLink />s that are active. In v5 `active` was the default | ||
| // value for `activeClassName`, but we are removing that API and can still | ||
| // use the old default behavior for a cleaner upgrade path and keep the | ||
| // simple styling rules working as they currently do. | ||
| className = [classNameProp, isActive ? "active" : null, isPending ? "pending" : null, isTransitioning ? "transitioning" : null].filter(Boolean).join(" "); | ||
| } | ||
| let style = typeof styleProp === "function" ? styleProp(renderProps) : styleProp; | ||
| return /*#__PURE__*/React__namespace.createElement(Link, _extends({}, rest, { | ||
| "aria-current": ariaCurrent, | ||
| className: className, | ||
| ref: ref, | ||
| style: style, | ||
| to: to, | ||
| unstable_viewTransition: unstable_viewTransition | ||
| }), typeof children === "function" ? children(renderProps) : children); | ||
| }); | ||
| { | ||
| NavLink.displayName = "NavLink"; | ||
| } | ||
| /** | ||
| * A `@remix-run/router`-aware `<form>`. It behaves like a normal form except | ||
| * that the interaction with the server is with `fetch` instead of new document | ||
| * requests, allowing components to add nicer UX to the page as the form is | ||
| * submitted and returns with data. | ||
| */ | ||
| const Form = /*#__PURE__*/React__namespace.forwardRef((props, ref) => { | ||
| let submit = useSubmit(); | ||
| return /*#__PURE__*/React__namespace.createElement(FormImpl, _extends({}, props, { | ||
| submit: submit, | ||
| ref: ref | ||
| })); | ||
| }); | ||
| { | ||
| Form.displayName = "Form"; | ||
| } | ||
| const FormImpl = /*#__PURE__*/React__namespace.forwardRef((_ref6, forwardedRef) => { | ||
| let { | ||
| reloadDocument, | ||
| replace, | ||
| state, | ||
| method = defaultMethod, | ||
| action, | ||
| onSubmit, | ||
| submit, | ||
| relative, | ||
| preventScrollReset, | ||
| unstable_viewTransition | ||
| } = _ref6, | ||
| props = _objectWithoutPropertiesLoose(_ref6, _excluded3); | ||
| let formMethod = method.toLowerCase() === "get" ? "get" : "post"; | ||
| let formAction = useFormAction(action, { | ||
| relative | ||
| }); | ||
| let submitHandler = event => { | ||
| onSubmit && onSubmit(event); | ||
| if (event.defaultPrevented) return; | ||
| event.preventDefault(); | ||
| let submitter = event.nativeEvent.submitter; | ||
| let submitMethod = (submitter == null ? void 0 : submitter.getAttribute("formmethod")) || method; | ||
| submit(submitter || event.currentTarget, { | ||
| method: submitMethod, | ||
| replace, | ||
| state, | ||
| relative, | ||
| preventScrollReset, | ||
| unstable_viewTransition | ||
| }); | ||
| }; | ||
| return /*#__PURE__*/React__namespace.createElement("form", _extends({ | ||
| ref: forwardedRef, | ||
| method: formMethod, | ||
| action: formAction, | ||
| onSubmit: reloadDocument ? onSubmit : submitHandler | ||
| }, props)); | ||
| }); | ||
| { | ||
| FormImpl.displayName = "FormImpl"; | ||
| } | ||
| /** | ||
| * This component will emulate the browser's scroll restoration on location | ||
| * changes. | ||
| */ | ||
| function ScrollRestoration(_ref7) { | ||
| let { | ||
| getKey, | ||
| storageKey | ||
| } = _ref7; | ||
| useScrollRestoration({ | ||
| getKey, | ||
| storageKey | ||
| }); | ||
| return null; | ||
| } | ||
| { | ||
| ScrollRestoration.displayName = "ScrollRestoration"; | ||
| } | ||
| //#endregion | ||
| //////////////////////////////////////////////////////////////////////////////// | ||
| //#region Hooks | ||
| //////////////////////////////////////////////////////////////////////////////// | ||
| var DataRouterHook = /*#__PURE__*/function (DataRouterHook) { | ||
| DataRouterHook["UseScrollRestoration"] = "useScrollRestoration"; | ||
| DataRouterHook["UseSubmit"] = "useSubmit"; | ||
| DataRouterHook["UseSubmitFetcher"] = "useSubmitFetcher"; | ||
| DataRouterHook["UseFetcher"] = "useFetcher"; | ||
| DataRouterHook["useViewTransitionStates"] = "useViewTransitionStates"; | ||
| DataRouterHook["useViewTransitionState"] = "useViewTransitionState"; | ||
| return DataRouterHook; | ||
| }(DataRouterHook || {}); | ||
| var DataRouterStateHook = /*#__PURE__*/function (DataRouterStateHook) { | ||
| DataRouterStateHook["UseFetchers"] = "useFetchers"; | ||
| DataRouterStateHook["UseScrollRestoration"] = "useScrollRestoration"; | ||
| return DataRouterStateHook; | ||
| }(DataRouterStateHook || {}); | ||
| function getDataRouterConsoleError(hookName) { | ||
| return hookName + " must be used within a data router. See https://reactrouter.com/routers/picking-a-router."; | ||
| } | ||
| function useDataRouterContext(hookName) { | ||
| let ctx = React__namespace.useContext(reactRouter.UNSAFE_DataRouterContext); | ||
| !ctx ? router.UNSAFE_invariant(false, getDataRouterConsoleError(hookName)) : void 0; | ||
| return ctx; | ||
| } | ||
| function useDataRouterState(hookName) { | ||
| let state = React__namespace.useContext(reactRouter.UNSAFE_DataRouterStateContext); | ||
| !state ? router.UNSAFE_invariant(false, getDataRouterConsoleError(hookName)) : void 0; | ||
| return state; | ||
| } | ||
| /** | ||
| * Handles the click behavior for router `<Link>` components. This is useful if | ||
| * you need to create custom `<Link>` components with the same click behavior we | ||
| * use in our exported `<Link>`. | ||
| */ | ||
| function useLinkClickHandler(to, _temp) { | ||
| let { | ||
| target, | ||
| replace: replaceProp, | ||
| state, | ||
| preventScrollReset, | ||
| relative, | ||
| unstable_viewTransition | ||
| } = _temp === void 0 ? {} : _temp; | ||
| let navigate = reactRouter.useNavigate(); | ||
| let location = reactRouter.useLocation(); | ||
| let path = reactRouter.useResolvedPath(to, { | ||
| relative | ||
| }); | ||
| return React__namespace.useCallback(event => { | ||
| if (shouldProcessLinkClick(event, target)) { | ||
| event.preventDefault(); | ||
| // If the URL hasn't changed, a regular <a> will do a replace instead of | ||
| // a push, so do the same here unless the replace prop is explicitly set | ||
| let replace = replaceProp !== undefined ? replaceProp : reactRouter.createPath(location) === reactRouter.createPath(path); | ||
| navigate(to, { | ||
| replace, | ||
| state, | ||
| preventScrollReset, | ||
| relative, | ||
| unstable_viewTransition | ||
| }); | ||
| } | ||
| }, [location, navigate, path, replaceProp, state, target, to, preventScrollReset, relative, unstable_viewTransition]); | ||
| } | ||
| /** | ||
| * A convenient wrapper for reading and writing search parameters via the | ||
| * URLSearchParams interface. | ||
| */ | ||
| function useSearchParams(defaultInit) { | ||
| router.UNSAFE_warning(typeof URLSearchParams !== "undefined", "You cannot use the `useSearchParams` hook in a browser that does not " + "support the URLSearchParams API. If you need to support Internet " + "Explorer 11, we recommend you load a polyfill such as " + "https://github.com/ungap/url-search-params\n\n" + "If you're unsure how to load polyfills, we recommend you check out " + "https://polyfill.io/v3/ which provides some recommendations about how " + "to load polyfills only for users that need them, instead of for every " + "user.") ; | ||
| let defaultSearchParamsRef = React__namespace.useRef(createSearchParams(defaultInit)); | ||
| let hasSetSearchParamsRef = React__namespace.useRef(false); | ||
| let location = reactRouter.useLocation(); | ||
| let searchParams = React__namespace.useMemo(() => | ||
| // Only merge in the defaults if we haven't yet called setSearchParams. | ||
| // Once we call that we want those to take precedence, otherwise you can't | ||
| // remove a param with setSearchParams({}) if it has an initial value | ||
| getSearchParamsForLocation(location.search, hasSetSearchParamsRef.current ? null : defaultSearchParamsRef.current), [location.search]); | ||
| let navigate = reactRouter.useNavigate(); | ||
| let setSearchParams = React__namespace.useCallback((nextInit, navigateOptions) => { | ||
| const newSearchParams = createSearchParams(typeof nextInit === "function" ? nextInit(searchParams) : nextInit); | ||
| hasSetSearchParamsRef.current = true; | ||
| navigate("?" + newSearchParams, navigateOptions); | ||
| }, [navigate, searchParams]); | ||
| return [searchParams, setSearchParams]; | ||
| } | ||
| /** | ||
| * Submits a HTML `<form>` to the server without reloading the page. | ||
| */ | ||
| /** | ||
| * Submits a fetcher `<form>` to the server without reloading the page. | ||
| */ | ||
| function validateClientSideSubmission() { | ||
| if (typeof document === "undefined") { | ||
| throw new Error("You are calling submit during the server render. " + "Try calling submit within a `useEffect` or callback instead."); | ||
| } | ||
| } | ||
| /** | ||
| * Returns a function that may be used to programmatically submit a form (or | ||
| * some arbitrary data) to the server. | ||
| */ | ||
| function useSubmit() { | ||
| let { | ||
| router | ||
| } = useDataRouterContext(DataRouterHook.UseSubmit); | ||
| let { | ||
| basename | ||
| } = React__namespace.useContext(reactRouter.UNSAFE_NavigationContext); | ||
| let currentRouteId = reactRouter.UNSAFE_useRouteId(); | ||
| return React__namespace.useCallback(function (target, options) { | ||
| if (options === void 0) { | ||
| options = {}; | ||
| } | ||
| validateClientSideSubmission(); | ||
| let { | ||
| action, | ||
| method, | ||
| encType, | ||
| formData, | ||
| body | ||
| } = getFormSubmissionInfo(target, basename); | ||
| router.navigate(options.action || action, { | ||
| preventScrollReset: options.preventScrollReset, | ||
| formData, | ||
| body, | ||
| formMethod: options.method || method, | ||
| formEncType: options.encType || encType, | ||
| replace: options.replace, | ||
| state: options.state, | ||
| fromRouteId: currentRouteId, | ||
| unstable_viewTransition: options.unstable_viewTransition | ||
| }); | ||
| }, [router, basename, currentRouteId]); | ||
| } | ||
| /** | ||
| * Returns the implementation for fetcher.submit | ||
| */ | ||
| function useSubmitFetcher(fetcherKey, fetcherRouteId) { | ||
| let { | ||
| router: router$1 | ||
| } = useDataRouterContext(DataRouterHook.UseSubmitFetcher); | ||
| let { | ||
| basename | ||
| } = React__namespace.useContext(reactRouter.UNSAFE_NavigationContext); | ||
| return React__namespace.useCallback(function (target, options) { | ||
| if (options === void 0) { | ||
| options = {}; | ||
| } | ||
| validateClientSideSubmission(); | ||
| let { | ||
| action, | ||
| method, | ||
| encType, | ||
| formData, | ||
| body | ||
| } = getFormSubmissionInfo(target, basename); | ||
| !(fetcherRouteId != null) ? router.UNSAFE_invariant(false, "No routeId available for useFetcher()") : void 0; | ||
| router$1.fetch(fetcherKey, fetcherRouteId, options.action || action, { | ||
| preventScrollReset: options.preventScrollReset, | ||
| formData, | ||
| body, | ||
| formMethod: options.method || method, | ||
| formEncType: options.encType || encType | ||
| }); | ||
| }, [router$1, basename, fetcherKey, fetcherRouteId]); | ||
| } | ||
| // v7: Eventually we should deprecate this entirely in favor of using the | ||
| // router method directly? | ||
| function useFormAction(action, _temp2) { | ||
| let { | ||
| relative | ||
| } = _temp2 === void 0 ? {} : _temp2; | ||
| let { | ||
| basename | ||
| } = React__namespace.useContext(reactRouter.UNSAFE_NavigationContext); | ||
| let routeContext = React__namespace.useContext(reactRouter.UNSAFE_RouteContext); | ||
| !routeContext ? router.UNSAFE_invariant(false, "useFormAction must be used inside a RouteContext") : void 0; | ||
| let [match] = routeContext.matches.slice(-1); | ||
| // Shallow clone path so we can modify it below, otherwise we modify the | ||
| // object referenced by useMemo inside useResolvedPath | ||
| let path = _extends({}, reactRouter.useResolvedPath(action ? action : ".", { | ||
| relative | ||
| })); | ||
| // Previously we set the default action to ".". The problem with this is that | ||
| // `useResolvedPath(".")` excludes search params of the resolved URL. This is | ||
| // the intended behavior of when "." is specifically provided as | ||
| // the form action, but inconsistent w/ browsers when the action is omitted. | ||
| // https://github.com/remix-run/remix/issues/927 | ||
| let location = reactRouter.useLocation(); | ||
| if (action == null) { | ||
| // Safe to write to this directly here since if action was undefined, we | ||
| // would have called useResolvedPath(".") which will never include a search | ||
| path.search = location.search; | ||
| // When grabbing search params from the URL, remove the automatically | ||
| // inserted ?index param so we match the useResolvedPath search behavior | ||
| // which would not include ?index | ||
| if (match.route.index) { | ||
| let params = new URLSearchParams(path.search); | ||
| params.delete("index"); | ||
| path.search = params.toString() ? "?" + params.toString() : ""; | ||
| } | ||
| } | ||
| if ((!action || action === ".") && match.route.index) { | ||
| path.search = path.search ? path.search.replace(/^\?/, "?index&") : "?index"; | ||
| } | ||
| // If we're operating within a basename, prepend it to the pathname prior | ||
| // to creating the form action. If this is a root navigation, then just use | ||
| // the raw basename which allows the basename to have full control over the | ||
| // presence of a trailing slash on root actions | ||
| if (basename !== "/") { | ||
| path.pathname = path.pathname === "/" ? basename : router.joinPaths([basename, path.pathname]); | ||
| } | ||
| return reactRouter.createPath(path); | ||
| } | ||
| function createFetcherForm(fetcherKey, routeId) { | ||
| let FetcherForm = /*#__PURE__*/React__namespace.forwardRef((props, ref) => { | ||
| let submit = useSubmitFetcher(fetcherKey, routeId); | ||
| return /*#__PURE__*/React__namespace.createElement(FormImpl, _extends({}, props, { | ||
| ref: ref, | ||
| submit: submit | ||
| })); | ||
| }); | ||
| { | ||
| FetcherForm.displayName = "fetcher.Form"; | ||
| } | ||
| return FetcherForm; | ||
| } | ||
| let fetcherId = 0; | ||
| // TODO: (v7) Change the useFetcher generic default from `any` to `unknown` | ||
| /** | ||
| * Interacts with route loaders and actions without causing a navigation. Great | ||
| * for any interaction that stays on the same page. | ||
| */ | ||
| function useFetcher() { | ||
| var _route$matches; | ||
| let { | ||
| router: router$1 | ||
| } = useDataRouterContext(DataRouterHook.UseFetcher); | ||
| let route = React__namespace.useContext(reactRouter.UNSAFE_RouteContext); | ||
| !route ? router.UNSAFE_invariant(false, "useFetcher must be used inside a RouteContext") : void 0; | ||
| let routeId = (_route$matches = route.matches[route.matches.length - 1]) == null ? void 0 : _route$matches.route.id; | ||
| !(routeId != null) ? router.UNSAFE_invariant(false, "useFetcher can only be used on routes that contain a unique \"id\"") : void 0; | ||
| let [fetcherKey] = React__namespace.useState(() => String(++fetcherId)); | ||
| let [Form] = React__namespace.useState(() => { | ||
| !routeId ? router.UNSAFE_invariant(false, "No routeId available for fetcher.Form()") : void 0; | ||
| return createFetcherForm(fetcherKey, routeId); | ||
| }); | ||
| let [load] = React__namespace.useState(() => href => { | ||
| !router$1 ? router.UNSAFE_invariant(false, "No router available for fetcher.load()") : void 0; | ||
| !routeId ? router.UNSAFE_invariant(false, "No routeId available for fetcher.load()") : void 0; | ||
| router$1.fetch(fetcherKey, routeId, href); | ||
| }); | ||
| let submit = useSubmitFetcher(fetcherKey, routeId); | ||
| let fetcher = router$1.getFetcher(fetcherKey); | ||
| let fetcherWithComponents = React__namespace.useMemo(() => _extends({ | ||
| Form, | ||
| submit, | ||
| load | ||
| }, fetcher), [fetcher, Form, submit, load]); | ||
| React__namespace.useEffect(() => { | ||
| // Is this busted when the React team gets real weird and calls effects | ||
| // twice on mount? We really just need to garbage collect here when this | ||
| // fetcher is no longer around. | ||
| return () => { | ||
| if (!router$1) { | ||
| console.warn("No router available to clean up from useFetcher()"); | ||
| return; | ||
| } | ||
| router$1.deleteFetcher(fetcherKey); | ||
| }; | ||
| }, [router$1, fetcherKey]); | ||
| return fetcherWithComponents; | ||
| } | ||
| /** | ||
| * Provides all fetchers currently on the page. Useful for layouts and parent | ||
| * routes that need to provide pending/optimistic UI regarding the fetch. | ||
| */ | ||
| function useFetchers() { | ||
| let state = useDataRouterState(DataRouterStateHook.UseFetchers); | ||
| return [...state.fetchers.values()]; | ||
| } | ||
| const SCROLL_RESTORATION_STORAGE_KEY = "react-router-scroll-positions"; | ||
| let savedScrollPositions = {}; | ||
| /** | ||
| * When rendered inside a RouterProvider, will restore scroll positions on navigations | ||
| */ | ||
| function useScrollRestoration(_temp3) { | ||
| let { | ||
| getKey, | ||
| storageKey | ||
| } = _temp3 === void 0 ? {} : _temp3; | ||
| let { | ||
| router: router$1 | ||
| } = useDataRouterContext(DataRouterHook.UseScrollRestoration); | ||
| let { | ||
| restoreScrollPosition, | ||
| preventScrollReset | ||
| } = useDataRouterState(DataRouterStateHook.UseScrollRestoration); | ||
| let { | ||
| basename | ||
| } = React__namespace.useContext(reactRouter.UNSAFE_NavigationContext); | ||
| let location = reactRouter.useLocation(); | ||
| let matches = reactRouter.useMatches(); | ||
| let navigation = reactRouter.useNavigation(); | ||
| // Trigger manual scroll restoration while we're active | ||
| React__namespace.useEffect(() => { | ||
| window.history.scrollRestoration = "manual"; | ||
| return () => { | ||
| window.history.scrollRestoration = "auto"; | ||
| }; | ||
| }, []); | ||
| // Save positions on pagehide | ||
| usePageHide(React__namespace.useCallback(() => { | ||
| if (navigation.state === "idle") { | ||
| let key = (getKey ? getKey(location, matches) : null) || location.key; | ||
| savedScrollPositions[key] = window.scrollY; | ||
| } | ||
| try { | ||
| sessionStorage.setItem(storageKey || SCROLL_RESTORATION_STORAGE_KEY, JSON.stringify(savedScrollPositions)); | ||
| } catch (error) { | ||
| router.UNSAFE_warning(false, "Failed to save scroll positions in sessionStorage, <ScrollRestoration /> will not work properly (" + error + ").") ; | ||
| } | ||
| window.history.scrollRestoration = "auto"; | ||
| }, [storageKey, getKey, navigation.state, location, matches])); | ||
| // Read in any saved scroll locations | ||
| if (typeof document !== "undefined") { | ||
| // eslint-disable-next-line react-hooks/rules-of-hooks | ||
| React__namespace.useLayoutEffect(() => { | ||
| try { | ||
| let sessionPositions = sessionStorage.getItem(storageKey || SCROLL_RESTORATION_STORAGE_KEY); | ||
| if (sessionPositions) { | ||
| savedScrollPositions = JSON.parse(sessionPositions); | ||
| } | ||
| } catch (e) { | ||
| // no-op, use default empty object | ||
| } | ||
| }, [storageKey]); | ||
| // Enable scroll restoration in the router | ||
| // eslint-disable-next-line react-hooks/rules-of-hooks | ||
| React__namespace.useLayoutEffect(() => { | ||
| let getKeyWithoutBasename = getKey && basename !== "/" ? (location, matches) => getKey( // Strip the basename to match useLocation() | ||
| _extends({}, location, { | ||
| pathname: router.stripBasename(location.pathname, basename) || location.pathname | ||
| }), matches) : getKey; | ||
| let disableScrollRestoration = router$1 == null ? void 0 : router$1.enableScrollRestoration(savedScrollPositions, () => window.scrollY, getKeyWithoutBasename); | ||
| return () => disableScrollRestoration && disableScrollRestoration(); | ||
| }, [router$1, basename, getKey]); | ||
| // Restore scrolling when state.restoreScrollPosition changes | ||
| // eslint-disable-next-line react-hooks/rules-of-hooks | ||
| React__namespace.useLayoutEffect(() => { | ||
| // Explicit false means don't do anything (used for submissions) | ||
| if (restoreScrollPosition === false) { | ||
| return; | ||
| } | ||
| // been here before, scroll to it | ||
| if (typeof restoreScrollPosition === "number") { | ||
| window.scrollTo(0, restoreScrollPosition); | ||
| return; | ||
| } | ||
| // try to scroll to the hash | ||
| if (location.hash) { | ||
| let el = document.getElementById(decodeURIComponent(location.hash.slice(1))); | ||
| if (el) { | ||
| el.scrollIntoView(); | ||
| return; | ||
| } | ||
| } | ||
| // Don't reset if this navigation opted out | ||
| if (preventScrollReset === true) { | ||
| return; | ||
| } | ||
| // otherwise go to the top on new locations | ||
| window.scrollTo(0, 0); | ||
| }, [location, restoreScrollPosition, preventScrollReset]); | ||
| } | ||
| } | ||
| /** | ||
| * Setup a callback to be fired on the window's `beforeunload` event. This is | ||
| * useful for saving some data to `window.localStorage` just before the page | ||
| * refreshes. | ||
| * | ||
| * Note: The `callback` argument should be a function created with | ||
| * `React.useCallback()`. | ||
| */ | ||
| function useBeforeUnload(callback, options) { | ||
| let { | ||
| capture | ||
| } = options || {}; | ||
| React__namespace.useEffect(() => { | ||
| let opts = capture != null ? { | ||
| capture | ||
| } : undefined; | ||
| window.addEventListener("beforeunload", callback, opts); | ||
| return () => { | ||
| window.removeEventListener("beforeunload", callback, opts); | ||
| }; | ||
| }, [callback, capture]); | ||
| } | ||
| /** | ||
| * Setup a callback to be fired on the window's `pagehide` event. This is | ||
| * useful for saving some data to `window.localStorage` just before the page | ||
| * refreshes. This event is better supported than beforeunload across browsers. | ||
| * | ||
| * Note: The `callback` argument should be a function created with | ||
| * `React.useCallback()`. | ||
| */ | ||
| function usePageHide(callback, options) { | ||
| let { | ||
| capture | ||
| } = options || {}; | ||
| React__namespace.useEffect(() => { | ||
| let opts = capture != null ? { | ||
| capture | ||
| } : undefined; | ||
| window.addEventListener("pagehide", callback, opts); | ||
| return () => { | ||
| window.removeEventListener("pagehide", callback, opts); | ||
| }; | ||
| }, [callback, capture]); | ||
| } | ||
| /** | ||
| * Wrapper around useBlocker to show a window.confirm prompt to users instead | ||
| * of building a custom UI with useBlocker. | ||
| * | ||
| * Warning: This has *a lot of rough edges* and behaves very differently (and | ||
| * very incorrectly in some cases) across browsers if user click addition | ||
| * back/forward navigations while the confirm is open. Use at your own risk. | ||
| */ | ||
| function usePrompt(_ref8) { | ||
| let { | ||
| when, | ||
| message | ||
| } = _ref8; | ||
| let blocker = reactRouter.unstable_useBlocker(when); | ||
| React__namespace.useEffect(() => { | ||
| if (blocker.state === "blocked") { | ||
| let proceed = window.confirm(message); | ||
| if (proceed) { | ||
| // This timeout is needed to avoid a weird "race" on POP navigations | ||
| // between the `window.history` revert navigation and the result of | ||
| // `window.confirm` | ||
| setTimeout(blocker.proceed, 0); | ||
| } else { | ||
| blocker.reset(); | ||
| } | ||
| } | ||
| }, [blocker, message]); | ||
| React__namespace.useEffect(() => { | ||
| if (blocker.state === "blocked" && !when) { | ||
| blocker.reset(); | ||
| } | ||
| }, [blocker, when]); | ||
| } | ||
| /** | ||
| * Return a boolean indicating if there is an active view transition to the | ||
| * given href. You can use this value to render CSS classes or viewTransitionName | ||
| * styles onto your elements | ||
| * | ||
| * @param href The destination href | ||
| * @param [opts.relative] Relative routing type ("route" | "path") | ||
| */ | ||
| function useViewTransitionState(to, opts) { | ||
| if (opts === void 0) { | ||
| opts = {}; | ||
| } | ||
| let vtContext = React__namespace.useContext(reactRouter.UNSAFE_ViewTransitionContext); | ||
| let { | ||
| basename | ||
| } = useDataRouterContext(DataRouterHook.useViewTransitionState); | ||
| let path = reactRouter.useResolvedPath(to, { | ||
| relative: opts.relative | ||
| }); | ||
| if (vtContext.isTransitioning) { | ||
| let currentPath = router.stripBasename(vtContext.currentLocation.pathname, basename) || vtContext.currentLocation.pathname; | ||
| let nextPath = router.stripBasename(vtContext.nextLocation.pathname, basename) || vtContext.nextLocation.pathname; | ||
| // Transition is active if we're going to or coming from the indicated | ||
| // destination. This ensures that other PUSH navigations that reverse | ||
| // an indicated transition apply. I.e., on the list view you have: | ||
| // | ||
| // <NavLink to="/details/1" unstable_viewTransition> | ||
| // | ||
| // If you click the breadcrumb back to the list view: | ||
| // | ||
| // <NavLink to="/list" unstable_viewTransition> | ||
| // | ||
| // We should apply the transition because it's indicated as active going | ||
| // from /list -> /details/1 and therefore should be active on the reverse | ||
| // (even though this isn't strictly a POP reverse) | ||
| return router.matchPath(path.pathname, nextPath) != null || router.matchPath(path.pathname, currentPath) != null; | ||
| } | ||
| return false; | ||
| } | ||
| //#endregion | ||
| Object.defineProperty(exports, 'AbortedDeferredError', { | ||
@@ -1221,2 +32,26 @@ enumerable: true, | ||
| }); | ||
| Object.defineProperty(exports, 'BrowserRouter', { | ||
| enumerable: true, | ||
| get: function () { return reactRouter.BrowserRouter; } | ||
| }); | ||
| Object.defineProperty(exports, 'Form', { | ||
| enumerable: true, | ||
| get: function () { return reactRouter.Form; } | ||
| }); | ||
| Object.defineProperty(exports, 'HashRouter', { | ||
| enumerable: true, | ||
| get: function () { return reactRouter.HashRouter; } | ||
| }); | ||
| Object.defineProperty(exports, 'HydratedRouter', { | ||
| enumerable: true, | ||
| get: function () { return reactRouter.HydratedRouter; } | ||
| }); | ||
| Object.defineProperty(exports, 'Link', { | ||
| enumerable: true, | ||
| get: function () { return reactRouter.Link; } | ||
| }); | ||
| Object.defineProperty(exports, 'Links', { | ||
| enumerable: true, | ||
| get: function () { return reactRouter.Links; } | ||
| }); | ||
| Object.defineProperty(exports, 'MemoryRouter', { | ||
@@ -1226,2 +61,10 @@ enumerable: true, | ||
| }); | ||
| Object.defineProperty(exports, 'Meta', { | ||
| enumerable: true, | ||
| get: function () { return reactRouter.Meta; } | ||
| }); | ||
| Object.defineProperty(exports, 'NavLink', { | ||
| enumerable: true, | ||
| get: function () { return reactRouter.NavLink; } | ||
| }); | ||
| Object.defineProperty(exports, 'Navigate', { | ||
@@ -1239,2 +82,10 @@ enumerable: true, | ||
| }); | ||
| Object.defineProperty(exports, 'PrefetchPageLinks', { | ||
| enumerable: true, | ||
| get: function () { return reactRouter.PrefetchPageLinks; } | ||
| }); | ||
| Object.defineProperty(exports, 'RemixServer', { | ||
| enumerable: true, | ||
| get: function () { return reactRouter.RemixServer; } | ||
| }); | ||
| Object.defineProperty(exports, 'Route', { | ||
@@ -1256,2 +107,22 @@ enumerable: true, | ||
| }); | ||
| Object.defineProperty(exports, 'Scripts', { | ||
| enumerable: true, | ||
| get: function () { return reactRouter.Scripts; } | ||
| }); | ||
| Object.defineProperty(exports, 'ScrollRestoration', { | ||
| enumerable: true, | ||
| get: function () { return reactRouter.ScrollRestoration; } | ||
| }); | ||
| Object.defineProperty(exports, 'StaticRouter', { | ||
| enumerable: true, | ||
| get: function () { return reactRouter.StaticRouter; } | ||
| }); | ||
| Object.defineProperty(exports, 'StaticRouterProvider', { | ||
| enumerable: true, | ||
| get: function () { return reactRouter.StaticRouterProvider; } | ||
| }); | ||
| Object.defineProperty(exports, 'UNSAFE_DEFERRED_SYMBOL', { | ||
| enumerable: true, | ||
| get: function () { return reactRouter.UNSAFE_DEFERRED_SYMBOL; } | ||
| }); | ||
| Object.defineProperty(exports, 'UNSAFE_DataRouterContext', { | ||
@@ -1265,2 +136,10 @@ enumerable: true, | ||
| }); | ||
| Object.defineProperty(exports, 'UNSAFE_ErrorResponseImpl', { | ||
| enumerable: true, | ||
| get: function () { return reactRouter.UNSAFE_ErrorResponseImpl; } | ||
| }); | ||
| Object.defineProperty(exports, 'UNSAFE_FetchersContext', { | ||
| enumerable: true, | ||
| get: function () { return reactRouter.UNSAFE_FetchersContext; } | ||
| }); | ||
| Object.defineProperty(exports, 'UNSAFE_LocationContext', { | ||
@@ -1274,2 +153,6 @@ enumerable: true, | ||
| }); | ||
| Object.defineProperty(exports, 'UNSAFE_RemixContext', { | ||
| enumerable: true, | ||
| get: function () { return reactRouter.UNSAFE_RemixContext; } | ||
| }); | ||
| Object.defineProperty(exports, 'UNSAFE_RouteContext', { | ||
@@ -1279,2 +162,6 @@ enumerable: true, | ||
| }); | ||
| Object.defineProperty(exports, 'UNSAFE_SingleFetchRedirectSymbol', { | ||
| enumerable: true, | ||
| get: function () { return reactRouter.UNSAFE_SingleFetchRedirectSymbol; } | ||
| }); | ||
| Object.defineProperty(exports, 'UNSAFE_ViewTransitionContext', { | ||
@@ -1284,2 +171,14 @@ enumerable: true, | ||
| }); | ||
| Object.defineProperty(exports, 'UNSAFE_convertRoutesToDataRoutes', { | ||
| enumerable: true, | ||
| get: function () { return reactRouter.UNSAFE_convertRoutesToDataRoutes; } | ||
| }); | ||
| Object.defineProperty(exports, 'UNSAFE_decodeViaTurboStream', { | ||
| enumerable: true, | ||
| get: function () { return reactRouter.UNSAFE_decodeViaTurboStream; } | ||
| }); | ||
| Object.defineProperty(exports, 'UNSAFE_mapRouteProperties', { | ||
| enumerable: true, | ||
| get: function () { return reactRouter.UNSAFE_mapRouteProperties; } | ||
| }); | ||
| Object.defineProperty(exports, 'UNSAFE_useRouteId', { | ||
@@ -1289,2 +188,18 @@ enumerable: true, | ||
| }); | ||
| Object.defineProperty(exports, 'UNSAFE_useRoutesImpl', { | ||
| enumerable: true, | ||
| get: function () { return reactRouter.UNSAFE_useRoutesImpl; } | ||
| }); | ||
| Object.defineProperty(exports, 'UNSAFE_useScrollRestoration', { | ||
| enumerable: true, | ||
| get: function () { return reactRouter.UNSAFE_useScrollRestoration; } | ||
| }); | ||
| Object.defineProperty(exports, 'createBrowserRouter', { | ||
| enumerable: true, | ||
| get: function () { return reactRouter.createBrowserRouter; } | ||
| }); | ||
| Object.defineProperty(exports, 'createHashRouter', { | ||
| enumerable: true, | ||
| get: function () { return reactRouter.createHashRouter; } | ||
| }); | ||
| Object.defineProperty(exports, 'createMemoryRouter', { | ||
@@ -1298,2 +213,6 @@ enumerable: true, | ||
| }); | ||
| Object.defineProperty(exports, 'createRemixStub', { | ||
| enumerable: true, | ||
| get: function () { return reactRouter.createRemixStub; } | ||
| }); | ||
| Object.defineProperty(exports, 'createRoutesFromChildren', { | ||
@@ -1305,4 +224,16 @@ enumerable: true, | ||
| enumerable: true, | ||
| get: function () { return reactRouter.createRoutesFromElements; } | ||
| get: function () { return reactRouter.createRoutesFromChildren; } | ||
| }); | ||
| Object.defineProperty(exports, 'createSearchParams', { | ||
| enumerable: true, | ||
| get: function () { return reactRouter.createSearchParams; } | ||
| }); | ||
| Object.defineProperty(exports, 'createStaticHandler', { | ||
| enumerable: true, | ||
| get: function () { return reactRouter.createStaticHandler; } | ||
| }); | ||
| Object.defineProperty(exports, 'createStaticRouter', { | ||
| enumerable: true, | ||
| get: function () { return reactRouter.createStaticRouter; } | ||
| }); | ||
| Object.defineProperty(exports, 'defer', { | ||
@@ -1316,2 +247,6 @@ enumerable: true, | ||
| }); | ||
| Object.defineProperty(exports, 'getStaticContextFromError', { | ||
| enumerable: true, | ||
| get: function () { return reactRouter.getStaticContextFromError; } | ||
| }); | ||
| Object.defineProperty(exports, 'isRouteErrorResponse', { | ||
@@ -1353,6 +288,18 @@ enumerable: true, | ||
| }); | ||
| Object.defineProperty(exports, 'unstable_useBlocker', { | ||
| Object.defineProperty(exports, 'stripBasename', { | ||
| enumerable: true, | ||
| get: function () { return reactRouter.unstable_useBlocker; } | ||
| get: function () { return reactRouter.stripBasename; } | ||
| }); | ||
| Object.defineProperty(exports, 'unstable_HistoryRouter', { | ||
| enumerable: true, | ||
| get: function () { return reactRouter.unstable_HistoryRouter; } | ||
| }); | ||
| Object.defineProperty(exports, 'unstable_usePrompt', { | ||
| enumerable: true, | ||
| get: function () { return reactRouter.unstable_usePrompt; } | ||
| }); | ||
| Object.defineProperty(exports, 'unstable_useViewTransitionState', { | ||
| enumerable: true, | ||
| get: function () { return reactRouter.unstable_useViewTransitionState; } | ||
| }); | ||
| Object.defineProperty(exports, 'useActionData', { | ||
@@ -1370,2 +317,22 @@ enumerable: true, | ||
| }); | ||
| Object.defineProperty(exports, 'useBeforeUnload', { | ||
| enumerable: true, | ||
| get: function () { return reactRouter.useBeforeUnload; } | ||
| }); | ||
| Object.defineProperty(exports, 'useBlocker', { | ||
| enumerable: true, | ||
| get: function () { return reactRouter.useBlocker; } | ||
| }); | ||
| Object.defineProperty(exports, 'useFetcher', { | ||
| enumerable: true, | ||
| get: function () { return reactRouter.useFetcher; } | ||
| }); | ||
| Object.defineProperty(exports, 'useFetchers', { | ||
| enumerable: true, | ||
| get: function () { return reactRouter.useFetchers; } | ||
| }); | ||
| Object.defineProperty(exports, 'useFormAction', { | ||
| enumerable: true, | ||
| get: function () { return reactRouter.useFormAction; } | ||
| }); | ||
| Object.defineProperty(exports, 'useHref', { | ||
@@ -1379,2 +346,6 @@ enumerable: true, | ||
| }); | ||
| Object.defineProperty(exports, 'useLinkClickHandler', { | ||
| enumerable: true, | ||
| get: function () { return reactRouter.useLinkClickHandler; } | ||
| }); | ||
| Object.defineProperty(exports, 'useLoaderData', { | ||
@@ -1440,22 +411,10 @@ enumerable: true, | ||
| }); | ||
| exports.BrowserRouter = BrowserRouter; | ||
| exports.Form = Form; | ||
| exports.HashRouter = HashRouter; | ||
| exports.Link = Link; | ||
| exports.NavLink = NavLink; | ||
| exports.ScrollRestoration = ScrollRestoration; | ||
| exports.UNSAFE_useScrollRestoration = useScrollRestoration; | ||
| exports.createBrowserRouter = createBrowserRouter; | ||
| exports.createHashRouter = createHashRouter; | ||
| exports.createSearchParams = createSearchParams; | ||
| exports.unstable_HistoryRouter = HistoryRouter; | ||
| exports.unstable_usePrompt = usePrompt; | ||
| exports.unstable_useViewTransitionState = useViewTransitionState; | ||
| exports.useBeforeUnload = useBeforeUnload; | ||
| exports.useFetcher = useFetcher; | ||
| exports.useFetchers = useFetchers; | ||
| exports.useFormAction = useFormAction; | ||
| exports.useLinkClickHandler = useLinkClickHandler; | ||
| exports.useSearchParams = useSearchParams; | ||
| exports.useSubmit = useSubmit; | ||
| Object.defineProperty(exports, 'useSearchParams', { | ||
| enumerable: true, | ||
| get: function () { return reactRouter.useSearchParams; } | ||
| }); | ||
| Object.defineProperty(exports, 'useSubmit', { | ||
| enumerable: true, | ||
| get: function () { return reactRouter.useSubmit; } | ||
| }); | ||
@@ -1462,0 +421,0 @@ Object.defineProperty(exports, '__esModule', { value: true }); |
| /** | ||
| * React Router DOM v0.0.0-experimental-4a8a492a | ||
| * React Router v0.0.0-experimental-4ed3f5da9 | ||
| * | ||
@@ -11,3 +11,3 @@ * Copyright (c) Remix Software Inc. | ||
| */ | ||
| !function(e,t){"object"==typeof exports&&"undefined"!=typeof module?t(exports,require("react"),require("react-router"),require("@remix-run/router")):"function"==typeof define&&define.amd?define(["exports","react","react-router","@remix-run/router"],t):t((e="undefined"!=typeof globalThis?globalThis:e||self).ReactRouterDOM={},e.React,e.ReactRouter,e.RemixRouter)}(this,(function(e,t,n,r){"use strict";function o(e){if(e&&e.__esModule)return e;var t=Object.create(null);return e&&Object.keys(e).forEach((function(n){if("default"!==n){var r=Object.getOwnPropertyDescriptor(e,n);Object.defineProperty(t,n,r.get?r:{enumerable:!0,get:function(){return e[n]}})}})),t.default=e,Object.freeze(t)}var a=o(t);function i(){return i=Object.assign?Object.assign.bind():function(e){for(var t=1;t<arguments.length;t++){var n=arguments[t];for(var r in n)Object.prototype.hasOwnProperty.call(n,r)&&(e[r]=n[r])}return e},i.apply(this,arguments)}function u(e,t){if(null==e)return{};var n,r,o={},a=Object.keys(e);for(r=0;r<a.length;r++)n=a[r],t.indexOf(n)>=0||(o[n]=e[n]);return o}const s="get",c="application/x-www-form-urlencoded";function l(e){return null!=e&&"string"==typeof e.tagName}function f(e){return void 0===e&&(e=""),new URLSearchParams("string"==typeof e||Array.isArray(e)||e instanceof URLSearchParams?e:Object.keys(e).reduce(((t,n)=>{let r=e[n];return t.concat(Array.isArray(r)?r.map((e=>[n,e])):[[n,r]])}),[]))}let d=null;const m=new Set(["application/x-www-form-urlencoded","multipart/form-data","text/plain"]);function b(e){return null==e||m.has(e)?e:null}function p(e,t){let n,o,a,i,u;if(l(f=e)&&"form"===f.tagName.toLowerCase()){let u=e.getAttribute("action");o=u?r.stripBasename(u,t):null,n=e.getAttribute("method")||s,a=b(e.getAttribute("enctype"))||c,i=new FormData(e)}else if(function(e){return l(e)&&"button"===e.tagName.toLowerCase()}(e)||function(e){return l(e)&&"input"===e.tagName.toLowerCase()}(e)&&("submit"===e.type||"image"===e.type)){let u=e.form;if(null==u)throw new Error('Cannot submit a <button> or <input type="submit"> without a <form>');let l=e.getAttribute("formaction")||u.getAttribute("action");if(o=l?r.stripBasename(l,t):null,n=e.getAttribute("formmethod")||u.getAttribute("method")||s,a=b(e.getAttribute("formenctype"))||b(u.getAttribute("enctype"))||c,i=new FormData(u,e),!function(){if(null===d)try{new FormData(document.createElement("form"),0),d=!1}catch(e){d=!0}return d}()){let{name:t,type:n,value:r}=e;if("image"===n){let e=t?t+".":"";i.append(e+"x","0"),i.append(e+"y","0")}else t&&i.append(t,r)}}else{if(l(e))throw new Error('Cannot submit element that is not <form>, <button>, or <input type="submit|image">');n=s,o=null,a=c,u=e}var f;return i&&"text/plain"===a&&(u=i,i=void 0),{action:o,method:n.toLowerCase(),encType:a,formData:i,body:u}}const h=["onClick","relative","reloadDocument","replace","state","target","to","preventScrollReset","unstable_viewTransition"],y=["aria-current","caseSensitive","className","end","style","to","unstable_viewTransition","children"],v=["reloadDocument","replace","state","method","action","onSubmit","submit","relative","preventScrollReset","unstable_viewTransition"];function g(){var e;let t=null==(e=window)?void 0:e.__staticRouterHydrationData;return t&&t.errors&&(t=i({},t,{errors:w(t.errors)})),t}function w(e){if(!e)return null;let t=Object.entries(e),n={};for(let[e,o]of t)if(o&&"RouteErrorResponse"===o.__type)n[e]=new r.UNSAFE_ErrorResponseImpl(o.status,o.statusText,o.data,!0===o.internal);else if(o&&"Error"===o.__type){if(o.__subType){let t=window[o.__subType];if("function"==typeof t)try{let r=new t(o.message);r.stack="",n[e]=r}catch(e){}}if(null==n[e]){let t=new Error(o.message);t.stack="",n[e]=t}}else n[e]=o;return n}const R=a.startTransition;const S="undefined"!=typeof window&&void 0!==window.document&&void 0!==window.document.createElement,P=/^(?:[a-z][a-z0-9+.-]*:|\/\/)/i,E=a.forwardRef((function(e,t){let o,{onClick:s,relative:c,reloadDocument:l,replace:f,state:d,target:m,to:b,preventScrollReset:p,unstable_viewTransition:y}=e,v=u(e,h),{basename:g}=a.useContext(n.UNSAFE_NavigationContext),w=!1;if("string"==typeof b&&P.test(b)&&(o=b,S))try{let e=new URL(window.location.href),t=b.startsWith("//")?new URL(e.protocol+b):new URL(b),n=r.stripBasename(t.pathname,g);t.origin===e.origin&&null!=n?b=n+t.search+t.hash:w=!0}catch(e){}let R=n.useHref(b,{relative:c}),E=x(b,{replace:f,state:d,target:m,preventScrollReset:p,relative:c,unstable_viewTransition:y});return a.createElement("a",i({},v,{href:o||R,onClick:w||l?s:function(e){s&&s(e),e.defaultPrevented||E(e)},ref:t,target:m}))})),_=a.forwardRef((function(e,t){let{"aria-current":r="page",caseSensitive:o=!1,className:s="",end:c=!1,style:l,to:f,unstable_viewTransition:d,children:m}=e,b=u(e,y),p=n.useResolvedPath(f,{relative:b.relative}),h=n.useLocation(),v=a.useContext(n.UNSAFE_DataRouterStateContext),{navigator:g}=a.useContext(n.UNSAFE_NavigationContext),w=I(p)&&!0===d,R=g.encodeLocation?g.encodeLocation(p).pathname:p.pathname,S=h.pathname,P=v&&v.navigation&&v.navigation.location?v.navigation.location.pathname:null;o||(S=S.toLowerCase(),P=P?P.toLowerCase():null,R=R.toLowerCase());let _,O=S===R||!c&&S.startsWith(R)&&"/"===S.charAt(R.length),N=null!=P&&(P===R||!c&&P.startsWith(R)&&"/"===P.charAt(R.length)),j={isActive:O,isPending:N,isTransitioning:w},A=O?r:void 0;_="function"==typeof s?s(j):[s,O?"active":null,N?"pending":null,w?"transitioning":null].filter(Boolean).join(" ");let C="function"==typeof l?l(j):l;return a.createElement(E,i({},b,{"aria-current":A,className:_,ref:t,style:C,to:f,unstable_viewTransition:d}),"function"==typeof m?m(j):m)})),O=a.forwardRef(((e,t)=>{let n=T();return a.createElement(N,i({},e,{submit:n,ref:t}))})),N=a.forwardRef(((e,t)=>{let{reloadDocument:n,replace:r,state:o,method:c=s,action:l,onSubmit:f,submit:d,relative:m,preventScrollReset:b,unstable_viewTransition:p}=e,h=u(e,v),y="get"===c.toLowerCase()?"get":"post",g=D(l,{relative:m});return a.createElement("form",i({ref:t,method:y,action:g,onSubmit:n?f:e=>{if(f&&f(e),e.defaultPrevented)return;e.preventDefault();let t=e.nativeEvent.submitter,n=(null==t?void 0:t.getAttribute("formmethod"))||c;d(t||e.currentTarget,{method:n,replace:r,state:o,relative:m,preventScrollReset:b,unstable_viewTransition:p})}},h))}));var j=function(e){return e.UseScrollRestoration="useScrollRestoration",e.UseSubmit="useSubmit",e.UseSubmitFetcher="useSubmitFetcher",e.UseFetcher="useFetcher",e.useViewTransitionStates="useViewTransitionStates",e.useViewTransitionState="useViewTransitionState",e}(j||{}),A=function(e){return e.UseFetchers="useFetchers",e.UseScrollRestoration="useScrollRestoration",e}(A||{});function C(e){let t=a.useContext(n.UNSAFE_DataRouterContext);return t||r.UNSAFE_invariant(!1),t}function F(e){let t=a.useContext(n.UNSAFE_DataRouterStateContext);return t||r.UNSAFE_invariant(!1),t}function x(e,t){let{target:r,replace:o,state:i,preventScrollReset:u,relative:s,unstable_viewTransition:c}=void 0===t?{}:t,l=n.useNavigate(),f=n.useLocation(),d=n.useResolvedPath(e,{relative:s});return a.useCallback((t=>{if(function(e,t){return!(0!==e.button||t&&"_self"!==t||function(e){return!!(e.metaKey||e.altKey||e.ctrlKey||e.shiftKey)}(e))}(t,r)){t.preventDefault();let r=void 0!==o?o:n.createPath(f)===n.createPath(d);l(e,{replace:r,state:i,preventScrollReset:u,relative:s,unstable_viewTransition:c})}}),[f,l,d,o,i,r,e,u,s,c])}function U(){if("undefined"==typeof document)throw new Error("You are calling submit during the server render. Try calling submit within a `useEffect` or callback instead.")}function T(){let{router:e}=C(j.UseSubmit),{basename:t}=a.useContext(n.UNSAFE_NavigationContext),r=n.UNSAFE_useRouteId();return a.useCallback((function(n,o){void 0===o&&(o={}),U();let{action:a,method:i,encType:u,formData:s,body:c}=p(n,t);e.navigate(o.action||a,{preventScrollReset:o.preventScrollReset,formData:s,body:c,formMethod:o.method||i,formEncType:o.encType||u,replace:o.replace,state:o.state,fromRouteId:r,unstable_viewTransition:o.unstable_viewTransition})}),[e,t,r])}function L(e,t){let{router:o}=C(j.UseSubmitFetcher),{basename:i}=a.useContext(n.UNSAFE_NavigationContext);return a.useCallback((function(n,a){void 0===a&&(a={}),U();let{action:u,method:s,encType:c,formData:l,body:f}=p(n,i);null==t&&r.UNSAFE_invariant(!1),o.fetch(e,t,a.action||u,{preventScrollReset:a.preventScrollReset,formData:l,body:f,formMethod:a.method||s,formEncType:a.encType||c})}),[o,i,e,t])}function D(e,t){let{relative:o}=void 0===t?{}:t,{basename:u}=a.useContext(n.UNSAFE_NavigationContext),s=a.useContext(n.UNSAFE_RouteContext);s||r.UNSAFE_invariant(!1);let[c]=s.matches.slice(-1),l=i({},n.useResolvedPath(e||".",{relative:o})),f=n.useLocation();if(null==e&&(l.search=f.search,c.route.index)){let e=new URLSearchParams(l.search);e.delete("index"),l.search=e.toString()?"?"+e.toString():""}return e&&"."!==e||!c.route.index||(l.search=l.search?l.search.replace(/^\?/,"?index&"):"?index"),"/"!==u&&(l.pathname="/"===l.pathname?u:r.joinPaths([u,l.pathname])),n.createPath(l)}let k=0;const B="react-router-scroll-positions";let M={};function H(e){let{getKey:t,storageKey:o}=void 0===e?{}:e,{router:u}=C(j.UseScrollRestoration),{restoreScrollPosition:s,preventScrollReset:c}=F(A.UseScrollRestoration),{basename:l}=a.useContext(n.UNSAFE_NavigationContext),f=n.useLocation(),d=n.useMatches(),m=n.useNavigation();a.useEffect((()=>(window.history.scrollRestoration="manual",()=>{window.history.scrollRestoration="auto"})),[]),function(e,t){let{capture:n}=t||{};a.useEffect((()=>{let t=null!=n?{capture:n}:void 0;return window.addEventListener("pagehide",e,t),()=>{window.removeEventListener("pagehide",e,t)}}),[e,n])}(a.useCallback((()=>{if("idle"===m.state){let e=(t?t(f,d):null)||f.key;M[e]=window.scrollY}try{sessionStorage.setItem(o||B,JSON.stringify(M))}catch(e){}window.history.scrollRestoration="auto"}),[o,t,m.state,f,d])),"undefined"!=typeof document&&(a.useLayoutEffect((()=>{try{let e=sessionStorage.getItem(o||B);e&&(M=JSON.parse(e))}catch(e){}}),[o]),a.useLayoutEffect((()=>{let e=t&&"/"!==l?(e,n)=>t(i({},e,{pathname:r.stripBasename(e.pathname,l)||e.pathname}),n):t,n=null==u?void 0:u.enableScrollRestoration(M,(()=>window.scrollY),e);return()=>n&&n()}),[u,l,t]),a.useLayoutEffect((()=>{if(!1!==s)if("number"!=typeof s){if(f.hash){let e=document.getElementById(decodeURIComponent(f.hash.slice(1)));if(e)return void e.scrollIntoView()}!0!==c&&window.scrollTo(0,0)}else window.scrollTo(0,s)}),[f,s,c]))}function I(e,t){void 0===t&&(t={});let o=a.useContext(n.UNSAFE_ViewTransitionContext),{basename:i}=C(j.useViewTransitionState),u=n.useResolvedPath(e,{relative:t.relative});if(o.isTransitioning){let e=r.stripBasename(o.currentLocation.pathname,i)||o.currentLocation.pathname,t=r.stripBasename(o.nextLocation.pathname,i)||o.nextLocation.pathname;return null!=r.matchPath(u.pathname,t)||null!=r.matchPath(u.pathname,e)}return!1}Object.defineProperty(e,"AbortedDeferredError",{enumerable:!0,get:function(){return n.AbortedDeferredError}}),Object.defineProperty(e,"Await",{enumerable:!0,get:function(){return n.Await}}),Object.defineProperty(e,"MemoryRouter",{enumerable:!0,get:function(){return n.MemoryRouter}}),Object.defineProperty(e,"Navigate",{enumerable:!0,get:function(){return n.Navigate}}),Object.defineProperty(e,"NavigationType",{enumerable:!0,get:function(){return n.NavigationType}}),Object.defineProperty(e,"Outlet",{enumerable:!0,get:function(){return n.Outlet}}),Object.defineProperty(e,"Route",{enumerable:!0,get:function(){return n.Route}}),Object.defineProperty(e,"Router",{enumerable:!0,get:function(){return n.Router}}),Object.defineProperty(e,"RouterProvider",{enumerable:!0,get:function(){return n.RouterProvider}}),Object.defineProperty(e,"Routes",{enumerable:!0,get:function(){return n.Routes}}),Object.defineProperty(e,"UNSAFE_DataRouterContext",{enumerable:!0,get:function(){return n.UNSAFE_DataRouterContext}}),Object.defineProperty(e,"UNSAFE_DataRouterStateContext",{enumerable:!0,get:function(){return n.UNSAFE_DataRouterStateContext}}),Object.defineProperty(e,"UNSAFE_LocationContext",{enumerable:!0,get:function(){return n.UNSAFE_LocationContext}}),Object.defineProperty(e,"UNSAFE_NavigationContext",{enumerable:!0,get:function(){return n.UNSAFE_NavigationContext}}),Object.defineProperty(e,"UNSAFE_RouteContext",{enumerable:!0,get:function(){return n.UNSAFE_RouteContext}}),Object.defineProperty(e,"UNSAFE_ViewTransitionContext",{enumerable:!0,get:function(){return n.UNSAFE_ViewTransitionContext}}),Object.defineProperty(e,"UNSAFE_useRouteId",{enumerable:!0,get:function(){return n.UNSAFE_useRouteId}}),Object.defineProperty(e,"createMemoryRouter",{enumerable:!0,get:function(){return n.createMemoryRouter}}),Object.defineProperty(e,"createPath",{enumerable:!0,get:function(){return n.createPath}}),Object.defineProperty(e,"createRoutesFromChildren",{enumerable:!0,get:function(){return n.createRoutesFromChildren}}),Object.defineProperty(e,"createRoutesFromElements",{enumerable:!0,get:function(){return n.createRoutesFromElements}}),Object.defineProperty(e,"defer",{enumerable:!0,get:function(){return n.defer}}),Object.defineProperty(e,"generatePath",{enumerable:!0,get:function(){return n.generatePath}}),Object.defineProperty(e,"isRouteErrorResponse",{enumerable:!0,get:function(){return n.isRouteErrorResponse}}),Object.defineProperty(e,"json",{enumerable:!0,get:function(){return n.json}}),Object.defineProperty(e,"matchPath",{enumerable:!0,get:function(){return n.matchPath}}),Object.defineProperty(e,"matchRoutes",{enumerable:!0,get:function(){return n.matchRoutes}}),Object.defineProperty(e,"parsePath",{enumerable:!0,get:function(){return n.parsePath}}),Object.defineProperty(e,"redirect",{enumerable:!0,get:function(){return n.redirect}}),Object.defineProperty(e,"redirectDocument",{enumerable:!0,get:function(){return n.redirectDocument}}),Object.defineProperty(e,"renderMatches",{enumerable:!0,get:function(){return n.renderMatches}}),Object.defineProperty(e,"resolvePath",{enumerable:!0,get:function(){return n.resolvePath}}),Object.defineProperty(e,"unstable_useBlocker",{enumerable:!0,get:function(){return n.unstable_useBlocker}}),Object.defineProperty(e,"useActionData",{enumerable:!0,get:function(){return n.useActionData}}),Object.defineProperty(e,"useAsyncError",{enumerable:!0,get:function(){return n.useAsyncError}}),Object.defineProperty(e,"useAsyncValue",{enumerable:!0,get:function(){return n.useAsyncValue}}),Object.defineProperty(e,"useHref",{enumerable:!0,get:function(){return n.useHref}}),Object.defineProperty(e,"useInRouterContext",{enumerable:!0,get:function(){return n.useInRouterContext}}),Object.defineProperty(e,"useLoaderData",{enumerable:!0,get:function(){return n.useLoaderData}}),Object.defineProperty(e,"useLocation",{enumerable:!0,get:function(){return n.useLocation}}),Object.defineProperty(e,"useMatch",{enumerable:!0,get:function(){return n.useMatch}}),Object.defineProperty(e,"useMatches",{enumerable:!0,get:function(){return n.useMatches}}),Object.defineProperty(e,"useNavigate",{enumerable:!0,get:function(){return n.useNavigate}}),Object.defineProperty(e,"useNavigation",{enumerable:!0,get:function(){return n.useNavigation}}),Object.defineProperty(e,"useNavigationType",{enumerable:!0,get:function(){return n.useNavigationType}}),Object.defineProperty(e,"useOutlet",{enumerable:!0,get:function(){return n.useOutlet}}),Object.defineProperty(e,"useOutletContext",{enumerable:!0,get:function(){return n.useOutletContext}}),Object.defineProperty(e,"useParams",{enumerable:!0,get:function(){return n.useParams}}),Object.defineProperty(e,"useResolvedPath",{enumerable:!0,get:function(){return n.useResolvedPath}}),Object.defineProperty(e,"useRevalidator",{enumerable:!0,get:function(){return n.useRevalidator}}),Object.defineProperty(e,"useRouteError",{enumerable:!0,get:function(){return n.useRouteError}}),Object.defineProperty(e,"useRouteLoaderData",{enumerable:!0,get:function(){return n.useRouteLoaderData}}),Object.defineProperty(e,"useRoutes",{enumerable:!0,get:function(){return n.useRoutes}}),e.BrowserRouter=function(e){let{basename:t,children:o,future:i,window:u}=e,s=a.useRef();null==s.current&&(s.current=r.createBrowserHistory({window:u,v5Compat:!0}));let c=s.current,[l,f]=a.useState({action:c.action,location:c.location}),{v7_startTransition:d}=i||{},m=a.useCallback((e=>{d&&R?R((()=>f(e))):f(e)}),[f,d]);return a.useLayoutEffect((()=>c.listen(m)),[c,m]),a.createElement(n.Router,{basename:t,children:o,location:l.location,navigationType:l.action,navigator:c})},e.Form=O,e.HashRouter=function(e){let{basename:t,children:o,future:i,window:u}=e,s=a.useRef();null==s.current&&(s.current=r.createHashHistory({window:u,v5Compat:!0}));let c=s.current,[l,f]=a.useState({action:c.action,location:c.location}),{v7_startTransition:d}=i||{},m=a.useCallback((e=>{d&&R?R((()=>f(e))):f(e)}),[f,d]);return a.useLayoutEffect((()=>c.listen(m)),[c,m]),a.createElement(n.Router,{basename:t,children:o,location:l.location,navigationType:l.action,navigator:c})},e.Link=E,e.NavLink=_,e.ScrollRestoration=function(e){let{getKey:t,storageKey:n}=e;return H({getKey:t,storageKey:n}),null},e.UNSAFE_useScrollRestoration=H,e.createBrowserRouter=function(e,t){return r.createRouter({basename:null==t?void 0:t.basename,future:i({},null==t?void 0:t.future,{v7_prependBasename:!0}),history:r.createBrowserHistory({window:null==t?void 0:t.window}),hydrationData:(null==t?void 0:t.hydrationData)||g(),routes:e,mapRouteProperties:n.UNSAFE_mapRouteProperties}).initialize()},e.createHashRouter=function(e,t){return r.createRouter({basename:null==t?void 0:t.basename,future:i({},null==t?void 0:t.future,{v7_prependBasename:!0}),history:r.createHashHistory({window:null==t?void 0:t.window}),hydrationData:(null==t?void 0:t.hydrationData)||g(),routes:e,mapRouteProperties:n.UNSAFE_mapRouteProperties}).initialize()},e.createSearchParams=f,e.unstable_HistoryRouter=function(e){let{basename:t,children:r,future:o,history:i}=e,[u,s]=a.useState({action:i.action,location:i.location}),{v7_startTransition:c}=o||{},l=a.useCallback((e=>{c&&R?R((()=>s(e))):s(e)}),[s,c]);return a.useLayoutEffect((()=>i.listen(l)),[i,l]),a.createElement(n.Router,{basename:t,children:r,location:u.location,navigationType:u.action,navigator:i})},e.unstable_usePrompt=function(e){let{when:t,message:r}=e,o=n.unstable_useBlocker(t);a.useEffect((()=>{if("blocked"===o.state){window.confirm(r)?setTimeout(o.proceed,0):o.reset()}}),[o,r]),a.useEffect((()=>{"blocked"!==o.state||t||o.reset()}),[o,t])},e.unstable_useViewTransitionState=I,e.useBeforeUnload=function(e,t){let{capture:n}=t||{};a.useEffect((()=>{let t=null!=n?{capture:n}:void 0;return window.addEventListener("beforeunload",e,t),()=>{window.removeEventListener("beforeunload",e,t)}}),[e,n])},e.useFetcher=function(){var e;let{router:t}=C(j.UseFetcher),o=a.useContext(n.UNSAFE_RouteContext);o||r.UNSAFE_invariant(!1);let u=null==(e=o.matches[o.matches.length-1])?void 0:e.route.id;null==u&&r.UNSAFE_invariant(!1);let[s]=a.useState((()=>String(++k))),[c]=a.useState((()=>(u||r.UNSAFE_invariant(!1),function(e,t){return a.forwardRef(((n,r)=>{let o=L(e,t);return a.createElement(N,i({},n,{ref:r,submit:o}))}))}(s,u)))),[l]=a.useState((()=>e=>{t||r.UNSAFE_invariant(!1),u||r.UNSAFE_invariant(!1),t.fetch(s,u,e)})),f=L(s,u),d=t.getFetcher(s),m=a.useMemo((()=>i({Form:c,submit:f,load:l},d)),[d,c,f,l]);return a.useEffect((()=>()=>{t?t.deleteFetcher(s):console.warn("No router available to clean up from useFetcher()")}),[t,s]),m},e.useFetchers=function(){return[...F(A.UseFetchers).fetchers.values()]},e.useFormAction=D,e.useLinkClickHandler=x,e.useSearchParams=function(e){let t=a.useRef(f(e)),r=a.useRef(!1),o=n.useLocation(),i=a.useMemo((()=>function(e,t){let n=f(e);return t&&t.forEach(((e,r)=>{n.has(r)||t.getAll(r).forEach((e=>{n.append(r,e)}))})),n}(o.search,r.current?null:t.current)),[o.search]),u=n.useNavigate(),s=a.useCallback(((e,t)=>{const n=f("function"==typeof e?e(i):e);r.current=!0,u("?"+n,t)}),[u,i]);return[i,s]},e.useSubmit=T,Object.defineProperty(e,"__esModule",{value:!0})})); | ||
| !function(e,t){"object"==typeof exports&&"undefined"!=typeof module?t(exports,require("react-router")):"function"==typeof define&&define.amd?define(["exports","react-router"],t):t((e="undefined"!=typeof globalThis?globalThis:e||self).ReactRouterDOM={},e.ReactRouter)}(this,(function(e,t){"use strict";let r=!1;r||"undefined"==typeof console||(r=!0,console.warn("The `react-router-dom` package is deprecated in v7, you can change all of your imports to load directly from the `react-router` package.")),Object.defineProperty(e,"AbortedDeferredError",{enumerable:!0,get:function(){return t.AbortedDeferredError}}),Object.defineProperty(e,"Await",{enumerable:!0,get:function(){return t.Await}}),Object.defineProperty(e,"BrowserRouter",{enumerable:!0,get:function(){return t.BrowserRouter}}),Object.defineProperty(e,"Form",{enumerable:!0,get:function(){return t.Form}}),Object.defineProperty(e,"HashRouter",{enumerable:!0,get:function(){return t.HashRouter}}),Object.defineProperty(e,"HydratedRouter",{enumerable:!0,get:function(){return t.HydratedRouter}}),Object.defineProperty(e,"Link",{enumerable:!0,get:function(){return t.Link}}),Object.defineProperty(e,"Links",{enumerable:!0,get:function(){return t.Links}}),Object.defineProperty(e,"MemoryRouter",{enumerable:!0,get:function(){return t.MemoryRouter}}),Object.defineProperty(e,"Meta",{enumerable:!0,get:function(){return t.Meta}}),Object.defineProperty(e,"NavLink",{enumerable:!0,get:function(){return t.NavLink}}),Object.defineProperty(e,"Navigate",{enumerable:!0,get:function(){return t.Navigate}}),Object.defineProperty(e,"NavigationType",{enumerable:!0,get:function(){return t.NavigationType}}),Object.defineProperty(e,"Outlet",{enumerable:!0,get:function(){return t.Outlet}}),Object.defineProperty(e,"PrefetchPageLinks",{enumerable:!0,get:function(){return t.PrefetchPageLinks}}),Object.defineProperty(e,"RemixServer",{enumerable:!0,get:function(){return t.RemixServer}}),Object.defineProperty(e,"Route",{enumerable:!0,get:function(){return t.Route}}),Object.defineProperty(e,"Router",{enumerable:!0,get:function(){return t.Router}}),Object.defineProperty(e,"RouterProvider",{enumerable:!0,get:function(){return t.RouterProvider}}),Object.defineProperty(e,"Routes",{enumerable:!0,get:function(){return t.Routes}}),Object.defineProperty(e,"Scripts",{enumerable:!0,get:function(){return t.Scripts}}),Object.defineProperty(e,"ScrollRestoration",{enumerable:!0,get:function(){return t.ScrollRestoration}}),Object.defineProperty(e,"StaticRouter",{enumerable:!0,get:function(){return t.StaticRouter}}),Object.defineProperty(e,"StaticRouterProvider",{enumerable:!0,get:function(){return t.StaticRouterProvider}}),Object.defineProperty(e,"UNSAFE_DEFERRED_SYMBOL",{enumerable:!0,get:function(){return t.UNSAFE_DEFERRED_SYMBOL}}),Object.defineProperty(e,"UNSAFE_DataRouterContext",{enumerable:!0,get:function(){return t.UNSAFE_DataRouterContext}}),Object.defineProperty(e,"UNSAFE_DataRouterStateContext",{enumerable:!0,get:function(){return t.UNSAFE_DataRouterStateContext}}),Object.defineProperty(e,"UNSAFE_ErrorResponseImpl",{enumerable:!0,get:function(){return t.UNSAFE_ErrorResponseImpl}}),Object.defineProperty(e,"UNSAFE_FetchersContext",{enumerable:!0,get:function(){return t.UNSAFE_FetchersContext}}),Object.defineProperty(e,"UNSAFE_LocationContext",{enumerable:!0,get:function(){return t.UNSAFE_LocationContext}}),Object.defineProperty(e,"UNSAFE_NavigationContext",{enumerable:!0,get:function(){return t.UNSAFE_NavigationContext}}),Object.defineProperty(e,"UNSAFE_RemixContext",{enumerable:!0,get:function(){return t.UNSAFE_RemixContext}}),Object.defineProperty(e,"UNSAFE_RouteContext",{enumerable:!0,get:function(){return t.UNSAFE_RouteContext}}),Object.defineProperty(e,"UNSAFE_SingleFetchRedirectSymbol",{enumerable:!0,get:function(){return t.UNSAFE_SingleFetchRedirectSymbol}}),Object.defineProperty(e,"UNSAFE_ViewTransitionContext",{enumerable:!0,get:function(){return t.UNSAFE_ViewTransitionContext}}),Object.defineProperty(e,"UNSAFE_convertRoutesToDataRoutes",{enumerable:!0,get:function(){return t.UNSAFE_convertRoutesToDataRoutes}}),Object.defineProperty(e,"UNSAFE_decodeViaTurboStream",{enumerable:!0,get:function(){return t.UNSAFE_decodeViaTurboStream}}),Object.defineProperty(e,"UNSAFE_mapRouteProperties",{enumerable:!0,get:function(){return t.UNSAFE_mapRouteProperties}}),Object.defineProperty(e,"UNSAFE_useRouteId",{enumerable:!0,get:function(){return t.UNSAFE_useRouteId}}),Object.defineProperty(e,"UNSAFE_useRoutesImpl",{enumerable:!0,get:function(){return t.UNSAFE_useRoutesImpl}}),Object.defineProperty(e,"UNSAFE_useScrollRestoration",{enumerable:!0,get:function(){return t.UNSAFE_useScrollRestoration}}),Object.defineProperty(e,"createBrowserRouter",{enumerable:!0,get:function(){return t.createBrowserRouter}}),Object.defineProperty(e,"createHashRouter",{enumerable:!0,get:function(){return t.createHashRouter}}),Object.defineProperty(e,"createMemoryRouter",{enumerable:!0,get:function(){return t.createMemoryRouter}}),Object.defineProperty(e,"createPath",{enumerable:!0,get:function(){return t.createPath}}),Object.defineProperty(e,"createRemixStub",{enumerable:!0,get:function(){return t.createRemixStub}}),Object.defineProperty(e,"createRoutesFromChildren",{enumerable:!0,get:function(){return t.createRoutesFromChildren}}),Object.defineProperty(e,"createRoutesFromElements",{enumerable:!0,get:function(){return t.createRoutesFromChildren}}),Object.defineProperty(e,"createSearchParams",{enumerable:!0,get:function(){return t.createSearchParams}}),Object.defineProperty(e,"createStaticHandler",{enumerable:!0,get:function(){return t.createStaticHandler}}),Object.defineProperty(e,"createStaticRouter",{enumerable:!0,get:function(){return t.createStaticRouter}}),Object.defineProperty(e,"defer",{enumerable:!0,get:function(){return t.defer}}),Object.defineProperty(e,"generatePath",{enumerable:!0,get:function(){return t.generatePath}}),Object.defineProperty(e,"getStaticContextFromError",{enumerable:!0,get:function(){return t.getStaticContextFromError}}),Object.defineProperty(e,"isRouteErrorResponse",{enumerable:!0,get:function(){return t.isRouteErrorResponse}}),Object.defineProperty(e,"json",{enumerable:!0,get:function(){return t.json}}),Object.defineProperty(e,"matchPath",{enumerable:!0,get:function(){return t.matchPath}}),Object.defineProperty(e,"matchRoutes",{enumerable:!0,get:function(){return t.matchRoutes}}),Object.defineProperty(e,"parsePath",{enumerable:!0,get:function(){return t.parsePath}}),Object.defineProperty(e,"redirect",{enumerable:!0,get:function(){return t.redirect}}),Object.defineProperty(e,"redirectDocument",{enumerable:!0,get:function(){return t.redirectDocument}}),Object.defineProperty(e,"renderMatches",{enumerable:!0,get:function(){return t.renderMatches}}),Object.defineProperty(e,"resolvePath",{enumerable:!0,get:function(){return t.resolvePath}}),Object.defineProperty(e,"stripBasename",{enumerable:!0,get:function(){return t.stripBasename}}),Object.defineProperty(e,"unstable_HistoryRouter",{enumerable:!0,get:function(){return t.unstable_HistoryRouter}}),Object.defineProperty(e,"unstable_usePrompt",{enumerable:!0,get:function(){return t.unstable_usePrompt}}),Object.defineProperty(e,"unstable_useViewTransitionState",{enumerable:!0,get:function(){return t.unstable_useViewTransitionState}}),Object.defineProperty(e,"useActionData",{enumerable:!0,get:function(){return t.useActionData}}),Object.defineProperty(e,"useAsyncError",{enumerable:!0,get:function(){return t.useAsyncError}}),Object.defineProperty(e,"useAsyncValue",{enumerable:!0,get:function(){return t.useAsyncValue}}),Object.defineProperty(e,"useBeforeUnload",{enumerable:!0,get:function(){return t.useBeforeUnload}}),Object.defineProperty(e,"useBlocker",{enumerable:!0,get:function(){return t.useBlocker}}),Object.defineProperty(e,"useFetcher",{enumerable:!0,get:function(){return t.useFetcher}}),Object.defineProperty(e,"useFetchers",{enumerable:!0,get:function(){return t.useFetchers}}),Object.defineProperty(e,"useFormAction",{enumerable:!0,get:function(){return t.useFormAction}}),Object.defineProperty(e,"useHref",{enumerable:!0,get:function(){return t.useHref}}),Object.defineProperty(e,"useInRouterContext",{enumerable:!0,get:function(){return t.useInRouterContext}}),Object.defineProperty(e,"useLinkClickHandler",{enumerable:!0,get:function(){return t.useLinkClickHandler}}),Object.defineProperty(e,"useLoaderData",{enumerable:!0,get:function(){return t.useLoaderData}}),Object.defineProperty(e,"useLocation",{enumerable:!0,get:function(){return t.useLocation}}),Object.defineProperty(e,"useMatch",{enumerable:!0,get:function(){return t.useMatch}}),Object.defineProperty(e,"useMatches",{enumerable:!0,get:function(){return t.useMatches}}),Object.defineProperty(e,"useNavigate",{enumerable:!0,get:function(){return t.useNavigate}}),Object.defineProperty(e,"useNavigation",{enumerable:!0,get:function(){return t.useNavigation}}),Object.defineProperty(e,"useNavigationType",{enumerable:!0,get:function(){return t.useNavigationType}}),Object.defineProperty(e,"useOutlet",{enumerable:!0,get:function(){return t.useOutlet}}),Object.defineProperty(e,"useOutletContext",{enumerable:!0,get:function(){return t.useOutletContext}}),Object.defineProperty(e,"useParams",{enumerable:!0,get:function(){return t.useParams}}),Object.defineProperty(e,"useResolvedPath",{enumerable:!0,get:function(){return t.useResolvedPath}}),Object.defineProperty(e,"useRevalidator",{enumerable:!0,get:function(){return t.useRevalidator}}),Object.defineProperty(e,"useRouteError",{enumerable:!0,get:function(){return t.useRouteError}}),Object.defineProperty(e,"useRouteLoaderData",{enumerable:!0,get:function(){return t.useRouteLoaderData}}),Object.defineProperty(e,"useRoutes",{enumerable:!0,get:function(){return t.useRoutes}}),Object.defineProperty(e,"useSearchParams",{enumerable:!0,get:function(){return t.useSearchParams}}),Object.defineProperty(e,"useSubmit",{enumerable:!0,get:function(){return t.useSubmit}}),Object.defineProperty(e,"__esModule",{value:!0})})); | ||
| //# sourceMappingURL=react-router-dom.production.min.js.map |
| { | ||
| "name": "react-router-dom", | ||
| "version": "0.0.0-experimental-4a8a492a", | ||
| "version": "0.0.0-experimental-4ed3f5da9", | ||
| "description": "Declarative routing for React web applications", | ||
@@ -26,4 +26,3 @@ "keywords": [ | ||
| "dependencies": { | ||
| "@remix-run/router": "0.0.0-experimental-4a8a492a", | ||
| "react-router": "0.0.0-experimental-4a8a492a" | ||
| "react-router": "0.0.0-experimental-4ed3f5da9" | ||
| }, | ||
@@ -40,8 +39,4 @@ "devDependencies": { | ||
| "dist/", | ||
| "CHANGELOG.md", | ||
| "LICENSE.md", | ||
| "README.md", | ||
| "server.d.ts", | ||
| "server.js", | ||
| "server.mjs" | ||
| "README.md" | ||
| ], | ||
@@ -51,2 +46,2 @@ "engines": { | ||
| } | ||
| } | ||
| } |
| # React Router DOM | ||
| The `react-router-dom` package contains bindings for using [React | ||
| Router](https://github.com/remix-run/react-router) in web applications. | ||
| Please see [the Getting Started guide](https://reactrouter.com/en/main/start/tutorial) for more information on how to get started with React Router. | ||
| The `react-router-dom` package is deprecated and only kept around for backwards-compatibility. It re-exports everything from the `react-router` package - you should convert your applications to import everything from `react-router` in v7 and beyond. |
Sorry, the diff of this file is not supported yet
Sorry, the diff of this file is not supported yet
Sorry, the diff of this file is not supported yet
Sorry, the diff of this file is not supported yet
Sorry, the diff of this file is not supported yet
New alerts
Major refactor
Supply chain riskPackage has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.
Found 1 instance in 1 package
Improved metrics
- Dependency count
- decreased by-25%
3
- Number of low supply chain risk alerts
- decreased by-96%
1
Worsened metrics
- Total package byte prevSize
- decreased by-90.38%
67300
- Number of package files
- decreased by-34.78%
15
- Lines of code
- decreased by-89.62%
551
- Number of lines in readme file
- decreased by-33.33%
4
- Number of medium supply chain risk alerts
- increased byInfinity%
1
Dependency changes
+ Addedreact-router@0.0.0-experimental-4ed3f5da9(transitive)
+ Addedturbo-stream@2.2.0(transitive)
- Removed@remix-run/router@0.0.0-experimental-4a8a492a(transitive)
- Removedreact-router@0.0.0-experimental-4a8a492a(transitive)