@qwik.dev/router 2.0.0-beta.36 → 2.0.0-beta.38

package/lib/chunks/http-error.qwik.mjs

@@ -1,11 +1,11 @@
 import { componentQrl, inlinedQrl, _jsxSorted, _fnSignal } from '@qwik.dev/core';
-import { k as useHttpStatus } from './use-functions.qwik.mjs';
+import { f as useHttpStatus } from './use-functions.qwik.mjs';
 
 const _hf0 = (p0) => p0.status || 500;
 const _hf0_str = "p0.status||500";
 const _hf1 = (p0) => p0.message || "";
 const _hf1_str = 'p0.message||""';
-const cacheKey = (status) => String(status);
+const cacheKey = (ev) => String(ev.status);
 const COLOR_400 = "#006ce9";
 const COLOR_500 = "#713fc2";
 const DisplayHttpStatus = /* @__PURE__ */ componentQrl(/* @__PURE__ */ inlinedQrl(() => {

package/lib/chunks/pathname.mjs

@@ -1,33 +1,4 @@
-function toTitleCase(str) {
-  return str.replace(/\w\S*/g, (txt) => {
-    return txt.charAt(0).toUpperCase() + txt.slice(1).toLowerCase();
-  });
-}
-function addError(ctx, e) {
-  ctx.diagnostics.push({
-    type: "error",
-    message: e ? String(e.stack || e) : "Error"
-  });
-}
-function addWarning(ctx, message) {
-  ctx.diagnostics.push({
-    type: "warn",
-    message: String(message)
-  });
-}
-function msToString(ms) {
-  if (ms < 1) {
-    return ms.toFixed(2) + " ms";
-  }
-  if (ms < 1e3) {
-    return ms.toFixed(1) + " ms";
-  }
-  if (ms < 6e4) {
-    return (ms / 1e3).toFixed(1) + " s";
-  }
-  return (ms / 6e4).toFixed(1) + " m";
-}
-
+const ensureSlash = (pathname) => pathname.endsWith("/") ? pathname : pathname + "/";
 function normalizePathname(pathname, basePathname) {
   if (typeof pathname === "string") {
     pathname = pathname.trim();
@@ -44,7 +15,7 @@ function normalizePathname(pathname, basePathname) {
               const segments = pathname.split("/");
               const lastSegment = segments[segments.length - 1];
               if (!lastSegment.includes(".")) {
-                pathname += "/";
+                pathname = ensureSlash(pathname);
               }
             }
           } else {
@@ -102,4 +73,4 @@ function isSameOriginUrl(url) {
   return false;
 }
 
-export { addError as a, addWarning as b, getPathnameForDynamicRoute as g, isSameOriginUrl as i, msToString as m, normalizePathname as n, toTitleCase as t };
+export { ensureSlash as e, getPathnameForDynamicRoute as g, isSameOriginUrl as i, normalizePathname as n };

package/lib/chunks/request-body-limit.mjs

@@ -0,0 +1,37 @@
+import { S as ServerError } from './server-error.mjs';
+
+const DEFAULT_REQUEST_BODY_LIMIT = 10 * 1024 * 1024;
+class RequestBodyLimitError extends ServerError {
+  code = "QWIK_REQUEST_BODY_LIMIT";
+  statusCode = 413;
+  constructor(limit) {
+    super(413, `Request body exceeds ${limit} bytes`);
+  }
+}
+const validateRequestBodyLimit = (requestBodyLimit) => {
+  if (!Number.isSafeInteger(requestBodyLimit) || requestBodyLimit <= 0) {
+    throw new TypeError("requestBodyLimit must be a positive safe integer");
+  }
+};
+const limitRequestBody = (request, requestBodyLimit = DEFAULT_REQUEST_BODY_LIMIT) => {
+  validateRequestBodyLimit(requestBodyLimit);
+  if (!request.body) {
+    return request;
+  }
+  let received = 0;
+  const body = request.body.pipeThrough(new TransformStream({
+    transform(chunk, controller) {
+      if (chunk.byteLength > requestBodyLimit - received) {
+        throw new RequestBodyLimitError(requestBodyLimit);
+      }
+      received += chunk.byteLength;
+      controller.enqueue(chunk);
+    }
+  }));
+  return new Request(request, {
+    body,
+    duplex: "half"
+  });
+};
+
+export { DEFAULT_REQUEST_BODY_LIMIT as D, RequestBodyLimitError as R, limitRequestBody as l, validateRequestBodyLimit as v };

package/lib/chunks/request-path.mjs

@@ -0,0 +1,60 @@
+import { e as ensureSlash } from './pathname.mjs';
+
+const IsQLoader = "@isQLoader";
+const IsQAction = "@isQAction";
+const QLoaderId = "@loaderId";
+const QActionId = "@actionId";
+const LOADER_REGEX = /\/(q-loader-([^/.]+)\.([^/.]+)\.json)$/;
+const getLoaderName = (loaderId, manifestHash) => `q-loader-${loaderId}.${manifestHash}.json`;
+function recognizeRequest(pathname) {
+  if (pathname.length < 10) {
+    return null;
+  }
+  const loaderMatch = pathname.match(LOADER_REGEX);
+  if (loaderMatch) {
+    return {
+      type: IsQLoader,
+      trimLength: loaderMatch[1].length + 1,
+      data: {
+        loaderId: loaderMatch[2],
+        manifestHash: loaderMatch[3]
+      }
+    };
+  }
+  return null;
+}
+function trimRecognizedInternalPathname(pathname, recognized) {
+  let trimmed = pathname.slice(0, pathname.length - recognized.trimLength) || "/";
+  if (!globalThis.__NO_TRAILING_SLASH__ && !trimmed.endsWith("/")) {
+    trimmed = ensureSlash(trimmed);
+  }
+  return trimmed;
+}
+function trimInternalPathname(pathname) {
+  const recognized = recognizeRequest(pathname);
+  if (recognized) {
+    return trimRecognizedInternalPathname(pathname, recognized);
+  }
+  return pathname;
+}
+function resolveValidInternalFullPathname(loaderPathname, fullPath) {
+  if (!fullPath || !fullPath.startsWith("/") || fullPath.startsWith("//")) {
+    return void 0;
+  }
+  try {
+    const pageUrl = new URL(fullPath, "http://qwik.internal");
+    if (pageUrl.origin !== "http://qwik.internal") {
+      return void 0;
+    }
+    const pagePathname = pageUrl.pathname;
+    if (pagePathname === loaderPathname) {
+      return void 0;
+    }
+    const loaderPrefix = ensureSlash(loaderPathname);
+    return pagePathname.startsWith(loaderPrefix) ? pagePathname : void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+export { IsQLoader as I, LOADER_REGEX as L, QLoaderId as Q, resolveValidInternalFullPathname as a, trimInternalPathname as b, IsQAction as c, QActionId as d, getLoaderName as g, recognizeRequest as r, trimRecognizedInternalPathname as t };

package/lib/chunks/routes.mjs

@@ -0,0 +1,47 @@
+function routeToRegExp(rule) {
+  let transformedRule;
+  if (rule === "/" || rule === "/*") {
+    transformedRule = rule;
+  } else if (rule.endsWith("/*")) {
+    transformedRule = `${rule.substring(0, rule.length - 2)}(/*)?`;
+  } else if (rule.endsWith("/")) {
+    transformedRule = `${rule.substring(0, rule.length - 1)}(/)?`;
+  } else if (rule.endsWith("*")) {
+    transformedRule = rule;
+  } else {
+    transformedRule = `${rule}(/)?`;
+  }
+  transformedRule = `^${transformedRule.replace(/\*/g, ".*")}$`;
+  return new RegExp(transformedRule);
+}
+function routesToRegExps(routes) {
+  if (!Array.isArray(routes)) {
+    return [];
+  }
+  return routes.filter((r) => typeof r === "string").map(routeToRegExp);
+}
+function createRouteTester(basePathname, includeRoutes, excludeRoutes) {
+  const includes = routesToRegExps(includeRoutes);
+  const excludes = routesToRegExps(excludeRoutes);
+  return (pathname) => {
+    if (basePathname !== "/") {
+      pathname = pathname.slice(basePathname.length - 1);
+    }
+    for (const exclude of excludes) {
+      if (exclude.test(pathname)) {
+        return false;
+      }
+    }
+    if (pathname.endsWith("/404.html")) {
+      return true;
+    }
+    for (const include of includes) {
+      if (include.test(pathname)) {
+        return true;
+      }
+    }
+    return false;
+  };
+}
+
+export { createRouteTester as c };

package/lib/chunks/server-error.mjs

@@ -0,0 +1,19 @@
+class AbortMessage {
+}
+class RedirectMessage extends AbortMessage {
+}
+
+class ServerError extends Error {
+  status;
+  data;
+  constructor(status, data) {
+    super(typeof data === "string" ? data : void 0), this.status = status, this.data = data;
+  }
+}
+const throwIfControlFlowSignal = (value) => {
+  if (value instanceof AbortMessage || value instanceof ServerError) {
+    throw value;
+  }
+};
+
+export { AbortMessage as A, RedirectMessage as R, ServerError as S, throwIfControlFlowSignal as t };

package/lib/chunks/system.mjs

@@ -3,6 +3,8 @@ import { isAbsolute, resolve, join, dirname } from 'node:path';
 import { cpus } from 'node:os';
 import { Worker } from 'node:worker_threads';
 import { k as normalizePath } from './fs.mjs';
+import { g as getLoaderName } from './request-path.mjs';
+import { e as ensureSlash } from './pathname.mjs';
 
 function ssgWorkerCompare(a, b) {
   if (a.activeTasks < b.activeTasks) {
@@ -165,7 +167,8 @@ async function createWorkerPool(sys, opts) {
   const render = async (ssgRoute) => {
     const ssgWorker = getNextWorker();
     const result = await ssgWorker.render(ssgRoute);
-    if (sitemapOutFile && result.ok && result.resourceType === "page") {
+    const isNotFoundPage = result.pathname.endsWith("/404.html");
+    if (sitemapOutFile && result.ok && result.resourceType === "page" && !isNotFoundPage) {
       sitemapBuffer.push(`<url><loc>${result.url}</loc></url>`);
       if (sitemapBuffer.length > 50) {
         const siteMapUrls = sitemapBuffer.join("\n") + "\n";
@@ -301,13 +304,10 @@ async function createSystem(opts, threadId) {
     }
     return join(outDir, pathname);
   };
-  const getDataFilePath = (pathname) => {
+  const getLoaderFilePath = (pathname, loaderId, manifestHash) => {
     pathname = decodeURIComponent(pathname.slice(basenameLen));
-    if (pathname.endsWith("/")) {
-      pathname += "q-data.json";
-    } else {
-      pathname += "/q-data.json";
-    }
+    const suffix = getLoaderName(loaderId, manifestHash);
+    pathname = ensureSlash(pathname) + suffix;
     return join(outDir, pathname);
   };
   const sys = {
@@ -319,7 +319,7 @@ async function createSystem(opts, threadId) {
     createTimer,
     access,
     getRouteFilePath,
-    getDataFilePath,
+    getLoaderFilePath,
     getEnv: (key) => process.env[key],
     platform: {
       static: true,

package/lib/chunks/use-functions.qwik.mjs

@@ -1,14 +1,5 @@
-import { createContextId, useContext, implicit$FirstArg, useVisibleTaskQrl, inlinedQrl, _captures, noSerialize, useServerData } from '@qwik.dev/core';
-
-const RouteStateContext = /* @__PURE__ */ createContextId("qr-s");
-const ContentContext = /* @__PURE__ */ createContextId("qr-c");
-const ContentInternalContext = /* @__PURE__ */ createContextId("qr-ic");
-const DocumentHeadContext = /* @__PURE__ */ createContextId("qr-h");
-const RouteLocationContext = /* @__PURE__ */ createContextId("qr-l");
-const RouteNavigateContext = /* @__PURE__ */ createContextId("qr-n");
-const RouteActionContext = /* @__PURE__ */ createContextId("qr-a");
-const RoutePreventNavigateContext = /* @__PURE__ */ createContextId("qr-p");
-const HttpStatusContext = /* @__PURE__ */ createContextId("qr-hs");
+import { useContext, implicit$FirstArg, useVisibleTaskQrl, inlinedQrl, _captures, noSerialize, useServerData } from '@qwik.dev/core';
+import { C as ContentContext, D as DocumentHeadContext, H as HttpStatusContext, h as RouteLocationContext, j as RouteNavigateContext, o as RoutePreventNavigateContext, n as RouteActionContext } from './head.qwik.mjs';
 
 const useHttpStatus = () => useContext(HttpStatusContext).value;
 const useContent = () => useContext(ContentContext);
@@ -29,4 +20,4 @@ const usePreventNavigate$ = implicit$FirstArg(usePreventNavigateQrl);
 const useAction = () => useContext(RouteActionContext);
 const useQwikRouterEnv = () => noSerialize(useServerData("qwikrouter"));
 
-export { ContentContext as C, DocumentHeadContext as D, HttpStatusContext as H, RouteLocationContext as R, useLocation as a, useQwikRouterEnv as b, ContentInternalContext as c, RouteNavigateContext as d, RouteStateContext as e, RouteActionContext as f, RoutePreventNavigateContext as g, useAction as h, useDocumentHead as i, useContent as j, useHttpStatus as k, usePreventNavigate$ as l, usePreventNavigateQrl as m, useNavigate as u };
+export { useLocation as a, useDocumentHead as b, useQwikRouterEnv as c, useAction as d, useContent as e, useHttpStatus as f, usePreventNavigate$ as g, usePreventNavigateQrl as h, useNavigate as u };