@react-router/dev 7.0.0-pre.2 → 7.0.0-pre.4

package/dist/typescript/plugin.js

@@ -1,5 +1,5 @@
 /**
- * @react-router/dev v7.0.0-pre.2
+ * @react-router/dev v7.0.0-pre.4
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -8,45 +8,493 @@
  *
  * @license MIT
  */
-'use strict';
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// typescript/plugin.ts
+var plugin_exports = {};
+__export(plugin_exports, {
+  default: () => init
+});
+module.exports = __toCommonJS(plugin_exports);
+var Path2 = __toESM(require("pathe"));
+
+// typescript/typegen.ts
+var import_node_fs = __toESM(require("fs"));
+var import_chokidar = __toESM(require("chokidar"));
+var import_dedent2 = __toESM(require("dedent"));
+var Path = __toESM(require("pathe"));
+var Pathe = __toESM(require("pathe/utils"));
+
+// config/routes.ts
+var import_node_path = require("path");
+var v = __toESM(require("valibot"));
+var import_pick = __toESM(require("lodash/pick"));
+
+// invariant.ts
+function invariant(value, message) {
+  if (value === false || value === null || typeof value === "undefined") {
+    console.error(
+      "The following error is a bug in React Router; please open an issue! https://github.com/remix-run/react-router/issues/new/choose"
+    );
+    throw new Error(message);
+  }
+}
+
+// config/routes.ts
+var routeConfigEntrySchema = v.pipe(
+  v.custom((value) => {
+    return !(typeof value === "object" && value !== null && "then" in value && "catch" in value);
+  }, "Invalid type: Expected object but received a promise. Did you forget to await?"),
+  v.object({
+    id: v.optional(v.string()),
+    path: v.optional(v.string()),
+    index: v.optional(v.boolean()),
+    caseSensitive: v.optional(v.boolean()),
+    file: v.string(),
+    children: v.optional(v.array(v.lazy(() => routeConfigEntrySchema)))
+  })
+);
+var resolvedRouteConfigSchema = v.array(routeConfigEntrySchema);
+function configRoutesToRouteManifest(routes, rootId = "root") {
+  let routeManifest = {};
+  function walk(route, parentId) {
+    let id2 = route.id || createRouteId(route.file);
+    let manifestItem = {
+      id: id2,
+      parentId,
+      file: route.file,
+      path: route.path,
+      index: route.index,
+      caseSensitive: route.caseSensitive
+    };
+    if (routeManifest.hasOwnProperty(id2)) {
+      throw new Error(
+        `Unable to define routes with duplicate route id: "${id2}"`
+      );
+    }
+    routeManifest[id2] = manifestItem;
+    if (route.children) {
+      for (let child of route.children) {
+        walk(child, id2);
+      }
+    }
+  }
+  for (let route of routes) {
+    walk(route, rootId);
+  }
+  return routeManifest;
+}
+function createRouteId(file) {
+  return normalizeSlashes(stripFileExtension(file));
+}
+function normalizeSlashes(file) {
+  return file.split(import_node_path.win32.sep).join("/");
+}
+function stripFileExtension(file) {
+  return file.replace(/\.[a-z0-9]+$/i, "");
+}
+
+// vite/vite-node.ts
+var import_server = require("vite-node/server");
+var import_client = require("vite-node/client");
+var import_source_map = require("vite-node/source-map");
+
+// vite/import-vite-esm-sync.ts
+var vite;
+async function preloadViteEsm() {
+  vite = await import("vite");
+}
+function importViteEsmSync() {
+  invariant(vite, "importViteEsmSync() called before preloadViteEsm()");
+  return vite;
+}
+
+// vite/vite-node.ts
+async function createContext(viteConfig = {}) {
+  await preloadViteEsm();
+  const vite2 = importViteEsmSync();
+  const devServer = await vite2.createServer(
+    vite2.mergeConfig(
+      {
+        server: {
+          preTransformRequests: false,
+          hmr: false
+        },
+        optimizeDeps: {
+          noDiscovery: true
+        },
+        configFile: false,
+        envFile: false,
+        plugins: []
+      },
+      viteConfig
+    )
+  );
+  await devServer.pluginContainer.buildStart({});
+  const server = new import_server.ViteNodeServer(devServer);
+  (0, import_source_map.installSourcemapsSupport)({
+    getSourceMap: (source) => server.getSourceMap(source)
+  });
+  const runner = new import_client.ViteNodeRunner({
+    root: devServer.config.root,
+    base: devServer.config.base,
+    fetchModule(id2) {
+      return server.fetchModule(id2);
+    },
+    resolveId(id2, importer) {
+      return server.resolveId(id2, importer);
+    }
+  });
+  return { devServer, server, runner };
+}
+
+// vite/config.ts
+var import_node_child_process = require("child_process");
+var import_node_path2 = __toESM(require("path"));
+var import_fs_extra = __toESM(require("fs-extra"));
+var import_picocolors = __toESM(require("picocolors"));
+var import_pick2 = __toESM(require("lodash/pick"));
+var import_omit = __toESM(require("lodash/omit"));
+var import_package_json = __toESM(require("@npmcli/package-json"));
+var entryExts = [".js", ".jsx", ".ts", ".tsx"];
+function findEntry(dir, basename3) {
+  for (let ext of entryExts) {
+    let file = import_node_path2.default.resolve(dir, basename3 + ext);
+    if (import_fs_extra.default.existsSync(file)) return import_node_path2.default.relative(dir, file);
+  }
+  return void 0;
+}
+
+// vite/plugin.ts
+var import_node_crypto = require("crypto");
+var path4 = __toESM(require("path"));
+var url = __toESM(require("url"));
+var fse2 = __toESM(require("fs-extra"));
+var babel = __toESM(require("@babel/core"));
+var import_react_router2 = require("react-router");
+var import_es_module_lexer = require("es-module-lexer");
+var import_jsesc = __toESM(require("jsesc"));
+var import_picocolors2 = __toESM(require("picocolors"));
+
+// vite/babel.ts
+var import_parser = require("@babel/parser");
+var t = __toESM(require("@babel/types"));
+var traverse = require("@babel/traverse").default;
+var generate = require("@babel/generator").default;
+
+// vite/node-adapter.ts
+var import_node_events = require("events");
+var import_node_stream = require("stream");
+var import_set_cookie_parser = require("set-cookie-parser");
+var import_node = require("@react-router/node");
+
+// vite/styles.ts
+var path3 = __toESM(require("path"));
+var import_react_router = require("react-router");
+
+// vite/resolve-file-url.ts
+var path2 = __toESM(require("path"));
+
+// vite/styles.ts
+var cssFileRegExp = /\.(css|less|sass|scss|styl|stylus|pcss|postcss|sss)(?:$|\?)/;
+var cssModulesRegExp = new RegExp(`\\.module${cssFileRegExp.source}`);
+
+// vite/vmod.ts
+var id = (name) => `virtual:react-router/${name}`;
+
+// vite/remove-exports.ts
+var import_babel_dead_code_elimination = require("babel-dead-code-elimination");
+
+// vite/with-props.ts
+var import_dedent = __toESM(require("dedent"));
+var vmodId = id("with-props");
 
-var Path = require('pathe');
-var typegen = require('./typegen.js');
+// vite/plugin.ts
+async function resolveViteConfig({
+  configFile,
+  mode,
+  root
+}) {
+  let vite2 = await import("vite");
+  let viteConfig = await vite2.resolveConfig(
+    { mode, configFile, root },
+    "build",
+    // command
+    "production",
+    // default mode
+    "production"
+    // default NODE_ENV
+  );
+  if (typeof viteConfig.build.manifest === "string") {
+    throw new Error("Custom Vite manifest paths are not supported");
+  }
+  return viteConfig;
+}
+async function extractPluginContext(viteConfig) {
+  return viteConfig["__reactRouterPluginContext"];
+}
+async function loadPluginContext({
+  configFile,
+  root
+}) {
+  if (!root) {
+    root = process.env.REACT_ROUTER_ROOT || process.cwd();
+  }
+  configFile = configFile ?? findConfig(root, "vite.config", [
+    ".ts",
+    ".cts",
+    ".mts",
+    ".js",
+    ".cjs",
+    ".mjs"
+  ]);
+  if (!configFile) {
+    console.error(import_picocolors2.default.red("Vite config file not found"));
+    process.exit(1);
+  }
+  let viteConfig = await resolveViteConfig({ configFile, root });
+  let ctx = await extractPluginContext(viteConfig);
+  if (!ctx) {
+    console.error(
+      import_picocolors2.default.red("React Router Vite plugin not found in Vite config")
+    );
+    process.exit(1);
+  }
+  return ctx;
+}
+var serverBuildId = id("server-build");
+var serverManifestId = id("server-manifest");
+var browserManifestId = id("browser-manifest");
+var hmrRuntimeId = id("hmr-runtime");
+var injectHmrRuntimeId = id("inject-hmr-runtime");
+var defaultEntriesDir = path4.resolve(
+  path4.dirname(require.resolve("@react-router/dev/package.json")),
+  "dist",
+  "config",
+  "defaults"
+);
+var defaultEntries = fse2.readdirSync(defaultEntriesDir).map((filename2) => path4.join(defaultEntriesDir, filename2));
+invariant(defaultEntries.length > 0, "No default entries found");
+function findConfig(dir, basename3, extensions) {
+  for (let ext of extensions) {
+    let name = basename3 + ext;
+    let file = path4.join(dir, name);
+    if (fse2.existsSync(file)) return file;
+  }
+  return void 0;
+}
+var REACT_REFRESH_HEADER = `
+import RefreshRuntime from "${hmrRuntimeId}";
 
-function _interopNamespace(e) {
-    if (e && e.__esModule) return e;
-    var n = Object.create(null);
-    if (e) {
-        Object.keys(e).forEach(function (k) {
-            if (k !== 'default') {
-                var d = Object.getOwnPropertyDescriptor(e, k);
-                Object.defineProperty(n, k, d.get ? d : {
-                    enumerable: true,
-                    get: function () { return e[k]; }
-                });
-            }
-        });
+const inWebWorker = typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope;
+let prevRefreshReg;
+let prevRefreshSig;
+
+if (import.meta.hot && !inWebWorker) {
+  if (!window.__vite_plugin_react_preamble_installed__) {
+    throw new Error(
+      "React Router Vite plugin can't detect preamble. Something is wrong."
+    );
+  }
+
+  prevRefreshReg = window.$RefreshReg$;
+  prevRefreshSig = window.$RefreshSig$;
+  window.$RefreshReg$ = (type, id) => {
+    RefreshRuntime.register(type, __SOURCE__ + " " + id)
+  };
+  window.$RefreshSig$ = RefreshRuntime.createSignatureFunctionForTransform;
+}`.trim();
+var REACT_REFRESH_FOOTER = `
+if (import.meta.hot && !inWebWorker) {
+  window.$RefreshReg$ = prevRefreshReg;
+  window.$RefreshSig$ = prevRefreshSig;
+  RefreshRuntime.__hmr_import(import.meta.url).then((currentExports) => {
+    RefreshRuntime.registerExportsForReactRefresh(__SOURCE__, currentExports);
+    import.meta.hot.accept((nextExports) => {
+      if (!nextExports) return;
+      __ROUTE_ID__ && window.__reactRouterRouteModuleUpdates.set(__ROUTE_ID__, nextExports);
+      const invalidateMessage = RefreshRuntime.validateRefreshBoundaryAndEnqueueUpdate(currentExports, nextExports, __ACCEPT_EXPORTS__);
+      if (invalidateMessage) import.meta.hot.invalidate(invalidateMessage);
+    });
+  });
+}`.trim();
+
+// typescript/typegen.ts
+function getDirectory(ctx) {
+  return Path.join(ctx.rootDirectory, ".react-router/types");
+}
+function getPath(ctx, route) {
+  return Path.join(
+    getDirectory(ctx),
+    Path.basename(ctx.appDirectory),
+    Path.dirname(route.file),
+    "+types." + Pathe.filename(route.file) + ".d.ts"
+  );
+}
+async function watch(rootDirectory) {
+  const vitePluginCtx = await loadPluginContext({ root: rootDirectory });
+  const routesTsPath = Path.join(
+    vitePluginCtx.reactRouterConfig.appDirectory,
+    "routes.ts"
+  );
+  const routesViteNodeContext = await createContext({
+    root: rootDirectory
+  });
+  async function getRoutes() {
+    const routes = {};
+    const rootRouteFile = findEntry(
+      vitePluginCtx.reactRouterConfig.appDirectory,
+      "root"
+    );
+    if (rootRouteFile) {
+      routes.root = { path: "", id: "root", file: rootRouteFile };
     }
-    n["default"] = e;
-    return Object.freeze(n);
+    routesViteNodeContext.devServer.moduleGraph.invalidateAll();
+    routesViteNodeContext.runner.moduleCache.clear();
+    const routeConfig = (await routesViteNodeContext.runner.executeFile(routesTsPath)).routes;
+    return {
+      ...routes,
+      ...configRoutesToRouteManifest(await routeConfig)
+    };
+  }
+  const ctx = {
+    rootDirectory,
+    appDirectory: vitePluginCtx.reactRouterConfig.appDirectory,
+    routes: await getRoutes()
+  };
+  await writeAll(ctx);
+  const watcher = import_chokidar.default.watch(ctx.appDirectory, { ignoreInitial: true });
+  watcher.on("all", async (event, path5) => {
+    path5 = Path.normalize(path5);
+    ctx.routes = await getRoutes();
+    const routeConfigChanged = Boolean(
+      routesViteNodeContext.devServer.moduleGraph.getModuleById(path5)
+    );
+    if (routeConfigChanged) {
+      await writeAll(ctx);
+      return;
+    }
+    const isRoute = Object.values(ctx.routes).find(
+      (route) => path5 === Path.join(ctx.appDirectory, route.file)
+    );
+    if (isRoute && (event === "add" || event === "unlink")) {
+      await writeAll(ctx);
+      return;
+    }
+  });
+}
+async function writeAll(ctx) {
+  import_node_fs.default.rmSync(getDirectory(ctx), { recursive: true, force: true });
+  Object.values(ctx.routes).forEach((route) => {
+    if (!import_node_fs.default.existsSync(Path.join(ctx.appDirectory, route.file))) return;
+    const typesPath = getPath(ctx, route);
+    const content = getModule(ctx.routes, route);
+    import_node_fs.default.mkdirSync(Path.dirname(typesPath), { recursive: true });
+    import_node_fs.default.writeFileSync(typesPath, content);
+  });
 }
+function getModule(routes, route) {
+  return import_dedent2.default`
+    // React Router generated types for route:
+    // ${route.file}
+
+    import * as T from "react-router/types"
+
+    export type Params = {${formattedParamsProperties(routes, route)}}
 
-var Path__namespace = /*#__PURE__*/_interopNamespace(Path);
+    type Route = typeof import("./${Pathe.filename(route.file)}")
 
-// For compatibility with the TS language service plugin API, this entrypoint:
+    export type LoaderData = T.CreateLoaderData<Route>
+    export type ActionData = T.CreateActionData<Route>
+
+    export type LoaderArgs = T.CreateServerLoaderArgs<Params>
+    export type ClientLoaderArgs = T.CreateClientLoaderArgs<Params, Route>
+    export type ActionArgs = T.CreateServerActionArgs<Params>
+    export type ClientActionArgs = T.CreateClientActionArgs<Params, Route>
+
+    export type HydrateFallbackProps = T.CreateHydrateFallbackProps<Params>
+    export type ComponentProps = T.CreateComponentProps<Params, LoaderData, ActionData>
+    export type ErrorBoundaryProps = T.CreateErrorBoundaryProps<Params, LoaderData, ActionData>
+  `;
+}
+function formattedParamsProperties(routes, route) {
+  const urlpath = routeLineage(routes, route).map((route2) => route2.path).join("/");
+  const params = parseParams(urlpath);
+  const indent = "  ".repeat(3);
+  const properties = Object.entries(params).map(([name, values]) => {
+    if (values.length === 1) {
+      const isOptional = values[0];
+      return indent + (isOptional ? `${name}?: string` : `${name}: string`);
+    }
+    const items = values.map(
+      (isOptional) => isOptional ? "string | undefined" : "string"
+    );
+    return indent + `${name}: [${items.join(", ")}]`;
+  });
+  const body = properties.length === 0 ? "" : "\n" + properties.join("\n") + "\n";
+  return body;
+}
+function routeLineage(routes, route) {
+  const result = [];
+  while (route) {
+    result.push(route);
+    if (!route.parentId) break;
+    route = routes[route.parentId];
+  }
+  result.reverse();
+  return result;
+}
+function parseParams(urlpath) {
+  const result = {};
+  let segments = urlpath.split("/");
+  segments.filter((s) => s.startsWith(":")).forEach((param) => {
+    param = param.slice(1);
+    let isOptional = param.endsWith("?");
+    if (isOptional) {
+      param = param.slice(0, -1);
+    }
+    result[param] ??= [];
+    result[param].push(isOptional);
+    return;
+  });
+  return result;
+}
+
+// typescript/plugin.ts
 function init() {
   function create(info) {
-    const {
-      logger
-    } = info.project.projectService;
+    const { logger } = info.project.projectService;
     logger.info("[react-router] setup");
-    const rootDirectory = Path__namespace.normalize(info.project.getCurrentDirectory());
-    typegen.watch(rootDirectory);
+    const rootDirectory = Path2.normalize(info.project.getCurrentDirectory());
+    watch(rootDirectory);
     return info.languageService;
   }
-  return {
-    create
-  };
+  return { create };
 }
-
-module.exports = init;

package/dist/vite/cloudflare.d.ts

@@ -1 +1,23 @@
-export { cloudflareDevProxyVitePlugin as cloudflareDevProxy } from "./cloudflare-dev-proxy";
+import { AppLoadContext } from 'react-router';
+import { Plugin } from 'vite';
+import { 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>;
+/**
+ * Vite plugin that provides [Node proxies to local workerd
+ * bindings](https://developers.cloudflare.com/workers/wrangler/api/#getplatformproxy)
+ * to `context.cloudflare` in your server loaders and server actions during
+ * development.
+ */
+declare const cloudflareDevProxyVitePlugin: <Env, Cf extends CfProperties>(options?: {
+    getLoadContext?: GetLoadContext<Env, Cf>;
+} & GetPlatformProxyOptions) => Plugin;
+
+export { cloudflareDevProxyVitePlugin as cloudflareDevProxy };