@react-router/dev 0.0.0-experimental-c0856287f

package/dist/vite/profiler.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="node" />
+import type { Session } from "node:inspector";
+export declare const getSession: () => Session | undefined;
+export declare const start: (callback?: () => void | Promise<void>) => Promise<void>;
+export declare const stop: (log: (message: string) => void) => void | Promise<void>;

package/dist/vite/profiler.js

@@ -0,0 +1,55 @@
+/**
+ * @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 fs = require('node:fs');
+var path = require('node:path');
+var colors = require('picocolors');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
+var path__default = /*#__PURE__*/_interopDefaultLegacy(path);
+var colors__default = /*#__PURE__*/_interopDefaultLegacy(colors);
+
+// Adapted from:
+const getSession = () => global.__reactRouter_profile_session;
+const 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);
+  });
+};
+let profileCount = 0;
+const 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__default["default"].resolve(`./react-router-${profileCount++}.cpuprofile`);
+      fs__default["default"].writeFileSync(outPath, JSON.stringify(profile));
+      log(colors__default["default"].yellow(`CPU profile written to ${colors__default["default"].white(colors__default["default"].dim(outPath))}`));
+      global.__reactRouter_profile_session = undefined;
+      res();
+    });
+  });
+};
+
+exports.getSession = getSession;
+exports.start = start;
+exports.stop = stop;

package/dist/vite/remove-exports-test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/vite/remove-exports.d.ts

@@ -0,0 +1,2 @@
+import type { GeneratorOptions } from "@babel/generator";
+export declare const removeExports: (source: string, exportsToRemove: string[], generateOptions?: GeneratorOptions) => import("@babel/generator").GeneratorResult;

package/dist/vite/remove-exports.js

@@ -0,0 +1,278 @@
+/**
+ * @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 babel = require('./babel.js');
+var parser = require('@babel/parser');
+var t = require('@babel/types');
+
+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]; }
+                });
+            }
+        });
+    }
+    n["default"] = e;
+    return Object.freeze(n);
+}
+
+var t__namespace = /*#__PURE__*/_interopNamespace(t);
+
+function getIdentifier(path) {
+  let parentPath = path.parentPath;
+  if (parentPath.type === "VariableDeclarator") {
+    let variablePath = parentPath;
+    let name = variablePath.get("id");
+    return name.node.type === "Identifier" ? name : null;
+  }
+  if (parentPath.type === "AssignmentExpression") {
+    let variablePath = parentPath;
+    let name = variablePath.get("left");
+    return name.node.type === "Identifier" ? name : null;
+  }
+  if (path.node.type === "ArrowFunctionExpression") {
+    return null;
+  }
+  return path.node.id && path.node.id.type === "Identifier" ? path.get("id") : null;
+}
+function isIdentifierReferenced(ident) {
+  let binding = ident.scope.getBinding(ident.node.name);
+  if (binding !== null && binding !== void 0 && binding.referenced) {
+    // Functions can reference themselves, so we need to check if there's a
+    // binding outside the function scope or not.
+    if (binding.path.type === "FunctionDeclaration") {
+      return !binding.constantViolations.concat(binding.referencePaths)
+      // Check that every reference is contained within the function:
+      .every(ref => ref.findParent(parent => parent === (binding === null || binding === void 0 ? void 0 : binding.path)));
+    }
+    return true;
+  }
+  return false;
+}
+const removeExports = (source, exportsToRemove, generateOptions = {}) => {
+  let document = parser.parse(source, {
+    sourceType: "module"
+  });
+  let referencedIdentifiers = new Set();
+  let removedExports = new Set();
+  let markImport = path => {
+    let local = path.get("local");
+    if (isIdentifierReferenced(local)) {
+      referencedIdentifiers.add(local);
+    }
+  };
+  let markFunction = path => {
+    let identifier = getIdentifier(path);
+    if (identifier !== null && identifier !== void 0 && identifier.node && isIdentifierReferenced(identifier)) {
+      referencedIdentifiers.add(identifier);
+    }
+  };
+  babel.traverse(document, {
+    VariableDeclarator(variablePath) {
+      if (variablePath.node.id.type === "Identifier") {
+        let local = variablePath.get("id");
+        if (isIdentifierReferenced(local)) {
+          referencedIdentifiers.add(local);
+        }
+      } else if (variablePath.node.id.type === "ObjectPattern") {
+        let pattern = variablePath.get("id");
+        let properties = pattern.get("properties");
+        properties.forEach(p => {
+          let local = p.get(p.node.type === "ObjectProperty" ? "value" : p.node.type === "RestElement" ? "argument" : function () {
+            throw new Error("invariant");
+          }());
+          if (isIdentifierReferenced(local)) {
+            referencedIdentifiers.add(local);
+          }
+        });
+      } else if (variablePath.node.id.type === "ArrayPattern") {
+        let pattern = variablePath.get("id");
+        let elements = pattern.get("elements");
+        elements.forEach(element => {
+          var _element$node, _element$node2;
+          let local;
+          if (((_element$node = element.node) === null || _element$node === void 0 ? void 0 : _element$node.type) === "Identifier") {
+            local = element;
+          } else if (((_element$node2 = element.node) === null || _element$node2 === void 0 ? void 0 : _element$node2.type) === "RestElement") {
+            local = element.get("argument");
+          } else {
+            return;
+          }
+          if (isIdentifierReferenced(local)) {
+            referencedIdentifiers.add(local);
+          }
+        });
+      }
+    },
+    FunctionDeclaration: markFunction,
+    FunctionExpression: markFunction,
+    ArrowFunctionExpression: markFunction,
+    ImportSpecifier: markImport,
+    ImportDefaultSpecifier: markImport,
+    ImportNamespaceSpecifier: markImport,
+    ExportNamedDeclaration(path) {
+      let shouldRemove = false;
+      // Handle re-exports: export { preload } from './foo'
+      path.node.specifiers = path.node.specifiers.filter(spec => {
+        if (spec.exported.type !== "Identifier") {
+          return true;
+        }
+        let {
+          name
+        } = spec.exported;
+        for (let namedExport of exportsToRemove) {
+          if (name === namedExport) {
+            removedExports.add(namedExport);
+            return false;
+          }
+        }
+        return true;
+      });
+      let {
+        declaration
+      } = path.node;
+      // When no re-exports are left, remove the path
+      if (!declaration && path.node.specifiers.length === 0) {
+        shouldRemove = true;
+      }
+      if (declaration && declaration.type === "VariableDeclaration") {
+        declaration.declarations = declaration.declarations.filter(declarator => {
+          for (let name of exportsToRemove) {
+            if (declarator.id.name === name) {
+              removedExports.add(name);
+              return false;
+            }
+          }
+          return true;
+        });
+        if (declaration.declarations.length === 0) {
+          shouldRemove = true;
+        }
+      }
+      if (declaration && declaration.type === "FunctionDeclaration") {
+        for (let name of exportsToRemove) {
+          var _declaration$id;
+          if (((_declaration$id = declaration.id) === null || _declaration$id === void 0 ? void 0 : _declaration$id.name) === name) {
+            shouldRemove = true;
+            removedExports.add(name);
+          }
+        }
+      }
+      if (shouldRemove) {
+        path.remove();
+      }
+    }
+  });
+  if (removedExports.size === 0) {
+    // No server-specific exports found so there's
+    // no need to remove unused references
+    return babel.generate(document, generateOptions);
+  }
+  let referencesRemovedInThisPass;
+  let sweepFunction = path => {
+    let identifier = getIdentifier(path);
+    if (identifier !== null && identifier !== void 0 && identifier.node && referencedIdentifiers.has(identifier) && !isIdentifierReferenced(identifier)) {
+      ++referencesRemovedInThisPass;
+      if (t__namespace.isAssignmentExpression(path.parentPath.node) || t__namespace.isVariableDeclarator(path.parentPath.node)) {
+        path.parentPath.remove();
+      } else {
+        path.remove();
+      }
+    }
+  };
+  let sweepImport = path => {
+    let local = path.get("local");
+    if (referencedIdentifiers.has(local) && !isIdentifierReferenced(local)) {
+      ++referencesRemovedInThisPass;
+      path.remove();
+      if (path.parent.specifiers.length === 0) {
+        path.parentPath.remove();
+      }
+    }
+  };
+  // Traverse again to remove unused references. This happens at least once,
+  // then repeats until no more references are removed.
+  do {
+    referencesRemovedInThisPass = 0;
+    babel.traverse(document, {
+      Program(path) {
+        path.scope.crawl();
+      },
+      // eslint-disable-next-line no-loop-func
+      VariableDeclarator(variablePath) {
+        if (variablePath.node.id.type === "Identifier") {
+          let local = variablePath.get("id");
+          if (referencedIdentifiers.has(local) && !isIdentifierReferenced(local)) {
+            ++referencesRemovedInThisPass;
+            variablePath.remove();
+          }
+        } else if (variablePath.node.id.type === "ObjectPattern") {
+          let pattern = variablePath.get("id");
+          let beforeCount = referencesRemovedInThisPass;
+          let properties = pattern.get("properties");
+          properties.forEach(property => {
+            let local = property.get(property.node.type === "ObjectProperty" ? "value" : property.node.type === "RestElement" ? "argument" : function () {
+              throw new Error("invariant");
+            }());
+            if (referencedIdentifiers.has(local) && !isIdentifierReferenced(local)) {
+              ++referencesRemovedInThisPass;
+              property.remove();
+            }
+          });
+          if (beforeCount !== referencesRemovedInThisPass && pattern.get("properties").length < 1) {
+            variablePath.remove();
+          }
+        } else if (variablePath.node.id.type === "ArrayPattern") {
+          let pattern = variablePath.get("id");
+          let beforeCount = referencesRemovedInThisPass;
+          let elements = pattern.get("elements");
+          elements.forEach(e => {
+            var _e$node, _e$node2;
+            let local;
+            if (((_e$node = e.node) === null || _e$node === void 0 ? void 0 : _e$node.type) === "Identifier") {
+              local = e;
+            } else if (((_e$node2 = e.node) === null || _e$node2 === void 0 ? void 0 : _e$node2.type) === "RestElement") {
+              local = e.get("argument");
+            } else {
+              return;
+            }
+            if (referencedIdentifiers.has(local) && !isIdentifierReferenced(local)) {
+              ++referencesRemovedInThisPass;
+              e.remove();
+            }
+          });
+          if (beforeCount !== referencesRemovedInThisPass && pattern.get("elements").length < 1) {
+            variablePath.remove();
+          }
+        }
+      },
+      FunctionDeclaration: sweepFunction,
+      FunctionExpression: sweepFunction,
+      ArrowFunctionExpression: sweepFunction,
+      ImportSpecifier: sweepImport,
+      ImportDefaultSpecifier: sweepImport,
+      ImportNamespaceSpecifier: sweepImport
+    });
+  } while (referencesRemovedInThisPass);
+  return babel.generate(document, generateOptions);
+};
+
+exports.removeExports = removeExports;

package/dist/vite/resolve-file-url.d.ts

@@ -0,0 +1,3 @@
+export declare const resolveFileUrl: ({ rootDirectory }: {
+    rootDirectory: string;
+}, filePath: string) => string;

package/dist/vite/resolve-file-url.js

@@ -0,0 +1,53 @@
+/**
+ * @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 importViteEsmSync = require('./import-vite-esm-sync.js');
+
+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]; }
+                });
+            }
+        });
+    }
+    n["default"] = e;
+    return Object.freeze(n);
+}
+
+var path__namespace = /*#__PURE__*/_interopNamespace(path);
+
+const resolveFileUrl = ({
+  rootDirectory
+}, filePath) => {
+  let vite = importViteEsmSync.importViteEsmSync();
+  let relativePath = path__namespace.relative(rootDirectory, filePath);
+  let isWithinRoot = !relativePath.startsWith("..") && !path__namespace.isAbsolute(relativePath);
+  if (!isWithinRoot) {
+    // Vite will prevent serving files outside of the workspace
+    // unless user explictly opts in with `server.fs.allow`
+    // https://vitejs.dev/config/server-options.html#server-fs-allow
+    return path__namespace.posix.join("/@fs", vite.normalizePath(filePath));
+  }
+  return "/" + vite.normalizePath(relativePath);
+};
+
+exports.resolveFileUrl = resolveFileUrl;

package/dist/vite/static/refresh-utils.cjs

@@ -0,0 +1,185 @@
+// 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(__remixManifest));
+
+    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.__remixRouteModules[route.id]?.default ?? imported.default
+          : imported.default,
+        ErrorBoundary: imported.ErrorBoundary
+          ? window.__remixRouteModules[route.id]?.ErrorBoundary ??
+            imported.ErrorBoundary
+          : imported.ErrorBoundary,
+        HydrateFallback: imported.HydrateFallback
+          ? window.__remixRouteModules[route.id]?.HydrateFallback ??
+            imported.HydrateFallback
+          : imported.HydrateFallback,
+      };
+      window.__remixRouteModules[route.id] = routeModule;
+    }
+
+    let needsRevalidation = new Set(
+      Array.from(routeUpdates.values())
+        .filter((route) => route.hasLoader || route.hasClientLoader)
+        .map((route) => route.id)
+    );
+
+    let routes = __remixRouter.createRoutesForHMR(
+      needsRevalidation,
+      manifest.routes,
+      window.__remixRouteModules,
+      window.__remixContext.future,
+      window.__remixContext.isSpaMode
+    );
+    __remixRouter._internalSetRoutes(routes);
+    routeUpdates.clear();
+    window.__reactRouterRouteModuleUpdates.clear();
+  }
+
+  await revalidate();
+  if (manifest) {
+    Object.assign(window.__remixManifest, 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();
+
+async function revalidate() {
+  let { promise, resolve } = channel();
+  let unsub = __remixRouter.subscribe((state) => {
+    if (state.revalidation === "idle") {
+      unsub();
+      // Ensure RouterProvider setState has flushed before re-rendering
+      resolve();
+    }
+  });
+  window.__remixRevalidation = (window.__remixRevalidation || 0) + 1;
+  __remixRouter.revalidate();
+  return promise;
+}
+
+function channel() {
+  let resolve;
+  let reject;
+
+  let promise = new Promise((_resolve, _reject) => {
+    resolve = _resolve;
+    reject = _reject;
+  });
+  return { promise, resolve, reject };
+}
+
+import.meta.hot.on("react-router:hmr", async ({ route }) => {
+  window.__remixClearCriticalCss();
+
+  if (route) {
+    routeUpdates.set(route.id, route);
+  }
+});
+
+exports.__hmr_import = __hmr_import;
+exports.registerExportsForReactRefresh = registerExportsForReactRefresh;
+exports.validateRefreshBoundaryAndEnqueueUpdate =
+  validateRefreshBoundaryAndEnqueueUpdate;
+exports.enqueueUpdate = enqueueUpdate;

package/dist/vite/styles.d.ts

@@ -0,0 +1,13 @@
+import type { ServerBuild } from "@react-router/server-runtime";
+import type { ViteDevServer } from "vite";
+import type { RemixConfig as ResolvedRemixConfig } from "../config";
+export declare const isCssModulesFile: (file: string) => boolean;
+export declare const getStylesForUrl: ({ viteDevServer, rootDirectory, reactRouterConfig, entryClientFilePath, cssModulesManifest, build, url, }: {
+    viteDevServer: ViteDevServer;
+    rootDirectory: string;
+    reactRouterConfig: Pick<ResolvedRemixConfig, "appDirectory" | "routes">;
+    entryClientFilePath: string;
+    cssModulesManifest: Record<string, string>;
+    build: ServerBuild;
+    url: string | undefined;
+}) => Promise<string | undefined>;