one 1.25.5 → 1.25.7

package/dist/cjs/vite/plugins/fileSystemRouterPlugin.native.js

@@ -0,0 +1,884 @@
+"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);
+var fileSystemRouterPlugin_exports = {};
+__export(fileSystemRouterPlugin_exports, {
+  createFileSystemRouterPlugin: () => createFileSystemRouterPlugin
+});
+module.exports = __toCommonJS(fileSystemRouterPlugin_exports);
+var import_path = __toESM(require("path"), 1);
+var import_stream = require("stream");
+var import_tls = require("tls");
+var import_perfect_debounce = require("perfect-debounce");
+var import_picocolors = __toESM(require("picocolors"), 1);
+var import_vite = require("vite");
+var import_constants = require("../../constants.native.js");
+var import_createHandleRequest = require("../../createHandleRequest.native.js");
+var import_getPageExport = require("../../utils/getPageExport.native.js");
+var import_getRouterRootFromOneOptions = require("../../utils/getRouterRootFromOneOptions.native.js");
+var import_isResponse = require("../../utils/isResponse.native.js");
+var import_isStatus = require("../../utils/isStatus.native.js");
+var import_promiseWithResolvers = require("../../utils/promiseWithResolvers.native.js");
+var import_routeFileWatch = require("../../utils/routeFileWatch.native.js");
+var import_trackLoaderDependencies = require("../../utils/trackLoaderDependencies.native.js");
+var import_replaceLoader = require("../../vite/replaceLoader.native.js");
+var import_one_server_only = require("../one-server-only.native.js");
+var import_virtualEntryConstants = require("./virtualEntryConstants.native.js");
+function _instanceof(left, right) {
+  if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+    return !!right[Symbol.hasInstance](left);
+  } else {
+    return left instanceof right;
+  }
+}
+function _type_of(obj) {
+  "@swc/helpers - typeof";
+
+  return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function staticParamMatches(staticValue, urlValue) {
+  var norm = function (v) {
+    return Array.isArray(v) ? v.join("/") : String(v !== null && v !== void 0 ? v : "");
+  };
+  return norm(staticValue) === norm(urlValue);
+}
+var debugRouter = process.env.ONE_DEBUG_ROUTER;
+var debugLoaderDeps = process.env.ONE_DEBUG_LOADER_DEPS;
+var routeTypeColors = {
+  ssg: import_picocolors.default.green,
+  ssr: import_picocolors.default.blue,
+  spa: import_picocolors.default.yellow,
+  api: import_picocolors.default.magenta
+};
+var USE_SERVER_ENV = false;
+//!!process.env.USE_SERVER_ENV
+function createFileSystemRouterPlugin(options, routeIndex) {
+  var preloads = ["/@vite/client", import_virtualEntryConstants.virtalEntryIdClient];
+  var runner;
+  var server;
+  var needsRouteRefresh = false;
+  var loaderFileDependencies = /* @__PURE__ */new Map();
+  var LOADER_DEPS_MAX = 2e3;
+  function setBoundedLoaderDep(filePath, routePath) {
+    var deps = loaderFileDependencies.get(filePath);
+    if (!deps) {
+      if (loaderFileDependencies.size >= LOADER_DEPS_MAX) {
+        var firstKey = loaderFileDependencies.keys().next().value;
+        if (firstKey !== void 0) {
+          loaderFileDependencies.delete(firstKey);
+        }
+      }
+      deps = /* @__PURE__ */new Set();
+      loaderFileDependencies.set(filePath, deps);
+      server === null || server === void 0 ? void 0 : server.watcher.add(filePath);
+    }
+    deps.add(routePath);
+  }
+  var handleRequest = createRequestHandler();
+  var renderPromise = null;
+  var ssgHtmlCache = /* @__PURE__ */new Map();
+  function getSsgHtmlCacheKey(route2, url2) {
+    return `${route2.file}
+${url2.pathname}
+${url2.search}`;
+  }
+  function createRequestHandler() {
+    var _options_router;
+    var routerRoot = (0, import_getRouterRootFromOneOptions.getRouterRootFromOneOptions)(options);
+    async function findNearestNotFoundPath(routeFile2) {
+      var routeDir2 = routeFile2.replace(/\/[^/]+$/, "");
+      var searchDir2 = routeDir2;
+      while (true) {
+        for (var _i2 = 0, _iter2 = [".tsx", ".ts", ".jsx", ".js"]; _i2 < _iter2.length; _i2++) {
+          var ext2 = _iter2[_i2];
+          var candidate2 = import_path.default.join(routerRoot, searchDir2, `+not-found${ext2}`);
+          try {
+            var mod = await runner.import(candidate2);
+            if (mod === null || mod === void 0 ? void 0 : mod.default) {
+              return searchDir2 ? `/${searchDir2}/+not-found` : "/+not-found";
+            }
+          } catch (unused) {}
+        }
+        if (!searchDir2) break;
+        var parent2 = searchDir2.replace(/\/[^/]+$/, "");
+        if (parent2 === searchDir2) {
+          searchDir2 = "";
+        } else {
+          searchDir2 = parent2;
+        }
+      }
+      return "/+not-found";
+    }
+    return (0, import_createHandleRequest.createHandleRequest)({
+      async handlePage(param) {
+        var {
+          route,
+          url,
+          loaderProps
+        } = param;
+        var _options_server;
+        var ssgCacheKey = route.type === "ssg" ? getSsgHtmlCacheKey(route, url) : null;
+        if (ssgCacheKey && !needsRouteRefresh) {
+          var cachedHtml = ssgHtmlCache.get(ssgCacheKey);
+          if (cachedHtml) {
+            return cachedHtml;
+          }
+        }
+        if (((_options_server = options.server) === null || _options_server === void 0 ? void 0 : _options_server.loggingEnabled) !== false) {
+          var colorType = routeTypeColors[route.type] || import_picocolors.default.white;
+          var pathname = typeof url === "string" ? new URL(url).pathname : url.pathname;
+          var file = route.isNotFound ? import_picocolors.default.red("404") : import_picocolors.default.dim(`app/${route.file.slice(2)}`);
+          console.info(` \u24F5  ${colorType(`[${route.type}]`)} ${pathname} ${import_picocolors.default.dim("\u2192")} ${file}`);
+        }
+        var layouts = route.layouts || [];
+        var isSpaShell = route.type === "spa" && layouts.some(function (layout) {
+          return layout.layoutRenderMode === "ssg" || layout.layoutRenderMode === "ssr";
+        });
+        if (route.type === "spa" && !isSpaShell) {
+          return `<!DOCTYPE html><html><head>
+            ${(0, import_constants.getSpaHeaderElements)({
+            serverContext: {
+              mode: "spa"
+            }
+          })}
+            <script type="module" src="/@one/dev.js"></script>
+            <script type="module" src="/@vite/client" async=""></script>
+            <script type="module" src="/@id/__x00__virtual:one-entry" async=""></script>
+          </head></html>`;
+        }
+        if (renderPromise) {
+          await renderPromise;
+        }
+        if (ssgCacheKey && !needsRouteRefresh) {
+          var cachedHtml = ssgHtmlCache.get(ssgCacheKey);
+          if (cachedHtml) {
+            return cachedHtml;
+          }
+        }
+        var {
+          promise,
+          resolve: resolveRender
+        } = (0, import_promiseWithResolvers.promiseWithResolvers)();
+        renderPromise = promise;
+        try {
+          var _globalThis___vxrnresetState, _globalThis;
+          var isGeneratedNotFound = route.file === "";
+          var routeFile = isGeneratedNotFound ? "" : import_path.default.join(routerRoot, route.file);
+          if (needsRouteRefresh) {
+            globalThis["__vxrnVersion"] = (globalThis["__vxrnVersion"] || 0) + 1;
+            ssgHtmlCache.clear();
+            needsRouteRefresh = false;
+          }
+          (_globalThis___vxrnresetState = (_globalThis = globalThis)["__vxrnresetState"]) === null || _globalThis___vxrnresetState === void 0 ? void 0 : _globalThis___vxrnresetState.call(_globalThis);
+          var exported = isGeneratedNotFound ? {} : await runner.import(routeFile);
+          async function runLoaderWithTracking(routeNode, loaderFn) {
+            var routeId = routeNode.contextKey;
+            if (!loaderFn) {
+              return {
+                loaderData: void 0,
+                routeId
+              };
+            }
+            try {
+              var tracked = await (0, import_trackLoaderDependencies.trackLoaderDependencies)(function () {
+                return loaderFn(loaderProps);
+              });
+              var routePath = (loaderProps === null || loaderProps === void 0 ? void 0 : loaderProps.path) || "/";
+              var _iteratorNormalCompletion = true,
+                _didIteratorError = false,
+                _iteratorError = void 0;
+              try {
+                for (var _iterator = tracked.dependencies[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+                  var dep = _step.value;
+                  var absoluteDep = import_path.default.resolve(dep);
+                  setBoundedLoaderDep(absoluteDep, routePath);
+                  if (debugLoaderDeps) {
+                    console.info(` \u24F5  [loader-dep] watching: ${absoluteDep}`);
+                  }
+                }
+              } catch (err) {
+                _didIteratorError = true;
+                _iteratorError = err;
+              } finally {
+                try {
+                  if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                  }
+                } finally {
+                  if (_didIteratorError) {
+                    throw _iteratorError;
+                  }
+                }
+              }
+              return {
+                loaderData: tracked.result,
+                routeId
+              };
+            } catch (err) {
+              if ((0, import_isResponse.isResponse)(err)) {
+                throw err;
+              }
+              if ((err === null || err === void 0 ? void 0 : err.code) === "ENOENT") {
+                return {
+                  loaderData: void 0,
+                  routeId,
+                  isEnoent: true
+                };
+              }
+              console.error(`[one] Error running loader for ${routeId}:`, err);
+              return {
+                loaderData: void 0,
+                routeId
+              };
+            }
+          }
+          var loaderData;
+          var matches;
+          var pageResult;
+          if (isSpaShell) {
+            var layoutLoaderPromises = layouts.map(async function (layout) {
+              var layoutFile = import_path.default.join(routerRoot, layout.contextKey);
+              var layoutExported = await runner.import(layoutFile);
+              return runLoaderWithTracking(layout, layoutExported.loader);
+            });
+            var layoutResults = await Promise.all(layoutLoaderPromises);
+            matches = layoutResults.map(function (result) {
+              return {
+                routeId: result.routeId,
+                pathname: (loaderProps === null || loaderProps === void 0 ? void 0 : loaderProps.path) || "/",
+                params: (loaderProps === null || loaderProps === void 0 ? void 0 : loaderProps.params) || {},
+                loaderData: result.loaderData
+              };
+            });
+            loaderData = void 0;
+          } else {
+            var layoutRoutes = route.layouts || [];
+            var pageRoute = {
+              contextKey: route.file,
+              file: route.file
+            };
+            var layoutLoaderPromises = layoutRoutes.map(async function (layout) {
+              var layoutFile = import_path.default.join(routerRoot, layout.contextKey);
+              var layoutExported = await runner.import(layoutFile);
+              return runLoaderWithTracking(layout, layoutExported.loader);
+            });
+            var pageLoaderPromise = runLoaderWithTracking(pageRoute, exported.loader);
+            var layoutResults;
+            [layoutResults, pageResult] = await Promise.all([Promise.all(layoutLoaderPromises), pageLoaderPromise]);
+            matches = [...layoutResults.map(function (result) {
+              return {
+                routeId: result.routeId,
+                pathname: (loaderProps === null || loaderProps === void 0 ? void 0 : loaderProps.path) || "/",
+                params: (loaderProps === null || loaderProps === void 0 ? void 0 : loaderProps.params) || {},
+                loaderData: result.loaderData
+              };
+            }), {
+              routeId: pageResult.routeId,
+              pathname: (loaderProps === null || loaderProps === void 0 ? void 0 : loaderProps.path) || "/",
+              params: (loaderProps === null || loaderProps === void 0 ? void 0 : loaderProps.params) || {},
+              loaderData: pageResult.loaderData
+            }];
+            loaderData = pageResult.loaderData;
+          }
+          eval(`process.env.TAMAGUI_IS_SERVER = '1'`);
+          var entry = await runner.import(import_virtualEntryConstants.virtualEntryId);
+          var render = entry.default.render;
+          (0, import_one_server_only.setServerContext)({
+            loaderData,
+            loaderProps,
+            matches
+          });
+          var isDynamicRoute = Object.keys(route.routeKeys || {}).length > 0;
+          var isMissingSsgSlug = false;
+          if (route.type === "ssg" && isDynamicRoute && exported.generateStaticParams) {
+            var staticParams = await exported.generateStaticParams({
+              params: loaderProps === null || loaderProps === void 0 ? void 0 : loaderProps.params
+            });
+            var currentParams = (loaderProps === null || loaderProps === void 0 ? void 0 : loaderProps.params) || {};
+            isMissingSsgSlug = !staticParams.some(function (sp) {
+              return Object.keys(sp).every(function (key) {
+                return staticParamMatches(sp[key], currentParams[key]);
+              });
+            });
+          }
+          var isLoaderEnoent = !isSpaShell && (pageResult === null || pageResult === void 0 ? void 0 : pageResult.isEnoent);
+          var is404 = route.isNotFound || !(0, import_getPageExport.getPageExport)(exported) || isMissingSsgSlug || isLoaderEnoent;
+          var notFoundRoutePath = null;
+          if (isMissingSsgSlug || isLoaderEnoent) {
+            var routeDir = route.file.replace(/^\.\//, "").replace(/\/[^/]+$/, "");
+            var searchDir = routeDir;
+            while (true) {
+              for (var _i = 0, _iter = [".tsx", ".ts", ".jsx", ".js"]; _i < _iter.length; _i++) {
+                var ext = _iter[_i];
+                var candidate = import_path.default.join(routerRoot, searchDir, `+not-found${ext}`);
+                try {
+                  var notFoundExported = await runner.import(candidate);
+                  if (notFoundExported === null || notFoundExported === void 0 ? void 0 : notFoundExported.default) {
+                    notFoundRoutePath = searchDir ? `/${searchDir}/+not-found` : "/+not-found";
+                    break;
+                  }
+                } catch (unused) {}
+              }
+              if (notFoundRoutePath || !searchDir) break;
+              var parent = searchDir.replace(/\/[^/]+$/, "");
+              if (parent === searchDir) {
+                searchDir = "";
+              } else {
+                searchDir = parent;
+              }
+            }
+            if (!notFoundRoutePath) {
+              return new Response("<html><body><h1>404 - Not Found</h1></body></html>", {
+                status: 404,
+                headers: {
+                  "Content-Type": "text/html"
+                }
+              });
+            }
+          }
+          var renderPath = notFoundRoutePath || (loaderProps === null || loaderProps === void 0 ? void 0 : loaderProps.path) || "/";
+          if (notFoundRoutePath && loaderProps) {
+            loaderProps = {
+              ...loaderProps,
+              path: notFoundRoutePath
+            };
+            (0, import_one_server_only.setServerContext)({
+              loaderProps
+            });
+          }
+          var html = await render({
+            mode: isSpaShell ? "spa-shell" : route.type === "ssg" ? "ssg" : route.type === "ssr" ? "ssr" : "spa",
+            loaderData,
+            loaderProps,
+            path: renderPath,
+            preloads,
+            matches
+          });
+          if (is404) {
+            if (notFoundRoutePath) {
+              var originalPath = (loaderProps === null || loaderProps === void 0 ? void 0 : loaderProps.path) || "/";
+              var notFoundMarker = `<script>window.__one404={originalPath:${JSON.stringify(originalPath)},notFoundPath:${JSON.stringify(notFoundRoutePath)}}</script>`;
+              html = html.includes("</head>") ? html.replace("</head>", `${notFoundMarker}</head>`) : html.replace("<body", `${notFoundMarker}<body`);
+            }
+            return new Response(html, {
+              status: 404,
+              headers: {
+                "Content-Type": "text/html"
+              }
+            });
+          }
+          if (ssgCacheKey) {
+            ssgHtmlCache.set(ssgCacheKey, html);
+          }
+          return html;
+        } catch (err) {
+          if ((0, import_isResponse.isResponse)(err)) {
+            return err;
+          }
+          console.error(`SSR error while loading file ${route.file} from URL ${url.href}
+`, err);
+          var title = `Error rendering ${url.pathname} on server`;
+          var message = _instanceof(err, Error) ? err.message : `${err}`;
+          var stack = _instanceof(err, Error) ? err.stack || "" : "";
+          var isDuplicateReactError = /at (useEffect|useState|useReducer|useContext|useLayoutEffect)\s*\(.*?react\.development\.js/g.test(stack);
+          var subMessage = isDuplicateReactError ? `
+            <h2>Duplicate React Error</h2>
+            <p style="font-size: 18px; line-height: 24px; max-width: 850px;">Note: These types of errors happen during SSR because One needs all dependencies that use React to be optimized. Find the dependency on the line after the react.development.js line below to find the failing dependency. So long as that dependency has "react" as a sub-dependency, you can add it to your package.json and One will optimize it automatically. If it doesn't list it properly, you can fix this manually by changing your vite.config.ts One plugin to add "one({ deps: { depName: true })" so One optimizes depName.</p>
+          ` : ``;
+          console.error(`${title}
+ ${message}
+
+${stack}
+`);
+          return `
+            <html>
+              <body style="background: #000; color: #fff; padding: 5%; font-family: monospace; line-height: 2rem;">
+                <h1 style="display: inline-flex; background: red; color: white; padding: 5px; margin: -5px;">${title}</h1>
+                <h2>${message}</h2>
+                ${subMessage}
+                ${stack ? `<pre style="font-size: 15px; line-height: 24px; white-space: pre;">
+                    ${stack}
+                </pre>` : ``}
+              </body>
+            </html>
+          `;
+        } finally {
+          resolveRender();
+        }
+      },
+      async handleLoader(param2) {
+        var {
+          route: route2,
+          url: url2,
+          loaderProps: loaderProps2
+        } = param2;
+        var _this;
+        var routeFile2 = import_path.default.join(routerRoot, route2.file);
+        var transformedJS = (_this = await server.transformRequest(routeFile2)) === null || _this === void 0 ? void 0 : _this.code;
+        if (!transformedJS) {
+          throw new Error(`No transformed js returned`);
+        }
+        if (!/export function loader\(\)/.test(transformedJS)) {
+          return transformedJS;
+        }
+        var exported2 = await runner.import(routeFile2);
+        var isDynamicRoute2 = Object.keys(route2.routeKeys || {}).length > 0;
+        if (route2.type === "ssg" && isDynamicRoute2 && exported2.generateStaticParams) {
+          var staticParams2 = await exported2.generateStaticParams({
+            params: loaderProps2 === null || loaderProps2 === void 0 ? void 0 : loaderProps2.params
+          });
+          var currentParams2 = (loaderProps2 === null || loaderProps2 === void 0 ? void 0 : loaderProps2.params) || {};
+          var isValidSlug = staticParams2.some(function (sp) {
+            return Object.keys(sp).every(function (key) {
+              return staticParamMatches(sp[key], currentParams2[key]);
+            });
+          });
+          if (!isValidSlug) {
+            var nfPath = await findNearestNotFoundPath(route2.file);
+            return `export function loader(){return{__oneError:404,__oneErrorMessage:'Not Found',__oneNotFoundPath:${JSON.stringify(nfPath)}}}`;
+          }
+        }
+        var loaderData2;
+        if (exported2.loader) {
+          try {
+            var tracked = await (0, import_trackLoaderDependencies.trackLoaderDependencies)(function () {
+              return exported2.loader(loaderProps2);
+            });
+            loaderData2 = tracked.result;
+            if ((0, import_isResponse.isResponse)(loaderData2)) {
+              throw loaderData2;
+            }
+            var routePath = (loaderProps2 === null || loaderProps2 === void 0 ? void 0 : loaderProps2.path) || "/";
+            var _iteratorNormalCompletion = true,
+              _didIteratorError = false,
+              _iteratorError = void 0;
+            try {
+              for (var _iterator = tracked.dependencies[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+                var dep = _step.value;
+                var absoluteDep = import_path.default.resolve(dep);
+                setBoundedLoaderDep(absoluteDep, routePath);
+                if (debugLoaderDeps) {
+                  console.info(` \u24F5  [loader-dep] watching: ${absoluteDep}`);
+                }
+              }
+            } catch (err) {
+              _didIteratorError = true;
+              _iteratorError = err;
+            } finally {
+              try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                  _iterator.return();
+                }
+              } finally {
+                if (_didIteratorError) {
+                  throw _iteratorError;
+                }
+              }
+            }
+          } catch (err) {
+            if ((0, import_isResponse.isResponse)(err)) {
+              throw err;
+            }
+            if ((err === null || err === void 0 ? void 0 : err.code) === "ENOENT") {
+              var nfPath1 = await findNearestNotFoundPath(route2.file);
+              return `export function loader(){return{__oneError:404,__oneErrorMessage:'Not Found',__oneNotFoundPath:${JSON.stringify(nfPath1)}}}`;
+            }
+            throw err;
+          }
+        }
+        if (loaderData2) {
+          transformedJS = (0, import_replaceLoader.replaceLoader)({
+            code: transformedJS,
+            loaderData: loaderData2
+          });
+        }
+        var platform = url2.searchParams.get("platform");
+        if (platform === "ios" || platform === "android" || platform === "native") {
+          var environment = server.environments[platform === "native" ? "ios" : platform || ""];
+          if (!environment) {
+            throw new Error(`[handleLoader] No Vite environment found for platform '${platform}'`);
+          }
+          var nativeTransformedJS = `exports.loader = () => (${JSON.stringify(loaderData2)});`;
+          return nativeTransformedJS;
+        }
+        return transformedJS;
+      },
+      async handleAPI(param2) {
+        var {
+          route: route2
+        } = param2;
+        return await runner.import(import_path.default.join(routerRoot, route2.file));
+      },
+      async loadMiddleware(route2) {
+        return await runner.import(import_path.default.join(routerRoot, route2.contextKey));
+      }
+    }, {
+      routerRoot,
+      ignoredRouteFiles: (_options_router = options.router) === null || _options_router === void 0 ? void 0 : _options_router.ignoredRouteFiles,
+      routePaths: routeIndex.getPaths()
+    });
+  }
+  function recreateRequestHandler(changedPath) {
+    try {
+      handleRequest = createRequestHandler();
+      ssgHtmlCache.clear();
+      needsRouteRefresh = true;
+    } catch (error) {
+      console.warn(`[one] Failed to rebuild routes after ${changedPath} changed.`, error);
+    }
+  }
+  return {
+    name: `one-router-fs`,
+    enforce: "post",
+    apply: "serve",
+    // the route tree we rendered from is built out of whatever route modules
+    // were resolved at the time, so any ssr-side change makes it stale. this
+    // runs inside vite's update sequence, after the graph has been invalidated,
+    // so by the time the next render reads the flag the fresh modules are
+    // already there to rebuild from.
+    //
+    // ask the graph rather than reading the `modules` argument: vite calls
+    // hotUpdate for every watcher event including files it knows nothing about,
+    // and an earlier plugin may have replaced `modules` (route-module-hmr-fix
+    // returns [] for ssr app files to suppress the full reload).
+    hotUpdate(param2) {
+      var {
+        file: file2
+      } = param2;
+      var _this_environment_moduleGraph_getModulesByFile;
+      if (this.environment.name !== "ssr") return;
+      if (!((_this_environment_moduleGraph_getModulesByFile = this.environment.moduleGraph.getModulesByFile(file2)) === null || _this_environment_moduleGraph_getModulesByFile === void 0 ? void 0 : _this_environment_moduleGraph_getModulesByFile.size)) return;
+      needsRouteRefresh = true;
+    },
+    async config() {
+      var _ref;
+      var _options_optimization;
+      var setting = (_ref = (_options_optimization = options.optimization) === null || _options_optimization === void 0 ? void 0 : _options_optimization.autoEntriesScanning) !== null && _ref !== void 0 ? _ref : "flat";
+      var routerRoot2 = (0, import_vite.normalizePath)((0, import_getRouterRootFromOneOptions.getRouterRootFromOneOptions)(options));
+      if (setting === false) {
+        return;
+      }
+      if (handleRequest.manifest.pageRoutes) {
+        var routesAndLayouts = [...new Set(handleRequest.manifest.pageRoutes.flatMap(function (route2) {
+          var _route_layouts;
+          if (route2.isNotFound) return [];
+          if (!route2.file) return [];
+          if (setting === "flat" && route2.file.split("/").filter(function (x) {
+            return !x.startsWith("(");
+          }).length > 3) {
+            return [];
+          }
+          return [import_path.default.posix.join(`./${routerRoot2}`, route2.file), ...(((_route_layouts = route2.layouts) === null || _route_layouts === void 0 ? void 0 : _route_layouts.flatMap(function (layout) {
+            if (!layout.contextKey) return [];
+            return [import_path.default.posix.join(`./${routerRoot2}`, layout.contextKey)];
+          })) || [])];
+        }))];
+        return {
+          optimizeDeps: {
+            /**
+            * This adds all our routes and layouts as entries which fixes initial load making
+            * optimizeDeps be triggered which causes hard refreshes (also on initial navigations)
+            *
+            * see: https://vitejs.dev/config/dep-optimization-options.html#optimizedeps-entries
+            * and: https://github.com/remix-run/remix/pull/9921
+            */
+            entries: routesAndLayouts
+          }
+        };
+      }
+    },
+    configureServer(serverIn) {
+      var _server_environments, _clientEnv_config;
+      server = serverIn;
+      var clientEnv = (_server_environments = server.environments) === null || _server_environments === void 0 ? void 0 : _server_environments.client;
+      if ((clientEnv === null || clientEnv === void 0 ? void 0 : (_clientEnv_config = clientEnv.config) === null || _clientEnv_config === void 0 ? void 0 : _clientEnv_config.isBundled) || (clientEnv === null || clientEnv === void 0 ? void 0 : clientEnv.bundledDev)) {
+        preloads = ["/bundledDevClient.mjs", "/assets/_virtual_one-entry.js"];
+      }
+      runner = (0, import_vite.createServerModuleRunner)(USE_SERVER_ENV ? server.environments.server : server.environments.ssr);
+      var appDir = import_path.default.resolve(process.cwd(), (0, import_getRouterRootFromOneOptions.getRouterRootFromOneOptions)(options));
+      var recreateRequestHandlerDebounced = (0, import_perfect_debounce.debounce)(function (changedPath) {
+        recreateRequestHandler(changedPath);
+      }, 100);
+      var fileWatcherChangeListener = function (type, changedPath) {
+        if ((0, import_routeFileWatch.isRouteFileWatchEvent)({
+          event: type,
+          filePath: changedPath,
+          routerRoot: appDir
+        })) {
+          routeIndex.update(type, changedPath);
+          return recreateRequestHandlerDebounced(changedPath);
+        }
+      };
+      server.watcher.addListener("all", fileWatcherChangeListener);
+      var loaderDepChangeListener = (0, import_perfect_debounce.debounce)(function (changedPath) {
+        var absolutePath = import_path.default.resolve(changedPath);
+        var routePaths = loaderFileDependencies.get(absolutePath);
+        if (routePaths && routePaths.size > 0) {
+          if (debugLoaderDeps) {
+            console.info(` \u24F5  [loader-dep] changed: ${absolutePath}, triggering loader refetch for routes:`, [...routePaths]);
+          }
+          server.hot.send({
+            type: "custom",
+            event: "one:loader-data-update",
+            data: {
+              routePaths: [...routePaths]
+            }
+          });
+          ssgHtmlCache.clear();
+        }
+      }, 100);
+      server.watcher.on("change", loaderDepChangeListener);
+      return function () {
+        server.middlewares.use(function (req, res, next) {
+          var _req_url;
+          if (req.url === "/status" || ((_req_url = req.url) === null || _req_url === void 0 ? void 0 : _req_url.startsWith("/status?"))) {
+            res.writeHead(200, {
+              "Content-Type": "text/plain"
+            });
+            res.end("packager-status:running");
+            return;
+          }
+          next();
+        });
+        server.middlewares.use(async function (req, res, next) {
+          res.setHeader("Cache-Control", "no-store");
+          var abortController = new AbortController();
+          var cleanupAbortListeners = function () {
+            req.removeListener("aborted", abortRequest);
+            req.removeListener("close", abortIncompleteRequest);
+            res.removeListener("close", abortIncompleteResponse);
+            res.removeListener("finish", cleanupAbortListeners);
+          };
+          var abortRequest = function () {
+            cleanupAbortListeners();
+            abortController.abort();
+          };
+          var abortIncompleteRequest = function () {
+            if (req.aborted || !req.complete) abortRequest();
+          };
+          var abortIncompleteResponse = function () {
+            if (!res.writableFinished) {
+              abortRequest();
+              return;
+            }
+            cleanupAbortListeners();
+          };
+          req.on("aborted", abortRequest);
+          req.on("close", abortIncompleteRequest);
+          res.on("close", abortIncompleteResponse);
+          res.on("finish", cleanupAbortListeners);
+          try {
+            var _options_web;
+            var redirects = (_options_web = options.web) === null || _options_web === void 0 ? void 0 : _options_web.redirects;
+            if (redirects) {
+              var url2 = new URL(req.url || "", "http://127.0.0.1");
+              var _iteratorNormalCompletion = true,
+                _didIteratorError = false,
+                _iteratorError = void 0;
+              try {
+                var _loop = function () {
+                  var redirect = _step.value;
+                  var regexStr = `^${redirect.source.replace(/:\w+/g, "([^/]+)")}$`;
+                  var match = url2.pathname.match(new RegExp(regexStr));
+                  if (match) {
+                    var destination = redirect.destination;
+                    var params = redirect.source.match(/:\w+/g);
+                    if (params) {
+                      params.forEach(function (param2, index) {
+                        destination = destination.replace(param2, match[index + 1] || "");
+                      });
+                    }
+                    if (debugRouter) {
+                      console.info(`[one] \u21AA redirect ${url2.pathname} \u2192 ${destination}`);
+                    }
+                    res.writeHead(redirect.permanent ? 301 : 302, {
+                      Location: destination
+                    });
+                    res.end();
+                    return {
+                      v: void 0
+                    };
+                  }
+                };
+                for (var _iterator = redirects[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+                  var _ret = _loop();
+                  if (_type_of(_ret) === "object") return _ret.v;
+                }
+              } catch (err) {
+                _didIteratorError = true;
+                _iteratorError = err;
+              } finally {
+                try {
+                  if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                  }
+                } finally {
+                  if (_didIteratorError) {
+                    throw _iteratorError;
+                  }
+                }
+              }
+            }
+            var reply = await handleRequest.handler(convertIncomingMessageToRequest(req, abortController.signal));
+            if (!reply) {
+              cleanupAbortListeners();
+              return next();
+            }
+            if (typeof reply !== "string" && (0, import_isResponse.isResponse)(reply)) {
+              if (debugRouter) {
+                var headers = {};
+                reply.headers.forEach(function (v, k) {
+                  headers[k] = v;
+                });
+                console.info(`[one] \u{1F4E4} response ${reply.status}`, headers);
+              }
+              reply.headers.forEach(function (value, key) {
+                if (key === "set-cookie") {
+                  var cookies = value.split(", ");
+                  var _iteratorNormalCompletion2 = true,
+                    _didIteratorError2 = false,
+                    _iteratorError2 = void 0;
+                  try {
+                    for (var _iterator2 = cookies[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+                      var cookie = _step2.value;
+                      res.appendHeader("Set-Cookie", cookie);
+                    }
+                  } catch (err) {
+                    _didIteratorError2 = true;
+                    _iteratorError2 = err;
+                  } finally {
+                    try {
+                      if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+                        _iterator2.return();
+                      }
+                    } finally {
+                      if (_didIteratorError2) {
+                        throw _iteratorError2;
+                      }
+                    }
+                  }
+                } else {
+                  res.setHeader(key, value);
+                }
+              });
+              if ((0, import_isStatus.isStatusRedirect)(reply.status)) {
+                var location = `${reply.headers.get("location") || ""}`;
+                if (debugRouter) {
+                  console.info(`[one] \u21AA response redirect \u2192 ${location}`);
+                }
+                if (location) {
+                  res.writeHead(reply.status, {
+                    Location: location
+                  });
+                  res.end();
+                  return;
+                }
+                console.error(`No location provided to redirected status reply`, reply);
+              }
+              res.statusCode = reply.status;
+              if (reply.body) {
+                if (reply.body.locked) {
+                  console.warn(`Body is locked??`, req.url);
+                  res.end();
+                  return;
+                }
+                try {
+                  var body = import_stream.Readable.fromWeb(reply.body);
+                  body.on("error", function (error) {
+                    if (!abortController.signal.aborted) {
+                      console.warn("Error streaming reply body to response:", error);
+                    }
+                    if (!res.destroyed) res.destroy();
+                  });
+                  body.pipe(res);
+                } catch (err) {
+                  console.warn("Error piping reply body to response:", err);
+                  res.end();
+                }
+                return;
+              }
+              res.end();
+              return;
+            }
+            if (reply && (typeof reply === "undefined" ? "undefined" : _type_of(reply)) === "object") {
+              res.setHeader("Content-Type", "application/json");
+              res.write(JSON.stringify(reply));
+              res.end();
+              return;
+            }
+            res.write(reply);
+            res.end();
+            return;
+          } catch (error) {
+            cleanupAbortListeners();
+            console.error(`[one] routing error ${req.url}: ${error}`);
+            next(error);
+          }
+          console.warn(`SSR handler didn't send a response for url: ${req.url}`);
+        });
+      };
+    }
+  };
+}
+var convertIncomingMessageToRequest = function (req, signal) {
+  if (!req.originalUrl) {
+    throw new Error(`Can't convert: originalUrl is missing`);
+  }
+  var protocol = _instanceof(req.socket, import_tls.TLSSocket) && req.socket.encrypted ? "https" : "http";
+  var host = `${req.headers["x-forwarded-host"] || req.headers.host || req.headers[":authority"] || "127.0.0.1"}`;
+  var urlBase = `${protocol}://${host}`;
+  var urlString = req.originalUrl;
+  var url2 = new URL(urlString, urlBase);
+  var headers = new Headers();
+  for (var key in req.headers) {
+    if (!key.startsWith(":") && req.headers[key]) {
+      headers.append(key, req.headers[key]);
+    }
+  }
+  if (!headers.has("host")) {
+    headers.set("host", host);
+  }
+  var hasBody = ["POST", "PUT", "PATCH", "DELETE"].includes(req.method || "");
+  var body = hasBody ? import_stream.Readable.toWeb(req) : null;
+  return new Request(url2, {
+    method: req.method,
+    headers,
+    body,
+    signal,
+    // Required for streaming bodies in Node's experimental fetch:
+    duplex: "half"
+  });
+};
+//# sourceMappingURL=fileSystemRouterPlugin.native.js.map