@react-router/dev 0.0.0-experimental-c0856287f

package/dist/vite/build.js

@@ -0,0 +1,271 @@
+/**
+ * @react-router/dev v0.0.0-experimental-c0856287f
+ *
+ * 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';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var path = require('node:path');
+var fse = require('fs-extra');
+var colors = require('picocolors');
+var plugin = require('./plugin.js');
+var invariant = require('../invariant.js');
+var importViteEsmSync = require('./import-vite-esm-sync.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var path__default = /*#__PURE__*/_interopDefaultLegacy(path);
+var fse__default = /*#__PURE__*/_interopDefaultLegacy(fse);
+var colors__default = /*#__PURE__*/_interopDefaultLegacy(colors);
+
+function getAddressableRoutes(routes) {
+  let nonAddressableIds = new Set();
+  for (let id in routes) {
+    let route = routes[id];
+    // We omit the parent route of index routes since the index route takes ownership of its parent's path
+    if (route.index) {
+      invariant["default"](route.parentId, `Expected index route "${route.id}" to have "parentId" set`);
+      nonAddressableIds.add(route.parentId);
+    }
+    // We omit pathless routes since they can only be addressed via descendant routes
+    if (typeof route.path !== "string" && !route.index) {
+      nonAddressableIds.add(id);
+    }
+  }
+  return Object.values(routes).filter(route => !nonAddressableIds.has(route.id));
+}
+function getRouteBranch(routes, routeId) {
+  let branch = [];
+  let currentRouteId = routeId;
+  while (currentRouteId) {
+    let route = routes[currentRouteId];
+    invariant["default"](route, `Missing route for ${currentRouteId}`);
+    branch.push(route);
+    currentRouteId = route.parentId;
+  }
+  return branch.reverse();
+}
+async function getServerBuilds(ctx) {
+  let {
+    rootDirectory
+  } = ctx;
+  const {
+    routes,
+    serverBuildFile,
+    serverBundles,
+    appDirectory
+  } = ctx.reactRouterConfig;
+  let serverBuildDirectory = plugin.getServerBuildDirectory(ctx);
+  if (!serverBundles) {
+    return {
+      serverBuilds: [{
+        ssr: true
+      }],
+      buildManifest: {
+        routes
+      }
+    };
+  }
+  let {
+    normalizePath
+  } = await import('vite');
+  let resolvedAppDirectory = path__default["default"].resolve(rootDirectory, appDirectory);
+  let rootRelativeRoutes = Object.fromEntries(Object.entries(routes).map(([id, route]) => {
+    let filePath = path__default["default"].join(resolvedAppDirectory, route.file);
+    let rootRelativeFilePath = normalizePath(path__default["default"].relative(rootDirectory, filePath));
+    return [id, {
+      ...route,
+      file: rootRelativeFilePath
+    }];
+  }));
+  let buildManifest = {
+    serverBundles: {},
+    routeIdToServerBundleId: {},
+    routes: rootRelativeRoutes
+  };
+  let serverBundleBuildConfigById = new Map();
+  await Promise.all(getAddressableRoutes(routes).map(async route => {
+    let branch = getRouteBranch(routes, route.id);
+    let serverBundleId = await serverBundles({
+      branch: branch.map(route => plugin.configRouteToBranchRoute({
+        ...route,
+        // Ensure absolute paths are passed to the serverBundles function
+        file: path__default["default"].join(resolvedAppDirectory, route.file)
+      }))
+    });
+    if (typeof serverBundleId !== "string") {
+      throw new Error(`The "serverBundles" function must return a string`);
+    }
+    if (!/^[a-zA-Z0-9-_]+$/.test(serverBundleId)) {
+      throw new Error(`The "serverBundles" function must only return strings containing alphanumeric characters, hyphens and underscores.`);
+    }
+    buildManifest.routeIdToServerBundleId[route.id] = serverBundleId;
+    let relativeServerBundleDirectory = path__default["default"].relative(rootDirectory, path__default["default"].join(serverBuildDirectory, serverBundleId));
+    let serverBuildConfig = serverBundleBuildConfigById.get(serverBundleId);
+    if (!serverBuildConfig) {
+      buildManifest.serverBundles[serverBundleId] = {
+        id: serverBundleId,
+        file: normalizePath(path__default["default"].join(relativeServerBundleDirectory, serverBuildFile))
+      };
+      serverBuildConfig = {
+        routes: {},
+        serverBundleId
+      };
+      serverBundleBuildConfigById.set(serverBundleId, serverBuildConfig);
+    }
+    for (let route of branch) {
+      serverBuildConfig.routes[route.id] = route;
+    }
+  }));
+  let serverBuilds = Array.from(serverBundleBuildConfigById.values()).map(serverBundleBuildConfig => {
+    let serverBuild = {
+      ssr: true,
+      serverBundleBuildConfig
+    };
+    return serverBuild;
+  });
+  return {
+    serverBuilds,
+    buildManifest
+  };
+}
+async function cleanBuildDirectory(viteConfig, ctx) {
+  let buildDirectory = ctx.reactRouterConfig.buildDirectory;
+  let isWithinRoot = () => {
+    let relativePath = path__default["default"].relative(ctx.rootDirectory, buildDirectory);
+    return !relativePath.startsWith("..") && !path__default["default"].isAbsolute(relativePath);
+  };
+  if (viteConfig.build.emptyOutDir ?? isWithinRoot()) {
+    await fse__default["default"].remove(buildDirectory);
+  }
+}
+function getViteManifestPaths(ctx, serverBuilds) {
+  let buildRelative = pathname => path__default["default"].resolve(ctx.reactRouterConfig.buildDirectory, pathname);
+  let viteManifestPaths = [{
+    srcPath: "client/.vite/manifest.json",
+    destPath: ".vite/client-manifest.json"
+  }, ...serverBuilds.map(({
+    serverBundleBuildConfig
+  }) => {
+    let serverBundleId = serverBundleBuildConfig === null || serverBundleBuildConfig === void 0 ? void 0 : serverBundleBuildConfig.serverBundleId;
+    let serverBundlePath = serverBundleId ? serverBundleId + "/" : "";
+    let serverBundleSuffix = serverBundleId ? serverBundleId + "-" : "";
+    return {
+      srcPath: `server/${serverBundlePath}.vite/manifest.json`,
+      destPath: `.vite/server-${serverBundleSuffix}manifest.json`
+    };
+  })].map(({
+    srcPath,
+    destPath
+  }) => ({
+    srcPath: buildRelative(srcPath),
+    destPath: buildRelative(destPath)
+  }));
+  return viteManifestPaths;
+}
+async function build(root, {
+  assetsInlineLimit,
+  clearScreen,
+  config: configFile,
+  emptyOutDir,
+  force,
+  logLevel,
+  minify,
+  mode,
+  sourcemapClient,
+  sourcemapServer
+}) {
+  var _reactRouterConfig$bu;
+  // Ensure Vite's ESM build is preloaded at the start of the process
+  // so it can be accessed synchronously via `importViteEsmSync`
+  await importViteEsmSync.preloadViteEsm();
+  let viteConfig = await plugin.resolveViteConfig({
+    configFile,
+    mode,
+    root
+  });
+  const ctx = await plugin.extractPluginContext(viteConfig);
+  if (!ctx) {
+    console.error(colors__default["default"].red("React Router Vite plugin not found in Vite config"));
+    process.exit(1);
+  }
+  let {
+    reactRouterConfig
+  } = ctx;
+  let vite = await import('vite');
+  async function viteBuild({
+    ssr,
+    serverBundleBuildConfig
+  }) {
+    await vite.build({
+      root,
+      mode,
+      configFile,
+      build: {
+        assetsInlineLimit,
+        emptyOutDir,
+        minify,
+        ssr,
+        sourcemap: ssr ? sourcemapServer : sourcemapClient
+      },
+      optimizeDeps: {
+        force
+      },
+      clearScreen,
+      logLevel,
+      ...(serverBundleBuildConfig ? {
+        __reactRouterServerBundleBuildConfig: serverBundleBuildConfig
+      } : {})
+    });
+  }
+  await cleanBuildDirectory(viteConfig, ctx);
+  // Run the Vite client build first
+  await viteBuild({
+    ssr: false
+  });
+  // Then run Vite SSR builds in parallel
+  let {
+    serverBuilds,
+    buildManifest
+  } = await getServerBuilds(ctx);
+  await Promise.all(serverBuilds.map(viteBuild));
+  let viteManifestPaths = getViteManifestPaths(ctx, serverBuilds);
+  await Promise.all(viteManifestPaths.map(async ({
+    srcPath,
+    destPath
+  }) => {
+    let manifestExists = await fse__default["default"].pathExists(srcPath);
+    if (!manifestExists) return;
+    // Move/delete original Vite manifest file
+    if (ctx.viteManifestEnabled) {
+      await fse__default["default"].ensureDir(path__default["default"].dirname(destPath));
+      await fse__default["default"].move(srcPath, destPath);
+    } else {
+      await fse__default["default"].remove(srcPath);
+    }
+    // Remove .vite dir if it's now empty
+    let viteDir = path__default["default"].dirname(srcPath);
+    let viteDirFiles = await fse__default["default"].readdir(viteDir);
+    if (viteDirFiles.length === 0) {
+      await fse__default["default"].remove(viteDir);
+    }
+  }));
+  if (ctx.reactRouterConfig.manifest) {
+    await fse__default["default"].ensureDir(path__default["default"].join(ctx.reactRouterConfig.buildDirectory, ".react-router"));
+    await fse__default["default"].writeFile(path__default["default"].join(ctx.reactRouterConfig.buildDirectory, ".react-router", "manifest.json"), JSON.stringify(buildManifest, null, 2), "utf-8");
+  }
+  await ((_reactRouterConfig$bu = reactRouterConfig.buildEnd) === null || _reactRouterConfig$bu === void 0 ? void 0 : _reactRouterConfig$bu.call(reactRouterConfig, {
+    buildManifest,
+    reactRouterConfig,
+    viteConfig
+  }));
+}
+
+exports.build = build;

package/dist/vite/cloudflare-proxy-plugin.d.ts

@@ -0,0 +1,15 @@
+import type { AppLoadContext } from "@react-router/server-runtime";
+import type { Plugin } from "vite";
+import type { GetPlatformProxyOptions, PlatformProxy } from "wrangler";
+type CfProperties = Record<string, unknown>;
+type LoadContext<Env, Cf extends CfProperties> = {
+    cloudflare: Omit<PlatformProxy<Env, Cf>, "dispose">;
+};
+type GetLoadContext<Env, Cf extends CfProperties> = (args: {
+    request: Request;
+    context: LoadContext<Env, Cf>;
+}) => AppLoadContext | Promise<AppLoadContext>;
+export declare const cloudflareDevProxyVitePlugin: <Env, Cf extends CfProperties>({ getLoadContext, ...options }?: {
+    getLoadContext?: GetLoadContext<Env, Cf>;
+} & GetPlatformProxyOptions) => Plugin;
+export {};

package/dist/vite/cloudflare-proxy-plugin.js

@@ -0,0 +1,82 @@
+/**
+ * @react-router/dev v0.0.0-experimental-c0856287f
+ *
+ * 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';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var serverRuntime = require('@react-router/server-runtime');
+var nodeAdapter = require('./node-adapter.js');
+
+let serverBuildId = "virtual:react-router/server-build";
+function importWrangler() {
+  try {
+    return import('wrangler');
+  } catch (_) {
+    throw Error("Could not import `wrangler`. Do you have it installed?");
+  }
+}
+const NAME = "vite-plugin-react-router-cloudflare-proxy";
+const cloudflareDevProxyVitePlugin = ({
+  getLoadContext,
+  ...options
+} = {}) => {
+  return {
+    name: NAME,
+    config: () => ({
+      ssr: {
+        resolve: {
+          externalConditions: ["workerd", "worker"]
+        }
+      }
+    }),
+    configResolved: viteConfig => {
+      let pluginIndex = name => viteConfig.plugins.findIndex(plugin => plugin.name === name);
+      let reactRouterPluginIndex = pluginIndex("react-router");
+      if (reactRouterPluginIndex >= 0 && reactRouterPluginIndex < pluginIndex(NAME)) {
+        throw new Error(`The "${NAME}" plugin should be placed before the React Router plugin in your Vite config file`);
+      }
+    },
+    configureServer: async viteDevServer => {
+      let {
+        getPlatformProxy
+      } = await importWrangler();
+      // Do not include `dispose` in Cloudflare context
+      let {
+        dispose,
+        ...cloudflare
+      } = await getPlatformProxy(options);
+      let context = {
+        cloudflare
+      };
+      return () => {
+        if (!viteDevServer.config.server.middlewareMode) {
+          viteDevServer.middlewares.use(async (nodeReq, nodeRes, next) => {
+            try {
+              let build = await viteDevServer.ssrLoadModule(serverBuildId);
+              let handler = serverRuntime.createRequestHandler(build, "development");
+              let req = nodeAdapter.fromNodeRequest(nodeReq);
+              let loadContext = getLoadContext ? await getLoadContext({
+                request: req,
+                context
+              }) : context;
+              let res = await handler(req, loadContext);
+              await nodeAdapter.toNodeRequest(res, nodeRes);
+            } catch (error) {
+              next(error);
+            }
+          });
+        }
+      };
+    }
+  };
+};
+
+exports.cloudflareDevProxyVitePlugin = cloudflareDevProxyVitePlugin;

package/dist/vite/dev.d.ts

@@ -0,0 +1,15 @@
+import type * as Vite from "vite";
+export interface ViteDevOptions {
+    clearScreen?: boolean;
+    config?: string;
+    cors?: boolean;
+    force?: boolean;
+    host?: boolean | string;
+    logLevel?: Vite.LogLevel;
+    mode?: string;
+    open?: boolean | string;
+    port?: number;
+    strictPort?: boolean;
+    profile?: boolean;
+}
+export declare function dev(root: string, { clearScreen, config: configFile, cors, force, host, logLevel, mode, open, port, strictPort, }: ViteDevOptions): Promise<void>;

package/dist/vite/dev.js

@@ -0,0 +1,81 @@
+/**
+ * @react-router/dev v0.0.0-experimental-c0856287f
+ *
+ * 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';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var colors = require('picocolors');
+var importViteEsmSync = require('./import-vite-esm-sync.js');
+var profiler = require('./profiler.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var colors__default = /*#__PURE__*/_interopDefaultLegacy(colors);
+
+async function dev(root, {
+  clearScreen,
+  config: configFile,
+  cors,
+  force,
+  host,
+  logLevel,
+  mode,
+  open,
+  port,
+  strictPort
+}) {
+  // Ensure Vite's ESM build is preloaded at the start of the process
+  // so it can be accessed synchronously via `importViteEsmSync`
+  await importViteEsmSync.preloadViteEsm();
+  let vite = await import('vite');
+  let server = await vite.createServer({
+    root,
+    mode,
+    configFile,
+    server: {
+      open,
+      cors,
+      host,
+      port,
+      strictPort
+    },
+    optimizeDeps: {
+      force
+    },
+    clearScreen,
+    logLevel
+  });
+  if (!server.config.plugins.find(plugin => plugin.name === "react-router")) {
+    console.error(colors__default["default"].red("React Router Vite plugin not found in Vite config"));
+    process.exit(1);
+  }
+  await server.listen();
+  server.printUrls();
+  let customShortcuts = [{
+    key: "p",
+    description: "start/stop the profiler",
+    async action(server) {
+      if (profiler.getSession()) {
+        await profiler.stop(server.config.logger.info);
+      } else {
+        await profiler.start(() => {
+          server.config.logger.info("Profiler started");
+        });
+      }
+    }
+  }];
+  server.bindCLIShortcuts({
+    print: true,
+    customShortcuts
+  });
+}
+
+exports.dev = dev;

package/dist/vite/import-vite-esm-sync.d.ts

@@ -0,0 +1,4 @@
+type Vite = typeof import("vite");
+export declare function preloadViteEsm(): Promise<void>;
+export declare function importViteEsmSync(): Vite;
+export {};

package/dist/vite/import-vite-esm-sync.js

@@ -0,0 +1,28 @@
+/**
+ * @react-router/dev v0.0.0-experimental-c0856287f
+ *
+ * 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';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var invariant = require('../invariant.js');
+
+// This file is used to avoid CJS deprecation warnings in Vite 5 since
+let vite;
+async function preloadViteEsm() {
+  vite = await import('vite');
+}
+function importViteEsmSync() {
+  invariant["default"](vite, "importViteEsmSync() called before preloadViteEsm()");
+  return vite;
+}
+
+exports.importViteEsmSync = importViteEsmSync;
+exports.preloadViteEsm = preloadViteEsm;

package/dist/vite/index.d.ts

@@ -0,0 +1,4 @@
+import type { ReactRouterVitePlugin } from "./plugin";
+export type { BuildManifest, Preset, VitePluginConfig, ServerBundlesFunction, } from "./plugin";
+export declare const vitePlugin: ReactRouterVitePlugin;
+export { cloudflareDevProxyVitePlugin } from "./cloudflare-proxy-plugin";

package/dist/vite/index.js

@@ -0,0 +1,30 @@
+/**
+ * @react-router/dev v0.0.0-experimental-c0856287f
+ *
+ * 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';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+require('@react-router/server-runtime');
+require('node:events');
+require('node:stream');
+require('set-cookie-parser');
+require('@react-router/node');
+
+const vitePlugin = (...args) => {
+  let {
+    reactRouterVitePlugin
+  } =
+  // eslint-disable-next-line @typescript-eslint/consistent-type-imports
+  require("./plugin");
+  return reactRouterVitePlugin(...args);
+};
+
+exports.vitePlugin = vitePlugin;

package/dist/vite/node-adapter.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+import type { ServerResponse } from "node:http";
+import type * as Vite from "vite";
+export type NodeRequestHandler = (req: Vite.Connect.IncomingMessage, res: ServerResponse) => Promise<void>;
+export declare function fromNodeRequest(nodeReq: Vite.Connect.IncomingMessage): Request;
+export declare function toNodeRequest(res: Response, nodeRes: ServerResponse): Promise<void>;

package/dist/vite/node-adapter.js

@@ -0,0 +1,78 @@
+/**
+ * @react-router/dev v0.0.0-experimental-c0856287f
+ *
+ * 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';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var node_events = require('node:events');
+var node_stream = require('node:stream');
+var setCookieParser = require('set-cookie-parser');
+var node = require('@react-router/node');
+var invariant = require('../invariant.js');
+
+function fromNodeHeaders(nodeHeaders) {
+  let headers = new Headers();
+  for (let [key, values] of Object.entries(nodeHeaders)) {
+    if (values) {
+      if (Array.isArray(values)) {
+        for (let value of values) {
+          headers.append(key, value);
+        }
+      } else {
+        headers.set(key, values);
+      }
+    }
+  }
+  return headers;
+}
+// Based on `createRemixRequest` in packages/remix-express/server.ts
+function fromNodeRequest(nodeReq) {
+  let origin = nodeReq.headers.origin && "null" !== nodeReq.headers.origin ? nodeReq.headers.origin : `http://${nodeReq.headers.host}`;
+  // Use `req.originalUrl` so React Router is aware of the full path
+  invariant["default"](nodeReq.originalUrl, "Expected `nodeReq.originalUrl` to be defined");
+  let url = new URL(nodeReq.originalUrl, origin);
+  let init = {
+    method: nodeReq.method,
+    headers: fromNodeHeaders(nodeReq.headers)
+  };
+  if (nodeReq.method !== "GET" && nodeReq.method !== "HEAD") {
+    init.body = node.createReadableStreamFromReadable(nodeReq);
+    init.duplex = "half";
+  }
+  return new Request(url.href, init);
+}
+// Adapted from solid-start's `handleNodeResponse`:
+// https://github.com/solidjs/solid-start/blob/7398163869b489cce503c167e284891cf51a6613/packages/start/node/fetch.js#L162-L185
+async function toNodeRequest(res, nodeRes) {
+  nodeRes.statusCode = res.status;
+  nodeRes.statusMessage = res.statusText;
+  let cookiesStrings = [];
+  for (let [name, value] of res.headers) {
+    if (name === "set-cookie") {
+      cookiesStrings.push(...setCookieParser.splitCookiesString(value));
+    } else nodeRes.setHeader(name, value);
+  }
+  if (cookiesStrings.length) {
+    nodeRes.setHeader("set-cookie", cookiesStrings);
+  }
+  if (res.body) {
+    // https://github.com/microsoft/TypeScript/issues/29867
+    let responseBody = res.body;
+    let readable = node_stream.Readable.from(responseBody);
+    readable.pipe(nodeRes);
+    await node_events.once(readable, "end");
+  } else {
+    nodeRes.end();
+  }
+}
+
+exports.fromNodeRequest = fromNodeRequest;
+exports.toNodeRequest = toNodeRequest;