react-router-dom-v5-compat 6.3.0 → 6.4.0-pre.0

package/LICENSE.md

@@ -1,7 +1,7 @@
 MIT License
 
 Copyright (c) React Training 2015-2019
-Copyright (c) Remix Software 2020-2021
+Copyright (c) Remix Software 2020-2022
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/index.d.ts

@@ -25,7 +25,7 @@
  * - TSC needs to generate the types, and it has to derive the output paths from
  *   the import paths. If we have a weird require *outside of this package* to
  *   "../../react-router-dom" it's going to generate types from the common root
- *   of all module paths (Which makes sense becuase what else would it do? It
+ *   of all module paths (Which makes sense because what else would it do? It
  *   needs to write the type files next to the source files so that typescript
  *   can resolve the types for tooling in the same location as the modules).
  *   Because tsc isn't as flexible as rollup, we have no control over this

package/index.js

@@ -1,5 +1,5 @@
 /**
- * React Router DOM v5 Compat v6.3.0
+ * React Router DOM v5 Compat v6.4.0-pre.0
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -8,10 +8,11 @@
  *
  * @license MIT
  */
-import { useRef, useState, useLayoutEffect, createElement, forwardRef, useCallback, useMemo } from 'react';
-import { createBrowserHistory, createHashHistory, parsePath, Action, createPath as createPath$1 } from 'history';
-import { Router, useHref, createPath, useLocation, useResolvedPath, useNavigate, Routes, Route } from 'react-router';
+import { useRef, useState, useLayoutEffect, createElement, forwardRef, useCallback, useContext, useMemo } from 'react';
+import { Router, useHref, createPath, useResolvedPath, useMatch, UNSAFE_DataRouterStateContext, useNavigate, useLocation, UNSAFE_DataRouterContext, UNSAFE_RouteContext, Routes, Route } from 'react-router';
 export { MemoryRouter, Navigate, NavigationType, Outlet, Route, Router, Routes, UNSAFE_LocationContext, UNSAFE_NavigationContext, UNSAFE_RouteContext, createPath, createRoutesFromChildren, generatePath, matchPath, matchRoutes, parsePath, renderMatches, resolvePath, useHref, useInRouterContext, useLocation, useMatch, useNavigate, useNavigationType, useOutlet, useOutletContext, useParams, useResolvedPath, useRoutes } from 'react-router';
+import { createBrowserHistory, createHashHistory, matchPath, invariant } from '@remix-run/router';
+import { parsePath, Action, createPath as createPath$1 } from 'history';
 import { Route as Route$1, useHistory } from 'react-router-dom';
 
 function _extends() {
@@ -47,41 +48,175 @@ function _objectWithoutPropertiesLoose(source, excluded) {
   return target;
 }
 
-const _excluded = ["onClick", "reloadDocument", "replace", "state", "target", "to"],
-      _excluded2 = ["aria-current", "caseSensitive", "className", "end", "style", "to", "children"];
+const defaultMethod = "get";
+const defaultEncType = "application/x-www-form-urlencoded";
+function isHtmlElement(object) {
+  return object != null && typeof object.tagName === "string";
+}
+function isButtonElement(object) {
+  return isHtmlElement(object) && object.tagName.toLowerCase() === "button";
+}
+function isFormElement(object) {
+  return isHtmlElement(object) && object.tagName.toLowerCase() === "form";
+}
+function isInputElement(object) {
+  return isHtmlElement(object) && object.tagName.toLowerCase() === "input";
+}
 
-function warning(cond, message) {
-  if (!cond) {
-    // eslint-disable-next-line no-console
-    if (typeof console !== "undefined") console.warn(message);
+function isModifiedEvent(event) {
+  return !!(event.metaKey || event.altKey || event.ctrlKey || event.shiftKey);
+}
 
-    try {
-      // Welcome to debugging React Router!
-      //
-      // This error is thrown as a convenience so you can more easily
-      // find the source for a warning that appears in the console by
-      // enabling "pause on exceptions" in your JavaScript debugger.
-      throw new Error(message); // eslint-disable-next-line no-empty
-    } catch (e) {}
+function shouldProcessLinkClick(event, target) {
+  return event.button === 0 && ( // Ignore everything but left clicks
+  !target || target === "_self") && // Let browser handle "target=_blank" etc.
+  !isModifiedEvent(event) // Ignore clicks with modifier keys
+  ;
+}
+
+/**
+ * Creates a URLSearchParams object using the given initializer.
+ *
+ * This is identical to `new URLSearchParams(init)` except it also
+ * supports arrays as values in the object form of the initializer
+ * instead of just strings. This is convenient when you need multiple
+ * values for a given key, but don't want to use an array initializer.
+ *
+ * For example, instead of:
+ *
+ *   let searchParams = new URLSearchParams([
+ *     ['sort', 'name'],
+ *     ['sort', 'price']
+ *   ]);
+ *
+ * you can do:
+ *
+ *   let searchParams = createSearchParams({
+ *     sort: ['name', 'price']
+ *   });
+ */
+function createSearchParams(init) {
+  if (init === void 0) {
+    init = "";
   }
-} ////////////////////////////////////////////////////////////////////////////////
-// COMPONENTS
-////////////////////////////////////////////////////////////////////////////////
+
+  return new URLSearchParams(typeof init === "string" || Array.isArray(init) || init instanceof URLSearchParams ? init : Object.keys(init).reduce((memo, key) => {
+    let value = init[key];
+    return memo.concat(Array.isArray(value) ? value.map(v => [key, v]) : [[key, value]]);
+  }, []));
+}
+function getSearchParamsForLocation(locationSearch, defaultSearchParams) {
+  let searchParams = createSearchParams(locationSearch);
+
+  for (let key of defaultSearchParams.keys()) {
+    if (!searchParams.has(key)) {
+      defaultSearchParams.getAll(key).forEach(value => {
+        searchParams.append(key, value);
+      });
+    }
+  }
+
+  return searchParams;
+}
+function getFormSubmissionInfo(target, defaultAction, options) {
+  let method;
+  let action;
+  let encType;
+  let formData;
+
+  if (isFormElement(target)) {
+    let submissionTrigger = options.submissionTrigger;
+    method = options.method || target.getAttribute("method") || defaultMethod;
+    action = options.action || target.getAttribute("action") || defaultAction;
+    encType = options.encType || target.getAttribute("enctype") || defaultEncType;
+    formData = new FormData(target);
+
+    if (submissionTrigger && submissionTrigger.name) {
+      formData.append(submissionTrigger.name, submissionTrigger.value);
+    }
+  } else if (isButtonElement(target) || isInputElement(target) && (target.type === "submit" || target.type === "image")) {
+    let form = target.form;
+
+    if (form == null) {
+      throw new Error("Cannot submit a <button> or <input type=\"submit\"> without a <form>");
+    } // <button>/<input type="submit"> may override attributes of <form>
+
+
+    method = options.method || target.getAttribute("formmethod") || form.getAttribute("method") || defaultMethod;
+    action = options.action || target.getAttribute("formaction") || form.getAttribute("action") || defaultAction;
+    encType = options.encType || target.getAttribute("formenctype") || form.getAttribute("enctype") || defaultEncType;
+    formData = new FormData(form); // Include name + value from a <button>
+
+    if (target.name) {
+      formData.set(target.name, target.value);
+    }
+  } else if (isHtmlElement(target)) {
+    throw new Error("Cannot submit element that is not <form>, <button>, or " + "<input type=\"submit|image\">");
+  } else {
+    method = options.method || defaultMethod;
+    action = options.action || defaultAction;
+    encType = options.encType || defaultEncType;
+
+    if (target instanceof FormData) {
+      formData = target;
+    } else {
+      formData = new FormData();
+
+      if (target instanceof URLSearchParams) {
+        for (let [name, value] of target) {
+          formData.append(name, value);
+        }
+      } else if (target != null) {
+        for (let name of Object.keys(target)) {
+          formData.append(name, target[name]);
+        }
+      }
+    }
+  }
+
+  let {
+    protocol,
+    host
+  } = window.location;
+  let url = new URL(action, protocol + "//" + host);
+
+  if (method.toLowerCase() === "get") {
+    for (let [name, value] of formData) {
+      if (typeof value === "string") {
+        url.searchParams.append(name, value);
+      } else {
+        throw new Error("Cannot submit binary form data using GET");
+      }
+    }
+  }
+
+  return {
+    url,
+    method,
+    encType,
+    formData
+  };
+}
+
+const _excluded = ["onClick", "reloadDocument", "replace", "state", "target", "to", "resetScroll"],
+      _excluded2 = ["aria-current", "caseSensitive", "className", "end", "style", "to", "children"],
+      _excluded3 = ["replace", "method", "action", "onSubmit", "fetcherKey"];
 
 /**
  * A `<Router>` for use in web browsers. Provides the cleanest URLs.
  */
-function BrowserRouter(_ref) {
+function BrowserRouter(_ref3) {
   let {
     basename,
     children,
     window
-  } = _ref;
+  } = _ref3;
   let historyRef = useRef();
 
   if (historyRef.current == null) {
     historyRef.current = createBrowserHistory({
-      window
+      window,
+      v5Compat: true
     });
   }
 
@@ -104,17 +239,18 @@ function BrowserRouter(_ref) {
  * A `<Router>` for use in web browsers. Stores the location in the hash
  * portion of the URL so it is not sent to the server.
  */
-function HashRouter(_ref2) {
+function HashRouter(_ref4) {
   let {
     basename,
     children,
     window
-  } = _ref2;
+  } = _ref4;
   let historyRef = useRef();
 
   if (historyRef.current == null) {
     historyRef.current = createHashHistory({
-      window
+      window,
+      v5Compat: true
     });
   }
 
@@ -139,12 +275,12 @@ function HashRouter(_ref2) {
  * two versions of the history library to your bundles unless you use the same
  * version of the history library that React Router uses internally.
  */
-function HistoryRouter(_ref3) {
+function HistoryRouter(_ref5) {
   let {
     basename,
     children,
     history
-  } = _ref3;
+  } = _ref5;
   const [state, setState] = useState({
     action: history.action,
     location: history.location
@@ -163,29 +299,27 @@ if (process.env.NODE_ENV !== "production") {
   HistoryRouter.displayName = "unstable_HistoryRouter";
 }
 
-function isModifiedEvent(event) {
-  return !!(event.metaKey || event.altKey || event.ctrlKey || event.shiftKey);
-}
-
 /**
  * The public API for rendering a history-aware <a>.
  */
-const Link = /*#__PURE__*/forwardRef(function LinkWithRef(_ref4, ref) {
+const Link = /*#__PURE__*/forwardRef(function LinkWithRef(_ref6, ref) {
   let {
     onClick,
     reloadDocument,
     replace = false,
     state,
     target,
-    to
-  } = _ref4,
-      rest = _objectWithoutPropertiesLoose(_ref4, _excluded);
+    to,
+    resetScroll
+  } = _ref6,
+      rest = _objectWithoutPropertiesLoose(_ref6, _excluded);
 
   let href = useHref(to);
   let internalOnClick = useLinkClickHandler(to, {
     replace,
     state,
-    target
+    target,
+    resetScroll
   });
 
   function handleClick(event) {
@@ -215,7 +349,7 @@ if (process.env.NODE_ENV !== "production") {
 /**
  * A <Link> wrapper that knows if it's "active" or not.
  */
-const NavLink = /*#__PURE__*/forwardRef(function NavLinkWithRef(_ref5, ref) {
+const NavLink = /*#__PURE__*/forwardRef(function NavLinkWithRef(_ref7, ref) {
   let {
     "aria-current": ariaCurrentProp = "page",
     caseSensitive = false,
@@ -224,26 +358,32 @@ const NavLink = /*#__PURE__*/forwardRef(function NavLinkWithRef(_ref5, ref) {
     style: styleProp,
     to,
     children
-  } = _ref5,
-      rest = _objectWithoutPropertiesLoose(_ref5, _excluded2);
+  } = _ref7,
+      rest = _objectWithoutPropertiesLoose(_ref7, _excluded2);
 
-  let location = useLocation();
   let path = useResolvedPath(to);
-  let locationPathname = location.pathname;
-  let toPathname = path.pathname;
-
-  if (!caseSensitive) {
-    locationPathname = locationPathname.toLowerCase();
-    toPathname = toPathname.toLowerCase();
-  }
-
-  let isActive = locationPathname === toPathname || !end && locationPathname.startsWith(toPathname) && locationPathname.charAt(toPathname.length) === "/";
+  let match = useMatch({
+    path: path.pathname,
+    end,
+    caseSensitive
+  });
+  let routerState = useContext(UNSAFE_DataRouterStateContext);
+  let nextLocation = routerState == null ? void 0 : routerState.navigation.location;
+  let nextPath = useResolvedPath(nextLocation || "");
+  let nextMatch = useMemo(() => nextLocation ? matchPath({
+    path: path.pathname,
+    end,
+    caseSensitive
+  }, nextPath.pathname) : null, [nextLocation, path.pathname, caseSensitive, end, nextPath.pathname]);
+  let isPending = nextMatch != null;
+  let isActive = match != null;
   let ariaCurrent = isActive ? ariaCurrentProp : undefined;
   let className;
 
   if (typeof classNameProp === "function") {
     className = classNameProp({
-      isActive
+      isActive,
+      isPending
     });
   } else {
     // If the className prop is not a function, we use a default `active`
@@ -251,11 +391,12 @@ const NavLink = /*#__PURE__*/forwardRef(function NavLinkWithRef(_ref5, ref) {
     // value for `activeClassName`, but we are removing that API and can still
     // use the old default behavior for a cleaner upgrade path and keep the
     // simple styling rules working as they currently do.
-    className = [classNameProp, isActive ? "active" : null].filter(Boolean).join(" ");
+    className = [classNameProp, isActive ? "active" : null, isPending ? "pending" : null].filter(Boolean).join(" ");
   }
 
   let style = typeof styleProp === "function" ? styleProp({
-    isActive
+    isActive,
+    isPending
   }) : styleProp;
   return /*#__PURE__*/createElement(Link, _extends({}, rest, {
     "aria-current": ariaCurrent,
@@ -264,14 +405,71 @@ const NavLink = /*#__PURE__*/forwardRef(function NavLinkWithRef(_ref5, ref) {
     style: style,
     to: to
   }), typeof children === "function" ? children({
-    isActive
+    isActive,
+    isPending
   }) : children);
 });
 
 if (process.env.NODE_ENV !== "production") {
   NavLink.displayName = "NavLink";
-} ////////////////////////////////////////////////////////////////////////////////
-// HOOKS
+}
+
+/**
+ * A `@remix-run/router`-aware `<form>`. It behaves like a normal form except
+ * that the interaction with the server is with `fetch` instead of new document
+ * requests, allowing components to add nicer UX to the page as the form is
+ * submitted and returns with data.
+ */
+const Form = /*#__PURE__*/forwardRef((props, ref) => {
+  return /*#__PURE__*/createElement(FormImpl, _extends({}, props, {
+    ref: ref
+  }));
+});
+
+if (process.env.NODE_ENV !== "production") {
+  Form.displayName = "Form";
+}
+
+const FormImpl = /*#__PURE__*/forwardRef((_ref8, forwardedRef) => {
+  let {
+    replace,
+    method = defaultMethod,
+    action = ".",
+    onSubmit,
+    fetcherKey
+  } = _ref8,
+      props = _objectWithoutPropertiesLoose(_ref8, _excluded3);
+
+  let submit = useSubmitImpl(fetcherKey);
+  let formMethod = method.toLowerCase() === "get" ? "get" : "post";
+  let formAction = useFormAction(action);
+
+  let submitHandler = event => {
+    onSubmit && onSubmit(event);
+    if (event.defaultPrevented) return;
+    event.preventDefault();
+    let submitter = event.nativeEvent.submitter;
+    submit(submitter || event.currentTarget, {
+      method,
+      replace
+    });
+  };
+
+  return /*#__PURE__*/createElement("form", _extends({
+    ref: forwardedRef,
+    method: formMethod,
+    action: formAction,
+    onSubmit: submitHandler
+  }, props));
+});
+
+if (process.env.NODE_ENV !== "production") {
+  Form.displayName = "Form";
+}
+
+if (process.env.NODE_ENV !== "production") ; //#endregion
+////////////////////////////////////////////////////////////////////////////////
+//#region Hooks
 ////////////////////////////////////////////////////////////////////////////////
 
 /**
@@ -285,26 +483,32 @@ function useLinkClickHandler(to, _temp) {
   let {
     target,
     replace: replaceProp,
-    state
+    state,
+    resetScroll
   } = _temp === void 0 ? {} : _temp;
   let navigate = useNavigate();
   let location = useLocation();
   let path = useResolvedPath(to);
   return useCallback(event => {
-    if (event.button === 0 && ( // Ignore everything but left clicks
-    !target || target === "_self") && // Let browser handle "target=_blank" etc.
-    !isModifiedEvent(event) // Ignore clicks with modifier keys
-    ) {
+    if (shouldProcessLinkClick(event, target)) {
       event.preventDefault(); // If the URL hasn't changed, a regular <a> will do a replace instead of
       // a push, so do the same here.
 
       let replace = !!replaceProp || createPath(location) === createPath(path);
+      let newState = state;
+
+      if (resetScroll === false) {
+        newState = _extends({}, state, {
+          __resetScrollPosition: false
+        });
+      }
+
       navigate(to, {
         replace,
-        state
+        state: newState
       });
     }
-  }, [location, navigate, path, replaceProp, state, target, to]);
+  }, [location, navigate, path, replaceProp, state, target, to, resetScroll]);
 }
 /**
  * A convenient wrapper for reading and writing search parameters via the
@@ -315,19 +519,7 @@ function useSearchParams(defaultInit) {
   process.env.NODE_ENV !== "production" ? warning(typeof URLSearchParams !== "undefined", "You cannot use the `useSearchParams` hook in a browser that does not " + "support the URLSearchParams API. If you need to support Internet " + "Explorer 11, we recommend you load a polyfill such as " + "https://github.com/ungap/url-search-params\n\n" + "If you're unsure how to load polyfills, we recommend you check out " + "https://polyfill.io/v3/ which provides some recommendations about how " + "to load polyfills only for users that need them, instead of for every " + "user.") : void 0;
   let defaultSearchParamsRef = useRef(createSearchParams(defaultInit));
   let location = useLocation();
-  let searchParams = useMemo(() => {
-    let searchParams = createSearchParams(location.search);
-
-    for (let key of defaultSearchParamsRef.current.keys()) {
-      if (!searchParams.has(key)) {
-        defaultSearchParamsRef.current.getAll(key).forEach(value => {
-          searchParams.append(key, value);
-        });
-      }
-    }
-
-    return searchParams;
-  }, [location.search]);
+  let searchParams = useMemo(() => getSearchParamsForLocation(location.search, defaultSearchParamsRef.current), [location.search]);
   let navigate = useNavigate();
   let setSearchParams = useCallback((nextInit, navigateOptions) => {
     navigate("?" + createSearchParams(nextInit), navigateOptions);
@@ -335,37 +527,83 @@ function useSearchParams(defaultInit) {
   return [searchParams, setSearchParams];
 }
 
-/**
- * Creates a URLSearchParams object using the given initializer.
- *
- * This is identical to `new URLSearchParams(init)` except it also
- * supports arrays as values in the object form of the initializer
- * instead of just strings. This is convenient when you need multiple
- * values for a given key, but don't want to use an array initializer.
- *
- * For example, instead of:
- *
- *   let searchParams = new URLSearchParams([
- *     ['sort', 'name'],
- *     ['sort', 'price']
- *   ]);
- *
- * you can do:
- *
- *   let searchParams = createSearchParams({
- *     sort: ['name', 'price']
- *   });
- */
-function createSearchParams(init) {
-  if (init === void 0) {
-    init = "";
+function useSubmitImpl(fetcherKey) {
+  let router = useContext(UNSAFE_DataRouterContext);
+  let defaultAction = useFormAction();
+  return useCallback(function (target, options) {
+    if (options === void 0) {
+      options = {};
+    }
+
+    !(router != null) ? process.env.NODE_ENV !== "production" ? invariant(false, "useSubmit() must be used within a <DataRouter>") : invariant(false) : void 0;
+
+    if (typeof document === "undefined") {
+      throw new Error("You are calling submit during the server render. " + "Try calling submit within a `useEffect` or callback instead.");
+    }
+
+    let {
+      method,
+      encType,
+      formData,
+      url
+    } = getFormSubmissionInfo(target, defaultAction, options);
+    let href = url.pathname + url.search;
+    let opts = {
+      // If replace is not specified, we'll default to false for GET and
+      // true otherwise
+      replace: options.replace != null ? options.replace === true : method !== "get",
+      formData,
+      formMethod: method,
+      formEncType: encType
+    };
+
+    if (fetcherKey) {
+      router.fetch(fetcherKey, href, opts);
+    } else {
+      router.navigate(href, opts);
+    }
+  }, [defaultAction, router, fetcherKey]);
+}
+
+function useFormAction(action) {
+  if (action === void 0) {
+    action = ".";
   }
 
-  return new URLSearchParams(typeof init === "string" || Array.isArray(init) || init instanceof URLSearchParams ? init : Object.keys(init).reduce((memo, key) => {
-    let value = init[key];
-    return memo.concat(Array.isArray(value) ? value.map(v => [key, v]) : [[key, value]]);
-  }, []));
+  let routeContext = useContext(UNSAFE_RouteContext);
+  !routeContext ? process.env.NODE_ENV !== "production" ? invariant(false, "useLoaderData must be used inside a RouteContext") : invariant(false) : void 0;
+  let [match] = routeContext.matches.slice(-1);
+  let {
+    pathname,
+    search
+  } = useResolvedPath(action);
+
+  if (action === "." && match.route.index) {
+    search = search ? search.replace(/^\?/, "?index&") : "?index";
+  }
+
+  return pathname + search;
 }
+////////////////////////////////////////////////////////////////////////////////
+//#region Utils
+////////////////////////////////////////////////////////////////////////////////
+
+
+function warning(cond, message) {
+  if (!cond) {
+    // eslint-disable-next-line no-console
+    if (typeof console !== "undefined") console.warn(message);
+
+    try {
+      // Welcome to debugging React Router!
+      //
+      // This error is thrown as a convenience so you can more easily
+      // find the source for a warning that appears in the console by
+      // enabling "pause on exceptions" in your JavaScript debugger.
+      throw new Error(message); // eslint-disable-next-line no-empty
+    } catch (e) {}
+  }
+} //#endregion
 
 // but not worried about that for now.
 
@@ -405,7 +643,7 @@ function CompatRouter(_ref) {
 }
 
 /**
- * A <Router> that may not transition to any other location. This is useful
+ * A <Router> that may not navigate to any other location. This is useful
  * on the server where there is no stateful UI.
  */
 function StaticRouter(_ref2) {