@c0va23/react-router-dev 7.8.3-alpha.1

package/dist/config/default-rsc-entries/entry.client.tsx

@@ -0,0 +1,46 @@
+import "virtual:react-router/unstable_rsc/inject-hmr-runtime";
+
+import { startTransition, StrictMode } from "react";
+import { hydrateRoot } from "react-dom/client";
+import {
+  createFromReadableStream,
+  createTemporaryReferenceSet,
+  encodeReply,
+  setServerCallback,
+} from "@vitejs/plugin-rsc/browser";
+import {
+  unstable_createCallServer as createCallServer,
+  unstable_getRSCStream as getRSCStream,
+  unstable_RSCHydratedRouter as RSCHydratedRouter,
+} from "react-router";
+import type { unstable_RSCPayload as RSCPayload } from "react-router";
+
+setServerCallback(
+  createCallServer({
+    createFromReadableStream,
+    createTemporaryReferenceSet,
+    encodeReply,
+  }),
+);
+
+createFromReadableStream<RSCPayload>(getRSCStream()).then((payload) => {
+  // @ts-expect-error - on 18 types, requires 19.
+  startTransition(async () => {
+    const formState =
+      payload.type === "render" ? await payload.formState : undefined;
+
+    hydrateRoot(
+      document,
+      <StrictMode>
+        <RSCHydratedRouter
+          payload={payload}
+          createFromReadableStream={createFromReadableStream}
+        />
+      </StrictMode>,
+      {
+        // @ts-expect-error - no types for this yet
+        formState,
+      },
+    );
+  });
+});

package/dist/config/default-rsc-entries/entry.rsc.tsx

@@ -0,0 +1,42 @@
+import {
+  createTemporaryReferenceSet,
+  decodeAction,
+  decodeFormState,
+  decodeReply,
+  loadServerAction,
+  renderToReadableStream,
+} from "@vitejs/plugin-rsc/rsc";
+import { unstable_matchRSCServerRequest as matchRSCServerRequest } from "react-router";
+
+import routes from "virtual:react-router/unstable_rsc/routes";
+import basename from "virtual:react-router/unstable_rsc/basename";
+
+export async function fetchServer(request: Request) {
+  return await matchRSCServerRequest({
+    createTemporaryReferenceSet,
+    decodeAction,
+    decodeFormState,
+    decodeReply,
+    loadServerAction,
+    request,
+    routes,
+    basename,
+    generateResponse(match, options) {
+      return new Response(renderToReadableStream(match.payload, options), {
+        status: match.statusCode,
+        headers: match.headers,
+      });
+    },
+  });
+}
+
+export default async function handler(request: Request) {
+  const ssr = await import.meta.viteRsc.loadModule<
+    typeof import("./entry.ssr")
+  >("ssr", "index");
+  return ssr.default(request, fetchServer);
+}
+
+if (import.meta.hot) {
+  import.meta.hot.accept();
+}

package/dist/config/default-rsc-entries/entry.ssr.tsx

@@ -0,0 +1,35 @@
+import { createFromReadableStream } from "@vitejs/plugin-rsc/ssr";
+// @ts-expect-error
+import * as ReactDomServer from "react-dom/server.edge";
+import {
+  unstable_RSCStaticRouter as RSCStaticRouter,
+  unstable_routeRSCServerRequest as routeRSCServerRequest,
+} from "react-router";
+
+export default async function handler(
+  request: Request,
+  fetchServer: (request: Request) => Promise<Response>,
+) {
+  const bootstrapScriptContent =
+    await import.meta.viteRsc.loadBootstrapScriptContent("index");
+
+  return routeRSCServerRequest({
+    request,
+    fetchServer,
+    createFromReadableStream,
+    async renderHTML(getPayload) {
+      const payload = await getPayload();
+      const formState =
+        payload.type === "render" ? await payload.formState : undefined;
+
+      return ReactDomServer.renderToReadableStream(
+        <RSCStaticRouter getPayload={getPayload} />,
+        {
+          bootstrapScriptContent,
+          signal: request.signal,
+          formState,
+        },
+      );
+    },
+  });
+}

package/dist/config/defaults/entry.client.tsx

@@ -0,0 +1,12 @@
+import { startTransition, StrictMode } from "react";
+import { hydrateRoot } from "react-dom/client";
+import { HydratedRouter } from "react-router/dom";
+
+startTransition(() => {
+  hydrateRoot(
+    document,
+    <StrictMode>
+      <HydratedRouter />
+    </StrictMode>,
+  );
+});

package/dist/config/defaults/entry.server.node.tsx

@@ -0,0 +1,80 @@
+import { PassThrough } from "node:stream";
+
+import type { AppLoadContext, EntryContext } from "react-router";
+import { createReadableStreamFromReadable } from "@react-router/node";
+import { ServerRouter } from "react-router";
+import { isbot } from "isbot";
+import type { RenderToPipeableStreamOptions } from "react-dom/server";
+import { renderToPipeableStream } from "react-dom/server";
+
+export const streamTimeout = 5_000;
+
+export default function handleRequest(
+  request: Request,
+  responseStatusCode: number,
+  responseHeaders: Headers,
+  routerContext: EntryContext,
+  loadContext: AppLoadContext,
+  // If you have middleware enabled:
+  // loadContext: RouterContextProvider
+) {
+  return new Promise((resolve, reject) => {
+    let shellRendered = false;
+    let userAgent = request.headers.get("user-agent");
+
+    // Ensure requests from bots and SPA Mode renders wait for all content to load before responding
+    // https://react.dev/reference/react-dom/server/renderToPipeableStream#waiting-for-all-content-to-load-for-crawlers-and-static-generation
+    let readyOption: keyof RenderToPipeableStreamOptions =
+      (userAgent && isbot(userAgent)) || routerContext.isSpaMode
+        ? "onAllReady"
+        : "onShellReady";
+
+    // Abort the rendering stream after the `streamTimeout` so it has time to
+    // flush down the rejected boundaries
+    let timeoutId: ReturnType<typeof setTimeout> | undefined = setTimeout(
+      () => abort(),
+      streamTimeout + 1000,
+    );
+
+    const { pipe, abort } = renderToPipeableStream(
+      <ServerRouter context={routerContext} url={request.url} />,
+      {
+        [readyOption]() {
+          shellRendered = true;
+          const body = new PassThrough({
+            final(callback) {
+              // Clear the timeout to prevent retaining the closure and memory leak
+              clearTimeout(timeoutId);
+              timeoutId = undefined;
+              callback();
+            },
+          });
+          const stream = createReadableStreamFromReadable(body);
+
+          responseHeaders.set("Content-Type", "text/html");
+
+          pipe(body);
+
+          resolve(
+            new Response(stream, {
+              headers: responseHeaders,
+              status: responseStatusCode,
+            }),
+          );
+        },
+        onShellError(error: unknown) {
+          reject(error);
+        },
+        onError(error: unknown) {
+          responseStatusCode = 500;
+          // Log streaming rendering errors from inside the shell.  Don't log
+          // errors encountered during initial shell rendering since they'll
+          // reject and get logged in handleDocumentRequest.
+          if (shellRendered) {
+            console.error(error);
+          }
+        },
+      },
+    );
+  });
+}

package/dist/config.d.ts

@@ -0,0 +1,211 @@
+import * as Vite from 'vite';
+import { R as RouteManifest, a as RouteManifestEntry, b as RouteConfigEntry } from './routes-CZR-bKRt.js';
+import 'valibot';
+
+declare const excludedConfigPresetKeys: readonly ["presets"];
+type ExcludedConfigPresetKey = (typeof excludedConfigPresetKeys)[number];
+type ConfigPreset = Omit<ReactRouterConfig, ExcludedConfigPresetKey>;
+type Preset = {
+    name: string;
+    reactRouterConfig?: (args: {
+        reactRouterUserConfig: ReactRouterConfig;
+    }) => ConfigPreset | Promise<ConfigPreset>;
+    reactRouterConfigResolved?: (args: {
+        reactRouterConfig: ResolvedReactRouterConfig;
+    }) => void | Promise<void>;
+};
+declare const branchRouteProperties: readonly ["id", "path", "file", "index"];
+type BranchRoute = Pick<RouteManifestEntry, (typeof branchRouteProperties)[number]>;
+type ServerBundlesFunction = (args: {
+    branch: BranchRoute[];
+}) => string | Promise<string>;
+type BaseBuildManifest = {
+    routes: RouteManifest;
+};
+type DefaultBuildManifest = BaseBuildManifest & {
+    serverBundles?: never;
+    routeIdToServerBundleId?: never;
+};
+type ServerBundlesBuildManifest = BaseBuildManifest & {
+    serverBundles: {
+        [serverBundleId: string]: {
+            id: string;
+            file: string;
+        };
+    };
+    routeIdToServerBundleId: Record<string, string>;
+};
+type ServerModuleFormat = "esm" | "cjs";
+interface FutureConfig {
+    /**
+     * Enable route middleware
+     */
+    v8_middleware: boolean;
+    unstable_optimizeDeps: boolean;
+    /**
+     * Automatically split route modules into multiple chunks when possible.
+     */
+    unstable_splitRouteModules: boolean | "enforce";
+    unstable_subResourceIntegrity: boolean;
+    /**
+     * Use Vite Environment API (experimental)
+     */
+    unstable_viteEnvironmentApi: boolean;
+}
+type BuildManifest = DefaultBuildManifest | ServerBundlesBuildManifest;
+type BuildEndHook = (args: {
+    buildManifest: BuildManifest | undefined;
+    reactRouterConfig: ResolvedReactRouterConfig;
+    viteConfig: Vite.ResolvedConfig;
+}) => void | Promise<void>;
+/**
+ * Config to be exported via the default export from `react-router.config.ts`.
+ */
+type ReactRouterConfig = {
+    /**
+     * The path to the `app` directory, relative to the root directory. Defaults
+     * to `"app"`.
+     */
+    appDirectory?: string;
+    /**
+     * The output format of the server build. Defaults to "esm".
+     */
+    serverModuleFormat?: ServerModuleFormat;
+    /**
+     * Enabled future flags
+     */
+    future?: [keyof FutureConfig] extends [never] ? {
+        [key: string]: never;
+    } : Partial<FutureConfig>;
+    /**
+     * The React Router app basename.  Defaults to `"/"`.
+     */
+    basename?: string;
+    /**
+     * The path to the build directory, relative to the project. Defaults to
+     * `"build"`.
+     */
+    buildDirectory?: string;
+    /**
+     * A function that is called after the full React Router build is complete.
+     */
+    buildEnd?: BuildEndHook;
+    /**
+     * An array of URLs to prerender to HTML files at build time.  Can also be a
+     * function returning an array to dynamically generate URLs.
+     */
+    prerender?: boolean | Array<string> | ((args: {
+        getStaticPaths: () => string[];
+    }) => Array<string> | Promise<Array<string>>);
+    /**
+     * An array of React Router plugin config presets to ease integration with
+     * other platforms and tools.
+     */
+    presets?: Array<Preset>;
+    /**
+     * Control the "Lazy Route Discovery" behavior
+     *
+     * - `routeDiscovery.mode`: By default, this resolves to `lazy` which will
+     *   lazily discover routes as the user navigates around your application.
+     *   You can set this to `initial` to opt-out of this behavior and load all
+     *   routes with the initial HTML document load.
+     * - `routeDiscovery.manifestPath`: The path to serve the manifest file from.
+     *    Only applies to `mode: "lazy"` and defaults to `/__manifest`.
+     */
+    routeDiscovery?: {
+        mode: "lazy";
+        manifestPath?: string;
+    } | {
+        mode: "initial";
+    };
+    /**
+     * The file name of the server build output. This file
+     * should end in a `.js` extension and should be deployed to your server.
+     * Defaults to `"index.js"`.
+     */
+    serverBuildFile?: string;
+    /**
+     * A function for assigning routes to different server bundles. This
+     * function should return a server bundle ID which will be used as the
+     * bundle's directory name within the server build directory.
+     */
+    serverBundles?: ServerBundlesFunction;
+    /**
+     * Enable server-side rendering for your application. Disable to use "SPA
+     * Mode", which will request the `/` path at build-time and save it as an
+     * `index.html` file with your assets so your application can be deployed as a
+     * SPA without server-rendering. Default's to `true`.
+     */
+    ssr?: boolean;
+};
+type ResolvedReactRouterConfig = Readonly<{
+    /**
+     * The absolute path to the application source directory.
+     */
+    appDirectory: string;
+    /**
+     * The React Router app basename.  Defaults to `"/"`.
+     */
+    basename: string;
+    /**
+     * The absolute path to the build directory.
+     */
+    buildDirectory: string;
+    /**
+     * A function that is called after the full React Router build is complete.
+     */
+    buildEnd?: BuildEndHook;
+    /**
+     * Enabled future flags
+     */
+    future: FutureConfig;
+    /**
+     * An array of URLs to prerender to HTML files at build time.  Can also be a
+     * function returning an array to dynamically generate URLs.
+     */
+    prerender: ReactRouterConfig["prerender"];
+    /**
+     * Control the "Lazy Route Discovery" behavior
+     *
+     * - `routeDiscovery.mode`: By default, this resolves to `lazy` which will
+     *   lazily discover routes as the user navigates around your application.
+     *   You can set this to `initial` to opt-out of this behavior and load all
+     *   routes with the initial HTML document load.
+     * - `routeDiscovery.manifestPath`: The path to serve the manifest file from.
+     *    Only applies to `mode: "lazy"` and defaults to `/__manifest`.
+     */
+    routeDiscovery: ReactRouterConfig["routeDiscovery"];
+    /**
+     * An object of all available routes, keyed by route id.
+     */
+    routes: RouteManifest;
+    /**
+     * The file name of the server build output. This file
+     * should end in a `.js` extension and should be deployed to your server.
+     * Defaults to `"index.js"`.
+     */
+    serverBuildFile: string;
+    /**
+     * A function for assigning routes to different server bundles. This
+     * function should return a server bundle ID which will be used as the
+     * bundle's directory name within the server build directory.
+     */
+    serverBundles?: ServerBundlesFunction;
+    /**
+     * The output format of the server build. Defaults to "esm".
+     */
+    serverModuleFormat: ServerModuleFormat;
+    /**
+     * Enable server-side rendering for your application. Disable to use "SPA
+     * Mode", which will request the `/` path at build-time and save it as an
+     * `index.html` file with your assets so your application can be deployed as a
+     * SPA without server-rendering. Default's to `true`.
+     */
+    ssr: boolean;
+    /**
+     * The resolved array of route config entries exported from `routes.ts`
+     */
+    unstable_routeConfig: RouteConfigEntry[];
+}>;
+
+export type { BuildManifest, ReactRouterConfig as Config, Preset, ServerBundlesFunction };

package/dist/config.js

@@ -0,0 +1,28 @@
+/**
+ * @c0va23/react-router-dev v7.8.3-alpha.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
+ */
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// config.ts
+var config_exports = {};
+module.exports = __toCommonJS(config_exports);

package/dist/internal.d.ts

@@ -0,0 +1,9 @@
+import * as Vite from 'vite';
+
+declare function reactRouterRSCVitePlugin(): Vite.PluginOption[];
+
+declare const __INTERNAL_DO_NOT_USE_OR_YOU_WILL_GET_A_STRONGLY_WORDED_LETTER__: {
+    unstable_reactRouterRSC: typeof reactRouterRSCVitePlugin;
+};
+
+export { __INTERNAL_DO_NOT_USE_OR_YOU_WILL_GET_A_STRONGLY_WORDED_LETTER__ };