one 1.10.6 → 1.11.0

package/dist/esm/server/oneServe.mjs

@@ -4,22 +4,24 @@ import { CSS_PRELOAD_JS_POSTFIX, LOADER_JS_POSTFIX_UNCACHED, PRELOAD_JS_POSTFIX
 import { compileManifest, getURLfromRequestURL, runMiddlewares } from "../createHandleRequest.mjs";
 import { getPathFromLoaderPath } from "../utils/cleanUrl.mjs";
 import { toAbsolute } from "../utils/toAbsolute.mjs";
+import { setSSRLoaderData } from "./ssrLoaderData.mjs";
 import { getFetchStaticHtml } from "./staticHtmlFetcher.mjs";
 const debugRouter = process.env.ONE_DEBUG_ROUTER;
-async function readStaticHtml(htmlPath) {
+async function readStaticHtml(htmlPath, outDir = "dist") {
   const fetchStaticHtml = getFetchStaticHtml();
   if (fetchStaticHtml) {
     const html = await fetchStaticHtml(htmlPath);
     if (html) return html;
   }
   try {
-    return await readFile(join("dist/client", htmlPath), "utf-8");
+    return await readFile(join(`${outDir}/client`, htmlPath), "utf-8");
   } catch {
     return null;
   }
 }
 async function oneServe(oneOptions, buildInfo, app, options) {
-  const {
+  const outDir = buildInfo.outDir || "dist",
+    {
       resolveAPIRoute,
       resolveLoaderRoute,
       resolvePageRoute
@@ -62,17 +64,70 @@ async function oneServe(oneOptions, buildInfo, app, options) {
       ...oneOptions,
       root: "."
     },
-    apiCJS = oneOptions.build?.api?.outputFormat === "cjs";
+    apiCJS = oneOptions.build?.api?.outputFormat === "cjs",
+    loaderCache = /* @__PURE__ */new Map(),
+    moduleImportCache = /* @__PURE__ */new Map(),
+    loaderCacheFnMap = /* @__PURE__ */new Map(),
+    pendingLoaderResults = /* @__PURE__ */new Map();
+  function resolveLoaderSync(serverPath, lazyKey) {
+    const cacheKey = lazyKey || serverPath || "",
+      cached = loaderCache.get(cacheKey);
+    return cached !== void 0 ? cached : (async () => {
+      const pathToResolve = serverPath || lazyKey || "",
+        resolvedPath = pathToResolve.includes(`${outDir}/server`) ? pathToResolve : join("./", `${outDir}/server`, pathToResolve);
+      let routeExported;
+      moduleImportCache.has(cacheKey) ? routeExported = moduleImportCache.get(cacheKey) : (routeExported = lazyKey ? options?.lazyRoutes?.pages?.[lazyKey] ? await options.lazyRoutes.pages[lazyKey]() : await import(toAbsolute(resolvedPath)) : await import(toAbsolute(serverPath)), moduleImportCache.set(cacheKey, routeExported));
+      const loader = routeExported?.loader || null;
+      loaderCache.set(cacheKey, loader);
+      const loaderCacheFn = routeExported?.loaderCache ?? null;
+      return loaderCacheFnMap.set(cacheKey, loaderCacheFn), loader;
+    })();
+  }
   async function importAndRunLoader(routeId, serverPath, lazyKey, loaderProps) {
     if (!serverPath && !lazyKey) return {
       loaderData: void 0,
       routeId
     };
+    const cacheMapKey = lazyKey || serverPath || "",
+      loaderCacheFn = loaderCacheFnMap.get(cacheMapKey);
+    let coalFullKey,
+      coalTtl = 0;
+    if (loaderCacheFn) {
+      const cacheResult = loaderCacheFn(loaderProps?.params, loaderProps?.request),
+        cacheKey = typeof cacheResult == "string" ? cacheResult : cacheResult?.key;
+      if (coalTtl = typeof cacheResult == "string" ? 0 : cacheResult?.ttl ?? 0, cacheKey != null) {
+        coalFullKey = routeId + "\0" + cacheKey;
+        const existing = pendingLoaderResults.get(coalFullKey);
+        if (existing && (!existing.expires || Date.now() < existing.expires)) return {
+          loaderData: await existing.promise,
+          routeId
+        };
+      }
+    }
     try {
-      const pathToResolve = serverPath || lazyKey || "",
-        resolvedPath = pathToResolve.includes("dist/server") ? pathToResolve : join("./", "dist/server", pathToResolve);
+      const loaderOrPromise = resolveLoaderSync(serverPath, lazyKey),
+        loader = loaderOrPromise instanceof Promise ? await loaderOrPromise : loaderOrPromise;
+      if (!loader) return {
+        loaderData: void 0,
+        routeId
+      };
+      if (coalFullKey) {
+        const promise = loader(loaderProps),
+          entry = {
+            promise,
+            expires: 0
+          };
+        return pendingLoaderResults.set(coalFullKey, entry), promise.then(() => {
+          entry.expires = coalTtl > 0 ? Date.now() + coalTtl : 0, coalTtl <= 0 && Promise.resolve().then(() => pendingLoaderResults.delete(coalFullKey));
+        }, () => {
+          pendingLoaderResults.delete(coalFullKey);
+        }), {
+          loaderData: await promise,
+          routeId
+        };
+      }
       return {
-        loaderData: await (lazyKey ? options?.lazyRoutes?.pages?.[lazyKey] ? await options.lazyRoutes.pages[lazyKey]() : await import(toAbsolute(resolvedPath)) : await import(toAbsolute(serverPath)))?.loader?.(loaderProps),
+        loaderData: await loader(loaderProps),
         routeId
       };
     } catch (err) {
@@ -87,198 +142,238 @@ async function oneServe(oneOptions, buildInfo, app, options) {
       });
     }
   }
-  let render = null;
-  async function getRender() {
-    return render || (render = (options?.lazyRoutes?.serverEntry ? await options.lazyRoutes.serverEntry() : await import(resolve(process.cwd(), `${serverOptions.root}/dist/server/_virtual_one-entry.${typeof oneOptions.build?.server == "object" && oneOptions.build.server.outputFormat === "cjs" ? "c" : ""}js`))).default.render), render;
+  let render = null,
+    renderStream = null,
+    renderLoading = null;
+  function ensureRenderLoaded() {
+    if (!render) return renderLoading || (renderLoading = (async () => {
+      const entry = options?.lazyRoutes?.serverEntry ? await options.lazyRoutes.serverEntry() : await import(resolve(process.cwd(), `${serverOptions.root}/${outDir}/server/_virtual_one-entry.${typeof oneOptions.build?.server == "object" && oneOptions.build.server.outputFormat === "cjs" ? "c" : ""}js`));
+      render = entry.default.render, renderStream = entry.default.renderStream;
+    })(), renderLoading);
   }
-  const requestHandlers = {
-    async handleAPI({
-      route
-    }) {
-      if (options?.lazyRoutes?.api?.[route.page]) return await options.lazyRoutes.api[route.page]();
-      const fileName = route.page.slice(1).replace(/\[/g, "_").replace(/\]/g, "_");
-      return await import(join(process.cwd(), "dist", "api", fileName + (apiCJS ? ".cjs" : ".js")));
-    },
-    async loadMiddleware(route) {
-      return options?.lazyRoutes?.middlewares?.[route.contextKey] ? await options.lazyRoutes.middlewares[route.contextKey]() : await import(toAbsolute(route.contextKey));
-    },
-    async handleLoader({
-      route,
-      loaderProps
-    }) {
-      const routeFile = route.routeFile || route.file,
-        serverPath = route.file.includes("dist/server") ? route.file : join("./", "dist/server", route.file);
-      let exports;
-      try {
-        exports = options?.lazyRoutes?.pages?.[routeFile] ? await options.lazyRoutes.pages[routeFile]() : await import(toAbsolute(serverPath));
-      } catch (err) {
-        if (err?.code === "ERR_MODULE_NOT_FOUND") return null;
-        throw err;
-      }
-      const {
-        loader
-      } = exports;
-      if (!loader) return null;
-      let json;
-      try {
-        json = await loader(loaderProps);
-      } catch (err) {
-        if (err?.code === "ENOENT") return make404LoaderJs(loaderProps?.path || "/", `ENOENT ${err?.path || err}`);
-        throw err;
-      }
-      if (isResponse(json)) throw json;
-      return `export function loader() { return ${JSON.stringify(json)} }`;
-    },
-    async handlePage({
-      route,
-      url,
-      loaderProps
-    }) {
-      const buildInfo2 = routeToBuildInfo[route.file];
-      if (route.type === "ssr") {
-        if (!buildInfo2) throw console.error("Error in route", route), new Error(`No buildinfo found for ${url}, route: ${route.file}, in keys:
+  const clientDir = join(process.cwd(), outDir, "client"),
+    requestHandlers = {
+      async handleStaticFile(filePath) {
+        try {
+          const fullPath = join(clientDir, filePath),
+            content = await readFile(fullPath, "utf-8");
+          return new Response(content, {
+            headers: {
+              "Content-Type": "text/javascript"
+            }
+          });
+        } catch {
+          return null;
+        }
+      },
+      async handleAPI({
+        route
+      }) {
+        if (options?.lazyRoutes?.api?.[route.page]) return await options.lazyRoutes.api[route.page]();
+        const fileName = route.page.slice(1).replace(/\[/g, "_").replace(/\]/g, "_");
+        return await import(join(process.cwd(), outDir, "api", fileName + (apiCJS ? ".cjs" : ".js")));
+      },
+      async loadMiddleware(route) {
+        return options?.lazyRoutes?.middlewares?.[route.contextKey] ? await options.lazyRoutes.middlewares[route.contextKey]() : await import(toAbsolute(route.contextKey));
+      },
+      async handleLoader({
+        route,
+        loaderProps
+      }) {
+        const routeFile = route.routeFile || route.file,
+          serverPath = route.file.includes(`${outDir}/server`) ? route.file : join("./", `${outDir}/server`, route.file);
+        let loader;
+        try {
+          const loaderResult = resolveLoaderSync(serverPath, routeFile);
+          loader = loaderResult instanceof Promise ? await loaderResult : loaderResult;
+        } catch (err) {
+          if (err?.code === "ERR_MODULE_NOT_FOUND") return null;
+          throw err;
+        }
+        if (!loader) return null;
+        let json;
+        try {
+          json = await loader(loaderProps);
+        } catch (err) {
+          if (err?.code === "ENOENT") return make404LoaderJs(loaderProps?.path || "/", `ENOENT ${err?.path || err}`);
+          throw err;
+        }
+        if (isResponse(json)) throw json;
+        return `export function loader() { return ${JSON.stringify(json)} }`;
+      },
+      async handlePage({
+        route,
+        url,
+        loaderProps
+      }) {
+        const buildInfo2 = routeToBuildInfo[route.file];
+        if (route.type === "ssr") {
+          if (!buildInfo2) throw console.error("Error in route", route), new Error(`No buildinfo found for ${url}, route: ${route.file}, in keys:
   ${Object.keys(routeToBuildInfo).join(`
   `)}`);
-        try {
-          const layoutLoaderPromises = (route.layouts || []).map(layout => {
-              const serverPath = layout.loaderServerPath || layout.contextKey;
-              return importAndRunLoader(layout.contextKey, serverPath, layout.contextKey, loaderProps);
-            }),
-            pageLoaderPromise = importAndRunLoader(route.file, buildInfo2.serverJsPath, route.file, loaderProps);
-          let layoutResults, pageResult;
           try {
-            [layoutResults, pageResult] = await Promise.all([Promise.all(layoutLoaderPromises), pageLoaderPromise]);
-          } catch (err) {
-            if (isResponse(err)) return err;
-            throw err;
-          }
-          if (pageResult.isEnoent) {
-            const nfPath = findNearestNotFoundPath(loaderProps?.path || "/"),
-              nfHtml = routeMap[nfPath];
-            if (nfHtml) try {
-              const html = await readFile(join(process.cwd(), "dist/client", nfHtml), "utf-8");
-              return new Response(html, {
-                headers: {
-                  "content-type": "text/html"
-                },
+            const layoutRoutes = route.layouts || [],
+              layoutLoaderPromises = layoutRoutes.map(layout => {
+                const serverPath = layout.loaderServerPath || layout.contextKey;
+                return importAndRunLoader(layout.contextKey, serverPath, layout.contextKey, loaderProps);
+              }),
+              pageLoaderPromise = importAndRunLoader(route.file, buildInfo2.serverJsPath, route.file, loaderProps);
+            let layoutResults, pageResult;
+            try {
+              [layoutResults, pageResult] = await Promise.all([Promise.all(layoutLoaderPromises), pageLoaderPromise]);
+            } catch (err) {
+              if (isResponse(err)) return err;
+              throw err;
+            }
+            if (pageResult.isEnoent) {
+              const nfPath = findNearestNotFoundPath(loaderProps?.path || "/"),
+                nfHtml = routeMap[nfPath];
+              if (nfHtml) try {
+                const html = await readFile(join(process.cwd(), `${outDir}/client`, nfHtml), "utf-8");
+                return new Response(html, {
+                  headers: {
+                    "content-type": "text/html"
+                  },
+                  status: 404
+                });
+              } catch {}
+              return new Response("404 Not Found", {
                 status: 404
               });
-            } catch {}
-            return new Response("404 Not Found", {
-              status: 404
+            }
+            const matches = [...layoutResults.map(result => ({
+                routeId: result.routeId,
+                pathname: loaderProps?.path || "/",
+                params: loaderProps?.params || {},
+                loaderData: result.loaderData
+              })), {
+                routeId: pageResult.routeId,
+                pathname: loaderProps?.path || "/",
+                params: loaderProps?.params || {},
+                loaderData: pageResult.loaderData
+              }],
+              loaderData = pageResult.loaderData;
+            for (const layout of layoutRoutes) {
+              const key = layout.contextKey,
+                loaderFn = loaderCache.get(key);
+              if (loaderFn) {
+                const result = layoutResults.find(r => r.routeId === key);
+                result && setSSRLoaderData(loaderFn, result.loaderData);
+              }
+            }
+            const pageLoaderFn = loaderCache.get(route.file);
+            pageLoaderFn && setSSRLoaderData(pageLoaderFn, pageResult.loaderData);
+            const headers = new Headers();
+            headers.set("content-type", "text/html"), globalThis.__vxrnresetState?.();
+            const renderProps = {
+                mode: route.type,
+                loaderData,
+                loaderProps,
+                path: loaderProps?.path || "/",
+                preloads: buildInfo2.criticalPreloads || buildInfo2.preloads,
+                deferredPreloads: buildInfo2.deferredPreloads,
+                css: buildInfo2.css,
+                cssContents: buildInfo2.cssContents,
+                matches
+              },
+              _rl = ensureRenderLoaded();
+            _rl && (await _rl);
+            const streamFn = process.env.ONE_BUFFERED_SSR ? null : renderStream;
+            if (streamFn) {
+              const stream = await streamFn(renderProps);
+              return new Response(stream, {
+                headers,
+                status: route.isNotFound ? 404 : 200
+              });
+            }
+            const rendered = await render(renderProps);
+            return new Response(rendered, {
+              headers,
+              status: route.isNotFound ? 404 : 200
             });
-          }
-          const matches = [...layoutResults.map(result => ({
-              routeId: result.routeId,
-              pathname: loaderProps?.path || "/",
-              params: loaderProps?.params || {},
-              loaderData: result.loaderData
-            })), {
-              routeId: pageResult.routeId,
-              pathname: loaderProps?.path || "/",
-              params: loaderProps?.params || {},
-              loaderData: pageResult.loaderData
-            }],
-            loaderData = pageResult.loaderData,
-            headers = new Headers();
-          headers.set("content-type", "text/html"), globalThis.__vxrnresetState?.();
-          const rendered = await (await getRender())({
-            mode: route.type,
-            loaderData,
-            loaderProps,
-            path: loaderProps?.path || "/",
-            // Use separated preloads for optimal loading
-            preloads: buildInfo2.criticalPreloads || buildInfo2.preloads,
-            deferredPreloads: buildInfo2.deferredPreloads,
-            css: buildInfo2.css,
-            cssContents: buildInfo2.cssContents,
-            matches
-          });
-          return new Response(rendered, {
-            headers,
-            status: route.isNotFound ? 404 : 200
-          });
-        } catch (err) {
-          if (isResponse(err)) return err;
-          console.error(`[one] Error rendering SSR route ${route.file}
+          } catch (err) {
+            if (isResponse(err)) return err;
+            console.error(`[one] Error rendering SSR route ${route.file}
 
 ${err?.stack ?? err}
 
 url: ${url}`);
-        }
-      } else {
-        const layoutRoutes = route.layouts || [];
-        if (route.type === "spa" && layoutRoutes.some(layout => layout.layoutRenderMode === "ssg" || layout.layoutRenderMode === "ssr")) try {
-          const matches = (await Promise.all(layoutRoutes.map(layout => {
-              const serverPath = layout.loaderServerPath || layout.contextKey;
-              return importAndRunLoader(layout.contextKey, serverPath, layout.contextKey, loaderProps);
-            }))).map(result => ({
-              routeId: result.routeId,
-              pathname: loaderProps?.path || "/",
-              params: loaderProps?.params || {},
-              loaderData: result.loaderData
-            })),
-            headers = new Headers();
-          headers.set("content-type", "text/html"), globalThis.__vxrnresetState?.();
-          const rendered = await (await getRender())({
-            mode: "spa-shell",
-            // don't pass loaderData for spa-shell - the page loader runs on client
-            // passing {} here would make useLoaderState think data is preloaded
-            loaderData: void 0,
-            loaderProps,
-            path: loaderProps?.path || "/",
-            preloads: buildInfo2?.criticalPreloads || buildInfo2?.preloads,
-            deferredPreloads: buildInfo2?.deferredPreloads,
-            css: buildInfo2?.css,
-            cssContents: buildInfo2?.cssContents,
-            matches
-          });
-          return new Response(rendered, {
-            headers,
-            status: route.isNotFound ? 404 : 200
-          });
-        } catch (err) {
-          if (isResponse(err)) return err;
-          console.error(`[one] Error rendering spa-shell for ${route.file}
-${err?.stack ?? err}
-url: ${url}`);
-        }
-        const isDynamicRoute = Object.keys(route.routeKeys).length > 0,
-          routeCleanPath = route.urlCleanPath.replace(/\?/g, ""),
-          notFoundKey = route.isNotFound ? route.page.replace(/\[([^\]]+)\]/g, ":$1") : null,
-          htmlPath = notFoundKey ? routeMap[notFoundKey] : isDynamicRoute ? routeMap[routeCleanPath] || routeMap[url.pathname] : routeMap[url.pathname] || routeMap[buildInfo2?.cleanPath];
-        if (htmlPath) {
-          const html = await readStaticHtml(htmlPath);
-          if (html) {
-            const headers = new Headers();
-            return headers.set("content-type", "text/html"), new Response(html, {
+          }
+        } else {
+          const layoutRoutes = route.layouts || [];
+          if (route.type === "spa" && layoutRoutes.some(layout => layout.layoutRenderMode === "ssg" || layout.layoutRenderMode === "ssr")) try {
+            const matches = (await Promise.all(layoutRoutes.map(layout => {
+                const serverPath = layout.loaderServerPath || layout.contextKey;
+                return importAndRunLoader(layout.contextKey, serverPath, layout.contextKey, loaderProps);
+              }))).map(result => ({
+                routeId: result.routeId,
+                pathname: loaderProps?.path || "/",
+                params: loaderProps?.params || {},
+                loaderData: result.loaderData
+              })),
+              headers = new Headers();
+            headers.set("content-type", "text/html"), globalThis.__vxrnresetState?.();
+            const _rl3 = ensureRenderLoaded();
+            _rl3 && (await _rl3);
+            const rendered = await render({
+              mode: "spa-shell",
+              // don't pass loaderData for spa-shell - the page loader runs on client
+              // passing {} here would make useLoaderState think data is preloaded
+              loaderData: void 0,
+              loaderProps,
+              path: loaderProps?.path || "/",
+              preloads: buildInfo2?.criticalPreloads || buildInfo2?.preloads,
+              deferredPreloads: buildInfo2?.deferredPreloads,
+              css: buildInfo2?.css,
+              cssContents: buildInfo2?.cssContents,
+              matches
+            });
+            return new Response(rendered, {
               headers,
               status: route.isNotFound ? 404 : 200
             });
+          } catch (err) {
+            if (isResponse(err)) return err;
+            console.error(`[one] Error rendering spa-shell for ${route.file}
+${err?.stack ?? err}
+url: ${url}`);
           }
-        }
-        if (isDynamicRoute) {
-          const notFoundRoute = findNearestNotFoundPath(url.pathname),
-            notFoundHtmlPath = routeMap[notFoundRoute];
-          if (notFoundHtmlPath) {
-            const notFoundHtml = await readStaticHtml(notFoundHtmlPath);
-            if (notFoundHtml) {
-              const notFoundMarker = `<script>window.__one404={originalPath:"${url.pathname}",notFoundPath:"${notFoundRoute}"}</script>`,
-                injectedHtml = notFoundHtml.includes("</head>") ? notFoundHtml.replace("</head>", `${notFoundMarker}</head>`) : notFoundHtml.replace("<body", `${notFoundMarker}<body`),
-                headers = new Headers();
-              return headers.set("content-type", "text/html"), new Response(injectedHtml, {
+          const isDynamicRoute = Object.keys(route.routeKeys).length > 0,
+            routeCleanPath = route.urlCleanPath.replace(/\?/g, ""),
+            notFoundKey = route.isNotFound ? route.page.replace(/\[([^\]]+)\]/g, ":$1") : null,
+            htmlPath = notFoundKey ? routeMap[notFoundKey] : isDynamicRoute ? routeMap[routeCleanPath] || routeMap[url.pathname] : routeMap[url.pathname] || routeMap[buildInfo2?.cleanPath];
+          if (htmlPath) {
+            const html = await readStaticHtml(htmlPath, outDir);
+            if (html) {
+              const headers = new Headers();
+              return headers.set("content-type", "text/html"), new Response(html, {
                 headers,
-                status: 404
+                status: route.isNotFound ? 404 : 200
               });
             }
           }
-          return new Response("404 Not Found", {
-            status: 404
-          });
+          if (isDynamicRoute) {
+            const notFoundRoute = findNearestNotFoundPath(url.pathname),
+              notFoundHtmlPath = routeMap[notFoundRoute];
+            if (notFoundHtmlPath) {
+              const notFoundHtml = await readStaticHtml(notFoundHtmlPath, outDir);
+              if (notFoundHtml) {
+                const notFoundMarker = `<script>window.__one404={originalPath:"${url.pathname}",notFoundPath:"${notFoundRoute}"}</script>`,
+                  injectedHtml = notFoundHtml.includes("</head>") ? notFoundHtml.replace("</head>", `${notFoundMarker}</head>`) : notFoundHtml.replace("<body", `${notFoundMarker}<body`),
+                  headers = new Headers();
+                return headers.set("content-type", "text/html"), new Response(injectedHtml, {
+                  headers,
+                  status: 404
+                });
+              }
+            }
+            return new Response("404 Not Found", {
+              status: 404
+            });
+          }
         }
       }
-    }
-  };
+    };
   function createHonoHandler(route) {
     return async (context, next) => {
       try {
@@ -299,8 +394,9 @@ url: ${url}`);
                   "Content-Type": "text/javascript"
                 }
               });
-              const finalUrl = new URL(originalUrl, url.origin),
-                cleanedRequest = new Request(finalUrl, request);
+              const finalUrl = new URL(originalUrl, url.origin);
+              finalUrl.search = url.search;
+              const cleanedRequest = new Request(finalUrl, request);
               return resolveLoaderRoute(requestHandlers, cleanedRequest, finalUrl, route);
             }
             switch (route.type) {
@@ -358,8 +454,9 @@ url: ${url}`);
             // preserve original for lazy route lookup
             file: route.loaderServerPath || c.req.path
           },
-          finalUrl = new URL(originalUrl, url.origin),
-          cleanedRequest = new Request(finalUrl, request);
+          finalUrl = new URL(originalUrl, url.origin);
+        finalUrl.search = url.search;
+        const cleanedRequest = new Request(finalUrl, request);
         try {
           return await resolveLoaderRoute(requestHandlers, cleanedRequest, finalUrl, loaderRoute);
         } catch (err) {