react-router 6.4.1 → 6.4.2-pre.1

package/dist/lib/context.d.ts

@@ -1,15 +1,39 @@
 import * as React from "react";
-import type { TrackedPromise, History, Location, Router, StaticHandlerContext, To, AgnosticRouteObject, AgnosticRouteMatch } from "@remix-run/router";
+import type { AgnosticRouteMatch, AgnosticIndexRouteObject, AgnosticNonIndexRouteObject, History, Location, Router, StaticHandlerContext, To, TrackedPromise } from "@remix-run/router";
 import type { Action as NavigationType } from "@remix-run/router";
-export interface RouteObject extends AgnosticRouteObject {
+export interface IndexRouteObject {
+    caseSensitive?: AgnosticIndexRouteObject["caseSensitive"];
+    path?: AgnosticIndexRouteObject["path"];
+    id?: AgnosticIndexRouteObject["id"];
+    loader?: AgnosticIndexRouteObject["loader"];
+    action?: AgnosticIndexRouteObject["action"];
+    hasErrorBoundary?: AgnosticIndexRouteObject["hasErrorBoundary"];
+    shouldRevalidate?: AgnosticIndexRouteObject["shouldRevalidate"];
+    handle?: AgnosticIndexRouteObject["handle"];
+    index: true;
+    children?: undefined;
+    element?: React.ReactNode | null;
+    errorElement?: React.ReactNode | null;
+}
+export interface NonIndexRouteObject {
+    caseSensitive?: AgnosticNonIndexRouteObject["caseSensitive"];
+    path?: AgnosticNonIndexRouteObject["path"];
+    id?: AgnosticNonIndexRouteObject["id"];
+    loader?: AgnosticNonIndexRouteObject["loader"];
+    action?: AgnosticNonIndexRouteObject["action"];
+    hasErrorBoundary?: AgnosticNonIndexRouteObject["hasErrorBoundary"];
+    shouldRevalidate?: AgnosticNonIndexRouteObject["shouldRevalidate"];
+    handle?: AgnosticNonIndexRouteObject["handle"];
+    index?: false;
     children?: RouteObject[];
     element?: React.ReactNode | null;
     errorElement?: React.ReactNode | null;
 }
-export interface DataRouteObject extends RouteObject {
+export declare type RouteObject = IndexRouteObject | NonIndexRouteObject;
+export declare type DataRouteObject = RouteObject & {
     children?: DataRouteObject[];
     id: string;
-}
+};
 export interface RouteMatch<ParamKey extends string = string, RouteObjectType extends RouteObject = RouteObject> extends AgnosticRouteMatch<ParamKey, RouteObjectType> {
 }
 export interface DataRouteMatch extends RouteMatch<string, DataRouteObject> {

package/dist/main.js

@@ -1,5 +1,5 @@
 /**
- * React Router v6.4.1
+ * React Router v6.4.2-pre.1
  *
  * Copyright (c) Remix Software Inc.
  *

package/dist/react-router.development.js

@@ -1,5 +1,5 @@
 /**
- * React Router v6.4.1
+ * React Router v6.4.2-pre.1
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -710,18 +710,34 @@ function _renderMatches(matches, parentMatches = [], dataRouterState) {
 var DataRouterHook;
 
 (function (DataRouterHook) {
-  DataRouterHook["UseLoaderData"] = "useLoaderData";
-  DataRouterHook["UseActionData"] = "useActionData";
-  DataRouterHook["UseRouteError"] = "useRouteError";
-  DataRouterHook["UseNavigation"] = "useNavigation";
-  DataRouterHook["UseRouteLoaderData"] = "useRouteLoaderData";
-  DataRouterHook["UseMatches"] = "useMatches";
   DataRouterHook["UseRevalidator"] = "useRevalidator";
 })(DataRouterHook || (DataRouterHook = {}));
 
+var DataRouterStateHook;
+
+(function (DataRouterStateHook) {
+  DataRouterStateHook["UseLoaderData"] = "useLoaderData";
+  DataRouterStateHook["UseActionData"] = "useActionData";
+  DataRouterStateHook["UseRouteError"] = "useRouteError";
+  DataRouterStateHook["UseNavigation"] = "useNavigation";
+  DataRouterStateHook["UseRouteLoaderData"] = "useRouteLoaderData";
+  DataRouterStateHook["UseMatches"] = "useMatches";
+  DataRouterStateHook["UseRevalidator"] = "useRevalidator";
+})(DataRouterStateHook || (DataRouterStateHook = {}));
+
+function getDataRouterConsoleError(hookName) {
+  return `${hookName} must be used within a data router.  See https://reactrouter.com/en/main/routers/picking-a-router.`;
+}
+
+function useDataRouterContext(hookName) {
+  let ctx = React.useContext(DataRouterContext);
+  !ctx ? invariant(false, getDataRouterConsoleError(hookName))  : void 0;
+  return ctx;
+}
+
 function useDataRouterState(hookName) {
   let state = React.useContext(DataRouterStateContext);
-  !state ? invariant(false, `${hookName} must be used within a DataRouterStateContext`)  : void 0;
+  !state ? invariant(false, getDataRouterConsoleError(hookName))  : void 0;
   return state;
 }
 /**
@@ -731,7 +747,7 @@ function useDataRouterState(hookName) {
 
 
 function useNavigation() {
-  let state = useDataRouterState(DataRouterHook.UseNavigation);
+  let state = useDataRouterState(DataRouterStateHook.UseNavigation);
   return state.navigation;
 }
 /**
@@ -740,9 +756,8 @@ function useNavigation() {
  */
 
 function useRevalidator() {
-  let dataRouterContext = React.useContext(DataRouterContext);
-  !dataRouterContext ? invariant(false, `useRevalidator must be used within a DataRouterContext`)  : void 0;
-  let state = useDataRouterState(DataRouterHook.UseRevalidator);
+  let dataRouterContext = useDataRouterContext(DataRouterHook.UseRevalidator);
+  let state = useDataRouterState(DataRouterStateHook.UseRevalidator);
   return {
     revalidate: dataRouterContext.router.revalidate,
     state: state.revalidation
@@ -757,7 +772,7 @@ function useMatches() {
   let {
     matches,
     loaderData
-  } = useDataRouterState(DataRouterHook.UseMatches);
+  } = useDataRouterState(DataRouterStateHook.UseMatches);
   return React.useMemo(() => matches.map(match => {
     let {
       pathname,
@@ -780,7 +795,7 @@ function useMatches() {
  */
 
 function useLoaderData() {
-  let state = useDataRouterState(DataRouterHook.UseLoaderData);
+  let state = useDataRouterState(DataRouterStateHook.UseLoaderData);
   let route = React.useContext(RouteContext);
   !route ? invariant(false, `useLoaderData must be used inside a RouteContext`)  : void 0;
   let thisRoute = route.matches[route.matches.length - 1];
@@ -792,7 +807,7 @@ function useLoaderData() {
  */
 
 function useRouteLoaderData(routeId) {
-  let state = useDataRouterState(DataRouterHook.UseRouteLoaderData);
+  let state = useDataRouterState(DataRouterStateHook.UseRouteLoaderData);
   return state.loaderData[routeId];
 }
 /**
@@ -800,7 +815,7 @@ function useRouteLoaderData(routeId) {
  */
 
 function useActionData() {
-  let state = useDataRouterState(DataRouterHook.UseActionData);
+  let state = useDataRouterState(DataRouterStateHook.UseActionData);
   let route = React.useContext(RouteContext);
   !route ? invariant(false, `useActionData must be used inside a RouteContext`)  : void 0;
   return Object.values(state?.actionData || {})[0];
@@ -813,7 +828,7 @@ function useActionData() {
 
 function useRouteError() {
   let error = React.useContext(RouteErrorContext);
-  let state = useDataRouterState(DataRouterHook.UseRouteError);
+  let state = useDataRouterState(DataRouterStateHook.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
@@ -1245,6 +1260,7 @@ function createRoutesFromChildren(children, parentPath = []) {
     }
 
     !(element.type === Route) ? 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) ? invariant(false, "An index route cannot have child routes.")  : void 0;
     let treePath = [...parentPath, index];
     let route = {
       id: element.props.id || treePath.join("-"),