UNPKG

react-router/dist/index.js

Version:
49.3 kBJavaScriptView Raw
1/**
* React Router v6.4.1
*
* 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
*/
11import { invariant, resolveTo, joinPaths, matchPath, warning, parsePath, matchRoutes, Action, isRouteErrorResponse, createMemoryHistory, stripBasename, AbortedDeferredError, createRouter } from '@remix-run/router';
12export { AbortedDeferredError, Action as NavigationType, createPath, defer, generatePath, isRouteErrorResponse, json, matchPath, matchRoutes, parsePath, redirect, resolvePath } from '@remix-run/router';
13import * as React from 'react';
14
15function _extends() {
_extends = Object.assign ? Object.assign.bind() : function (target) {
for (var i = 1; i < arguments.length; i++) {
var source = arguments[i];
19
for (var key in source) {
if (Object.prototype.hasOwnProperty.call(source, key)) {
target[key] = source[key];
}
}
}
26
return target;
};
return _extends.apply(this, arguments);
30}
31
32/**
* Copyright (c) Facebook, Inc. and its affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
38/**
* inlined Object.is polyfill to avoid requiring consumers ship their own
* https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
*/
42
43function isPolyfill(x, y) {
return x === y && (x !== 0 || 1 / x === 1 / y) || x !== x && y !== y // eslint-disable-line no-self-compare
;
46}
47
48const is = typeof Object.is === "function" ? Object.is : isPolyfill; // Intentionally not using named imports because Rollup uses dynamic
49// dispatch for CommonJS interop named imports.
50
51const {
useState,
useEffect,
useLayoutEffect,
useDebugValue
56} = React;
57let didWarnOld18Alpha = false;
58let didWarnUncachedGetSnapshot = false; // Disclaimer: This shim breaks many of the rules of React, and only works
59// because of a very particular set of implementation details and assumptions
60// -- change any one of them and it will break. The most important assumption
61// is that updates are always synchronous, because concurrent rendering is
62// only available in versions of React that also have a built-in
63// useSyncExternalStore API. And we only use this shim when the built-in API
64// does not exist.
65//
66// Do not assume that the clever hacks used by this hook also work in general.
67// The point of this shim is to replace the need for hacks by other libraries.
68
69function useSyncExternalStore$2(subscribe, getSnapshot, // Note: The shim does not use getServerSnapshot, because pre-18 versions of
70// React do not expose a way to check if we're hydrating. So users of the shim
71// will need to track that themselves and return the correct value
72// from `getSnapshot`.
73getServerSnapshot) {
if (process.env.NODE_ENV !== "production") {
if (!didWarnOld18Alpha) {
if ("startTransition" in React) {
didWarnOld18Alpha = true;
console.error("You are using an outdated, pre-release alpha of React 18 that " + "does not support useSyncExternalStore. The " + "use-sync-external-store shim will not work correctly. Upgrade " + "to a newer pre-release.");
}
}
} // Read the current snapshot from the store on every render. Again, this
// breaks the rules of React, and only works here because of specific
// implementation details, most importantly that updates are
// always synchronous.
85
86
const value = getSnapshot();
88
if (process.env.NODE_ENV !== "production") {
if (!didWarnUncachedGetSnapshot) {
const cachedValue = getSnapshot();
92
if (!is(value, cachedValue)) {
console.error("The result of getSnapshot should be cached to avoid an infinite loop");
didWarnUncachedGetSnapshot = true;
}
}
} // Because updates are synchronous, we don't queue them. Instead we force a
// re-render whenever the subscribed state changes by updating an some
// arbitrary useState hook. Then, during render, we call getSnapshot to read
// the current value.
//
// Because we don't actually use the state returned by the useState hook, we
// can save a bit of memory by storing other stuff in that slot.
//
// To implement the early bailout, we need to track some things on a mutable
// object. Usually, we would put that in a useRef hook, but we can stash it in
// our useState hook instead.
//
// To force a re-render, we call forceUpdate({inst}). That works because the
// new object always fails an equality check.
112
113
const [{
inst
}, forceUpdate] = useState({
inst: {
value,
getSnapshot
}
}); // Track the latest getSnapshot function with a ref. This needs to be updated
// in the layout phase so we can access it during the tearing check that
// happens on subscribe.
124
useLayoutEffect(() => {
inst.value = value;
inst.getSnapshot = getSnapshot; // Whenever getSnapshot or subscribe changes, we need to check in the
// commit phase if there was an interleaved mutation. In concurrent mode
// this can happen all the time, but even in synchronous mode, an earlier
// effect may have mutated the store.
131
if (checkIfSnapshotChanged(inst)) {
// Force a re-render.
forceUpdate({
inst
});
} // eslint-disable-next-line react-hooks/exhaustive-deps
138
}, [subscribe, value, getSnapshot]);
useEffect(() => {
// Check for changes right before subscribing. Subsequent changes will be
// detected in the subscription handler.
if (checkIfSnapshotChanged(inst)) {
// Force a re-render.
forceUpdate({
inst
});
}
149
const handleStoreChange = () => {
// TODO: Because there is no cross-renderer API for batching updates, it's
// up to the consumer of this library to wrap their subscription event
// with unstable_batchedUpdates. Should we try to detect when this isn't
// the case and print a warning in development?
// The store changed. Check if the snapshot changed since the last time we
// read from the store.
if (checkIfSnapshotChanged(inst)) {
// Force a re-render.
forceUpdate({
inst
});
}
}; // Subscribe to the store and return a clean-up function.
164
165
return subscribe(handleStoreChange); // eslint-disable-next-line react-hooks/exhaustive-deps
}, [subscribe]);
useDebugValue(value);
return value;
170}
171
172function checkIfSnapshotChanged(inst) {
const latestGetSnapshot = inst.getSnapshot;
const prevValue = inst.value;
175
try {
const nextValue = latestGetSnapshot();
return !is(prevValue, nextValue);
} catch (error) {
return true;
}
182}
183
184/**
* Copyright (c) Facebook, Inc. and its affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* @flow
*/
192function useSyncExternalStore$1(subscribe, getSnapshot, getServerSnapshot) {
// Note: The shim does not use getServerSnapshot, because pre-18 versions of
// React do not expose a way to check if we're hydrating. So users of the shim
// will need to track that themselves and return the correct value
// from `getSnapshot`.
return getSnapshot();
198}
199
200/**
* Inlined into the react-router repo since use-sync-external-store does not
* provide a UMD-compatible package, so we need this to be able to distribute
* UMD react-router bundles
*/
205const canUseDOM = !!(typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement !== "undefined");
206const isServerEnvironment = !canUseDOM;
207const shim = isServerEnvironment ? useSyncExternalStore$1 : useSyncExternalStore$2;
208const useSyncExternalStore = "useSyncExternalStore" in React ? (module => module.useSyncExternalStore)(React) : shim;
209
210// Contexts for data routers
211const DataStaticRouterContext = /*#__PURE__*/React.createContext(null);
212
213if (process.env.NODE_ENV !== "production") {
DataStaticRouterContext.displayName = "DataStaticRouterContext";
215}
216
217const DataRouterContext = /*#__PURE__*/React.createContext(null);
218
219if (process.env.NODE_ENV !== "production") {
DataRouterContext.displayName = "DataRouter";
221}
222
223const DataRouterStateContext = /*#__PURE__*/React.createContext(null);
224
225if (process.env.NODE_ENV !== "production") {
DataRouterStateContext.displayName = "DataRouterState";
227}
228
229const AwaitContext = /*#__PURE__*/React.createContext(null);
230
231if (process.env.NODE_ENV !== "production") {
AwaitContext.displayName = "Await";
233}
234
235const NavigationContext = /*#__PURE__*/React.createContext(null);
236
237if (process.env.NODE_ENV !== "production") {
NavigationContext.displayName = "Navigation";
239}
240
241const LocationContext = /*#__PURE__*/React.createContext(null);
242
243if (process.env.NODE_ENV !== "production") {
LocationContext.displayName = "Location";
245}
246
247const RouteContext = /*#__PURE__*/React.createContext({
outlet: null,
matches: []
250});
251
252if (process.env.NODE_ENV !== "production") {
RouteContext.displayName = "Route";
254}
255
256const RouteErrorContext = /*#__PURE__*/React.createContext(null);
257
258if (process.env.NODE_ENV !== "production") {
RouteErrorContext.displayName = "RouteError";
260}
261
262/**
* Returns the full href for the given "to" value. This is useful for building
* custom links that are also accessible and preserve right-click behavior.
*
* @see https://reactrouter.com/docs/en/v6/hooks/use-href
*/
268
269function useHref(to, _temp) {
let {
relative
} = _temp === void 0 ? {} : _temp;
!useInRouterContext() ? process.env.NODE_ENV !== "production" ? invariant(false, // TODO: This error is probably because they somehow have 2 versions of the
// router loaded. We can help them understand how to avoid that.
"useHref() may be used only in the context of a <Router> component.") : invariant(false) : void 0;
let {
basename,
navigator
} = React.useContext(NavigationContext);
let {
hash,
pathname,
search
} = useResolvedPath(to, {
relative
});
let joinedPathname = pathname; // If we're operating within a basename, prepend it to the pathname prior
// to creating the href. 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 links
291
if (basename !== "/") {
joinedPathname = pathname === "/" ? basename : joinPaths([basename, pathname]);
}
295
return navigator.createHref({
pathname: joinedPathname,
search,
hash
});
301}
302/**
* Returns true if this component is a descendant of a <Router>.
*
* @see https://reactrouter.com/docs/en/v6/hooks/use-in-router-context
*/
307
308function useInRouterContext() {
return React.useContext(LocationContext) != null;
310}
311/**
* Returns the current location object, which represents the current URL in web
* browsers.
*
* Note: If you're using this it may mean you're doing some of your own
* "routing" in your app, and we'd like to know what your use case is. We may
* be able to provide something higher-level to better suit your needs.
*
* @see https://reactrouter.com/docs/en/v6/hooks/use-location
*/
321
322function useLocation() {
!useInRouterContext() ? process.env.NODE_ENV !== "production" ? invariant(false, // TODO: This error is probably because they somehow have 2 versions of the
// router loaded. We can help them understand how to avoid that.
"useLocation() may be used only in the context of a <Router> component.") : invariant(false) : void 0;
return React.useContext(LocationContext).location;
327}
328/**
* Returns the current navigation action which describes how the router came to
* the current location, either by a pop, push, or replace on the history stack.
*
* @see https://reactrouter.com/docs/en/v6/hooks/use-navigation-type
*/
334
335function useNavigationType() {
return React.useContext(LocationContext).navigationType;
337}
338/**
* Returns true if the URL for the given "to" value matches the current URL.
* This is useful for components that need to know "active" state, e.g.
* <NavLink>.
*
* @see https://reactrouter.com/docs/en/v6/hooks/use-match
*/
345
346function useMatch(pattern) {
!useInRouterContext() ? process.env.NODE_ENV !== "production" ? invariant(false, // TODO: This error is probably because they somehow have 2 versions of the
// router loaded. We can help them understand how to avoid that.
"useMatch() may be used only in the context of a <Router> component.") : invariant(false) : void 0;
let {
pathname
} = useLocation();
return React.useMemo(() => matchPath(pattern, pathname), [pathname, pattern]);
354}
355/**
* The interface for the navigate() function returned from useNavigate().
*/
358
359/**
* When processing relative navigation we want to ignore ancestor routes that
* do not contribute to the path, such that index/pathless layout routes don't
* interfere.
*
* For example, when moving a route element into an index route and/or a
* pathless layout route, relative link behavior contained within should stay
* the same. Both of the following examples should link back to the root:
*
* <Route path="/">
* <Route path="accounts" element={<Link to=".."}>
* </Route>
*
* <Route path="/">
* <Route path="accounts">
* <Route element={<AccountsLayout />}> // <-- Does not contribute
* <Route index element={<Link to=".."} /> // <-- Does not contribute
* </Route
* </Route>
* </Route>
*/
380function getPathContributingMatches(matches) {
return matches.filter((match, index) => index === 0 || !match.route.index && match.pathnameBase !== matches[index - 1].pathnameBase);
382}
383/**
* Returns an imperative method for changing the location. Used by <Link>s, but
* may also be used by other elements to change the location.
*
* @see https://reactrouter.com/docs/en/v6/hooks/use-navigate
*/
389
390
391function useNavigate() {
!useInRouterContext() ? process.env.NODE_ENV !== "production" ? invariant(false, // TODO: This error is probably because they somehow have 2 versions of the
// router loaded. We can help them understand how to avoid that.
"useNavigate() may be used only in the context of a <Router> component.") : invariant(false) : void 0;
let {
basename,
navigator
} = React.useContext(NavigationContext);
let {
matches
} = React.useContext(RouteContext);
let {
pathname: locationPathname
} = useLocation();
let routePathnamesJson = JSON.stringify(getPathContributingMatches(matches).map(match => match.pathnameBase));
let activeRef = React.useRef(false);
React.useEffect(() => {
activeRef.current = true;
});
let navigate = React.useCallback(function (to, options) {
if (options === void 0) {
options = {};
}
414
process.env.NODE_ENV !== "production" ? warning(activeRef.current, "You should call navigate() in a React.useEffect(), not when " + "your component is first rendered.") : void 0;
if (!activeRef.current) return;
417
if (typeof to === "number") {
navigator.go(to);
return;
}
422
let path = resolveTo(to, JSON.parse(routePathnamesJson), locationPathname, options.relative === "path"); // If we're operating within a basename, prepend it to the pathname prior
// to handing off to history. If this is a root navigation, then we
// navigate to the raw basename which allows the basename to have full
// control over the presence of a trailing slash on root links
427
if (basename !== "/") {
path.pathname = path.pathname === "/" ? basename : joinPaths([basename, path.pathname]);
}
431
(!!options.replace ? navigator.replace : navigator.push)(path, options.state, options);
}, [basename, navigator, routePathnamesJson, locationPathname]);
return navigate;
435}
436const OutletContext = /*#__PURE__*/React.createContext(null);
437/**
* Returns the context (if provided) for the child route at this level of the route
* hierarchy.
* @see https://reactrouter.com/docs/en/v6/hooks/use-outlet-context
*/
442
443function useOutletContext() {
return React.useContext(OutletContext);
445}
446/**
* Returns the element for the child route at this level of the route
* hierarchy. Used internally by <Outlet> to render child routes.
*
* @see https://reactrouter.com/docs/en/v6/hooks/use-outlet
*/
452
453function useOutlet(context) {
let outlet = React.useContext(RouteContext).outlet;
455
if (outlet) {
return /*#__PURE__*/React.createElement(OutletContext.Provider, {
value: context
}, outlet);
}
461
return outlet;
463}
464/**
* Returns an object of key/value pairs of the dynamic params from the current
* URL that were matched by the route path.
*
* @see https://reactrouter.com/docs/en/v6/hooks/use-params
*/
470
471function useParams() {
let {
matches
} = React.useContext(RouteContext);
let routeMatch = matches[matches.length - 1];
return routeMatch ? routeMatch.params : {};
477}
478/**
* Resolves the pathname of the given `to` value against the current location.
*
* @see https://reactrouter.com/docs/en/v6/hooks/use-resolved-path
*/
483
484function useResolvedPath(to, _temp2) {
let {
relative
} = _temp2 === void 0 ? {} : _temp2;
let {
matches
} = React.useContext(RouteContext);
let {
pathname: locationPathname
} = useLocation();
let routePathnamesJson = JSON.stringify(getPathContributingMatches(matches).map(match => match.pathnameBase));
return React.useMemo(() => resolveTo(to, JSON.parse(routePathnamesJson), locationPathname, relative === "path"), [to, routePathnamesJson, locationPathname, relative]);
496}
497/**
* Returns the element of the route that matched the current location, prepared
* with the correct context to render the remainder of the route tree. Route
* elements in the tree must render an <Outlet> to render their child route's
* element.
*
* @see https://reactrouter.com/docs/en/v6/hooks/use-routes
*/
505
506function useRoutes(routes, locationArg) {
!useInRouterContext() ? process.env.NODE_ENV !== "production" ? invariant(false, // TODO: This error is probably because they somehow have 2 versions of the
// router loaded. We can help them understand how to avoid that.
"useRoutes() may be used only in the context of a <Router> component.") : invariant(false) : void 0;
let dataRouterStateContext = React.useContext(DataRouterStateContext);
let {
matches: parentMatches
} = React.useContext(RouteContext);
let routeMatch = parentMatches[parentMatches.length - 1];
let parentParams = routeMatch ? routeMatch.params : {};
let parentPathname = routeMatch ? routeMatch.pathname : "/";
let parentPathnameBase = routeMatch ? routeMatch.pathnameBase : "/";
let parentRoute = routeMatch && routeMatch.route;
519
if (process.env.NODE_ENV !== "production") {
// You won't get a warning about 2 different <Routes> under a <Route>
// without a trailing *, but this is a best-effort warning anyway since we
// cannot even give the warning unless they land at the parent route.
//
// Example:
//
// <Routes>
// {/* This route path MUST end with /* because otherwise
// it will never match /blog/post/123 */}
// <Route path="blog" element={<Blog />} />
// <Route path="blog/feed" element={<BlogFeed />} />
// </Routes>
//
// function Blog() {
// return (
// <Routes>
// <Route path="post/:id" element={<Post />} />
// </Routes>
// );
// }
let parentPath = parentRoute && parentRoute.path || "";
warningOnce(parentPathname, !parentRoute || parentPath.endsWith("*"), "You rendered descendant <Routes> (or called `useRoutes()`) at " + ("\"" + parentPathname + "\" (under <Route path=\"" + parentPath + "\">) but the ") + "parent route path has no trailing \"*\". This means if you navigate " + "deeper, the parent won't match anymore and therefore the child " + "routes will never render.\n\n" + ("Please change the parent <Route path=\"" + parentPath + "\"> to <Route ") + ("path=\"" + (parentPath === "/" ? "*" : parentPath + "/*") + "\">."));
}
544
let locationFromContext = useLocation();
let location;
547
if (locationArg) {
var _parsedLocationArg$pa;
550
let parsedLocationArg = typeof locationArg === "string" ? parsePath(locationArg) : locationArg;
!(parentPathnameBase === "/" || ((_parsedLocationArg$pa = parsedLocationArg.pathname) == null ? void 0 : _parsedLocationArg$pa.startsWith(parentPathnameBase))) ? process.env.NODE_ENV !== "production" ? invariant(false, "When overriding the location using `<Routes location>` or `useRoutes(routes, location)`, " + "the location pathname must begin with the portion of the URL pathname that was " + ("matched by all parent routes. The current pathname base is \"" + parentPathnameBase + "\" ") + ("but pathname \"" + parsedLocationArg.pathname + "\" was given in the `location` prop.")) : invariant(false) : void 0;
location = parsedLocationArg;
} else {
location = locationFromContext;
}
557
let pathname = location.pathname || "/";
let remainingPathname = parentPathnameBase === "/" ? pathname : pathname.slice(parentPathnameBase.length) || "/";
let matches = matchRoutes(routes, {
pathname: remainingPathname
});
563
if (process.env.NODE_ENV !== "production") {
process.env.NODE_ENV !== "production" ? warning(parentRoute || matches != null, "No routes matched location \"" + location.pathname + location.search + location.hash + "\" ") : void 0;
process.env.NODE_ENV !== "production" ? warning(matches == null || matches[matches.length - 1].route.element !== undefined, "Matched leaf route at location \"" + location.pathname + location.search + location.hash + "\" does not have an element. " + "This means it will render an <Outlet /> with a null value by default resulting in an \"empty\" page.") : void 0;
}
568
let renderedMatches = _renderMatches(matches && matches.map(match => Object.assign({}, match, {
params: Object.assign({}, parentParams, match.params),
pathname: joinPaths([parentPathnameBase, match.pathname]),
pathnameBase: match.pathnameBase === "/" ? parentPathnameBase : joinPaths([parentPathnameBase, match.pathnameBase])
})), parentMatches, dataRouterStateContext || undefined); // When a user passes in a `locationArg`, the associated routes need to
// be wrapped in a new `LocationContext.Provider` in order for `useLocation`
// to use the scoped location instead of the global location.
576
577
if (locationArg) {
return /*#__PURE__*/React.createElement(LocationContext.Provider, {
value: {
location: _extends({
pathname: "/",
search: "",
hash: "",
state: null,
key: "default"
}, location),
navigationType: Action.Pop
}
}, renderedMatches);
}
592
return renderedMatches;
594}
595
596function DefaultErrorElement() {
let error = useRouteError();
let message = isRouteErrorResponse(error) ? error.status + " " + error.statusText : error instanceof Error ? error.message : JSON.stringify(error);
let stack = error instanceof Error ? error.stack : null;
let lightgrey = "rgba(200,200,200, 0.5)";
let preStyles = {
padding: "0.5rem",
backgroundColor: lightgrey
};
let codeStyles = {
padding: "2px 4px",
backgroundColor: lightgrey
};
return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("h2", null, "Unhandled Thrown Error!"), /*#__PURE__*/React.createElement("h3", {
style: {
fontStyle: "italic"
}
}, message), stack ? /*#__PURE__*/React.createElement("pre", {
style: preStyles
}, stack) : null, /*#__PURE__*/React.createElement("p", null, "\uD83D\uDCBF Hey developer \uD83D\uDC4B"), /*#__PURE__*/React.createElement("p", null, "You can provide a way better UX than this when your app throws errors by providing your own\xA0", /*#__PURE__*/React.createElement("code", {
style: codeStyles
}, "errorElement"), " props on\xA0", /*#__PURE__*/React.createElement("code", {
style: codeStyles
}, "<Route>")));
620}
621
622class RenderErrorBoundary extends React.Component {
constructor(props) {
super(props);
this.state = {
location: props.location,
error: props.error
};
}
630
static getDerivedStateFromError(error) {
return {
error: error
};
}
636
static getDerivedStateFromProps(props, state) {
// When we get into an error state, the user will likely click "back" to the
// previous page that didn't have an error. Because this wraps the entire
// application, that will have no effect--the error page continues to display.
// This gives us a mechanism to recover from the error when the location changes.
//
// Whether we're in an error state or not, we update the location in state
// so that when we are in an error state, it gets reset when a new location
// comes in and the user recovers from the error.
if (state.location !== props.location) {
return {
error: props.error,
location: props.location
};
} // If we're not changing locations, preserve the location but still surface
// any new errors that may come through. We retain the existing error, we do
// this because the error provided from the app state may be cleared without
// the location changing.
655
656
return {
error: props.error || state.error,
location: state.location
};
}
662
componentDidCatch(error, errorInfo) {
console.error("React Router caught the following error during render", error, errorInfo);
}
666
render() {
return this.state.error ? /*#__PURE__*/React.createElement(RouteErrorContext.Provider, {
value: this.state.error,
children: this.props.component
}) : this.props.children;
}
673
674}
675
676function RenderedRoute(_ref) {
let {
routeContext,
match,
children
} = _ref;
let dataStaticRouterContext = React.useContext(DataStaticRouterContext); // Track how deep we got in our render pass to emulate SSR componentDidCatch
// in a DataStaticRouter
684
if (dataStaticRouterContext && match.route.errorElement) {
dataStaticRouterContext._deepestRenderedBoundaryId = match.route.id;
}
688
return /*#__PURE__*/React.createElement(RouteContext.Provider, {
value: routeContext
}, children);
692}
693
694function _renderMatches(matches, parentMatches, dataRouterState) {
if (parentMatches === void 0) {
parentMatches = [];
}
698
if (matches == null) {
if (dataRouterState != null && dataRouterState.errors) {
// Don't bail if we have data router errors so we can render them in the
// boundary. Use the pre-matched (or shimmed) matches
matches = dataRouterState.matches;
} else {
return null;
}
}
708
let renderedMatches = matches; // If we have data errors, trim matches to the highest error boundary
710
let errors = dataRouterState == null ? void 0 : dataRouterState.errors;
712
if (errors != null) {
let errorIndex = renderedMatches.findIndex(m => m.route.id && (errors == null ? void 0 : errors[m.route.id]));
!(errorIndex >= 0) ? process.env.NODE_ENV !== "production" ? invariant(false, "Could not find a matching route for the current errors: " + errors) : invariant(false) : void 0;
renderedMatches = renderedMatches.slice(0, Math.min(renderedMatches.length, errorIndex + 1));
}
718
return renderedMatches.reduceRight((outlet, match, index) => {
let error = match.route.id ? errors == null ? void 0 : errors[match.route.id] : null; // Only data routers handle errors
721
let errorElement = dataRouterState ? match.route.errorElement || /*#__PURE__*/React.createElement(DefaultErrorElement, null) : null;
723
let getChildren = () => /*#__PURE__*/React.createElement(RenderedRoute, {
match: match,
routeContext: {
outlet,
matches: parentMatches.concat(renderedMatches.slice(0, index + 1))
}
}, error ? errorElement : match.route.element !== undefined ? match.route.element : outlet); // Only wrap in an error boundary within data router usages when we have an
// errorElement on this route. Otherwise let it bubble up to an ancestor
// errorElement
733
734
return dataRouterState && (match.route.errorElement || index === 0) ? /*#__PURE__*/React.createElement(RenderErrorBoundary, {
location: dataRouterState.location,
component: errorElement,
error: error,
children: getChildren()
}) : getChildren();
}, null);
742}
743var DataRouterHook;
744
745(function (DataRouterHook) {
DataRouterHook["UseLoaderData"] = "useLoaderData";
DataRouterHook["UseActionData"] = "useActionData";
DataRouterHook["UseRouteError"] = "useRouteError";
DataRouterHook["UseNavigation"] = "useNavigation";
DataRouterHook["UseRouteLoaderData"] = "useRouteLoaderData";
DataRouterHook["UseMatches"] = "useMatches";
DataRouterHook["UseRevalidator"] = "useRevalidator";
753})(DataRouterHook || (DataRouterHook = {}));
754
755function useDataRouterState(hookName) {
let state = React.useContext(DataRouterStateContext);
!state ? process.env.NODE_ENV !== "production" ? invariant(false, hookName + " must be used within a DataRouterStateContext") : invariant(false) : void 0;
return state;
759}
760/**
* Returns the current navigation, defaulting to an "idle" navigation when
* no navigation is in progress
*/
764
765
766function useNavigation() {
let state = useDataRouterState(DataRouterHook.UseNavigation);
return state.navigation;
769}
770/**
* Returns a revalidate function for manually triggering revalidation, as well
* as the current state of any manual revalidations
*/
774
775function useRevalidator() {
let dataRouterContext = React.useContext(DataRouterContext);
!dataRouterContext ? process.env.NODE_ENV !== "production" ? invariant(false, "useRevalidator must be used within a DataRouterContext") : invariant(false) : void 0;
let state = useDataRouterState(DataRouterHook.UseRevalidator);
return {
revalidate: dataRouterContext.router.revalidate,
state: state.revalidation
};
783}
784/**
* Returns the active route matches, useful for accessing loaderData for
* parent/child routes or the route "handle" property
*/
788
789function useMatches() {
let {
matches,
loaderData
} = useDataRouterState(DataRouterHook.UseMatches);
return React.useMemo(() => matches.map(match => {
let {
pathname,
params
} = match; // Note: This structure matches that created by createUseMatchesMatch
// in the @remix-run/router , so if you change this please also change
// that :) Eventually we'll DRY this up
801
return {
id: match.route.id,
pathname,
params,
data: loaderData[match.route.id],
handle: match.route.handle
};
}), [matches, loaderData]);
810}
811/**
* Returns the loader data for the nearest ancestor Route loader
*/
814
815function useLoaderData() {
let state = useDataRouterState(DataRouterHook.UseLoaderData);
let route = React.useContext(RouteContext);
!route ? process.env.NODE_ENV !== "production" ? invariant(false, "useLoaderData must be used inside a RouteContext") : invariant(false) : void 0;
let thisRoute = route.matches[route.matches.length - 1];
!thisRoute.route.id ? process.env.NODE_ENV !== "production" ? invariant(false, "useLoaderData can only be used on routes that contain a unique \"id\"") : invariant(false) : void 0;
return state.loaderData[thisRoute.route.id];
822}
823/**
* Returns the loaderData for the given routeId
*/
826
827function useRouteLoaderData(routeId) {
let state = useDataRouterState(DataRouterHook.UseRouteLoaderData);
return state.loaderData[routeId];
830}
831/**
* Returns the action data for the nearest ancestor Route action
*/
834
835function useActionData() {
let state = useDataRouterState(DataRouterHook.UseActionData);
let route = React.useContext(RouteContext);
!route ? process.env.NODE_ENV !== "production" ? invariant(false, "useActionData must be used inside a RouteContext") : invariant(false) : void 0;
return Object.values((state == null ? void 0 : state.actionData) || {})[0];
840}
841/**
* Returns the nearest ancestor Route error, which could be a loader/action
* error or a render error. This is intended to be called from your
* errorElement to display a proper error message.
*/
846
847function useRouteError() {
var _state$errors;
849
let error = React.useContext(RouteErrorContext);
let state = useDataRouterState(DataRouterHook.UseRouteError);
let route = React.useContext(RouteContext);
let thisRoute = route.matches[route.matches.length - 1]; // If this was a render error, we put it in a RouteError context inside
// of RenderErrorBoundary
855
if (error) {
return error;
}
859
!route ? process.env.NODE_ENV !== "production" ? invariant(false, "useRouteError must be used inside a RouteContext") : invariant(false) : void 0;
!thisRoute.route.id ? process.env.NODE_ENV !== "production" ? invariant(false, "useRouteError can only be used on routes that contain a unique \"id\"") : invariant(false) : void 0; // Otherwise look for errors from our data router state
862
return (_state$errors = state.errors) == null ? void 0 : _state$errors[thisRoute.route.id];
864}
865/**
* Returns the happy-path data from the nearest ancestor <Await /> value
*/
868
869function useAsyncValue() {
let value = React.useContext(AwaitContext);
return value == null ? void 0 : value._data;
872}
873/**
* Returns the error from the nearest ancestor <Await /> value
*/
876
877function useAsyncError() {
let value = React.useContext(AwaitContext);
return value == null ? void 0 : value._error;
880}
881const alreadyWarned = {};
882
883function warningOnce(key, cond, message) {
if (!cond && !alreadyWarned[key]) {
alreadyWarned[key] = true;
process.env.NODE_ENV !== "production" ? warning(false, message) : void 0;
}
888}
889
890/**
* Given a Remix Router instance, render the appropriate UI
*/
893function RouterProvider(_ref) {
let {
fallbackElement,
router
} = _ref;
// Sync router state to our component state to force re-renders
let state = useSyncExternalStore(router.subscribe, () => router.state, // We have to provide this so React@18 doesn't complain during hydration,
// but we pass our serialized hydration data into the router so state here
// is already synced with what the server saw
() => router.state);
let navigator = React.useMemo(() => {
return {
createHref: router.createHref,
go: n => router.navigate(n),
push: (to, state, opts) => router.navigate(to, {
state,
preventScrollReset: opts == null ? void 0 : opts.preventScrollReset
}),
replace: (to, state, opts) => router.navigate(to, {
replace: true,
state,
preventScrollReset: opts == null ? void 0 : opts.preventScrollReset
})
};
}, [router]);
let basename = router.basename || "/";
return /*#__PURE__*/React.createElement(DataRouterContext.Provider, {
value: {
router,
navigator,
static: false,
// Do we need this?
basename
}
}, /*#__PURE__*/React.createElement(DataRouterStateContext.Provider, {
value: state
}, /*#__PURE__*/React.createElement(Router, {
basename: router.basename,
location: router.state.location,
navigationType: router.state.historyAction,
navigator: navigator
}, router.state.initialized ? /*#__PURE__*/React.createElement(Routes, null) : fallbackElement)));
935}
936
937/**
* A <Router> that stores all entries in memory.
*
* @see https://reactrouter.com/docs/en/v6/routers/memory-router
*/
942function MemoryRouter(_ref2) {
let {
basename,
children,
initialEntries,
initialIndex
} = _ref2;
let historyRef = React.useRef();
950
if (historyRef.current == null) {
historyRef.current = createMemoryHistory({
initialEntries,
initialIndex,
v5Compat: true
});
}
958
let history = historyRef.current;
let [state, setState] = React.useState({
action: history.action,
location: history.location
});
React.useLayoutEffect(() => history.listen(setState), [history]);
return /*#__PURE__*/React.createElement(Router, {
basename: basename,
children: children,
location: state.location,
navigationType: state.action,
navigator: history
});
972}
973
974/**
* Changes the current location.
*
* Note: This API is mostly useful in React.Component subclasses that are not
* able to use hooks. In functional components, we recommend you use the
* `useNavigate` hook instead.
*
* @see https://reactrouter.com/docs/en/v6/components/navigate
*/
983function Navigate(_ref3) {
let {
to,
replace,
state,
relative
} = _ref3;
!useInRouterContext() ? process.env.NODE_ENV !== "production" ? invariant(false, // TODO: This error is probably because they somehow have 2 versions of
// the router loaded. We can help them understand how to avoid that.
"<Navigate> may be used only in the context of a <Router> component.") : invariant(false) : void 0;
process.env.NODE_ENV !== "production" ? warning(!React.useContext(NavigationContext).static, "<Navigate> must not be used on the initial render in a <StaticRouter>. " + "This is a no-op, but you should modify your code so the <Navigate> is " + "only ever rendered in response to some user interaction or state change.") : void 0;
let dataRouterState = React.useContext(DataRouterStateContext);
let navigate = useNavigate();
React.useEffect(() => {
// Avoid kicking off multiple navigations if we're in the middle of a
// data-router navigation, since components get re-rendered when we enter
// a submitting/loading state
if (dataRouterState && dataRouterState.navigation.state !== "idle") {
return;
}
1003
navigate(to, {
replace,
state,
relative
});
});
return null;
1011}
1012
1013/**
* Renders the child route's element, if there is one.
*
* @see https://reactrouter.com/docs/en/v6/components/outlet
*/
1018function Outlet(props) {
return useOutlet(props.context);
1020}
1021
1022/**
* Declares an element that should be rendered at a certain URL path.
*
* @see https://reactrouter.com/docs/en/v6/components/route
*/
1027function Route(_props) {
process.env.NODE_ENV !== "production" ? invariant(false, "A <Route> is only ever to be used as the child of <Routes> element, " + "never rendered directly. Please wrap your <Route> in a <Routes>.") : invariant(false) ;
1029}
1030
1031/**
* Provides location context for the rest of the app.
*
* Note: You usually won't render a <Router> directly. Instead, you'll render a
* router that is more specific to your environment such as a <BrowserRouter>
* in web browsers or a <StaticRouter> for server rendering.
*
* @see https://reactrouter.com/docs/en/v6/routers/router
*/
1040function Router(_ref4) {
let {
basename: basenameProp = "/",
children = null,
location: locationProp,
navigationType = Action.Pop,
navigator,
static: staticProp = false
} = _ref4;
!!useInRouterContext() ? process.env.NODE_ENV !== "production" ? invariant(false, "You cannot render a <Router> inside another <Router>." + " You should never have more than one in your app.") : invariant(false) : void 0; // Preserve trailing slashes on basename, so we can let the user control
// the enforcement of trailing slashes throughout the app
1051
let basename = basenameProp.replace(/^\/*/, "/");
let navigationContext = React.useMemo(() => ({
basename,
navigator,
static: staticProp
}), [basename, navigator, staticProp]);
1058
if (typeof locationProp === "string") {
locationProp = parsePath(locationProp);
}
1062
let {
pathname = "/",
search = "",
hash = "",
state = null,
key = "default"
} = locationProp;
let location = React.useMemo(() => {
let trailingPathname = stripBasename(pathname, basename);
1072
if (trailingPathname == null) {
return null;
}
1076
return {
pathname: trailingPathname,
search,
hash,
state,
key
};
}, [basename, pathname, search, hash, state, key]);
process.env.NODE_ENV !== "production" ? warning(location != null, "<Router basename=\"" + basename + "\"> is not able to match the URL " + ("\"" + pathname + search + hash + "\" because it does not start with the ") + "basename, so the <Router> won't render anything.") : void 0;
1086
if (location == null) {
return null;
}
1090
return /*#__PURE__*/React.createElement(NavigationContext.Provider, {
value: navigationContext
}, /*#__PURE__*/React.createElement(LocationContext.Provider, {
children: children,
value: {
location,
navigationType
}
}));
1100}
1101
1102/**
* A container for a nested tree of <Route> elements that renders the branch
* that best matches the current location.
*
* @see https://reactrouter.com/docs/en/v6/components/routes
*/
1108function Routes(_ref5) {
let {
children,
location
} = _ref5;
let dataRouterContext = React.useContext(DataRouterContext); // When in a DataRouterContext _without_ children, we use the router routes
// directly. If we have children, then we're in a descendant tree and we
// need to use child routes.
1116
let routes = dataRouterContext && !children ? dataRouterContext.router.routes : createRoutesFromChildren(children);
return useRoutes(routes, location);
1119}
1120
1121/**
* Component to use for rendering lazily loaded data from returning defer()
* in a loader function
*/
1125function Await(_ref6) {
let {
children,
errorElement,
resolve
} = _ref6;
return /*#__PURE__*/React.createElement(AwaitErrorBoundary, {
resolve: resolve,
errorElement: errorElement
}, /*#__PURE__*/React.createElement(ResolveAwait, null, children));
1135}
1136var AwaitRenderStatus;
1137
1138(function (AwaitRenderStatus) {
AwaitRenderStatus[AwaitRenderStatus["pending"] = 0] = "pending";
AwaitRenderStatus[AwaitRenderStatus["success"] = 1] = "success";
AwaitRenderStatus[AwaitRenderStatus["error"] = 2] = "error";
1142})(AwaitRenderStatus || (AwaitRenderStatus = {}));
1143
1144const neverSettledPromise = new Promise(() => {});
1145
1146class AwaitErrorBoundary extends React.Component {
constructor(props) {
super(props);
this.state = {
error: null
};
}
1153
static getDerivedStateFromError(error) {
return {
error
};
}
1159
componentDidCatch(error, errorInfo) {
console.error("<Await> caught the following error during render", error, errorInfo);
}
1163
render() {
let {
children,
errorElement,
resolve
} = this.props;
let promise = null;
let status = AwaitRenderStatus.pending;
1172
if (!(resolve instanceof Promise)) {
// Didn't get a promise - provide as a resolved promise
status = AwaitRenderStatus.success;
promise = Promise.resolve();
Object.defineProperty(promise, "_tracked", {
get: () => true
});
Object.defineProperty(promise, "_data", {
get: () => resolve
});
} else if (this.state.error) {
// Caught a render error, provide it as a rejected promise
status = AwaitRenderStatus.error;
let renderError = this.state.error;
promise = Promise.reject().catch(() => {}); // Avoid unhandled rejection warnings
1188
Object.defineProperty(promise, "_tracked", {
get: () => true
});
Object.defineProperty(promise, "_error", {
get: () => renderError
});
} else if (resolve._tracked) {
// Already tracked promise - check contents
promise = resolve;
status = promise._error !== undefined ? AwaitRenderStatus.error : promise._data !== undefined ? AwaitRenderStatus.success : AwaitRenderStatus.pending;
} else {
// Raw (untracked) promise - track it
status = AwaitRenderStatus.pending;
Object.defineProperty(resolve, "_tracked", {
get: () => true
});
promise = resolve.then(data => Object.defineProperty(resolve, "_data", {
get: () => data
}), error => Object.defineProperty(resolve, "_error", {
get: () => error
}));
}
1211
if (status === AwaitRenderStatus.error && promise._error instanceof AbortedDeferredError) {
// Freeze the UI by throwing a never resolved promise
throw neverSettledPromise;
}
1216
if (status === AwaitRenderStatus.error && !errorElement) {
// No errorElement, throw to the nearest route-level error boundary
throw promise._error;
}
1221
if (status === AwaitRenderStatus.error) {
// Render via our errorElement
return /*#__PURE__*/React.createElement(AwaitContext.Provider, {
value: promise,
children: errorElement
});
}
1229
if (status === AwaitRenderStatus.success) {
// Render children with resolved value
return /*#__PURE__*/React.createElement(AwaitContext.Provider, {
value: promise,
children: children
});
} // Throw to the suspense boundary
1237
1238
throw promise;
}
1241
1242}
1243/**
* @private
* Indirection to leverage useAsyncValue for a render-prop API on <Await>
*/
1247
1248
1249function ResolveAwait(_ref7) {
let {
children
} = _ref7;
let data = useAsyncValue();
1254
if (typeof children === "function") {
return children(data);
}
1258
return /*#__PURE__*/React.createElement(React.Fragment, null, children);
1260} ///////////////////////////////////////////////////////////////////////////////
1261// UTILS
1262///////////////////////////////////////////////////////////////////////////////
1263
1264/**
* Creates a route config from a React "children" object, which is usually
* either a `<Route>` element or an array of them. Used internally by
* `<Routes>` to create a route config from its children.
*
* @see https://reactrouter.com/docs/en/v6/utils/create-routes-from-children
*/
1271
1272
1273function createRoutesFromChildren(children, parentPath) {
if (parentPath === void 0) {
parentPath = [];
}
1277
let routes = [];
React.Children.forEach(children, (element, index) => {
if (! /*#__PURE__*/React.isValidElement(element)) {
// Ignore non-elements. This allows people to more easily inline
// conditionals in their route config.
return;
}
1285
if (element.type === React.Fragment) {
// Transparently support React.Fragment and its children.
routes.push.apply(routes, createRoutesFromChildren(element.props.children, parentPath));
return;
}
1291
!(element.type === Route) ? process.env.NODE_ENV !== "production" ? invariant(false, "[" + (typeof element.type === "string" ? element.type : element.type.name) + "] is not a <Route> component. All component children of <Routes> must be a <Route> or <React.Fragment>") : invariant(false) : void 0;
let treePath = [...parentPath, index];
let route = {
id: element.props.id || treePath.join("-"),
caseSensitive: element.props.caseSensitive,
element: element.props.element,
index: element.props.index,
path: element.props.path,
loader: element.props.loader,
action: element.props.action,
errorElement: element.props.errorElement,
hasErrorBoundary: element.props.errorElement != null,
shouldRevalidate: element.props.shouldRevalidate,
handle: element.props.handle
};
1307
if (element.props.children) {
route.children = createRoutesFromChildren(element.props.children, treePath);
}
1311
routes.push(route);
});
return routes;
1315}
1316/**
* Renders the result of `matchRoutes()` into a React element.
*/
1319
1320function renderMatches(matches) {
return _renderMatches(matches);
1322}
1323/**
* @private
* Walk the route tree and add hasErrorBoundary if it's not provided, so that
* users providing manual route arrays can just specify errorElement
*/
1328
1329function enhanceManualRouteObjects(routes) {
return routes.map(route => {
let routeClone = _extends({}, route);
1332
if (routeClone.hasErrorBoundary == null) {
routeClone.hasErrorBoundary = routeClone.errorElement != null;
}
1336
if (routeClone.children) {
routeClone.children = enhanceManualRouteObjects(routeClone.children);
}
1340
return routeClone;
});
1343}
1344
1345function createMemoryRouter(routes, opts) {
return createRouter({
basename: opts == null ? void 0 : opts.basename,
history: createMemoryHistory({
initialEntries: opts == null ? void 0 : opts.initialEntries,
initialIndex: opts == null ? void 0 : opts.initialIndex
}),
hydrationData: opts == null ? void 0 : opts.hydrationData,
routes: enhanceManualRouteObjects(routes)
}).initialize();
1355} ///////////////////////////////////////////////////////////////////////////////
1356
1357export { Await, MemoryRouter, Navigate, Outlet, Route, Router, RouterProvider, Routes, DataRouterContext as UNSAFE_DataRouterContext, DataRouterStateContext as UNSAFE_DataRouterStateContext, DataStaticRouterContext as UNSAFE_DataStaticRouterContext, LocationContext as UNSAFE_LocationContext, NavigationContext as UNSAFE_NavigationContext, RouteContext as UNSAFE_RouteContext, enhanceManualRouteObjects as UNSAFE_enhanceManualRouteObjects, createMemoryRouter, createRoutesFromChildren, createRoutesFromChildren as createRoutesFromElements, renderMatches, useActionData, useAsyncError, useAsyncValue, useHref, useInRouterContext, useLoaderData, useLocation, useMatch, useMatches, useNavigate, useNavigation, useNavigationType, useOutlet, useOutletContext, useParams, useResolvedPath, useRevalidator, useRouteError, useRouteLoaderData, useRoutes };
1358//# sourceMappingURL=index.js.map