@qwik.dev/router 2.0.0-beta.37 → 2.0.0-beta.39

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

@@ -4,7 +4,7 @@ const IsQLoader = "@isQLoader";
 const IsQAction = "@isQAction";
 const QLoaderId = "@loaderId";
 const QActionId = "@actionId";
-const LOADER_REGEX = /\/(q-loader-([^.]+)\.([^.]+)\.json)$/;
+const LOADER_REGEX = /\/(q-loader-([^/.]+)\.([^/.]+)\.json)$/;
 const getLoaderName = (loaderId, manifestHash) => `q-loader-${loaderId}.${manifestHash}.json`;
 function recognizeRequest(pathname) {
   if (pathname.length < 10) {
@@ -57,4 +57,4 @@ function resolveValidInternalFullPathname(loaderPathname, fullPath) {
   }
 }
 
-export { IsQLoader as I, LOADER_REGEX as L, QLoaderId as Q, QActionId as a, IsQAction as b, resolveValidInternalFullPathname as c, trimInternalPathname as d, getLoaderName as g, recognizeRequest as r, trimRecognizedInternalPathname as t };
+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

@@ -167,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";

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

@@ -1,5 +1,5 @@
 import { useContext, implicit$FirstArg, useVisibleTaskQrl, inlinedQrl, _captures, noSerialize, useServerData } from '@qwik.dev/core';
-import { C as ContentContext, D as DocumentHeadContext, H as HttpStatusContext, R as RouteLocationContext, b as RouteNavigateContext, h as RoutePreventNavigateContext, g as RouteActionContext } from './deepFreeze.qwik.mjs';
+import { C as ContentContext, D as DocumentHeadContext, H as HttpStatusContext, j as RouteLocationContext, k as RouteNavigateContext, p as RoutePreventNavigateContext, o as RouteActionContext } from './head.qwik.mjs';
 
 const useHttpStatus = () => useContext(HttpStatusContext).value;
 const useContent = () => useContext(ContentContext);