@richie-router/server 0.1.3 → 0.1.5

package/dist/cjs/index.cjs

@@ -39,8 +39,11 @@ var __export = (target, all) => {
 // packages/server/src/index.ts
 var exports_src = {};
 __export(exports_src, {
+  matchesSpaPath: () => matchesSpaPath,
+  handleSpaRequest: () => handleSpaRequest,
   handleRequest: () => handleRequest,
   handleHeadTagRequest: () => handleHeadTagRequest,
+  handleHeadRequest: () => handleHeadRequest,
   defineHeadTags: () => defineHeadTags
 });
 module.exports = __toCommonJS(exports_src);
@@ -54,32 +57,143 @@ function defineHeadTags(routeManifest, routerSchema, definitions) {
 }
 var HEAD_PLACEHOLDER = "<!--richie-router-head-->";
 var MANAGED_HEAD_ATTRIBUTE = "data-richie-router-head";
+var HEAD_RESPONSE_KIND_HEADER = "x-richie-router-head";
+var EMPTY_HEAD = [];
+function ensureLeadingSlash(value) {
+  return value.startsWith("/") ? value : `/${value}`;
+}
+function normalizeBasePath(basePath) {
+  if (!basePath) {
+    return "";
+  }
+  const trimmed = basePath.trim();
+  if (trimmed === "" || trimmed === "/") {
+    return "";
+  }
+  const normalized = ensureLeadingSlash(trimmed).replace(/\/+$/u, "");
+  return normalized === "/" ? "" : normalized;
+}
+function stripBasePathFromPathname(pathname, basePath) {
+  if (!basePath) {
+    return pathname;
+  }
+  if (pathname === basePath) {
+    return "/";
+  }
+  if (pathname.startsWith(`${basePath}/`)) {
+    return pathname.slice(basePath.length) || "/";
+  }
+  return null;
+}
+function prependBasePathToPathname(pathname, basePath) {
+  if (!basePath) {
+    return pathname;
+  }
+  return pathname === "/" ? basePath : `${basePath}${ensureLeadingSlash(pathname)}`;
+}
 function routeHasRecord(value) {
   return typeof value === "object" && value !== null;
 }
-function createHeadSnapshotScript(href, head) {
-  const payload = JSON.stringify({ href, head }).replaceAll("</script>", "<\\/script>");
+function createHeadSnapshotScript(href, head, routeHeads) {
+  const payload = JSON.stringify({ href, head, routeHeads }).replaceAll("</script>", "<\\/script>");
   return `<script ${MANAGED_HEAD_ATTRIBUTE}="true">window.__RICHIE_ROUTER_HEAD__=${payload}</script>`;
 }
-async function renderTemplate(html, ctx) {
+function createRichieRouterHead(href, head, routeHeads) {
+  const headHtml = import_core.serializeHeadConfig(head, {
+    managedAttribute: MANAGED_HEAD_ATTRIBUTE
+  });
+  return `${headHtml}${createHeadSnapshotScript(href, head, routeHeads)}`;
+}
+async function renderTemplate(html, ctx, options) {
   const template = html.template;
   if (typeof template === "function") {
     return await template(ctx);
   }
   if (!template.includes(HEAD_PLACEHOLDER)) {
+    if (options?.requireHeadPlaceholder === false) {
+      return template;
+    }
     throw new Error(`HTML template is missing required Richie Router placeholder: ${HEAD_PLACEHOLDER}`);
   }
   return template.replace(HEAD_PLACEHOLDER, ctx.richieRouterHead);
 }
 function jsonResponse(data, init) {
+  const headers = new Headers(init?.headers);
+  if (!headers.has("content-type")) {
+    headers.set("content-type", "application/json; charset=utf-8");
+  }
   return new Response(JSON.stringify(data), {
     ...init,
-    headers: {
-      "content-type": "application/json; charset=utf-8",
-      ...init?.headers ?? {}
-    }
+    headers
   });
 }
+function notFoundResult() {
+  return {
+    matched: false,
+    response: new Response("Not Found", { status: 404 })
+  };
+}
+function htmlResponse(html, headers) {
+  const responseHeaders = new Headers(headers);
+  if (!responseHeaders.has("content-type")) {
+    responseHeaders.set("content-type", "text/html; charset=utf-8");
+  }
+  return new Response(html, {
+    status: 200,
+    headers: responseHeaders
+  });
+}
+function withResponseHeaders(response, headersToSet) {
+  const headers = new Headers(response.headers);
+  new Headers(headersToSet).forEach((value, key) => {
+    headers.set(key, value);
+  });
+  return new Response(response.body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers
+  });
+}
+function formatHeadCacheControl(staleTime) {
+  if (staleTime === undefined) {
+    return "private, no-store";
+  }
+  return `private, max-age=${Math.max(0, Math.floor(staleTime / 1000))}`;
+}
+function createHeadResponseHeaders(kind, staleTime, headers) {
+  const responseHeaders = new Headers(headers);
+  responseHeaders.set(HEAD_RESPONSE_KIND_HEADER, kind);
+  responseHeaders.set("cache-control", formatHeadCacheControl(staleTime));
+  return responseHeaders;
+}
+function resolveDocumentRequest(request, basePathOption) {
+  return resolveDocumentPath(request.url, basePathOption);
+}
+function resolveDocumentPath(path, basePathOption) {
+  const url = new URL(path, "http://richie-router.local");
+  const basePath = normalizeBasePath(basePathOption);
+  const strippedPathname = stripBasePathFromPathname(url.pathname, basePath);
+  if (strippedPathname === null) {
+    return null;
+  }
+  return {
+    basePath,
+    location: import_core.createParsedLocation(`${strippedPathname}${url.search}${url.hash}`, null, import_core.defaultParseSearch)
+  };
+}
+async function renderDocumentResponse(request, html, richieRouterHead, head, options) {
+  const template = await renderTemplate(html, {
+    request,
+    richieRouterHead,
+    head
+  }, {
+    requireHeadPlaceholder: options?.requireHeadPlaceholder
+  });
+  return {
+    matched: true,
+    response: htmlResponse(template, options?.headers)
+  };
+}
 function resolveSearch(route, rawSearch) {
   const fromSchema = route.searchSchema ? route.searchSchema.parse(rawSearch) : {};
   if (routeHasRecord(fromSchema)) {
@@ -112,6 +226,29 @@ function buildMatches(routeManifest, location) {
     };
   });
 }
+function resolveSpaRoutes(spaRoutesManifest) {
+  if (!routeHasRecord(spaRoutesManifest)) {
+    throw new Error("Invalid spaRoutesManifest: expected an object.");
+  }
+  const { spaRoutes } = spaRoutesManifest;
+  if (!Array.isArray(spaRoutes) || spaRoutes.some((route) => typeof route !== "string")) {
+    throw new Error('Invalid spaRoutesManifest: expected "spaRoutes" to be an array of strings.');
+  }
+  return spaRoutes;
+}
+function matchesSpaLocation(options, location) {
+  if ("routeManifest" in options) {
+    return buildMatches(options.routeManifest, location).length > 0;
+  }
+  return resolveSpaRoutes(options.spaRoutesManifest).some((route) => import_core.matchPathname(route, location.pathname) !== null);
+}
+function matchesSpaPath(path, options) {
+  const documentRequest = resolveDocumentPath(path, options.basePath);
+  if (documentRequest === null) {
+    return false;
+  }
+  return matchesSpaLocation(options, documentRequest.location);
+}
 async function executeHeadTag(request, headTags, routeId, params, rawSearch) {
   const definition = headTags.definitions[routeId];
   const schemaEntry = headTags.routerSchema[routeId];
@@ -131,29 +268,132 @@ async function executeHeadTag(request, headTags, routeId, params, rawSearch) {
 }
 async function resolveMatchedHead(request, headTags, matches) {
   const resolvedHeadByRoute = new Map;
+  const routeHeads = [];
+  let staleTime;
   for (const match of matches) {
     if (!match.route.serverHead) {
       continue;
     }
     const result = await executeHeadTag(request, headTags, match.route.fullPath, match.params, match.search);
     resolvedHeadByRoute.set(match.route.fullPath, result.head);
+    routeHeads.push({
+      routeId: match.route.fullPath,
+      head: result.head,
+      staleTime: result.staleTime
+    });
+    if (result.staleTime !== undefined) {
+      staleTime = staleTime === undefined ? result.staleTime : Math.min(staleTime, result.staleTime);
+    }
   }
-  return import_core.resolveHeadConfig(matches, resolvedHeadByRoute);
+  return {
+    head: import_core.resolveHeadConfig(matches, resolvedHeadByRoute),
+    routeHeads,
+    staleTime
+  };
 }
-async function handleHeadTagRequest(request, options) {
+function createDocumentHeadRequest(sourceRequest, href) {
+  const requestUrl = new URL(sourceRequest.url);
+  const targetUrl = new URL(href, requestUrl);
+  return new Request(targetUrl.toString(), {
+    method: "GET",
+    headers: sourceRequest.headers
+  });
+}
+async function handleDocumentHeadRequest(request, options, href) {
+  const documentRequest = createDocumentHeadRequest(request, href);
+  const resolvedDocumentRequest = resolveDocumentRequest(documentRequest, options.basePath);
+  if (resolvedDocumentRequest === null) {
+    return {
+      matched: true,
+      response: jsonResponse({ message: "Not Found" }, {
+        status: 404,
+        headers: createHeadResponseHeaders("document")
+      })
+    };
+  }
+  try {
+    const matches = buildMatches(options.headTags.routeManifest, resolvedDocumentRequest.location);
+    if (matches.length === 0) {
+      return {
+        matched: true,
+        response: jsonResponse({ message: "Not Found" }, {
+          status: 404,
+          headers: createHeadResponseHeaders("document")
+        })
+      };
+    }
+    const { head, routeHeads, staleTime } = await resolveMatchedHead(documentRequest, options.headTags, matches);
+    return {
+      matched: true,
+      response: jsonResponse({
+        href: resolvedDocumentRequest.location.href,
+        head,
+        routeHeads,
+        staleTime,
+        richieRouterHead: createRichieRouterHead(resolvedDocumentRequest.location.href, head, routeHeads)
+      }, {
+        headers: createHeadResponseHeaders("document", staleTime)
+      })
+    };
+  } catch (error) {
+    if (import_core.isRedirect(error)) {
+      const redirectPath = prependBasePathToPathname(import_core.buildPath(error.options.to, error.options.params ?? {}), resolvedDocumentRequest.basePath);
+      const redirectSearch = import_core.defaultStringifySearch(error.options.search === true ? {} : error.options.search ?? {});
+      const redirectHash = error.options.hash ? `#${error.options.hash.replace(/^#/, "")}` : "";
+      const redirectUrl = `${redirectPath}${redirectSearch}${redirectHash}`;
+      return {
+        matched: true,
+        response: new Response(null, {
+          status: error.options.replace ? 307 : 302,
+          headers: createHeadResponseHeaders("document", undefined, {
+            location: redirectUrl
+          })
+        })
+      };
+    }
+    if (error instanceof Response) {
+      return {
+        matched: true,
+        response: withResponseHeaders(error, createHeadResponseHeaders("document"))
+      };
+    }
+    if (import_core.isNotFound(error)) {
+      return {
+        matched: true,
+        response: jsonResponse({ message: "Not Found" }, {
+          status: 404,
+          headers: createHeadResponseHeaders("document")
+        })
+      };
+    }
+    throw error;
+  }
+}
+async function handleHeadRequest(request, options) {
   const url = new URL(request.url);
-  const headBasePath = options.headBasePath ?? "/head-api";
+  const basePath = normalizeBasePath(options.basePath);
+  const headBasePath = options.headBasePath ?? prependBasePathToPathname("/head-api", basePath);
   if (url.pathname !== headBasePath) {
     return {
       matched: false,
       response: new Response("Not Found", { status: 404 })
     };
   }
+  const href = url.searchParams.get("href");
+  if (href !== null) {
+    return await handleDocumentHeadRequest(request, {
+      ...options,
+      basePath
+    }, href);
+  }
   const routeId = url.searchParams.get("routeId");
   if (!routeId) {
     return {
       matched: true,
-      response: jsonResponse({ message: "Missing routeId" }, { status: 400 })
+      response: jsonResponse({ message: "Missing routeId" }, {
+        status: 400,
+        headers: createHeadResponseHeaders("route")
+      })
     };
   }
   const params = JSON.parse(url.searchParams.get("params") ?? "{}");
@@ -162,71 +402,72 @@ async function handleHeadTagRequest(request, options) {
     const result = await executeHeadTag(request, options.headTags, routeId, params, search);
     return {
       matched: true,
-      response: jsonResponse(result)
+      response: jsonResponse(result, {
+        headers: createHeadResponseHeaders("route", result.staleTime)
+      })
     };
   } catch (error) {
     if (error instanceof Response) {
       return {
         matched: true,
-        response: error
+        response: withResponseHeaders(error, createHeadResponseHeaders("route"))
       };
     }
     if (import_core.isNotFound(error)) {
       return {
         matched: true,
-        response: jsonResponse({ message: "Not Found" }, { status: 404 })
+        response: jsonResponse({ message: "Not Found" }, {
+          status: 404,
+          headers: createHeadResponseHeaders("route")
+        })
       };
     }
     throw error;
   }
 }
+async function handleHeadTagRequest(request, options) {
+  return await handleHeadRequest(request, options);
+}
+async function handleSpaRequest(request, options) {
+  const documentRequest = resolveDocumentRequest(request, options.basePath);
+  if (documentRequest === null) {
+    return notFoundResult();
+  }
+  if (!matchesSpaLocation(options, documentRequest.location)) {
+    return notFoundResult();
+  }
+  return await renderDocumentResponse(request, options.html, "", EMPTY_HEAD, {
+    headers: options.headers,
+    requireHeadPlaceholder: false
+  });
+}
 async function handleRequest(request, options) {
-  const url = new URL(request.url);
-  const routeBasePath = options.routeBasePath ?? "/";
+  const basePath = normalizeBasePath(options.basePath);
   const handledHeadTagRequest = await handleHeadTagRequest(request, {
     headTags: options.headTags,
+    basePath,
     headBasePath: options.headBasePath
   });
   if (handledHeadTagRequest.matched) {
     return handledHeadTagRequest;
   }
-  if (!url.pathname.startsWith(routeBasePath)) {
-    return {
-      matched: false,
-      response: new Response("Not Found", { status: 404 })
-    };
+  const documentRequest = resolveDocumentRequest(request, basePath);
+  if (documentRequest === null) {
+    return notFoundResult();
   }
-  const location = import_core.createParsedLocation(`${url.pathname}${url.search}${url.hash}`, null, import_core.defaultParseSearch);
-  const matches = buildMatches(options.routeManifest, location);
+  const matches = buildMatches(options.routeManifest, documentRequest.location);
   if (matches.length === 0) {
-    return {
-      matched: false,
-      response: new Response("Not Found", { status: 404 })
-    };
+    return notFoundResult();
   }
   try {
-    const head = await resolveMatchedHead(request, options.headTags, matches);
-    const headHtml = import_core.serializeHeadConfig(head, {
-      managedAttribute: MANAGED_HEAD_ATTRIBUTE
+    const { head, routeHeads } = await resolveMatchedHead(request, options.headTags, matches);
+    const richieRouterHead = createRichieRouterHead(documentRequest.location.href, head, routeHeads);
+    return await renderDocumentResponse(request, options.html, richieRouterHead, head, {
+      headers: options.headers
     });
-    const richieRouterHead = `${headHtml}${createHeadSnapshotScript(location.href, head)}`;
-    const html = await renderTemplate(options.html, {
-      request,
-      richieRouterHead,
-      head
-    });
-    return {
-      matched: true,
-      response: new Response(html, {
-        status: 200,
-        headers: {
-          "content-type": "text/html; charset=utf-8"
-        }
-      })
-    };
   } catch (error) {
     if (import_core.isRedirect(error)) {
-      const redirectPath = import_core.buildPath(error.options.to, error.options.params ?? {});
+      const redirectPath = prependBasePathToPathname(import_core.buildPath(error.options.to, error.options.params ?? {}), documentRequest.basePath);
       const redirectSearch = import_core.defaultStringifySearch(error.options.search === true ? {} : error.options.search ?? {});
       const redirectHash = error.options.hash ? `#${error.options.hash.replace(/^#/, "")}` : "";
       const redirectUrl = `${redirectPath}${redirectSearch}${redirectHash}`;