react-router 6.27.0 → 7.0.0-pre.1

package/CHANGELOG.md

@@ -1,23 +1,321 @@
 # `react-router`
 
-## 6.27.0
+## 7.0.0-pre.1
+
+### Patch Changes
+
+- Fix typegen for routes with a client loader but no server loader ([#12117](https://github.com/remix-run/react-router/pull/12117))
+- - Fix `react-router-serve` handling of prerendered HTML files by removing the `redirect: false` option so it now falls back on the default `redirect: true` behavior of redirecting from `/folder` -> `/folder/` which will then pick up `/folder/index.html` from disk. See https://expressjs.com/en/resources/middleware/serve-static.html ([#12071](https://github.com/remix-run/react-router/pull/12071))
+  - Proxy prerendered loader data into prerender pass for HTML files to avoid double-invocations of the loader at build time
+- Updated dependencies:
+  - `react-router@7.0.0-pre.1`
+
+## 7.0.0-pre.0
+
+### Major Changes
+
+- Remove the original `defer` implementation in favor of using raw promises via single fetch and `turbo-stream`. This removes these exports from React Router: ([#11744](https://github.com/remix-run/react-router/pull/11744))
+
+  - `defer`
+  - `AbortedDeferredError`
+  - `type TypedDeferredData`
+  - `UNSAFE_DeferredData`
+  - `UNSAFE_DEFERRED_SYMBOL`,
+
+- - Collapse `@remix-run/router` into `react-router` ([#11505](https://github.com/remix-run/react-router/pull/11505))
+  - Collapse `react-router-dom` into `react-router`
+  - Collapse `@remix-run/server-runtime` into `react-router`
+  - Collapse `@remix-run/testing` into `react-router`
+- Remove single_fetch future flag. ([#11522](https://github.com/remix-run/react-router/pull/11522))
+- Drop support for Node 16, React Router SSR now requires Node 18 or higher ([#11391](https://github.com/remix-run/react-router/pull/11391))
+- Remove `future.v7_startTransition` flag ([#11696](https://github.com/remix-run/react-router/pull/11696))
+- - Expose the underlying router promises from the following APIs for compsition in React 19 APIs: ([#11521](https://github.com/remix-run/react-router/pull/11521))
+    - `useNavigate()`
+    - `useSubmit`
+    - `useFetcher().load`
+    - `useFetcher().submit`
+    - `useRevalidator.revalidate`
+- Remove `future.v7_normalizeFormMethod` future flag ([#11697](https://github.com/remix-run/react-router/pull/11697))
+- For Remix consumers migrating to React Router, the `crypto` global from the [Web Crypto API](https://developer.mozilla.org/en-US/docs/Web/API/Web_Crypto_API) is now required when using cookie and session APIs. This means that the following APIs are provided from `react-router` rather than platform-specific packages: ([#11837](https://github.com/remix-run/react-router/pull/11837))
+
+  - `createCookie`
+  - `createCookieSessionStorage`
+  - `createMemorySessionStorage`
+  - `createSessionStorage`
+
+  For consumers running older versions of Node, the `installGlobals` function from `@remix-run/node` has been updated to define `globalThis.crypto`, using [Node's `require('node:crypto').webcrypto` implementation.](https://nodejs.org/api/webcrypto.html)
+
+  Since platform-specific packages no longer need to implement this API, the following low-level APIs have been removed:
+
+  - `createCookieFactory`
+  - `createSessionStorageFactory`
+  - `createCookieSessionStorageFactory`
+  - `createMemorySessionStorageFactory`
+
+- Imports/Exports cleanup ([#11840](https://github.com/remix-run/react-router/pull/11840))
+
+  - Removed the following exports that were previously public API from `@remix-run/router`
+    - types
+      - `AgnosticDataIndexRouteObject`
+      - `AgnosticDataNonIndexRouteObject`
+      - `AgnosticDataRouteMatch`
+      - `AgnosticDataRouteObject`
+      - `AgnosticIndexRouteObject`
+      - `AgnosticNonIndexRouteObject`
+      - `AgnosticRouteMatch`
+      - `AgnosticRouteObject`
+      - `TrackedPromise`
+      - `unstable_AgnosticPatchRoutesOnMissFunction`
+      - `Action` -> exported as `NavigationType` via `react-router`
+      - `Router` exported as `DataRouter` to differentiate from RR's `<Router>`
+    - API
+      - `getToPathname` (`@private`)
+      - `joinPaths` (`@private`)
+      - `normalizePathname` (`@private`)
+      - `resolveTo` (`@private`)
+      - `stripBasename` (`@private`)
+      - `createBrowserHistory` -> in favor of `createBrowserRouter`
+      - `createHashHistory` -> in favor of `createHashRouter`
+      - `createMemoryHistory` -> in favor of `createMemoryRouter`
+      - `createRouter`
+      - `createStaticHandler` -> in favor of wrapper `createStaticHandler` in RR Dom
+      - `getStaticContextFromError`
+  - Removed the following exports that were previously public API from `react-router`
+    - `Hash`
+    - `Pathname`
+    - `Search`
+
+- update minimum node version to 18 ([#11690](https://github.com/remix-run/react-router/pull/11690))
+- Remove `future.v7_prependBasename` from the ionternalized `@remix-run/router` package ([#11726](https://github.com/remix-run/react-router/pull/11726))
+- Remove `future.v7_throwAbortReason` from internalized `@remix-run/router` package ([#11728](https://github.com/remix-run/react-router/pull/11728))
+- Add `exports` field to all packages ([#11675](https://github.com/remix-run/react-router/pull/11675))
+- node package no longer re-exports from react-router ([#11702](https://github.com/remix-run/react-router/pull/11702))
+- renamed RemixContext to FrameworkContext ([#11705](https://github.com/remix-run/react-router/pull/11705))
+- updates the minimum React version to 18 ([#11689](https://github.com/remix-run/react-router/pull/11689))
+- PrefetchPageDescriptor replaced by PageLinkDescriptor ([#11960](https://github.com/remix-run/react-router/pull/11960))
+- - Remove the `future.v7_partialHydration` flag ([#11725](https://github.com/remix-run/react-router/pull/11725))
+    - This also removes the `<RouterProvider fallbackElement>` prop
+      - To migrate, move the `fallbackElement` to a `hydrateFallbackElement`/`HydrateFallback` on your root route
+    - Also worth nothing there is a related breaking changer with this future flag:
+      - Without `future.v7_partialHydration` (when using `fallbackElement`), `state.navigation` was populated during the initial load
+      - With `future.v7_partialHydration`, `state.navigation` remains in an `"idle"` state during the initial load
+- Remove `v7_relativeSplatPath` future flag ([#11695](https://github.com/remix-run/react-router/pull/11695))
+- Remove remaining future flags ([#11820](https://github.com/remix-run/react-router/pull/11820))
+
+  - React Router `v7_skipActionErrorRevalidation`
+  - Remix `v3_fetcherPersist`, `v3_relativeSplatPath`, `v3_throwAbortReason`
+
+- rename createRemixStub to createRoutesStub ([#11692](https://github.com/remix-run/react-router/pull/11692))
+- Remove `@remix-run/router` deprecated `detectErrorBoundary` option in favor of `mapRouteProperties` ([#11751](https://github.com/remix-run/react-router/pull/11751))
+- Add `react-router/dom` subpath export to properly enable `react-dom` as an optional `peerDependency` ([#11851](https://github.com/remix-run/react-router/pull/11851))
+
+  - This ensures that we don't blindly `import ReactDOM from "react-dom"` in `<RouterProvider>` in order to access `ReactDOM.flushSync()`, since that would break `createMemoryRouter` use cases in non-DOM environments
+  - DOM environments should import from `react-router/dom` to get the proper component that makes `ReactDOM.flushSync()` available:
+    - If you are using the Vite plugin, use this in your `entry.client.tsx`:
+      - `import { HydratedRouter } from 'react-router/dom'`
+    - If you are not using the Vite plugin and are manually calling `createBrowserRouter`/`createHashRouter`:
+      - `import { RouterProvider } from "react-router/dom"`
+
+- Remove `future.v7_fetcherPersist` flag ([#11731](https://github.com/remix-run/react-router/pull/11731))
 
 ### Minor Changes
 
-- Stabilize `unstable_patchRoutesOnNavigation` ([#11973](https://github.com/remix-run/react-router/pull/11973))
-  - Add new `PatchRoutesOnNavigationFunctionArgs` type for convenience ([#11967](https://github.com/remix-run/react-router/pull/11967))
-- Stabilize `unstable_dataStrategy` ([#11974](https://github.com/remix-run/react-router/pull/11974))
-- Stabilize the `unstable_flushSync` option for navigations and fetchers ([#11989](https://github.com/remix-run/react-router/pull/11989))
-- Stabilize the `unstable_viewTransition` option for navigations and the corresponding `unstable_useViewTransitionState` hook ([#11989](https://github.com/remix-run/react-router/pull/11989))
+- - Add support for `prerender` config in the React Router vite plugin, to support existing SSG use-cases ([#11539](https://github.com/remix-run/react-router/pull/11539))
+    - You can use the `prerender` config to pre-render your `.html` and `.data` files at build time and then serve them statically at runtime (either from a running server or a CDN)
+    - `prerender` can either be an array of string paths, or a function (sync or async) that returns an array of strings so that you can dynamically generate the paths by talking to your CMS, etc.
+
+  ```ts
+  export default defineConfig({
+    plugins: [
+      reactRouter({
+        async prerender() {
+          let slugs = await fakeGetSlugsFromCms();
+          // Prerender these paths into `.html` files at build time, and `.data`
+          // files if they have loaders
+          return ["/", "/about", ...slugs.map((slug) => `/product/${slug}`)];
+        },
+      }),
+      tsconfigPaths(),
+    ],
+  });
 
-### Patch Changes
+  async function fakeGetSlugsFromCms() {
+    await new Promise((r) => setTimeout(r, 1000));
+    return ["shirt", "hat"];
+  }
+  ```
+
+- [REMOVE] Allow returning undefined from loaders/actions part 2 ([#12057](https://github.com/remix-run/react-router/pull/12057))
+
+  - This is a follow up to #11680 which missed some of the Remix codepaths
+
+- Params, loader data, and action data as props for route component exports ([#11961](https://github.com/remix-run/react-router/pull/11961))
+
+  ```tsx
+  export default function Component({ params, loaderData, actionData }) {}
+
+  export function HydrateFallback({ params }) {}
+  export function ErrorBoundary({ params, loaderData, actionData }) {}
+  ```
+
+- Remove duplicate `RouterProvider` impliementations ([#11679](https://github.com/remix-run/react-router/pull/11679))
+- ### Typesafety improvements ([#12019](https://github.com/remix-run/react-router/pull/12019))
+
+  React Router now generates types for each of your route modules.
+  You can access those types by importing them from `./+types.<route filename without extension>`.
+  For example:
+
+  ```ts
+  // app/routes/product.tsx
+  import type * as Route from "./+types.product";
+
+  export function loader({ params }: Route.LoaderArgs) {}
+
+  export default function Component({ loaderData }: Route.ComponentProps) {}
+  ```
+
+  This initial implementation targets type inference for:
+
+  - `Params` : Path parameters from your routing config in `routes.ts` including file-based routing
+  - `LoaderData` : Loader data from `loader` and/or `clientLoader` within your route module
+  - `ActionData` : Action data from `action` and/or `clientAction` within your route module
+
+  These types are then used to create types for route export args and props:
+
+  - `LoaderArgs`
+  - `ClientLoaderArgs`
+  - `ActionArgs`
+  - `ClientActionArgs`
+  - `HydrateFallbackProps`
+  - `ComponentProps` (for the `default` export)
+  - `ErrorBoundaryProps`
+
+  In the future, we plan to add types for the rest of the route module exports: `meta`, `links`, `headers`, `shouldRevalidate`, etc.
+  We also plan to generate types for typesafe `Link`s:
+
+  ```tsx
+  <Link to="/products/:id" params={{ id: 1 }} />
+  //        ^^^^^^^^^^^^^          ^^^^^^^^^
+  // typesafe `to` and `params` based on the available routes in your app
+  ```
+
+  #### Setup
+
+  React Router will generate types into a `.react-router/` directory at the root of your app.
+  This directory is fully managed by React Router and is derived based on your route config (`routes.ts`).
+
+  👉 **Add `.react-router/` to `.gitignore`**
+
+  ```txt
+  .react-router
+  ```
+
+  You should also ensure that generated types for routes are always present before running typechecking,
+  especially for running typechecking in CI.
+
+  👉 **Add `react-router typegen` to your `typecheck` command in `package.json`**
 
-- Fix bug when submitting to the current contextual route (parent route with an index child) when an `?index` param already exists from a prior submission ([#12003](https://github.com/remix-run/react-router/pull/12003))
-- Fix `useFormAction` bug - when removing `?index` param it would not keep other non-Remix `index` params ([#12003](https://github.com/remix-run/react-router/pull/12003))
-- Fix types for `RouteObject` within `PatchRoutesOnNavigationFunction`'s `patch` method so it doesn't expect agnostic route objects passed to `patch` ([#11967](https://github.com/remix-run/react-router/pull/11967))
+  ```json
+  {
+    "scripts": {
+      "typecheck": "react-router typegen && tsc"
+    }
+  }
+  ```
+
+  To get TypeScript to use those generated types, you'll need to add them to `include` in `tsconfig.json`.
+  And to be able to import them as if they files next to your route modules, you'll also need to configure `rootDirs`.
+
+  👉 **Configure `tsconfig.json` for generated types**
+
+  ```json
+  {
+    "include": [".react-router/types/**/*"],
+    "compilerOptions": {
+      "rootDirs": [".", "./.react-router/types"]
+    }
+  }
+  ```
+
+  #### `typegen` command
+
+  You can manually generate types with the new `typegen` command:
+
+  ```sh
+  react-router typegen
+  ```
+
+  However, manual type generation is tedious and types can get out of sync quickly if you ever forget to run `typegen`.
+  Instead, we recommend that you setup our new TypeScript plugin which will automatically generate fresh types whenever routes change.
+  That way, you'll always have up-to-date types.
+
+  #### TypeScript plugin
+
+  To get automatic type generation, you can use our new TypeScript plugin.
+
+  👉 **Add the TypeScript plugin to `tsconfig.json`**
+
+  ```json
+  {
+    "compilerOptions": {
+      "plugins": [{ "name": "@react-router/dev" }]
+    }
+  }
+  ```
+
+  We plan to add some other goodies to our TypeScript plugin soon, including:
+
+  - Automatic `jsdoc` for route exports that include links to official docs
+  - Autocomplete for route exports
+  - Warnings for non-HMR compliant exports
+
+  ##### VSCode
+
+  TypeScript looks for plugins registered in `tsconfig.json` in the local `node_modules/`,
+  but VSCode ships with its own copy of TypeScript that is installed outside of your project.
+  For TypeScript plugins to work, you'll need to tell VSCode to use the local workspace version of TypeScript.
+  For security reasons, [VSCode won't use the workspace version of TypeScript](https://code.visualstudio.com/docs/typescript/typescript-compiling#_using-the-workspace-version-of-typescript) until you manually opt-in.
+
+  Your project should have a `.vscode/settings.json` with the following settings:
+
+  ```json
+  {
+    "typescript.tsdk": "node_modules/typescript/lib",
+    "typescript.enablePromptUseWorkspaceTsdk": true
+  }
+  ```
+
+  That way [VSCode will ask you](https://code.visualstudio.com/updates/v1_45#_prompt-users-to-switch-to-the-workspace-version-of-typescript) if you want to use the workspace version of TypeScript the first time you open a TS file in that project.
+
+  > [!IMPORTANT]
+  > You'll need to install dependencies first so that the workspace version of TypeScript is available.
+
+  👉 **Select "Allow" when VSCode asks if you want to use the workspace version of TypeScript**
+
+  Otherwise, you can also manually opt-in to the workspace version:
+
+  1. Open up any TypeScript file in your project
+  2. Open up the VSCode Command Palette (<kbd>Cmd</kbd>+<kbd>Shift</kbd>+<kbd>P</kbd>)
+  3. Search for `Select TypeScript Version`
+  4. Choose `Use Workspace Version`
+  5. Quit and reopen VSCode
+
+  ##### Troubleshooting
+
+  In VSCode, open up any TypeScript file in your project and then use <kbd>CMD</kbd>+<kbd>SHIFT</kbd>+<kbd>P</kbd> to select `Open TS Server log`.
+  There should be a log for `[react-router] setup` that indicates that the plugin was resolved correctly.
+  Then look for any errors in the log.
+
+- Stabilize `unstable_dataStrategy` ([#11969](https://github.com/remix-run/react-router/pull/11969))
+- Stabilize `unstable_patchRoutesOnNavigation` ([#11970](https://github.com/remix-run/react-router/pull/11970))
+
+### Patch Changes
 
+- Remove unstable upload handler. ([#12015](https://github.com/remix-run/react-router/pull/12015))
+- Fix redirects returned from loaders/actions using `data()` ([#12021](https://github.com/remix-run/react-router/pull/12021))
+- [REMOVE] Rename RemixRouter->DataRouter ([#12062](https://github.com/remix-run/react-router/pull/12062))
 - Updated dependencies:
-  - `@remix-run/router@1.20.0`
+  - `react-router@7.0.0-pre.0`
 
 ## 6.26.2
 

package/README.md

@@ -1,16 +1,3 @@
 # React Router
 
-The `react-router` package is the heart of [React Router](https://github.com/remix-run/react-router) and provides all
-the core functionality for both
-[`react-router-dom`](https://github.com/remix-run/react-router/tree/main/packages/react-router-dom)
-and
-[`react-router-native`](https://github.com/remix-run/react-router/tree/main/packages/react-router-native).
-
-If you're using React Router, you should never `import` anything directly from
-the `react-router` package, but you should have everything you need in either
-`react-router-dom` or `react-router-native`. Both of those packages re-export
-everything from `react-router`.
-
-If you'd like to extend React Router and you know what you're doing, you should
-add `react-router` **as a peer dependency, not a regular dependency** in your
-package.
+The `react-router` package is the heart of [React Router](https://github.com/remix-run/react-router) and provides all the core functionality.

package/dist/dom-export.d.ts

@@ -0,0 +1,3 @@
+export type { RouterProviderProps } from "./lib/dom-export/dom-router-provider";
+export { RouterProvider } from "./lib/dom-export/dom-router-provider";
+export { HydratedRouter } from "./lib/dom-export/hydrated-router";

package/dist/dom-export.mjs

@@ -0,0 +1,205 @@
+/**
+ * React Router v7.0.0-pre.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
+ */
+import * as React from 'react';
+import * as ReactDOM from 'react-dom';
+import { UNSAFE_invariant, UNSAFE_useFogOFWarDiscovery, UNSAFE_FrameworkContext, UNSAFE_RemixErrorBoundary, UNSAFE_decodeViaTurboStream, UNSAFE_createClientRoutes, matchRoutes, UNSAFE_shouldHydrateRouteLoader, UNSAFE_deserializeErrors, UNSAFE_createRouter, UNSAFE_createBrowserHistory, UNSAFE_mapRouteProperties, UNSAFE_getSingleFetchDataStrategy, UNSAFE_getPatchRoutesOnNavigationFunction, UNSAFE_createClientRoutesWithHMRRevalidationOptOut, RouterProvider as RouterProvider$1 } from 'react-router';
+
+function _extends() {
+  _extends = Object.assign ? Object.assign.bind() : function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+    return target;
+  };
+  return _extends.apply(this, arguments);
+}
+
+let ssrInfo = null;
+let router = null;
+function initSsrInfo() {
+  if (!ssrInfo && window.__reactRouterContext && window.__reactRouterManifest && window.__reactRouterRouteModules) {
+    ssrInfo = {
+      context: window.__reactRouterContext,
+      manifest: window.__reactRouterManifest,
+      routeModules: window.__reactRouterRouteModules,
+      stateDecodingPromise: undefined,
+      router: undefined,
+      routerInitialized: false
+    };
+  }
+}
+function createHydratedRouter() {
+  initSsrInfo();
+  if (!ssrInfo) {
+    throw new Error("You must be using the SSR features of React Router in order to skip " + "passing a `router` prop to `<RouterProvider>`");
+  }
+  // We need to suspend until the initial state snapshot is decoded into
+  // window.__reactRouterContext.state
+  let localSsrInfo = ssrInfo;
+  // Note: `stateDecodingPromise` is not coupled to `router` - we'll reach this
+  // code potentially many times waiting for our state to arrive, but we'll
+  // then only get past here and create the `router` one time
+  if (!ssrInfo.stateDecodingPromise) {
+    let stream = ssrInfo.context.stream;
+    !stream ? process.env.NODE_ENV !== "production" ? UNSAFE_invariant(false, "No stream found for single fetch decoding") : UNSAFE_invariant(false) : void 0;
+    ssrInfo.context.stream = undefined;
+    ssrInfo.stateDecodingPromise = UNSAFE_decodeViaTurboStream(stream, window).then(value => {
+      ssrInfo.context.state = value.value;
+      localSsrInfo.stateDecodingPromise.value = true;
+    }).catch(e => {
+      localSsrInfo.stateDecodingPromise.error = e;
+    });
+  }
+  if (ssrInfo.stateDecodingPromise.error) {
+    throw ssrInfo.stateDecodingPromise.error;
+  }
+  if (!ssrInfo.stateDecodingPromise.value) {
+    throw ssrInfo.stateDecodingPromise;
+  }
+  let routes = UNSAFE_createClientRoutes(ssrInfo.manifest.routes, ssrInfo.routeModules, ssrInfo.context.state, ssrInfo.context.isSpaMode);
+  let hydrationData = undefined;
+  if (!ssrInfo.context.isSpaMode) {
+    var _window$__reactRouter;
+    // Create a shallow clone of `loaderData` we can mutate for partial hydration.
+    // When a route exports a `clientLoader` and a `HydrateFallback`, the SSR will
+    // render the fallback so we need the client to do the same for hydration.
+    // The server loader data has already been exposed to these route `clientLoader`'s
+    // in `createClientRoutes` above, so we need to clear out the version we pass to
+    // `createBrowserRouter` so it initializes and runs the client loaders.
+    hydrationData = _extends({}, ssrInfo.context.state, {
+      loaderData: _extends({}, ssrInfo.context.state.loaderData)
+    });
+    let initialMatches = matchRoutes(routes, window.location, (_window$__reactRouter = window.__reactRouterContext) == null ? void 0 : _window$__reactRouter.basename);
+    if (initialMatches) {
+      for (let match of initialMatches) {
+        let routeId = match.route.id;
+        let route = ssrInfo.routeModules[routeId];
+        let manifestRoute = ssrInfo.manifest.routes[routeId];
+        // Clear out the loaderData to avoid rendering the route component when the
+        // route opted into clientLoader hydration and either:
+        // * gave us a HydrateFallback
+        // * or doesn't have a server loader and we have no data to render
+        if (route && UNSAFE_shouldHydrateRouteLoader(manifestRoute, route, ssrInfo.context.isSpaMode) && (route.HydrateFallback || !manifestRoute.hasLoader)) {
+          delete hydrationData.loaderData[routeId];
+        } else if (manifestRoute && !manifestRoute.hasLoader) {
+          // Since every Remix route gets a `loader` on the client side to load
+          // the route JS module, we need to add a `null` value to `loaderData`
+          // for any routes that don't have server loaders so our partial
+          // hydration logic doesn't kick off the route module loaders during
+          // hydration
+          hydrationData.loaderData[routeId] = null;
+        }
+      }
+    }
+    if (hydrationData && hydrationData.errors) {
+      // TODO: De-dup this or remove entirely in v7 where single fetch is the
+      // only approach and we have already serialized or deserialized on the server
+      hydrationData.errors = UNSAFE_deserializeErrors(hydrationData.errors);
+    }
+  }
+  // We don't use createBrowserRouter here because we need fine-grained control
+  // over initialization to support synchronous `clientLoader` flows.
+  let router = UNSAFE_createRouter({
+    routes,
+    history: UNSAFE_createBrowserHistory(),
+    basename: ssrInfo.context.basename,
+    hydrationData,
+    mapRouteProperties: UNSAFE_mapRouteProperties,
+    dataStrategy: UNSAFE_getSingleFetchDataStrategy(ssrInfo.manifest, ssrInfo.routeModules, () => router),
+    patchRoutesOnNavigation: UNSAFE_getPatchRoutesOnNavigationFunction(ssrInfo.manifest, ssrInfo.routeModules, ssrInfo.context.isSpaMode, ssrInfo.context.basename)
+  });
+  ssrInfo.router = router;
+  // We can call initialize() immediately if the router doesn't have any
+  // loaders to run on hydration
+  if (router.state.initialized) {
+    ssrInfo.routerInitialized = true;
+    router.initialize();
+  }
+  // @ts-ignore
+  router.createRoutesForHMR = /* spacer so ts-ignore does not affect the right hand of the assignment */
+  UNSAFE_createClientRoutesWithHMRRevalidationOptOut;
+  window.__reactRouterDataRouter = router;
+  return router;
+}
+/**
+ * @category Router Components
+ */
+function HydratedRouter() {
+  var _ssrInfo;
+  if (!router) {
+    router = createHydratedRouter();
+  }
+  // Critical CSS can become stale after code changes, e.g. styles might be
+  // removed from a component, but the styles will still be present in the
+  // server HTML. This allows our HMR logic to clear the critical CSS state.
+  let [criticalCss, setCriticalCss] = React.useState(process.env.NODE_ENV === "development" ? (_ssrInfo = ssrInfo) == null ? void 0 : _ssrInfo.context.criticalCss : undefined);
+  if (process.env.NODE_ENV === "development") {
+    if (ssrInfo) {
+      window.__reactRouterClearCriticalCss = () => setCriticalCss(undefined);
+    }
+  }
+  let [location, setLocation] = React.useState(router.state.location);
+  React.useLayoutEffect(() => {
+    // If we had to run clientLoaders on hydration, we delay initialization until
+    // after we've hydrated to avoid hydration issues from synchronous client loaders
+    if (ssrInfo && ssrInfo.router && !ssrInfo.routerInitialized) {
+      ssrInfo.routerInitialized = true;
+      ssrInfo.router.initialize();
+    }
+  }, []);
+  React.useLayoutEffect(() => {
+    if (ssrInfo && ssrInfo.router) {
+      return ssrInfo.router.subscribe(newState => {
+        if (newState.location !== location) {
+          setLocation(newState.location);
+        }
+      });
+    }
+  }, [location]);
+  !ssrInfo ? process.env.NODE_ENV !== "production" ? UNSAFE_invariant(false, "ssrInfo unavailable for HydratedRouter") : UNSAFE_invariant(false) : void 0;
+  UNSAFE_useFogOFWarDiscovery(router, ssrInfo.manifest, ssrInfo.routeModules, ssrInfo.context.isSpaMode);
+  // We need to include a wrapper RemixErrorBoundary here in case the root error
+  // boundary also throws and we need to bubble up outside of the router entirely.
+  // Then we need a stateful location here so the user can back-button navigate
+  // out of there
+  return (
+    /*#__PURE__*/
+    // This fragment is important to ensure we match the <ServerRouter> JSX
+    // structure so that useId values hydrate correctly
+    React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(UNSAFE_FrameworkContext.Provider, {
+      value: {
+        manifest: ssrInfo.manifest,
+        routeModules: ssrInfo.routeModules,
+        future: ssrInfo.context.future,
+        criticalCss,
+        isSpaMode: ssrInfo.context.isSpaMode
+      }
+    }, /*#__PURE__*/React.createElement(UNSAFE_RemixErrorBoundary, {
+      location: location
+    }, /*#__PURE__*/React.createElement(RouterProvider, {
+      router: router
+    }))), /*#__PURE__*/React.createElement(React.Fragment, null))
+  );
+}
+
+function RouterProvider(props) {
+  return /*#__PURE__*/React.createElement(RouterProvider$1, _extends({
+    flushSync: ReactDOM.flushSync
+  }, props));
+}
+
+export { HydratedRouter, RouterProvider };
+//# sourceMappingURL=dom-export.mjs.map

package/dist/dom-export.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"dom-export.mjs","sources":["../../lib/dom-export/hydrated-router.tsx","../../lib/dom-export/dom-router-provider.tsx"],"sourcesContent":["import * as React from \"react\";\n\nimport type {\n  UNSAFE_AssetsManifest as AssetsManifest,\n  UNSAFE_RouteModules as RouteModules,\n  DataRouter,\n  HydrationState,\n} from \"react-router\";\nimport {\n  UNSAFE_invariant as invariant,\n  UNSAFE_FrameworkContext as FrameworkContext,\n  UNSAFE_decodeViaTurboStream as decodeViaTurboStream,\n  UNSAFE_RemixErrorBoundary as RemixErrorBoundary,\n  UNSAFE_createBrowserHistory as createBrowserHistory,\n  UNSAFE_createClientRoutes as createClientRoutes,\n  UNSAFE_createRouter as createRouter,\n  UNSAFE_deserializeErrors as deserializeErrors,\n  UNSAFE_getSingleFetchDataStrategy as getSingleFetchDataStrategy,\n  UNSAFE_getPatchRoutesOnNavigationFunction as getPatchRoutesOnNavigationFunction,\n  UNSAFE_shouldHydrateRouteLoader as shouldHydrateRouteLoader,\n  UNSAFE_useFogOFWarDiscovery as useFogOFWarDiscovery,\n  UNSAFE_mapRouteProperties as mapRouteProperties,\n  UNSAFE_createClientRoutesWithHMRRevalidationOptOut as createClientRoutesWithHMRRevalidationOptOut,\n  matchRoutes,\n} from \"react-router\";\nimport { RouterProvider } from \"./dom-router-provider\";\n\ntype SSRInfo = {\n  context: NonNullable<(typeof window)[\"__reactRouterContext\"]>;\n  routeModules: RouteModules;\n  manifest: AssetsManifest;\n  stateDecodingPromise:\n    | (Promise<void> & {\n        value?: unknown;\n        error?: unknown;\n      })\n    | undefined;\n  router: DataRouter | undefined;\n  routerInitialized: boolean;\n};\n\nlet ssrInfo: SSRInfo | null = null;\nlet router: DataRouter | null = null;\n\nfunction initSsrInfo(): void {\n  if (\n    !ssrInfo &&\n    window.__reactRouterContext &&\n    window.__reactRouterManifest &&\n    window.__reactRouterRouteModules\n  ) {\n    ssrInfo = {\n      context: window.__reactRouterContext,\n      manifest: window.__reactRouterManifest,\n      routeModules: window.__reactRouterRouteModules,\n      stateDecodingPromise: undefined,\n      router: undefined,\n      routerInitialized: false,\n    };\n  }\n}\n\nfunction createHydratedRouter(): DataRouter {\n  initSsrInfo();\n\n  if (!ssrInfo) {\n    throw new Error(\n      \"You must be using the SSR features of React Router in order to skip \" +\n        \"passing a `router` prop to `<RouterProvider>`\"\n    );\n  }\n\n  // We need to suspend until the initial state snapshot is decoded into\n  // window.__reactRouterContext.state\n\n  let localSsrInfo = ssrInfo;\n  // Note: `stateDecodingPromise` is not coupled to `router` - we'll reach this\n  // code potentially many times waiting for our state to arrive, but we'll\n  // then only get past here and create the `router` one time\n  if (!ssrInfo.stateDecodingPromise) {\n    let stream = ssrInfo.context.stream;\n    invariant(stream, \"No stream found for single fetch decoding\");\n    ssrInfo.context.stream = undefined;\n    ssrInfo.stateDecodingPromise = decodeViaTurboStream(stream, window)\n      .then((value) => {\n        ssrInfo!.context.state =\n          value.value as typeof localSsrInfo.context.state;\n        localSsrInfo.stateDecodingPromise!.value = true;\n      })\n      .catch((e) => {\n        localSsrInfo.stateDecodingPromise!.error = e;\n      });\n  }\n  if (ssrInfo.stateDecodingPromise.error) {\n    throw ssrInfo.stateDecodingPromise.error;\n  }\n  if (!ssrInfo.stateDecodingPromise.value) {\n    throw ssrInfo.stateDecodingPromise;\n  }\n\n  let routes = createClientRoutes(\n    ssrInfo.manifest.routes,\n    ssrInfo.routeModules,\n    ssrInfo.context.state,\n    ssrInfo.context.isSpaMode\n  );\n\n  let hydrationData: HydrationState | undefined = undefined;\n  if (!ssrInfo.context.isSpaMode) {\n    // Create a shallow clone of `loaderData` we can mutate for partial hydration.\n    // When a route exports a `clientLoader` and a `HydrateFallback`, the SSR will\n    // render the fallback so we need the client to do the same for hydration.\n    // The server loader data has already been exposed to these route `clientLoader`'s\n    // in `createClientRoutes` above, so we need to clear out the version we pass to\n    // `createBrowserRouter` so it initializes and runs the client loaders.\n    hydrationData = {\n      ...ssrInfo.context.state,\n      loaderData: { ...ssrInfo.context.state.loaderData },\n    };\n    let initialMatches = matchRoutes(\n      routes,\n      window.location,\n      window.__reactRouterContext?.basename\n    );\n    if (initialMatches) {\n      for (let match of initialMatches) {\n        let routeId = match.route.id;\n        let route = ssrInfo.routeModules[routeId];\n        let manifestRoute = ssrInfo.manifest.routes[routeId];\n        // Clear out the loaderData to avoid rendering the route component when the\n        // route opted into clientLoader hydration and either:\n        // * gave us a HydrateFallback\n        // * or doesn't have a server loader and we have no data to render\n        if (\n          route &&\n          shouldHydrateRouteLoader(\n            manifestRoute,\n            route,\n            ssrInfo.context.isSpaMode\n          ) &&\n          (route.HydrateFallback || !manifestRoute.hasLoader)\n        ) {\n          delete hydrationData.loaderData![routeId];\n        } else if (manifestRoute && !manifestRoute.hasLoader) {\n          // Since every Remix route gets a `loader` on the client side to load\n          // the route JS module, we need to add a `null` value to `loaderData`\n          // for any routes that don't have server loaders so our partial\n          // hydration logic doesn't kick off the route module loaders during\n          // hydration\n          hydrationData.loaderData![routeId] = null;\n        }\n      }\n    }\n\n    if (hydrationData && hydrationData.errors) {\n      // TODO: De-dup this or remove entirely in v7 where single fetch is the\n      // only approach and we have already serialized or deserialized on the server\n      hydrationData.errors = deserializeErrors(hydrationData.errors);\n    }\n  }\n\n  // We don't use createBrowserRouter here because we need fine-grained control\n  // over initialization to support synchronous `clientLoader` flows.\n  let router = createRouter({\n    routes,\n    history: createBrowserHistory(),\n    basename: ssrInfo.context.basename,\n    hydrationData,\n    mapRouteProperties,\n    dataStrategy: getSingleFetchDataStrategy(\n      ssrInfo.manifest,\n      ssrInfo.routeModules,\n      () => router\n    ),\n    patchRoutesOnNavigation: getPatchRoutesOnNavigationFunction(\n      ssrInfo.manifest,\n      ssrInfo.routeModules,\n      ssrInfo.context.isSpaMode,\n      ssrInfo.context.basename\n    ),\n  });\n  ssrInfo.router = router;\n\n  // We can call initialize() immediately if the router doesn't have any\n  // loaders to run on hydration\n  if (router.state.initialized) {\n    ssrInfo.routerInitialized = true;\n    router.initialize();\n  }\n\n  // @ts-ignore\n  router.createRoutesForHMR =\n    /* spacer so ts-ignore does not affect the right hand of the assignment */\n    createClientRoutesWithHMRRevalidationOptOut;\n  window.__reactRouterDataRouter = router;\n\n  return router;\n}\n\n/**\n * @category Router Components\n */\nexport function HydratedRouter() {\n  if (!router) {\n    router = createHydratedRouter();\n  }\n\n  // Critical CSS can become stale after code changes, e.g. styles might be\n  // removed from a component, but the styles will still be present in the\n  // server HTML. This allows our HMR logic to clear the critical CSS state.\n  let [criticalCss, setCriticalCss] = React.useState(\n    process.env.NODE_ENV === \"development\"\n      ? ssrInfo?.context.criticalCss\n      : undefined\n  );\n  if (process.env.NODE_ENV === \"development\") {\n    if (ssrInfo) {\n      window.__reactRouterClearCriticalCss = () => setCriticalCss(undefined);\n    }\n  }\n\n  let [location, setLocation] = React.useState(router.state.location);\n\n  React.useLayoutEffect(() => {\n    // If we had to run clientLoaders on hydration, we delay initialization until\n    // after we've hydrated to avoid hydration issues from synchronous client loaders\n    if (ssrInfo && ssrInfo.router && !ssrInfo.routerInitialized) {\n      ssrInfo.routerInitialized = true;\n      ssrInfo.router.initialize();\n    }\n  }, []);\n\n  React.useLayoutEffect(() => {\n    if (ssrInfo && ssrInfo.router) {\n      return ssrInfo.router.subscribe((newState) => {\n        if (newState.location !== location) {\n          setLocation(newState.location);\n        }\n      });\n    }\n  }, [location]);\n\n  invariant(ssrInfo, \"ssrInfo unavailable for HydratedRouter\");\n\n  useFogOFWarDiscovery(\n    router,\n    ssrInfo.manifest,\n    ssrInfo.routeModules,\n    ssrInfo.context.isSpaMode\n  );\n\n  // We need to include a wrapper RemixErrorBoundary here in case the root error\n  // boundary also throws and we need to bubble up outside of the router entirely.\n  // Then we need a stateful location here so the user can back-button navigate\n  // out of there\n  return (\n    // This fragment is important to ensure we match the <ServerRouter> JSX\n    // structure so that useId values hydrate correctly\n    <>\n      <FrameworkContext.Provider\n        value={{\n          manifest: ssrInfo.manifest,\n          routeModules: ssrInfo.routeModules,\n          future: ssrInfo.context.future,\n          criticalCss,\n          isSpaMode: ssrInfo.context.isSpaMode,\n        }}\n      >\n        <RemixErrorBoundary location={location}>\n          <RouterProvider router={router} />\n        </RemixErrorBoundary>\n      </FrameworkContext.Provider>\n      {/*\n          This fragment is important to ensure we match the <ServerRouter> JSX\n          structure so that useId values hydrate correctly\n        */}\n      <></>\n    </>\n  );\n}\n","import * as React from \"react\";\nimport * as ReactDOM from \"react-dom\";\n\nimport type { RouterProviderProps as BaseRouterProviderProps } from \"react-router\";\nimport { RouterProvider as BaseRouterProvider } from \"react-router\";\n\nexport { HydratedRouter } from \"./hydrated-router\";\n\nexport type RouterProviderProps = Omit<BaseRouterProviderProps, \"flushSync\">;\n\nexport function RouterProvider(props: Omit<RouterProviderProps, \"flushSync\">) {\n  return <BaseRouterProvider flushSync={ReactDOM.flushSync} {...props} />;\n}\n"],"names":["ssrInfo","router","initSsrInfo","window","__reactRouterContext","__reactRouterManifest","__reactRouterRouteModules","context","manifest","routeModules","stateDecodingPromise","undefined","routerInitialized","createHydratedRouter","Error","localSsrInfo","stream","process","env","NODE_ENV","invariant","decodeViaTurboStream","then","value","state","catch","e","error","routes","createClientRoutes","isSpaMode","hydrationData","_window$__reactRouter","_extends","loaderData","initialMatches","matchRoutes","location","basename","match","routeId","route","id","manifestRoute","shouldHydrateRouteLoader","HydrateFallback","hasLoader","errors","deserializeErrors","createRouter","history","createBrowserHistory","mapRouteProperties","dataStrategy","getSingleFetchDataStrategy","patchRoutesOnNavigation","getPatchRoutesOnNavigationFunction","initialized","initialize","createRoutesForHMR","createClientRoutesWithHMRRevalidationOptOut","__reactRouterDataRouter","HydratedRouter","_ssrInfo","criticalCss","setCriticalCss","React","useState","__reactRouterClearCriticalCss","setLocation","useLayoutEffect","subscribe","newState","useFogOFWarDiscovery","createElement","Fragment","FrameworkContext","Provider","future","RemixErrorBoundary","RouterProvider","props","BaseRouterProvider","flushSync","ReactDOM"],"mappings":"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"}