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

package/dist/routes-CZR-bKRt.d.ts

@@ -0,0 +1,123 @@
+import * as v from 'valibot';
+
+declare global {
+    var __reactRouterAppDirectory: string;
+}
+/**
+ * Provides the absolute path to the app directory, for use within `routes.ts`.
+ * This is designed to support resolving file system routes.
+ */
+declare function getAppDirectory(): string;
+interface RouteManifestEntry {
+    /**
+     * The path this route uses to match on the URL pathname.
+     */
+    path?: string;
+    /**
+     * Should be `true` if it is an index route. This disallows child routes.
+     */
+    index?: boolean;
+    /**
+     * Should be `true` if the `path` is case-sensitive. Defaults to `false`.
+     */
+    caseSensitive?: boolean;
+    /**
+     * The unique id for this route, named like its `file` but without the
+     * extension. So `app/routes/gists/$username.tsx` will have an `id` of
+     * `routes/gists/$username`.
+     */
+    id: string;
+    /**
+     * The unique `id` for this route's parent route, if there is one.
+     */
+    parentId?: string;
+    /**
+     * The path to the entry point for this route, relative to
+     * `config.appDirectory`.
+     */
+    file: string;
+}
+interface RouteManifest {
+    [routeId: string]: RouteManifestEntry;
+}
+/**
+ * Configuration for an individual route, for use within `routes.ts`. As a
+ * convenience, route config entries can be created with the {@link route},
+ * {@link index} and {@link layout} helper functions.
+ */
+interface RouteConfigEntry {
+    /**
+     * The unique id for this route.
+     */
+    id?: string;
+    /**
+     * The path this route uses to match on the URL pathname.
+     */
+    path?: string;
+    /**
+     * Should be `true` if it is an index route. This disallows child routes.
+     */
+    index?: boolean;
+    /**
+     * Should be `true` if the `path` is case-sensitive. Defaults to `false`.
+     */
+    caseSensitive?: boolean;
+    /**
+     * The path to the entry point for this route, relative to
+     * `config.appDirectory`.
+     */
+    file: string;
+    /**
+     * The child routes.
+     */
+    children?: RouteConfigEntry[];
+}
+declare const resolvedRouteConfigSchema: v.ArraySchema<v.BaseSchema<RouteConfigEntry, any, v.BaseIssue<unknown>>, undefined>;
+type ResolvedRouteConfig = v.InferInput<typeof resolvedRouteConfigSchema>;
+/**
+ * Route config to be exported via the default export from `app/routes.ts`.
+ */
+type RouteConfig = ResolvedRouteConfig | Promise<ResolvedRouteConfig>;
+declare const createConfigRouteOptionKeys: ["id", "index", "caseSensitive"];
+type CreateRouteOptions = Pick<RouteConfigEntry, (typeof createConfigRouteOptionKeys)[number]>;
+/**
+ * Helper function for creating a route config entry, for use within
+ * `routes.ts`.
+ */
+declare function route(path: string | null | undefined, file: string, children?: RouteConfigEntry[]): RouteConfigEntry;
+declare function route(path: string | null | undefined, file: string, options: CreateRouteOptions, children?: RouteConfigEntry[]): RouteConfigEntry;
+declare const createIndexOptionKeys: ["id"];
+type CreateIndexOptions = Pick<RouteConfigEntry, (typeof createIndexOptionKeys)[number]>;
+/**
+ * Helper function for creating a route config entry for an index route, for use
+ * within `routes.ts`.
+ */
+declare function index(file: string, options?: CreateIndexOptions): RouteConfigEntry;
+declare const createLayoutOptionKeys: ["id"];
+type CreateLayoutOptions = Pick<RouteConfigEntry, (typeof createLayoutOptionKeys)[number]>;
+/**
+ * Helper function for creating a route config entry for a layout route, for use
+ * within `routes.ts`.
+ */
+declare function layout(file: string, children?: RouteConfigEntry[]): RouteConfigEntry;
+declare function layout(file: string, options: CreateLayoutOptions, children?: RouteConfigEntry[]): RouteConfigEntry;
+/**
+ * Helper function for adding a path prefix to a set of routes without needing
+ * to introduce a parent route file, for use within `routes.ts`.
+ */
+declare function prefix(prefixPath: string, routes: RouteConfigEntry[]): RouteConfigEntry[];
+declare const helpers: {
+    route: typeof route;
+    index: typeof index;
+    layout: typeof layout;
+    prefix: typeof prefix;
+};
+
+/**
+ * Creates a set of route config helpers that resolve file paths relative to the
+ * given directory, for use within `routes.ts`. This is designed to support
+ * splitting route config into multiple files within different directories.
+ */
+declare function relative(directory: string): typeof helpers;
+
+export { type RouteManifest as R, type RouteManifestEntry as a, type RouteConfigEntry as b, type RouteConfig as c, relative as d, getAppDirectory as g, index as i, layout as l, prefix as p, route as r };

package/dist/routes.d.ts

@@ -0,0 +1,2 @@
+export { c as RouteConfig, b as RouteConfigEntry, g as getAppDirectory, i as index, l as layout, p as prefix, d as relative, r as route } from './routes-CZR-bKRt.js';
+import 'valibot';

package/dist/routes.js

@@ -0,0 +1,199 @@
+/**
+ * @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 __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);
+
+// routes.ts
+var routes_exports = {};
+__export(routes_exports, {
+  getAppDirectory: () => getAppDirectory,
+  index: () => index,
+  layout: () => layout,
+  prefix: () => prefix,
+  relative: () => relative2,
+  route: () => route
+});
+module.exports = __toCommonJS(routes_exports);
+
+// config/routes.ts
+var Path = __toESM(require("pathe"));
+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
+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.pipe(
+        v.string(),
+        v.notValue("root", "A route cannot use the reserved id 'root'.")
+      )
+    ),
+    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);
+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,
+    ...(0, import_pick.default)(options, createConfigRouteOptionKeys)
+  };
+}
+var createIndexOptionKeys = ["id"];
+function index(file, options) {
+  return {
+    file,
+    index: true,
+    ...(0, import_pick.default)(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,
+    ...(0, import_pick.default)(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 joinRoutePaths(path1, path2) {
+  return [
+    path1.replace(/\/+$/, ""),
+    // Remove trailing slashes
+    path2.replace(/^\/+/, "")
+    // Remove leading slashes
+  ].join("/");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getAppDirectory,
+  index,
+  layout,
+  prefix,
+  relative,
+  route
+});

package/dist/static/refresh-utils.mjs

@@ -0,0 +1,170 @@
+// adapted from https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react/src/refreshUtils.js
+// This file gets injected into the browser as a part of the HMR runtime
+
+function debounce(fn, delay) {
+  let handle;
+  return () => {
+    clearTimeout(handle);
+    handle = setTimeout(fn, delay);
+  };
+}
+
+/* eslint-disable no-undef */
+const enqueueUpdate = debounce(async () => {
+  let manifest;
+  if (routeUpdates.size > 0) {
+    manifest = JSON.parse(JSON.stringify(__reactRouterManifest));
+
+    for (let route of routeUpdates.values()) {
+      manifest.routes[route.id] = route;
+      let imported = window.__reactRouterRouteModuleUpdates.get(route.id);
+      if (!imported) {
+        throw Error(
+          `[react-router:hmr] No module update found for route ${route.id}`,
+        );
+      }
+      let routeModule = {
+        ...imported,
+        // react-refresh takes care of updating these in-place,
+        // if we don't preserve existing values we'll loose state.
+        default: imported.default
+          ? (window.__reactRouterRouteModules[route.id]?.default ??
+            imported.default)
+          : imported.default,
+        ErrorBoundary: imported.ErrorBoundary
+          ? (window.__reactRouterRouteModules[route.id]?.ErrorBoundary ??
+            imported.ErrorBoundary)
+          : imported.ErrorBoundary,
+        HydrateFallback: imported.HydrateFallback
+          ? (window.__reactRouterRouteModules[route.id]?.HydrateFallback ??
+            imported.HydrateFallback)
+          : imported.HydrateFallback,
+      };
+      window.__reactRouterRouteModules[route.id] = routeModule;
+    }
+
+    let needsRevalidation = new Set(
+      Array.from(routeUpdates.values())
+        .filter(
+          (route) =>
+            route.hasLoader ||
+            route.hasClientLoader ||
+            route.hasClientMiddleware,
+        )
+        .map((route) => route.id),
+    );
+
+    let routes = __reactRouterDataRouter.createRoutesForHMR(
+      needsRevalidation,
+      manifest.routes,
+      window.__reactRouterRouteModules,
+      window.__reactRouterContext.ssr,
+      window.__reactRouterContext.isSpaMode,
+    );
+    __reactRouterDataRouter._internalSetRoutes(routes);
+    routeUpdates.clear();
+    window.__reactRouterRouteModuleUpdates.clear();
+  }
+
+  try {
+    window.__reactRouterHdrActive = true;
+    await __reactRouterDataRouter.revalidate();
+  } finally {
+    window.__reactRouterHdrActive = false;
+  }
+
+  if (manifest) {
+    Object.assign(window.__reactRouterManifest, manifest);
+  }
+  exports.performReactRefresh();
+}, 16);
+
+// Taken from https://github.com/pmmmwh/react-refresh-webpack-plugin/blob/main/lib/runtime/RefreshUtils.js#L141
+// This allows to resister components not detected by SWC like styled component
+function registerExportsForReactRefresh(filename, moduleExports) {
+  for (let key in moduleExports) {
+    if (key === "__esModule") continue;
+    let exportValue = moduleExports[key];
+    if (exports.isLikelyComponentType(exportValue)) {
+      // 'export' is required to avoid key collision when renamed exports that
+      // shadow a local component name: https://github.com/vitejs/vite-plugin-react/issues/116
+      // The register function has an identity check to not register twice the same component,
+      // so this is safe to not used the same key here.
+      exports.register(exportValue, filename + " export " + key);
+    }
+  }
+}
+
+function validateRefreshBoundaryAndEnqueueUpdate(
+  prevExports,
+  nextExports,
+  // non-component exports that are handled by the framework (e.g. `meta` and `links` for route modules)
+  acceptExports = [],
+) {
+  if (
+    !predicateOnExport(
+      prevExports,
+      (key) => key in nextExports || acceptExports.includes(key),
+    )
+  ) {
+    return "Could not Fast Refresh (export removed)";
+  }
+  if (
+    !predicateOnExport(
+      nextExports,
+      (key) => key in prevExports || acceptExports.includes(key),
+    )
+  ) {
+    return "Could not Fast Refresh (new export)";
+  }
+
+  let hasExports = false;
+  let allExportsAreHandledOrUnchanged = predicateOnExport(
+    nextExports,
+    (key, value) => {
+      hasExports = true;
+      // Remix can handle Remix-specific exports (e.g. `meta` and `links`)
+      if (acceptExports.includes(key)) return true;
+      // React Fast Refresh can handle component exports
+      if (exports.isLikelyComponentType(value)) return true;
+      // Unchanged exports are implicitly handled
+      return prevExports[key] === nextExports[key];
+    },
+  );
+  if (hasExports && allExportsAreHandledOrUnchanged) {
+    enqueueUpdate();
+  } else {
+    return "Could not Fast Refresh. Learn more at https://github.com/vitejs/vite-plugin-react/tree/main/packages/plugin-react#consistent-components-exports";
+  }
+}
+
+function predicateOnExport(moduleExports, predicate) {
+  for (let key in moduleExports) {
+    if (key === "__esModule") continue;
+    let desc = Object.getOwnPropertyDescriptor(moduleExports, key);
+    if (desc && desc.get) return false;
+    if (!predicate(key, moduleExports[key])) return false;
+  }
+  return true;
+}
+
+// Hides vite-ignored dynamic import so that Vite can skip analysis if no other
+// dynamic import is present (https://github.com/vitejs/vite/pull/12732)
+function __hmr_import(module) {
+  return import(/* @vite-ignore */ module);
+}
+
+const routeUpdates = new Map();
+window.__reactRouterRouteModuleUpdates = new Map();
+
+import.meta.hot.on("react-router:hmr", async ({ route }) => {
+  if (route) {
+    routeUpdates.set(route.id, route);
+  }
+});
+
+exports.__hmr_import = __hmr_import;
+exports.registerExportsForReactRefresh = registerExportsForReactRefresh;
+exports.validateRefreshBoundaryAndEnqueueUpdate =
+  validateRefreshBoundaryAndEnqueueUpdate;
+exports.enqueueUpdate = enqueueUpdate;

package/dist/static/rsc-refresh-utils.mjs

@@ -0,0 +1,126 @@
+// adapted from https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react/src/refreshUtils.js
+// This file gets injected into the browser as a part of the HMR runtime
+
+function debounce(fn, delay) {
+  let handle;
+  return () => {
+    clearTimeout(handle);
+    handle = setTimeout(fn, delay);
+  };
+}
+
+/* eslint-disable no-undef */
+const enqueueUpdate = debounce(async () => {
+  if (routeUpdates.size > 0) {
+    const routeUpdateByRouteId = new Map();
+    for (const routeUpdate of routeUpdates) {
+      const routeId = routeUpdate.routeId;
+      const routeModule = window.__reactRouterRouteModuleUpdates.get(routeId);
+      if (routeModule) {
+        routeUpdateByRouteId.set(routeId, { routeModule, ...routeUpdate });
+      }
+    }
+    routeUpdates.clear();
+    __reactRouterDataRouter._updateRoutesForHMR(routeUpdateByRouteId);
+  }
+
+  try {
+    window.__reactRouterHdrActive = true;
+    await __reactRouterDataRouter.revalidate();
+  } finally {
+    window.__reactRouterHdrActive = false;
+  }
+
+  exports.performReactRefresh();
+}, 16);
+
+// Taken from https://github.com/pmmmwh/react-refresh-webpack-plugin/blob/main/lib/runtime/RefreshUtils.js#L141
+// This allows to resister components not detected by SWC like styled component
+function registerExportsForReactRefresh(filename, moduleExports) {
+  for (const key in moduleExports) {
+    if (key === "__esModule") continue;
+    const exportValue = moduleExports[key];
+    if (exports.isLikelyComponentType(exportValue)) {
+      // 'export' is required to avoid key collision when renamed exports that
+      // shadow a local component name: https://github.com/vitejs/vite-plugin-react/issues/116
+      // The register function has an identity check to not register twice the same component,
+      // so this is safe to not used the same key here.
+      exports.register(exportValue, filename + " export " + key);
+    }
+  }
+}
+
+function validateRefreshBoundaryAndEnqueueUpdate(
+  prevExports,
+  nextExports,
+  // non-component exports that are handled by the framework (e.g. `meta` and `links` for route modules)
+  acceptExports = [],
+) {
+  if (
+    !predicateOnExport(
+      prevExports,
+      (key) => key in nextExports || acceptExports.includes(key),
+    )
+  ) {
+    return "Could not Fast Refresh (export removed)";
+  }
+  if (
+    !predicateOnExport(
+      nextExports,
+      (key) => key in prevExports || acceptExports.includes(key),
+    )
+  ) {
+    return "Could not Fast Refresh (new export)";
+  }
+
+  let hasExports = false;
+  const allExportsAreHandledOrUnchanged = predicateOnExport(
+    nextExports,
+    (key, value) => {
+      hasExports = true;
+      // React Router can handle additional exports (e.g. `meta` and `links`)
+      if (acceptExports.includes(key)) return true;
+      // React Fast Refresh can handle component exports
+      if (exports.isLikelyComponentType(value)) return true;
+      // Unchanged exports are implicitly handled
+      return prevExports[key] === nextExports[key];
+    },
+  );
+  if (hasExports && allExportsAreHandledOrUnchanged) {
+    enqueueUpdate();
+  } else {
+    return "Could not Fast Refresh. Learn more at https://github.com/vitejs/vite-plugin-react/tree/main/packages/plugin-react#consistent-components-exports";
+  }
+}
+
+function predicateOnExport(moduleExports, predicate) {
+  for (const key in moduleExports) {
+    if (key === "__esModule") continue;
+    const desc = Object.getOwnPropertyDescriptor(moduleExports, key);
+    if (desc && desc.get) return false;
+    if (!predicate(key, moduleExports[key])) return false;
+  }
+  return true;
+}
+
+// Hides vite-ignored dynamic import so that Vite can skip analysis if no other
+// dynamic import is present (https://github.com/vitejs/vite/pull/12732)
+function __hmr_import(module) {
+  return import(/* @vite-ignore */ module);
+}
+
+const routeUpdates = new Set();
+window.__reactRouterRouteModuleUpdates = new Map();
+
+import.meta.hot.on("react-router:hmr", async (routeUpdate) => {
+  routeUpdates.add(routeUpdate);
+  if (routeUpdate.isServerOnlyChange) {
+    enqueueUpdate();
+  }
+});
+
+exports.__hmr_import = __hmr_import;
+exports.registerExportsForReactRefresh = registerExportsForReactRefresh;
+exports.validateRefreshBoundaryAndEnqueueUpdate =
+  validateRefreshBoundaryAndEnqueueUpdate;
+exports.enqueueUpdate = enqueueUpdate;

package/dist/vite/cloudflare.d.ts

@@ -0,0 +1,24 @@
+import { UNSAFE_MiddlewareEnabled, RouterContextProvider, AppLoadContext } from 'react-router';
+import { Plugin } from 'vite';
+import { PlatformProxy, GetPlatformProxyOptions } from 'wrangler';
+
+type MaybePromise<T> = T | Promise<T>;
+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>;
+}) => UNSAFE_MiddlewareEnabled extends true ? MaybePromise<RouterContextProvider> : MaybePromise<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 };