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

package/dist/chunk-B3M3SF27.js

@@ -0,0 +1,219 @@
+/**
+ * @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 {
+  invariant
+} from "./chunk-XJYIKBPH.js";
+
+// config/routes.ts
+import * as Path from "pathe";
+import * as v from "valibot";
+import pick from "lodash/pick.js";
+function setAppDirectory(directory) {
+  globalThis.__reactRouterAppDirectory = directory;
+}
+function getAppDirectory() {
+  invariant(globalThis.__reactRouterAppDirectory);
+  return globalThis.__reactRouterAppDirectory;
+}
+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 validateRouteConfig({
+  routeConfigFile,
+  routeConfig
+}) {
+  if (!routeConfig) {
+    return {
+      valid: false,
+      message: `Route config must be the default export in "${routeConfigFile}".`
+    };
+  }
+  if (!Array.isArray(routeConfig)) {
+    return {
+      valid: false,
+      message: `Route config in "${routeConfigFile}" must be an array.`
+    };
+  }
+  let { issues } = v.safeParse(resolvedRouteConfigSchema, routeConfig);
+  if (issues?.length) {
+    let { root, nested } = v.flatten(issues);
+    return {
+      valid: false,
+      message: [
+        `Route config in "${routeConfigFile}" is invalid.`,
+        root ? `${root}` : [],
+        nested ? Object.entries(nested).map(
+          ([path, message]) => `Path: routes.${path}
+${message}`
+        ) : []
+      ].flat().join("\n\n")
+    };
+  }
+  return { valid: true };
+}
+var createConfigRouteOptionKeys = [
+  "id",
+  "index",
+  "caseSensitive"
+];
+function route(path, file, optionsOrChildren, children) {
+  let options = {};
+  if (Array.isArray(optionsOrChildren) || !optionsOrChildren) {
+    children = optionsOrChildren;
+  } else {
+    options = optionsOrChildren;
+  }
+  return {
+    file,
+    children,
+    path: path ?? void 0,
+    ...pick(options, createConfigRouteOptionKeys)
+  };
+}
+var createIndexOptionKeys = ["id"];
+function index(file, options) {
+  return {
+    file,
+    index: true,
+    ...pick(options, createIndexOptionKeys)
+  };
+}
+var createLayoutOptionKeys = ["id"];
+function layout(file, optionsOrChildren, children) {
+  let options = {};
+  if (Array.isArray(optionsOrChildren) || !optionsOrChildren) {
+    children = optionsOrChildren;
+  } else {
+    options = optionsOrChildren;
+  }
+  return {
+    file,
+    children,
+    ...pick(options, createLayoutOptionKeys)
+  };
+}
+function prefix(prefixPath, routes) {
+  return routes.map((route2) => {
+    if (route2.index || typeof route2.path === "string") {
+      return {
+        ...route2,
+        path: route2.path ? joinRoutePaths(prefixPath, route2.path) : prefixPath,
+        children: route2.children
+      };
+    } else if (route2.children) {
+      return {
+        ...route2,
+        children: prefix(prefixPath, route2.children)
+      };
+    }
+    return route2;
+  });
+}
+function relative2(directory) {
+  return {
+    /**
+     * Helper function for creating a route config entry, for use within
+     * `routes.ts`. Note that this helper has been scoped, meaning that file
+     * path will be resolved relative to the directory provided to the
+     * `relative` call that created this helper.
+     */
+    route: (path, file, ...rest) => {
+      return route(path, Path.resolve(directory, file), ...rest);
+    },
+    /**
+     * Helper function for creating a route config entry for an index route, for
+     * use within `routes.ts`. Note that this helper has been scoped, meaning
+     * that file path will be resolved relative to the directory provided to the
+     * `relative` call that created this helper.
+     */
+    index: (file, ...rest) => {
+      return index(Path.resolve(directory, file), ...rest);
+    },
+    /**
+     * Helper function for creating a route config entry for a layout route, for
+     * use within `routes.ts`. Note that this helper has been scoped, meaning
+     * that file path will be resolved relative to the directory provided to the
+     * `relative` call that created this helper.
+     */
+    layout: (file, ...rest) => {
+      return layout(Path.resolve(directory, file), ...rest);
+    },
+    // Passthrough of helper functions that don't need relative scoping so that
+    // a complete API is still provided.
+    prefix
+  };
+}
+function configRoutesToRouteManifest(appDirectory, routes, rootId = "root") {
+  let routeManifest = {};
+  function walk(route2, parentId) {
+    let id = route2.id || createRouteId(route2.file);
+    let manifestItem = {
+      id,
+      parentId,
+      file: Path.isAbsolute(route2.file) ? Path.relative(appDirectory, route2.file) : route2.file,
+      path: route2.path,
+      index: route2.index,
+      caseSensitive: route2.caseSensitive
+    };
+    if (routeManifest.hasOwnProperty(id)) {
+      throw new Error(
+        `Unable to define routes with duplicate route id: "${id}"`
+      );
+    }
+    routeManifest[id] = manifestItem;
+    if (route2.children) {
+      for (let child of route2.children) {
+        walk(child, id);
+      }
+    }
+  }
+  for (let route2 of routes) {
+    walk(route2, rootId);
+  }
+  return routeManifest;
+}
+function createRouteId(file) {
+  return Path.normalize(stripFileExtension(file));
+}
+function stripFileExtension(file) {
+  return file.replace(/\.[a-z0-9]+$/i, "");
+}
+function joinRoutePaths(path1, path2) {
+  return [
+    path1.replace(/\/+$/, ""),
+    // Remove trailing slashes
+    path2.replace(/^\/+/, "")
+    // Remove leading slashes
+  ].join("/");
+}
+
+export {
+  setAppDirectory,
+  getAppDirectory,
+  validateRouteConfig,
+  route,
+  index,
+  layout,
+  prefix,
+  relative2 as relative,
+  configRoutesToRouteManifest
+};

package/dist/chunk-HICCFFJA.js

@@ -0,0 +1,81 @@
+/**
+ * @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 {
+  invariant
+} from "./chunk-XJYIKBPH.js";
+
+// vite/node-adapter.ts
+import { once } from "node:events";
+import { Readable } from "node:stream";
+import { splitCookiesString } from "set-cookie-parser";
+import { createReadableStreamFromReadable } from "@react-router/node";
+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;
+}
+function fromNodeRequest(nodeReq, nodeRes) {
+  let origin = nodeReq.headers.origin && "null" !== nodeReq.headers.origin ? nodeReq.headers.origin : `http://${nodeReq.headers.host}`;
+  invariant(
+    nodeReq.originalUrl,
+    "Expected `nodeReq.originalUrl` to be defined"
+  );
+  let url = new URL(nodeReq.originalUrl, origin);
+  let controller = new AbortController();
+  let init = {
+    method: nodeReq.method,
+    headers: fromNodeHeaders(nodeReq.headers),
+    signal: controller.signal
+  };
+  nodeRes.on("finish", () => controller = null);
+  nodeRes.on("close", () => controller?.abort());
+  if (nodeReq.method !== "GET" && nodeReq.method !== "HEAD") {
+    init.body = createReadableStreamFromReadable(nodeReq);
+    init.duplex = "half";
+  }
+  return new Request(url.href, init);
+}
+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(...splitCookiesString(value));
+    } else nodeRes.setHeader(name, value);
+  }
+  if (cookiesStrings.length) {
+    nodeRes.setHeader("set-cookie", cookiesStrings);
+  }
+  if (res.body) {
+    let responseBody = res.body;
+    let readable = Readable.from(responseBody);
+    readable.pipe(nodeRes);
+    await once(readable, "end");
+  } else {
+    nodeRes.end();
+  }
+}
+
+export {
+  fromNodeRequest,
+  toNodeRequest
+};

package/dist/chunk-VTJ3CG32.js

@@ -0,0 +1,49 @@
+/**
+ * @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
+ */
+
+// vite/profiler.ts
+import fs from "node:fs";
+import path from "node:path";
+import colors from "picocolors";
+var getSession = () => global.__reactRouter_profile_session;
+var start = async (callback) => {
+  let inspector = await import("node:inspector").then((r) => r.default);
+  let session = global.__reactRouter_profile_session = new inspector.Session();
+  session.connect();
+  session.post("Profiler.enable", () => {
+    session.post("Profiler.start", callback);
+  });
+};
+var profileCount = 0;
+var stop = (log) => {
+  let session = getSession();
+  if (!session) return;
+  return new Promise((res, rej) => {
+    session.post("Profiler.stop", (err, { profile }) => {
+      if (err) return rej(err);
+      let outPath = path.resolve(`./react-router-${profileCount++}.cpuprofile`);
+      fs.writeFileSync(outPath, JSON.stringify(profile));
+      log(
+        colors.yellow(
+          `CPU profile written to ${colors.white(colors.dim(outPath))}`
+        )
+      );
+      global.__reactRouter_profile_session = void 0;
+      res();
+    });
+  });
+};
+
+export {
+  getSession,
+  start,
+  stop
+};

package/dist/chunk-X234P535.js

@@ -0,0 +1,57 @@
+/**
+ * @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 {
+  invariant
+} from "./chunk-XJYIKBPH.js";
+
+// vite/vite.ts
+import { createRequire as createRequire2 } from "node:module";
+import path2 from "pathe";
+
+// config/is-react-router-repo.ts
+import path from "pathe";
+import { createRequire } from "node:module";
+var require2 = createRequire(import.meta.url);
+function isReactRouterRepo() {
+  let serverRuntimePath = path.dirname(
+    require2.resolve("@react-router/node/package.json")
+  );
+  let serverRuntimeParentDir = path.basename(
+    path.resolve(serverRuntimePath, "..")
+  );
+  return serverRuntimeParentDir === "packages";
+}
+
+// vite/vite.ts
+var require3 = createRequire2(import.meta.url);
+var vite;
+var viteImportSpecifier = isReactRouterRepo() ? (
+  // Support testing against different versions of Vite by ensuring that Vite
+  // is resolved from the current working directory when running within this
+  // repo. If we don't do this, Vite will always be imported relative to this
+  // file, which means that it will always resolve to Vite 6.
+  `file:///${path2.normalize(
+    require3.resolve("vite/package.json", { paths: [process.cwd()] })
+  ).replace("package.json", "dist/node/index.js")}`
+) : "vite";
+async function preloadVite() {
+  vite = await import(viteImportSpecifier);
+}
+function getVite() {
+  invariant(vite, "getVite() called before preloadVite()");
+  return vite;
+}
+
+export {
+  isReactRouterRepo,
+  preloadVite,
+  getVite
+};

package/dist/chunk-XJYIKBPH.js

@@ -0,0 +1,31 @@
+/**
+ * @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
+ */
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// 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);
+  }
+}
+
+export {
+  __require,
+  invariant
+};