1100 lines
38 KiB
JavaScript
1100 lines
38 KiB
JavaScript
|
/**
|
||
|
* React Router DOM v6.16.0
|
||
|
*
|
||
|
* Copyright (c) Remix Software Inc.
|
||
|
*
|
||
|
* This source code is licensed under the MIT license found in the
|
||
|
* LICENSE.md file in the root directory of this source tree.
|
||
|
*
|
||
|
* @license MIT
|
||
|
*/
|
||
|
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_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_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 } from '@remix-run/router';
|
||
|
|
||
|
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 = "") {
|
||
|
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,
|
||
|
...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
|
||
|
});
|
||
|
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,
|
||
|
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 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 ariaCurrent = isActive ? ariaCurrentProp : undefined;
|
||
|
let className;
|
||
|
if (typeof classNameProp === "function") {
|
||
|
className = classNameProp({
|
||
|
isActive,
|
||
|
isPending
|
||
|
});
|
||
|
} 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].filter(Boolean).join(" ");
|
||
|
}
|
||
|
let style = typeof styleProp === "function" ? styleProp({
|
||
|
isActive,
|
||
|
isPending
|
||
|
}) : styleProp;
|
||
|
return /*#__PURE__*/React.createElement(Link, Object.assign({}, rest, {
|
||
|
"aria-current": ariaCurrent,
|
||
|
className: className,
|
||
|
ref: ref,
|
||
|
style: style,
|
||
|
to: to
|
||
|
}), typeof children === "function" ? children({
|
||
|
isActive,
|
||
|
isPending
|
||
|
}) : 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,
|
||
|
...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
|
||
|
});
|
||
|
};
|
||
|
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";
|
||
|
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
|
||
|
} = {}) {
|
||
|
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
|
||
|
});
|
||
|
}
|
||
|
}, [location, navigate, path, replaceProp, state, target, to, preventScrollReset, relative]);
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* 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
|
||
|
});
|
||
|
}, [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;
|
||
|
}
|
||
|
sessionStorage.setItem(storageKey || SCROLL_RESTORATION_STORAGE_KEY, JSON.stringify(savedScrollPositions));
|
||
|
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]);
|
||
|
}
|
||
|
|
||
|
//#endregion
|
||
|
|
||
|
export { BrowserRouter, Form, HashRouter, Link, NavLink, ScrollRestoration, useScrollRestoration as UNSAFE_useScrollRestoration, createBrowserRouter, createHashRouter, createSearchParams, HistoryRouter as unstable_HistoryRouter, usePrompt as unstable_usePrompt, useBeforeUnload, useFetcher, useFetchers, useFormAction, useLinkClickHandler, useSearchParams, useSubmit };
|
||
|
//# sourceMappingURL=react-router-dom.development.js.map
|