UNPKG

react-router/dist/react-router.development.js

Version:
49.1 kB JavaScript View Raw
1/**
* React Router v6.9.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
*/
11import { UNSAFE_invariant, joinPaths, matchPath, UNSAFE_getPathContributingMatches, UNSAFE_warning, resolveTo, 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
15/**
* 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.
*/
21/**
* 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
*/
25
26function isPolyfill(x, y) {
return x === y && (x !== 0 || 1 / x === 1 / y) || x !== x && y !== y // eslint-disable-line no-self-compare
;
29}
30
31const is = typeof Object.is === "function" ? Object.is : isPolyfill; // Intentionally not using named imports because Rollup uses dynamic
32// dispatch for CommonJS interop named imports.
33
34const {
useState,
useEffect,
useLayoutEffect,
useDebugValue
39} = React;
40let didWarnOld18Alpha = false;
41let didWarnUncachedGetSnapshot = false; // Disclaimer: This shim breaks many of the rules of React, and only works
42// because of a very particular set of implementation details and assumptions
43// -- change any one of them and it will break. The most important assumption
44// is that updates are always synchronous, because concurrent rendering is
45// only available in versions of React that also have a built-in
46// useSyncExternalStore API. And we only use this shim when the built-in API
47// does not exist.
48//
49// Do not assume that the clever hacks used by this hook also work in general.
50// The point of this shim is to replace the need for hacks by other libraries.
51
52function useSyncExternalStore$2(subscribe, getSnapshot, // Note: The shim does not use getServerSnapshot, because pre-18 versions of
53// React do not expose a way to check if we're hydrating. So users of the shim
54// will need to track that themselves and return the correct value
55// from `getSnapshot`.
56getServerSnapshot) {
{
  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.
68
69
const value = getSnapshot();
71
{
  if (!didWarnUncachedGetSnapshot) {
    const cachedValue = getSnapshot();
75
    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.
95
96
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.
107
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.
114
  if (checkIfSnapshotChanged(inst)) {
    // Force a re-render.
    forceUpdate({
      inst
    });
  } // eslint-disable-next-line react-hooks/exhaustive-deps
121
}, [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
    });
  }
132
  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.
147
148
  return subscribe(handleStoreChange); // eslint-disable-next-line react-hooks/exhaustive-deps
}, [subscribe]);
useDebugValue(value);
return value;
153}
154
155function checkIfSnapshotChanged(inst) {
const latestGetSnapshot = inst.getSnapshot;
const prevValue = inst.value;
158
try {
  const nextValue = latestGetSnapshot();
  return !is(prevValue, nextValue);
} catch (error) {
  return true;
}
165}
166
167/**
* 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
*/
175function 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();
181}
182
183/**
* 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
*/
188const canUseDOM = !!(typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement !== "undefined");
189const isServerEnvironment = !canUseDOM;
190const shim = isServerEnvironment ? useSyncExternalStore$1 : useSyncExternalStore$2;
191const useSyncExternalStore = "useSyncExternalStore" in React ? (module => module.useSyncExternalStore)(React) : shim;
192
193const DataRouterContext = /*#__PURE__*/React.createContext(null);
194
195{
DataRouterContext.displayName = "DataRouter";
197}
198
199const DataRouterStateContext = /*#__PURE__*/React.createContext(null);
200
201{
DataRouterStateContext.displayName = "DataRouterState";
203}
204
205const AwaitContext = /*#__PURE__*/React.createContext(null);
206
207{
AwaitContext.displayName = "Await";
209}
210
211const NavigationContext = /*#__PURE__*/React.createContext(null);
212
213{
NavigationContext.displayName = "Navigation";
215}
216
217const LocationContext = /*#__PURE__*/React.createContext(null);
218
219{
LocationContext.displayName = "Location";
221}
222
223const RouteContext = /*#__PURE__*/React.createContext({
outlet: null,
matches: []
226});
227
228{
RouteContext.displayName = "Route";
230}
231
232const RouteErrorContext = /*#__PURE__*/React.createContext(null);
233
234{
RouteErrorContext.displayName = "RouteError";
236}
237
238/**
* 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/hooks/use-href
*/
244
245function useHref(to, {
relative
247} = {}) {
!useInRouterContext() ? UNSAFE_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.`)  : 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
266
if (basename !== "/") {
  joinedPathname = pathname === "/" ? basename : joinPaths([basename, pathname]);
}
270
return navigator.createHref({
  pathname: joinedPathname,
  search,
  hash
});
276}
277/**
* Returns true if this component is a descendant of a <Router>.
*
* @see https://reactrouter.com/hooks/use-in-router-context
*/
282
283function useInRouterContext() {
return React.useContext(LocationContext) != null;
285}
286/**
* 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/hooks/use-location
*/
296
297function useLocation() {
!useInRouterContext() ? UNSAFE_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.`)  : void 0;
return React.useContext(LocationContext).location;
302}
303/**
* 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/hooks/use-navigation-type
*/
309
310function useNavigationType() {
return React.useContext(LocationContext).navigationType;
312}
313/**
* Returns a PathMatch object if the given pattern matches the current URL.
* This is useful for components that need to know "active" state, e.g.
* <NavLink>.
*
* @see https://reactrouter.com/hooks/use-match
*/
320
321function useMatch(pattern) {
!useInRouterContext() ? UNSAFE_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.`)  : void 0;
let {
  pathname
} = useLocation();
return React.useMemo(() => matchPath(pattern, pathname), [pathname, pattern]);
329}
330/**
* 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/hooks/use-navigate
*/
336
337function useNavigate() {
!useInRouterContext() ? UNSAFE_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.`)  : void 0;
let {
  basename,
  navigator
} = React.useContext(NavigationContext);
let {
  matches
} = React.useContext(RouteContext);
let {
  pathname: locationPathname
} = useLocation();
let routePathnamesJson = JSON.stringify(UNSAFE_getPathContributingMatches(matches).map(match => match.pathnameBase));
let activeRef = React.useRef(false);
React.useEffect(() => {
  activeRef.current = true;
});
let navigate = React.useCallback((to, options = {}) => {
  UNSAFE_warning(activeRef.current, `You should call navigate() in a React.useEffect(), not when ` + `your component is first rendered.`) ;
  if (!activeRef.current) return;
359
  if (typeof to === "number") {
    navigator.go(to);
    return;
  }
364
  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
369
  if (basename !== "/") {
    path.pathname = path.pathname === "/" ? basename : joinPaths([basename, path.pathname]);
  }
373
  (!!options.replace ? navigator.replace : navigator.push)(path, options.state, options);
}, [basename, navigator, routePathnamesJson, locationPathname]);
return navigate;
377}
378const OutletContext = /*#__PURE__*/React.createContext(null);
379/**
* Returns the context (if provided) for the child route at this level of the route
* hierarchy.
* @see https://reactrouter.com/hooks/use-outlet-context
*/
384
385function useOutletContext() {
return React.useContext(OutletContext);
387}
388/**
* 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/hooks/use-outlet
*/
394
395function useOutlet(context) {
let outlet = React.useContext(RouteContext).outlet;
397
if (outlet) {
  return /*#__PURE__*/React.createElement(OutletContext.Provider, {
    value: context
  }, outlet);
}
403
return outlet;
405}
406/**
* 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/hooks/use-params
*/
412
413function useParams() {
let {
  matches
} = React.useContext(RouteContext);
let routeMatch = matches[matches.length - 1];
return routeMatch ? routeMatch.params : {};
419}
420/**
* Resolves the pathname of the given `to` value against the current location.
*
* @see https://reactrouter.com/hooks/use-resolved-path
*/
425
426function useResolvedPath(to, {
relative
428} = {}) {
let {
  matches
} = React.useContext(RouteContext);
let {
  pathname: locationPathname
} = useLocation();
let routePathnamesJson = JSON.stringify(UNSAFE_getPathContributingMatches(matches).map(match => match.pathnameBase));
return React.useMemo(() => resolveTo(to, JSON.parse(routePathnamesJson), locationPathname, relative === "path"), [to, routePathnamesJson, locationPathname, relative]);
437}
438/**
* 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/hooks/use-routes
*/
446
447function useRoutes(routes, locationArg) {
!useInRouterContext() ? UNSAFE_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.`)  : void 0;
let {
  navigator
} = React.useContext(NavigationContext);
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;
463
{
  // 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}/*`}">.`);
}
488
let locationFromContext = useLocation();
let location;
491
if (locationArg) {
  let parsedLocationArg = typeof locationArg === "string" ? parsePath(locationArg) : locationArg;
  !(parentPathnameBase === "/" || parsedLocationArg.pathname?.startsWith(parentPathnameBase)) ? UNSAFE_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.`)  : void 0;
  location = parsedLocationArg;
} else {
  location = locationFromContext;
}
499
let pathname = location.pathname || "/";
let remainingPathname = parentPathnameBase === "/" ? pathname : pathname.slice(parentPathnameBase.length) || "/";
let matches = matchRoutes(routes, {
  pathname: remainingPathname
});
505
{
  UNSAFE_warning(parentRoute || matches != null, `No routes matched location "${location.pathname}${location.search}${location.hash}" `) ;
  UNSAFE_warning(matches == null || matches[matches.length - 1].route.element !== undefined || matches[matches.length - 1].route.Component !== undefined, `Matched leaf route at location "${location.pathname}${location.search}${location.hash}" ` + `does not have an element or Component. This means it will render an <Outlet /> with a ` + `null value by default resulting in an "empty" page.`) ;
}
510
let renderedMatches = _renderMatches(matches && matches.map(match => Object.assign({}, match, {
  params: Object.assign({}, parentParams, match.params),
  pathname: joinPaths([parentPathnameBase, // Re-encode pathnames that were decoded inside matchRoutes
  navigator.encodeLocation ? navigator.encodeLocation(match.pathname).pathname : match.pathname]),
  pathnameBase: match.pathnameBase === "/" ? parentPathnameBase : joinPaths([parentPathnameBase, // Re-encode pathnames that were decoded inside matchRoutes
  navigator.encodeLocation ? navigator.encodeLocation(match.pathnameBase).pathname : 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.
520
521
if (locationArg && renderedMatches) {
  return /*#__PURE__*/React.createElement(LocationContext.Provider, {
    value: {
      location: {
        pathname: "/",
        search: "",
        hash: "",
        state: null,
        key: "default",
        ...location
      },
      navigationType: Action.Pop
    }
  }, renderedMatches);
}
537
return renderedMatches;
539}
540
541function DefaultErrorComponent() {
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
};
let devInfo = null;
555
{
  devInfo = /*#__PURE__*/React.createElement(React.Fragment, 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\u00A0", /*#__PURE__*/React.createElement("code", {
    style: codeStyles
  }, "ErrorBoundary"), " prop on\u00A0", /*#__PURE__*/React.createElement("code", {
    style: codeStyles
  }, "<Route>")));
}
563
return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("h2", null, "Unexpected Application Error!"), /*#__PURE__*/React.createElement("h3", {
  style: {
    fontStyle: "italic"
  }
}, message), stack ? /*#__PURE__*/React.createElement("pre", {
  style: preStyles
}, stack) : null, devInfo);
571}
572
573class RenderErrorBoundary extends React.Component {
constructor(props) {
  super(props);
  this.state = {
    location: props.location,
    error: props.error
  };
}
581
static getDerivedStateFromError(error) {
  return {
    error: error
  };
}
587
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.
606
607
  return {
    error: props.error || state.error,
    location: state.location
  };
}
613
componentDidCatch(error, errorInfo) {
  console.error("React Router caught the following error during render", error, errorInfo);
}
617
render() {
  return this.state.error ? /*#__PURE__*/React.createElement(RouteContext.Provider, {
    value: this.props.routeContext
  }, /*#__PURE__*/React.createElement(RouteErrorContext.Provider, {
    value: this.state.error,
    children: this.props.component
  })) : this.props.children;
}
626
627}
628
629function RenderedRoute({
routeContext,
match,
children
633}) {
let dataRouterContext = React.useContext(DataRouterContext); // Track how deep we got in our render pass to emulate SSR componentDidCatch
// in a DataStaticRouter
636
if (dataRouterContext && dataRouterContext.static && dataRouterContext.staticContext && (match.route.errorElement || match.route.ErrorBoundary)) {
  dataRouterContext.staticContext._deepestRenderedBoundaryId = match.route.id;
}
640
return /*#__PURE__*/React.createElement(RouteContext.Provider, {
  value: routeContext
}, children);
644}
645
646function _renderMatches(matches, parentMatches = [], dataRouterState) {
if (matches == null) {
  if (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;
  }
}
656
let renderedMatches = matches; // If we have data errors, trim matches to the highest error boundary
658
let errors = dataRouterState?.errors;
660
if (errors != null) {
  let errorIndex = renderedMatches.findIndex(m => m.route.id && errors?.[m.route.id]);
  !(errorIndex >= 0) ? UNSAFE_invariant(false, `Could not find a matching route for the current errors: ${errors}`)  : void 0;
  renderedMatches = renderedMatches.slice(0, Math.min(renderedMatches.length, errorIndex + 1));
}
666
return renderedMatches.reduceRight((outlet, match, index) => {
  let error = match.route.id ? errors?.[match.route.id] : null; // Only data routers handle errors
669
  let errorElement = null;
671
  if (dataRouterState) {
    if (match.route.ErrorBoundary) {
      errorElement = /*#__PURE__*/React.createElement(match.route.ErrorBoundary, null);
    } else if (match.route.errorElement) {
      errorElement = match.route.errorElement;
    } else {
      errorElement = /*#__PURE__*/React.createElement(DefaultErrorComponent, null);
    }
  }
681
  let matches = parentMatches.concat(renderedMatches.slice(0, index + 1));
683
  let getChildren = () => {
    let children = outlet;
686
    if (error) {
      children = errorElement;
    } else if (match.route.Component) {
      children = /*#__PURE__*/React.createElement(match.route.Component, null);
    } else if (match.route.element) {
      children = match.route.element;
    }
694
    return /*#__PURE__*/React.createElement(RenderedRoute, {
      match: match,
      routeContext: {
        outlet,
        matches
      },
      children: children
    });
  }; // Only wrap in an error boundary within data router usages when we have an
  // ErrorBoundary/errorElement on this route.  Otherwise let it bubble up to
  // an ancestor ErrorBoundary/errorElement
706
707
  return dataRouterState && (match.route.ErrorBoundary || match.route.errorElement || index === 0) ? /*#__PURE__*/React.createElement(RenderErrorBoundary, {
    location: dataRouterState.location,
    component: errorElement,
    error: error,
    children: getChildren(),
    routeContext: {
      outlet: null,
      matches
    }
  }) : getChildren();
}, null);
719}
720var DataRouterHook;
721
722(function (DataRouterHook) {
DataRouterHook["UseBlocker"] = "useBlocker";
DataRouterHook["UseRevalidator"] = "useRevalidator";
725})(DataRouterHook || (DataRouterHook = {}));
726
727var DataRouterStateHook;
728
729(function (DataRouterStateHook) {
DataRouterStateHook["UseBlocker"] = "useBlocker";
DataRouterStateHook["UseLoaderData"] = "useLoaderData";
DataRouterStateHook["UseActionData"] = "useActionData";
DataRouterStateHook["UseRouteError"] = "useRouteError";
DataRouterStateHook["UseNavigation"] = "useNavigation";
DataRouterStateHook["UseRouteLoaderData"] = "useRouteLoaderData";
DataRouterStateHook["UseMatches"] = "useMatches";
DataRouterStateHook["UseRevalidator"] = "useRevalidator";
738})(DataRouterStateHook || (DataRouterStateHook = {}));
739
740function getDataRouterConsoleError(hookName) {
return `${hookName} must be used within a data router.  See https://reactrouter.com/routers/picking-a-router.`;
742}
743
744function useDataRouterContext(hookName) {
let ctx = React.useContext(DataRouterContext);
!ctx ? UNSAFE_invariant(false, getDataRouterConsoleError(hookName))  : void 0;
return ctx;
748}
749
750function useDataRouterState(hookName) {
let state = React.useContext(DataRouterStateContext);
!state ? UNSAFE_invariant(false, getDataRouterConsoleError(hookName))  : void 0;
return state;
754}
755
756function useRouteContext(hookName) {
let route = React.useContext(RouteContext);
!route ? UNSAFE_invariant(false, getDataRouterConsoleError(hookName))  : void 0;
return route;
760}
761
762function useCurrentRouteId(hookName) {
let route = useRouteContext(hookName);
let thisRoute = route.matches[route.matches.length - 1];
!thisRoute.route.id ? UNSAFE_invariant(false, `${hookName} can only be used on routes that contain a unique "id"`)  : void 0;
return thisRoute.route.id;
767}
768/**
* Returns the current navigation, defaulting to an "idle" navigation when
* no navigation is in progress
*/
772
773
774function useNavigation() {
let state = useDataRouterState(DataRouterStateHook.UseNavigation);
return state.navigation;
777}
778/**
* Returns a revalidate function for manually triggering revalidation, as well
* as the current state of any manual revalidations
*/
782
783function useRevalidator() {
let dataRouterContext = useDataRouterContext(DataRouterHook.UseRevalidator);
let state = useDataRouterState(DataRouterStateHook.UseRevalidator);
return {
  revalidate: dataRouterContext.router.revalidate,
  state: state.revalidation
};
790}
791/**
* Returns the active route matches, useful for accessing loaderData for
* parent/child routes or the route "handle" property
*/
795
796function useMatches() {
let {
  matches,
  loaderData
} = useDataRouterState(DataRouterStateHook.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
808
  return {
    id: match.route.id,
    pathname,
    params,
    data: loaderData[match.route.id],
    handle: match.route.handle
  };
}), [matches, loaderData]);
817}
818/**
* Returns the loader data for the nearest ancestor Route loader
*/
821
822function useLoaderData() {
let state = useDataRouterState(DataRouterStateHook.UseLoaderData);
let routeId = useCurrentRouteId(DataRouterStateHook.UseLoaderData);
825
if (state.errors && state.errors[routeId] != null) {
  console.error(`You cannot \`useLoaderData\` in an errorElement (routeId: ${routeId})`);
  return undefined;
}
830
return state.loaderData[routeId];
832}
833/**
* Returns the loaderData for the given routeId
*/
836
837function useRouteLoaderData(routeId) {
let state = useDataRouterState(DataRouterStateHook.UseRouteLoaderData);
return state.loaderData[routeId];
840}
841/**
* Returns the action data for the nearest ancestor Route action
*/
844
845function useActionData() {
let state = useDataRouterState(DataRouterStateHook.UseActionData);
let route = React.useContext(RouteContext);
!route ? UNSAFE_invariant(false, `useActionData must be used inside a RouteContext`)  : void 0;
return Object.values(state?.actionData || {})[0];
850}
851/**
* 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
* ErrorBoundary/errorElement to display a proper error message.
*/
856
857function useRouteError() {
let error = React.useContext(RouteErrorContext);
let state = useDataRouterState(DataRouterStateHook.UseRouteError);
let routeId = useCurrentRouteId(DataRouterStateHook.UseRouteError); // If this was a render error, we put it in a RouteError context inside
// of RenderErrorBoundary
862
if (error) {
  return error;
} // Otherwise look for errors from our data router state
866
867
return state.errors?.[routeId];
869}
870/**
* Returns the happy-path data from the nearest ancestor <Await /> value
*/
873
874function useAsyncValue() {
let value = React.useContext(AwaitContext);
return value?._data;
877}
878/**
* Returns the error from the nearest ancestor <Await /> value
*/
881
882function useAsyncError() {
let value = React.useContext(AwaitContext);
return value?._error;
885}
886let blockerId = 0;
887/**
* Allow the application to block navigations within the SPA and present the
* user a confirmation dialog to confirm the navigation.  Mostly used to avoid
* using half-filled form data.  This does not handle hard-reloads or
* cross-origin navigations.
*/
893
894function useBlocker(shouldBlock) {
let {
  router
} = useDataRouterContext(DataRouterHook.UseBlocker);
let state = useDataRouterState(DataRouterStateHook.UseBlocker);
let [blockerKey] = React.useState(() => String(++blockerId));
let blockerFunction = React.useCallback(args => {
  return typeof shouldBlock === "function" ? !!shouldBlock(args) : !!shouldBlock;
}, [shouldBlock]);
let blocker = router.getBlocker(blockerKey, blockerFunction); // Cleanup on unmount
904
React.useEffect(() => () => router.deleteBlocker(blockerKey), [router, blockerKey]); // Prefer the blocker from state since DataRouterContext is memoized so this
// ensures we update on blocker state updates
907
return state.blockers.get(blockerKey) || blocker;
909}
910const alreadyWarned = {};
911
912function warningOnce(key, cond, message) {
if (!cond && !alreadyWarned[key]) {
  alreadyWarned[key] = true;
  UNSAFE_warning(false, message) ;
}
917}
918
919/**
* Given a Remix Router instance, render the appropriate UI
*/
922
923function RouterProvider({
fallbackElement,
router
926}) {
let getState = React.useCallback(() => router.state, [router]); // Sync router state to our component state to force re-renders
928
let state = useSyncExternalStore(router.subscribe, getState, // 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
getState);
let navigator = React.useMemo(() => {
  return {
    createHref: router.createHref,
    encodeLocation: router.encodeLocation,
    go: n => router.navigate(n),
    push: (to, state, opts) => router.navigate(to, {
      state,
      preventScrollReset: opts?.preventScrollReset
    }),
    replace: (to, state, opts) => router.navigate(to, {
      replace: true,
      state,
      preventScrollReset: opts?.preventScrollReset
    })
  };
}, [router]);
let basename = router.basename || "/";
let dataRouterContext = React.useMemo(() => ({
  router,
  navigator,
  static: false,
  basename
}), [router, navigator, basename]); // The fragment and {null} here are important!  We need them to keep React 18's
// useId happy when we are server-rendering since we may have a <script> here
// containing the hydrated server-side staticContext (from StaticRouterProvider).
// useId relies on the component tree structure to generate deterministic id's
// so we need to ensure it remains the same on the client even though
// we don't need the <script> tag
961
return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(DataRouterContext.Provider, {
  value: dataRouterContext
}, /*#__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))), null);
972}
973/**
* A <Router> that stores all entries in memory.
*
* @see https://reactrouter.com/router-components/memory-router
*/
978
979function MemoryRouter({
basename,
children,
initialEntries,
initialIndex
984}) {
let historyRef = React.useRef();
986
if (historyRef.current == null) {
  historyRef.current = createMemoryHistory({
    initialEntries,
    initialIndex,
    v5Compat: true
  });
}
994
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
});
1008}
1009/**
* 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/components/navigate
*/
1018
1019function Navigate({
to,
replace,
state,
relative
1024}) {
!useInRouterContext() ? UNSAFE_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.`)  : void 0;
UNSAFE_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.`) ;
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;
  }
1038
  navigate(to, {
    replace,
    state,
    relative
  });
});
return null;
1046}
1047/**
* Renders the child route's element, if there is one.
*
* @see https://reactrouter.com/components/outlet
*/
1052
1053function Outlet(props) {
return useOutlet(props.context);
1055}
1056/**
* Declares an element that should be rendered at a certain URL path.
*
* @see https://reactrouter.com/components/route
*/
1061
1062function Route(_props) {
UNSAFE_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>.`)  ;
1064}
1065/**
* 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/router-components/router
*/
1074
1075function Router({
basename: basenameProp = "/",
children = null,
location: locationProp,
navigationType = Action.Pop,
navigator,
static: staticProp = false
1082}) {
!!useInRouterContext() ? UNSAFE_invariant(false, `You cannot render a <Router> inside another <Router>.` + ` You should never have more than one in your app.`)  : void 0; // Preserve trailing slashes on basename, so we can let the user control
// the enforcement of trailing slashes throughout the app
1085
let basename = basenameProp.replace(/^\/*/, "/");
let navigationContext = React.useMemo(() => ({
  basename,
  navigator,
  static: staticProp
}), [basename, navigator, staticProp]);
1092
if (typeof locationProp === "string") {
  locationProp = parsePath(locationProp);
}
1096
let {
  pathname = "/",
  search = "",
  hash = "",
  state = null,
  key = "default"
} = locationProp;
let locationContext = React.useMemo(() => {
  let trailingPathname = stripBasename(pathname, basename);
1106
  if (trailingPathname == null) {
    return null;
  }
1110
  return {
    location: {
      pathname: trailingPathname,
      search,
      hash,
      state,
      key
    },
    navigationType
  };
}, [basename, pathname, search, hash, state, key, navigationType]);
UNSAFE_warning(locationContext != 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.`) ;
1123
if (locationContext == null) {
  return null;
}
1127
return /*#__PURE__*/React.createElement(NavigationContext.Provider, {
  value: navigationContext
}, /*#__PURE__*/React.createElement(LocationContext.Provider, {
  children: children,
  value: locationContext
}));
1134}
1135/**
* A container for a nested tree of <Route> elements that renders the branch
* that best matches the current location.
*
* @see https://reactrouter.com/components/routes
*/
1141
1142function Routes({
children,
location
1145}) {
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.
1149
let routes = dataRouterContext && !children ? dataRouterContext.router.routes : createRoutesFromChildren(children);
return useRoutes(routes, location);
1152}
1153/**
* Component to use for rendering lazily loaded data from returning defer()
* in a loader function
*/
1157
1158function Await({
children,
errorElement,
resolve
1162}) {
return /*#__PURE__*/React.createElement(AwaitErrorBoundary, {
  resolve: resolve,
  errorElement: errorElement
}, /*#__PURE__*/React.createElement(ResolveAwait, null, children));
1167}
1168var AwaitRenderStatus;
1169
1170(function (AwaitRenderStatus) {
AwaitRenderStatus[AwaitRenderStatus["pending"] = 0] = "pending";
AwaitRenderStatus[AwaitRenderStatus["success"] = 1] = "success";
AwaitRenderStatus[AwaitRenderStatus["error"] = 2] = "error";
1174})(AwaitRenderStatus || (AwaitRenderStatus = {}));
1175
1176const neverSettledPromise = new Promise(() => {});
1177
1178class AwaitErrorBoundary extends React.Component {
constructor(props) {
  super(props);
  this.state = {
    error: null
  };
}
1185
static getDerivedStateFromError(error) {
  return {
    error
  };
}
1191
componentDidCatch(error, errorInfo) {
  console.error("<Await> caught the following error during render", error, errorInfo);
}
1195
render() {
  let {
    children,
    errorElement,
    resolve
  } = this.props;
  let promise = null;
  let status = AwaitRenderStatus.pending;
1204
  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
1220
    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
    }));
  }
1243
  if (status === AwaitRenderStatus.error && promise._error instanceof AbortedDeferredError) {
    // Freeze the UI by throwing a never resolved promise
    throw neverSettledPromise;
  }
1248
  if (status === AwaitRenderStatus.error && !errorElement) {
    // No errorElement, throw to the nearest route-level error boundary
    throw promise._error;
  }
1253
  if (status === AwaitRenderStatus.error) {
    // Render via our errorElement
    return /*#__PURE__*/React.createElement(AwaitContext.Provider, {
      value: promise,
      children: errorElement
    });
  }
1261
  if (status === AwaitRenderStatus.success) {
    // Render children with resolved value
    return /*#__PURE__*/React.createElement(AwaitContext.Provider, {
      value: promise,
      children: children
    });
  } // Throw to the suspense boundary
1269
1270
  throw promise;
}
1273
1274}
1275/**
* @private
* Indirection to leverage useAsyncValue for a render-prop API on <Await>
*/
1279
1280
1281function ResolveAwait({
children
1283}) {
let data = useAsyncValue();
let toRender = typeof children === "function" ? children(data) : children;
return /*#__PURE__*/React.createElement(React.Fragment, null, toRender);
1287} ///////////////////////////////////////////////////////////////////////////////
1288// UTILS
1289///////////////////////////////////////////////////////////////////////////////
1290
1291/**
* 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/utils/create-routes-from-children
*/
1298
1299
1300function createRoutesFromChildren(children, parentPath = []) {
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;
  }
1308
  if (element.type === React.Fragment) {
    // Transparently support React.Fragment and its children.
    routes.push.apply(routes, createRoutesFromChildren(element.props.children, parentPath));
    return;
  }
1314
  !(element.type === Route) ? UNSAFE_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>`)  : void 0;
  !(!element.props.index || !element.props.children) ? UNSAFE_invariant(false, "An index route cannot have child routes.")  : void 0;
  let treePath = [...parentPath, index];
  let route = {
    id: element.props.id || treePath.join("-"),
    caseSensitive: element.props.caseSensitive,
    element: element.props.element,
    Component: element.props.Component,
    index: element.props.index,
    path: element.props.path,
    loader: element.props.loader,
    action: element.props.action,
    errorElement: element.props.errorElement,
    ErrorBoundary: element.props.ErrorBoundary,
    hasErrorBoundary: element.props.ErrorBoundary != null || element.props.errorElement != null,
    shouldRevalidate: element.props.shouldRevalidate,
    handle: element.props.handle,
    lazy: element.props.lazy
  };
1334
  if (element.props.children) {
    route.children = createRoutesFromChildren(element.props.children, treePath);
  }
1338
  routes.push(route);
});
return routes;
1342}
1343/**
* Renders the result of `matchRoutes()` into a React element.
*/
1346
1347function renderMatches(matches) {
return _renderMatches(matches);
1349}
1350
1351function detectErrorBoundary(route) {
{
  if (route.Component && route.element) {
    UNSAFE_warning(false, "You should not include both `Component` and `element` on your route - " + "`element` will be ignored.") ;
  }
1356
  if (route.ErrorBoundary && route.errorElement) {
    UNSAFE_warning(false, "You should not include both `ErrorBoundary` and `errorElement` on your route - " + "`errorElement` will be ignored.") ;
  }
} // Note: this check also occurs in createRoutesFromChildren so update
// there if you change this
1362
1363
return Boolean(route.ErrorBoundary) || Boolean(route.errorElement);
1365}
1366
1367function createMemoryRouter(routes, opts) {
return createRouter({
  basename: opts?.basename,
  history: createMemoryHistory({
    initialEntries: opts?.initialEntries,
    initialIndex: opts?.initialIndex
  }),
  hydrationData: opts?.hydrationData,
  routes,
  detectErrorBoundary
}).initialize();
1378} ///////////////////////////////////////////////////////////////////////////////
1379
1380export { Await, MemoryRouter, Navigate, Outlet, Route, Router, RouterProvider, Routes, DataRouterContext as UNSAFE_DataRouterContext, DataRouterStateContext as UNSAFE_DataRouterStateContext, LocationContext as UNSAFE_LocationContext, NavigationContext as UNSAFE_NavigationContext, RouteContext as UNSAFE_RouteContext, detectErrorBoundary as UNSAFE_detectErrorBoundary, createMemoryRouter, createRoutesFromChildren, createRoutesFromChildren as createRoutesFromElements, renderMatches, useBlocker as unstable_useBlocker, useActionData, useAsyncError, useAsyncValue, useHref, useInRouterContext, useLoaderData, useLocation, useMatch, useMatches, useNavigate, useNavigation, useNavigationType, useOutlet, useOutletContext, useParams, useResolvedPath, useRevalidator, useRouteError, useRouteLoaderData, useRoutes };
1381//# sourceMappingURL=react-router.development.js.map