@react-router/dev 0.0.0-experimental-4d16b23b6 → 0.0.0-experimental-4d6793aa7

package/bin.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-let arg = require("arg");
+import arg from "arg";
 
 // Minimal replication of our actual parsing in `run.ts`.  If not already set,
 // default `NODE_ENV` so React loads the proper version in it's CJS entry script.
@@ -12,4 +12,6 @@ if (args._[0] === "dev") {
   process.env.NODE_ENV = process.env.NODE_ENV ?? "production";
 }
 
-require("./dist/cli/index");
+(async () => {
+  await import("./dist/cli/index.js");
+})();

package/dist/build-VA3X4T4U.js

@@ -0,0 +1,239 @@
+/**
+ * @react-router/dev v0.0.0-experimental-4d6793aa7
+ *
+ * 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 {
+  configRouteToBranchRoute,
+  extractPluginContext,
+  getServerBuildDirectory,
+  resolveViteConfig
+} from "./chunk-B25E3JGK.js";
+import "./chunk-B3M3SF27.js";
+import "./chunk-HICCFFJA.js";
+import {
+  getVite,
+  preloadVite
+} from "./chunk-X234P535.js";
+import {
+  invariant
+} from "./chunk-XJYIKBPH.js";
+
+// vite/build.ts
+import path from "node:path";
+import fse from "fs-extra";
+import colors from "picocolors";
+function getAddressableRoutes(routes) {
+  let nonAddressableIds = /* @__PURE__ */ new Set();
+  for (let id in routes) {
+    let route = routes[id];
+    if (route.index) {
+      invariant(
+        route.parentId,
+        `Expected index route "${route.id}" to have "parentId" set`
+      );
+      nonAddressableIds.add(route.parentId);
+    }
+    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(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 = getServerBuildDirectory(ctx);
+  if (!serverBundles) {
+    return {
+      serverBuilds: [{ ssr: true }],
+      buildManifest: { routes }
+    };
+  }
+  let { normalizePath } = await import("vite");
+  let resolvedAppDirectory = path.resolve(rootDirectory, appDirectory);
+  let rootRelativeRoutes = Object.fromEntries(
+    Object.entries(routes).map(([id, route]) => {
+      let filePath = path.join(resolvedAppDirectory, route.file);
+      let rootRelativeFilePath = normalizePath(
+        path.relative(rootDirectory, filePath)
+      );
+      return [id, { ...route, file: rootRelativeFilePath }];
+    })
+  );
+  let buildManifest = {
+    serverBundles: {},
+    routeIdToServerBundleId: {},
+    routes: rootRelativeRoutes
+  };
+  let serverBundleBuildConfigById = /* @__PURE__ */ new Map();
+  await Promise.all(
+    getAddressableRoutes(routes).map(async (route) => {
+      let branch = getRouteBranch(routes, route.id);
+      let serverBundleId = await serverBundles({
+        branch: branch.map(
+          (route2) => configRouteToBranchRoute({
+            ...route2,
+            // Ensure absolute paths are passed to the serverBundles function
+            file: path.join(resolvedAppDirectory, route2.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.relative(
+        rootDirectory,
+        path.join(serverBuildDirectory, serverBundleId)
+      );
+      let serverBuildConfig = serverBundleBuildConfigById.get(serverBundleId);
+      if (!serverBuildConfig) {
+        buildManifest.serverBundles[serverBundleId] = {
+          id: serverBundleId,
+          file: normalizePath(
+            path.join(relativeServerBundleDirectory, serverBuildFile)
+          )
+        };
+        serverBuildConfig = {
+          routes: {},
+          serverBundleId
+        };
+        serverBundleBuildConfigById.set(serverBundleId, serverBuildConfig);
+      }
+      for (let route2 of branch) {
+        serverBuildConfig.routes[route2.id] = route2;
+      }
+    })
+  );
+  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.relative(ctx.rootDirectory, buildDirectory);
+    return !relativePath.startsWith("..") && !path.isAbsolute(relativePath);
+  };
+  if (viteConfig.build.emptyOutDir ?? isWithinRoot()) {
+    await fse.remove(buildDirectory);
+  }
+}
+function getViteManifestPaths(ctx, serverBuilds) {
+  let buildRelative = (pathname) => path.resolve(ctx.reactRouterConfig.buildDirectory, pathname);
+  let viteManifestPaths = [
+    "client/.vite/manifest.json",
+    ...serverBuilds.map(({ serverBundleBuildConfig }) => {
+      let serverBundleId = serverBundleBuildConfig?.serverBundleId;
+      let serverBundlePath = serverBundleId ? serverBundleId + "/" : "";
+      return `server/${serverBundlePath}.vite/manifest.json`;
+    })
+  ].map((srcPath) => buildRelative(srcPath));
+  return viteManifestPaths;
+}
+async function build(root, {
+  assetsInlineLimit,
+  clearScreen,
+  config: configFile,
+  emptyOutDir,
+  force,
+  logLevel,
+  minify,
+  mode,
+  sourcemapClient,
+  sourcemapServer
+}) {
+  await preloadVite();
+  let viteConfig = await resolveViteConfig({ configFile, mode, root });
+  const ctx = await extractPluginContext(viteConfig);
+  if (!ctx) {
+    console.error(
+      colors.red("React Router Vite plugin not found in Vite config")
+    );
+    process.exit(1);
+  }
+  let { reactRouterConfig } = ctx;
+  let vite = getVite();
+  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);
+  await viteBuild({ ssr: false });
+  let { serverBuilds, buildManifest } = await getServerBuilds(ctx);
+  await Promise.all(serverBuilds.map(viteBuild));
+  let viteManifestPaths = getViteManifestPaths(ctx, serverBuilds);
+  await Promise.all(
+    viteManifestPaths.map(async (viteManifestPath) => {
+      let manifestExists = await fse.pathExists(viteManifestPath);
+      if (!manifestExists) return;
+      if (!ctx.viteManifestEnabled) {
+        await fse.remove(viteManifestPath);
+      }
+      let viteDir = path.dirname(viteManifestPath);
+      let viteDirFiles = await fse.readdir(viteDir);
+      if (viteDirFiles.length === 0) {
+        await fse.remove(viteDir);
+      }
+    })
+  );
+  await reactRouterConfig.buildEnd?.({
+    buildManifest,
+    reactRouterConfig,
+    viteConfig
+  });
+}
+export {
+  build
+};