@qwik.dev/router 2.0.0-beta.11 → 2.0.0-beta.14

package/lib/middleware/aws-lambda/index.mjs

@@ -1,41 +1,51 @@
-import { createQwikRouter as c } from "@qwik.dev/router/middleware/node";
-function u(r) {
-  r.qwikCityPlan && !r.qwikRouterConfig && (console.warn("qwikCityPlan is deprecated. Simply remove it."), r.qwikRouterConfig = r.qwikCityPlan);
+import { createQwikRouter as createQwikRouter$1 } from '@qwik.dev/router/middleware/node';
+
+function createQwikRouter(opts) {
+  if (opts.qwikCityPlan && !opts.qwikRouterConfig) {
+    console.warn("qwikCityPlan is deprecated. Simply remove it.");
+    opts.qwikRouterConfig = opts.qwikCityPlan;
+  }
   try {
-    const { router: n, staticFile: i, notFound: a } = c({
-      render: r.render,
-      qwikRouterConfig: r.qwikRouterConfig,
-      manifest: r.manifest,
+    const { router, staticFile, notFound } = createQwikRouter$1({
+      render: opts.render,
+      qwikRouterConfig: opts.qwikRouterConfig,
+      manifest: opts.manifest,
       static: {
         cacheControl: "public, max-age=31557600"
       },
-      getOrigin(e) {
-        return process.env.IS_OFFLINE ? `http://${e.headers.host}` : null;
+      getOrigin(req) {
+        if (process.env.IS_OFFLINE) {
+          return `http://${req.headers.host}`;
+        }
+        return null;
       }
-    }), o = (e) => {
+    });
+    const fixPath = (pathT) => {
       if (!globalThis.__NO_TRAILING_SLASH__) {
-        const t = new URL(e, "http://aws-qwik.local");
-        if (t.pathname.includes(".", t.pathname.lastIndexOf("/")))
-          return e;
-        if (!t.pathname.endsWith("/"))
-          return t.pathname + "/" + t.search;
+        const url = new URL(pathT, "http://aws-qwik.local");
+        if (url.pathname.includes(".", url.pathname.lastIndexOf("/"))) {
+          return pathT;
+        }
+        if (!url.pathname.endsWith("/")) {
+          return url.pathname + "/" + url.search;
+        }
       }
-      return e;
+      return pathT;
     };
-    return { fixPath: o, router: n, staticFile: i, notFound: a, handle: (e, t) => {
-      e.url = o(e.url), i(e, t, () => {
-        n(e, t, () => {
-          a(e, t, () => {
+    const handle = (req, res) => {
+      req.url = fixPath(req.url);
+      staticFile(req, res, () => {
+        router(req, res, () => {
+          notFound(req, res, () => {
           });
         });
       });
-    } };
-  } catch (n) {
-    throw new Error(n.message);
+    };
+    return { fixPath, router, staticFile, notFound, handle };
+  } catch (err) {
+    throw new Error(err.message);
   }
 }
-const s = u;
-export {
-  s as createQwikCity,
-  u as createQwikRouter
-};
+const createQwikCity = createQwikRouter;
+
+export { createQwikCity, createQwikRouter };

package/lib/middleware/azure-swa/index.mjs

@@ -1,74 +1,91 @@
-import { setServerPlatform as w } from "@qwik.dev/core/server";
-import { requestHandler as p, isStaticPath as b, getNotFound as g } from "@qwik.dev/router/middleware/request-handler";
-import { parseString as C } from "set-cookie-parser";
-function v(t) {
-  t.qwikCityPlan && !t.qwikRouterConfig && (console.warn("qwikCityPlan is deprecated. Simply remove it."), t.qwikRouterConfig = t.qwikCityPlan), t.manifest && w(t.manifest);
-  async function c(u, e) {
+import { setServerPlatform } from '@qwik.dev/core/server';
+import { requestHandler, isStaticPath, getNotFound } from '@qwik.dev/router/middleware/request-handler';
+import { parseString } from 'set-cookie-parser';
+
+function createQwikRouter(opts) {
+  if (opts.qwikCityPlan && !opts.qwikRouterConfig) {
+    console.warn("qwikCityPlan is deprecated. Simply remove it.");
+    opts.qwikRouterConfig = opts.qwikCityPlan;
+  }
+  if (opts.manifest) {
+    setServerPlatform(opts.manifest);
+  }
+  async function onAzureSwaRequest(context, req) {
     try {
-      const n = new URL(e.headers["x-ms-original-url"]), l = {
-        method: e.method || "GET",
-        headers: e.headers,
-        body: e.bufferBody || e.rawBody || e.body
-      }, f = {
+      const url = new URL(req.headers["x-ms-original-url"]);
+      const options = {
+        method: req.method || "GET",
+        headers: req.headers,
+        body: req.bufferBody || req.rawBody || req.body
+      };
+      const serverRequestEv = {
         mode: "server",
         locale: void 0,
-        url: n,
-        platform: u,
+        url,
+        platform: context,
         env: {
-          get(o) {
-            return process.env[o];
+          get(key) {
+            return process.env[key];
           }
         },
-        request: new Request(n, l),
-        getWritableStream: (o, i, m, y) => {
-          const r = {
-            status: o,
+        request: new Request(url, options),
+        getWritableStream: (status, headers, cookies, resolve) => {
+          const response = {
+            status,
             body: new Uint8Array(),
             headers: {},
-            cookies: m.headers().map((a) => C(a))
+            cookies: cookies.headers().map((header) => parseString(header))
           };
-          return i.forEach((a, s) => r.headers[s] = a), new WritableStream({
-            write(a) {
-              if (r.body instanceof Uint8Array) {
-                const s = new Uint8Array(r.body.length + a.length);
-                s.set(r.body), s.set(a, r.body.length), r.body = s;
+          headers.forEach((value, key) => response.headers[key] = value);
+          return new WritableStream({
+            write(chunk) {
+              if (response.body instanceof Uint8Array) {
+                const newBuffer = new Uint8Array(response.body.length + chunk.length);
+                newBuffer.set(response.body);
+                newBuffer.set(chunk, response.body.length);
+                response.body = newBuffer;
               }
             },
             close() {
-              y(r);
+              resolve(response);
             }
           });
         },
-        getClientConn: () => ({
-          ip: e.headers["x-forwarded-client-Ip"],
-          country: void 0
-        })
-      }, d = await p(f, t);
-      if (d) {
-        d.completion.then((i) => {
-          i && console.error(i);
+        getClientConn: () => {
+          return {
+            ip: req.headers["x-forwarded-client-Ip"],
+            country: void 0
+          };
+        }
+      };
+      const handledResponse = await requestHandler(serverRequestEv, opts);
+      if (handledResponse) {
+        handledResponse.completion.then((err) => {
+          if (err) {
+            console.error(err);
+          }
         });
-        const o = await d.response;
-        if (o)
-          return o;
+        const response = await handledResponse.response;
+        if (response) {
+          return response;
+        }
       }
-      const h = !e.headers.accept?.includes("text/html") || b(e.method || "GET", n) ? "Not Found" : g(n.pathname);
+      const notFoundHtml = !req.headers.accept?.includes("text/html") || isStaticPath(req.method || "GET", url) ? "Not Found" : getNotFound(url.pathname);
       return {
         status: 404,
-        headers: { "Content-Type": "text/html; charset=utf-8", "X-Not-Found": n.pathname },
-        body: h
+        headers: { "Content-Type": "text/html; charset=utf-8", "X-Not-Found": url.pathname },
+        body: notFoundHtml
       };
-    } catch (n) {
-      return console.error(n), {
+    } catch (e) {
+      console.error(e);
+      return {
         status: 500,
         headers: { "Content-Type": "text/plain; charset=utf-8" }
       };
     }
   }
-  return c;
+  return onAzureSwaRequest;
 }
-const x = v;
-export {
-  x as createQwikCity,
-  v as createQwikRouter
-};
+const createQwikCity = createQwikRouter;
+
+export { createQwikCity, createQwikRouter };

package/lib/middleware/bun/index.mjs

@@ -1,156 +1,141 @@
-import { setServerPlatform as x } from "@qwik.dev/core/server";
-import { _TextEncoderStream_polyfill as w, mergeHeadersCookies as C, requestHandler as R, isStaticPath as p, getNotFound as y } from "@qwik.dev/router/middleware/request-handler";
-import { join as s, extname as b } from "node:path";
-const T = {
-  "3gp": "video/3gpp",
-  "3gpp": "video/3gpp",
-  asf: "video/x-ms-asf",
-  asx: "video/x-ms-asf",
-  avi: "video/x-msvideo",
-  avif: "image/avif",
-  bmp: "image/x-ms-bmp",
-  css: "text/css",
-  flv: "video/x-flv",
-  gif: "image/gif",
-  htm: "text/html",
-  html: "text/html",
-  ico: "image/x-icon",
-  jng: "image/x-jng",
-  jpeg: "image/jpeg",
-  jpg: "image/jpeg",
-  js: "application/javascript",
-  json: "application/json",
-  kar: "audio/midi",
-  m4a: "audio/x-m4a",
-  m4v: "video/x-m4v",
-  mid: "audio/midi",
-  midi: "audio/midi",
-  mng: "video/x-mng",
-  mov: "video/quicktime",
-  mp3: "audio/mpeg",
-  mp4: "video/mp4",
-  mpeg: "video/mpeg",
-  mpg: "video/mpeg",
-  ogg: "audio/ogg",
-  pdf: "application/pdf",
-  png: "image/png",
-  rar: "application/x-rar-compressed",
-  shtml: "text/html",
-  svg: "image/svg+xml",
-  svgz: "image/svg+xml",
-  tif: "image/tiff",
-  tiff: "image/tiff",
-  ts: "video/mp2t",
-  txt: "text/plain",
-  wbmp: "image/vnd.wap.wbmp",
-  webm: "video/webm",
-  webp: "image/webp",
-  wmv: "video/x-ms-wmv",
-  woff: "font/woff",
-  woff2: "font/woff2",
-  xml: "text/xml",
-  zip: "application/zip"
-};
-function S(i) {
-  i.qwikCityPlan && !i.qwikRouterConfig && (console.warn("qwikCityPlan is deprecated. Simply remove it."), i.qwikRouterConfig = i.qwikCityPlan), globalThis.TextEncoderStream ||= w, i.manifest && x(i.manifest);
-  const m = i.static?.root ?? s(Bun.fileURLToPath(import.meta.url), "..", "..", "dist");
-  async function d(t) {
+import { setServerPlatform } from '@qwik.dev/core/server';
+import { _TextEncoderStream_polyfill, isStaticPath, getNotFound, mergeHeadersCookies, requestHandler } from '@qwik.dev/router/middleware/request-handler';
+import { join, extname } from 'node:path';
+import { M as MIME_TYPES } from '../../chunks/mime-types.mjs';
+
+function createQwikRouter(opts) {
+  if (opts.qwikCityPlan && !opts.qwikRouterConfig) {
+    console.warn("qwikCityPlan is deprecated. Simply remove it.");
+    opts.qwikRouterConfig = opts.qwikCityPlan;
+  }
+  globalThis.TextEncoderStream ||= _TextEncoderStream_polyfill;
+  if (opts.manifest) {
+    setServerPlatform(opts.manifest);
+  }
+  const staticFolder = opts.static?.root ?? join(Bun.fileURLToPath(import.meta.url), "..", "..", "dist");
+  async function router(request) {
     try {
-      const a = {
+      const url = new URL(request.url);
+      const serverRequestEv = {
         mode: "server",
         locale: void 0,
-        url: new URL(t.url),
+        url,
         env: {
-          get(o) {
-            return Bun.env[o];
+          get(key) {
+            return Bun.env[key];
           }
         },
-        request: t,
-        getWritableStream: (o, r, l, c) => {
-          const { readable: g, writable: h } = new TransformStream(), v = new Response(g, {
-            status: o,
-            headers: C(r, l)
+        request,
+        getWritableStream: (status, headers, cookies, resolve) => {
+          const { readable, writable } = new TransformStream();
+          const response = new Response(readable, {
+            status,
+            headers: mergeHeadersCookies(headers, cookies)
           });
-          return c(v), h;
+          resolve(response);
+          return writable;
         },
         platform: {
-          ssr: !0
+          ssr: true
         },
-        getClientConn: () => i.getClientConn ? i.getClientConn(t) : {}
-      }, n = await R(a, i);
-      if (n) {
-        n.completion.then((r) => {
-          r && console.error(r);
+        getClientConn: () => {
+          return opts.getClientConn ? opts.getClientConn(request) : {};
+        }
+      };
+      const handledResponse = await requestHandler(serverRequestEv, opts);
+      if (handledResponse) {
+        handledResponse.completion.then((v) => {
+          if (v) {
+            console.error(v);
+          }
         });
-        const o = await n.response;
-        if (o) {
-          const r = o.status, l = o.headers.get("Location");
-          return r >= 301 && r <= 308 && l ? new Response(null, o) : o;
+        const response = await handledResponse.response;
+        if (response) {
+          const status = response.status;
+          const location = response.headers.get("Location");
+          const isRedirect = status >= 301 && status <= 308 && location;
+          if (isRedirect) {
+            return new Response(null, response);
+          }
+          return response;
         }
       }
       return null;
     } catch (e) {
-      return console.error(e), new Response(String(e || "Error"), {
+      console.error(e);
+      return new Response(String(e || "Error"), {
         status: 500,
         headers: { "Content-Type": "text/plain; charset=utf-8", "X-Error": "bun-server" }
       });
     }
   }
-  const u = async (t) => {
+  const notFound = async (request) => {
     try {
-      const e = new URL(t.url), a = !t.headers.get("accept")?.includes("text/html") || p(t.method || "GET", e) ? "Not Found" : y(e.pathname);
-      return new Response(a, {
+      const url = new URL(request.url);
+      const notFoundHtml = !request.headers.get("accept")?.includes("text/html") || isStaticPath(request.method || "GET", url) ? "Not Found" : getNotFound(url.pathname);
+      return new Response(notFoundHtml, {
         status: 404,
-        headers: { "Content-Type": "text/html; charset=utf-8", "X-Not-Found": e.pathname }
+        headers: { "Content-Type": "text/html; charset=utf-8", "X-Not-Found": url.pathname }
       });
     } catch (e) {
-      return console.error(e), new Response(String(e || "Error"), {
+      console.error(e);
+      return new Response(String(e || "Error"), {
         status: 500,
         headers: { "Content-Type": "text/plain; charset=utf-8", "X-Error": "bun-server" }
       });
     }
-  }, f = async (t) => {
-    const e = t.pathname, a = e.slice(t.pathname.lastIndexOf("/"));
-    let n;
-    return a.includes(".") ? n = s(m, e) : globalThis.__NO_TRAILING_SLASH__ ? n = s(m, e, "index.html") : n = s(m, e + "index.html"), {
-      filePath: n,
-      content: Bun.file(n)
+  };
+  const openStaticFile = async (url) => {
+    const pathname = url.pathname;
+    const fileName = pathname.slice(url.pathname.lastIndexOf("/"));
+    let filePath;
+    if (fileName.includes(".")) {
+      filePath = join(staticFolder, pathname);
+    } else if (!globalThis.__NO_TRAILING_SLASH__) {
+      filePath = join(staticFolder, pathname + "index.html");
+    } else {
+      filePath = join(staticFolder, pathname, "index.html");
+    }
+    return {
+      filePath,
+      content: Bun.file(filePath)
     };
   };
-  return {
-    router: d,
-    notFound: u,
-    staticFile: async (t) => {
-      try {
-        const e = new URL(t.url);
-        if (p(t.method || "GET", e)) {
-          const { filePath: a, content: n } = await f(e);
-          if (!await n.exists())
-            return new Response("Not Found", {
-              status: 404,
-              headers: { "Content-Type": "text/plain; charset=utf-8", "X-Not-Found": e.pathname }
-            });
-          const o = b(a).replace(/^\./, "");
-          return new Response(await n.stream(), {
-            status: 200,
-            headers: {
-              "content-type": T[o] || "text/plain; charset=utf-8",
-              "Cache-Control": i.static?.cacheControl || "max-age=3600"
-            }
+  const staticFile = async (request) => {
+    try {
+      const url = new URL(request.url);
+      if (isStaticPath(request.method || "GET", url)) {
+        const { filePath, content } = await openStaticFile(url);
+        if (!await content.exists()) {
+          return new Response("Not Found", {
+            status: 404,
+            headers: { "Content-Type": "text/plain; charset=utf-8", "X-Not-Found": url.pathname }
           });
         }
-        return null;
-      } catch (e) {
-        return console.error(e), new Response(String(e || "Error"), {
-          status: 500,
-          headers: { "Content-Type": "text/plain; charset=utf-8", "X-Error": "bun-server" }
+        const ext = extname(filePath).replace(/^\./, "");
+        return new Response(await content.stream(), {
+          status: 200,
+          headers: {
+            "content-type": MIME_TYPES[ext] || "text/plain; charset=utf-8",
+            "Cache-Control": opts.static?.cacheControl || "max-age=3600"
+          }
         });
       }
+      return null;
+    } catch (e) {
+      console.error(e);
+      return new Response(String(e || "Error"), {
+        status: 500,
+        headers: { "Content-Type": "text/plain; charset=utf-8", "X-Error": "bun-server" }
+      });
     }
   };
+  return {
+    router,
+    notFound,
+    staticFile
+  };
 }
-const P = S;
-export {
-  P as createQwikCity,
-  S as createQwikRouter
-};
+const createQwikCity = createQwikRouter;
+
+export { createQwikCity, createQwikRouter };

package/lib/middleware/cloudflare-pages/index.mjs

@@ -1,75 +1,95 @@
-import { setServerPlatform as y } from "@qwik.dev/core/server";
-import { _TextEncoderStream_polyfill as R, isStaticPath as h, mergeHeadersCookies as S, requestHandler as T, getNotFound as k } from "@qwik.dev/router/middleware/request-handler";
-function E(r) {
-  r.qwikCityPlan && !r.qwikRouterConfig && (console.warn("qwikCityPlan is deprecated. Simply remove it."), r.qwikRouterConfig = r.qwikCityPlan);
+import { setServerPlatform } from '@qwik.dev/core/server';
+import { _TextEncoderStream_polyfill, isStaticPath, mergeHeadersCookies, requestHandler, getNotFound } from '@qwik.dev/router/middleware/request-handler';
+
+function createQwikRouter(opts) {
+  if (opts.qwikCityPlan && !opts.qwikRouterConfig) {
+    console.warn("qwikCityPlan is deprecated. Simply remove it.");
+    opts.qwikRouterConfig = opts.qwikCityPlan;
+  }
   try {
     new globalThis.TextEncoderStream();
   } catch {
-    globalThis.TextEncoderStream = R;
+    globalThis.TextEncoderStream = _TextEncoderStream_polyfill;
+  }
+  if (opts.manifest) {
+    setServerPlatform(opts.manifest);
   }
-  r.manifest && y(r.manifest);
-  async function m(n, s, i) {
+  async function onCloudflarePagesFetch(request, env, ctx) {
     try {
-      const e = new URL(n.url);
-      if (h(n.method, e))
-        return s.ASSETS.fetch(n);
-      const d = e.hostname !== "127.0.0.1" && e.hostname !== "localhost" && e.port === "" && n.method === "GET", l = new Request(e.href, n), o = d ? await caches.open("custom:qwikrouter") : null;
-      if (o) {
-        const t = await o.match(l);
-        if (t)
-          return t;
+      const url = new URL(request.url);
+      if (isStaticPath(request.method, url)) {
+        return env.ASSETS.fetch(request);
+      }
+      const useCache = url.hostname !== "127.0.0.1" && url.hostname !== "localhost" && url.port === "" && request.method === "GET";
+      const cacheKey = new Request(url.href, request);
+      const cache = useCache ? await caches.open("custom:qwikrouter") : null;
+      if (cache) {
+        const cachedResponse = await cache.match(cacheKey);
+        if (cachedResponse) {
+          return cachedResponse;
+        }
       }
-      const c = await T({
+      const serverRequestEv = {
         mode: "server",
         locale: void 0,
-        url: e,
-        request: n,
+        url,
+        request,
         env: {
-          get(t) {
-            return s[t];
+          get(key) {
+            return env[key];
           }
         },
-        getWritableStream: (t, a, f, p) => {
-          const { readable: w, writable: C } = new TransformStream(), g = new Response(w, {
-            status: t,
-            headers: S(a, f)
+        getWritableStream: (status, headers, cookies, resolve) => {
+          const { readable, writable } = new TransformStream();
+          const response = new Response(readable, {
+            status,
+            headers: mergeHeadersCookies(headers, cookies)
           });
-          return p(g), C;
+          resolve(response);
+          return writable;
+        },
+        getClientConn: () => {
+          return {
+            ip: request.headers.get("CF-connecting-ip") || "",
+            country: request.headers.get("CF-IPCountry") || ""
+          };
         },
-        getClientConn: () => ({
-          ip: n.headers.get("CF-connecting-ip") || "",
-          country: n.headers.get("CF-IPCountry") || ""
-        }),
         platform: {
-          request: n,
-          env: s,
-          ctx: i
+          request,
+          env,
+          ctx
         }
-      }, r);
-      if (c) {
-        c.completion.then((a) => {
-          a && console.error(a);
+      };
+      const handledResponse = await requestHandler(serverRequestEv, opts);
+      if (handledResponse) {
+        handledResponse.completion.then((v) => {
+          if (v) {
+            console.error(v);
+          }
         });
-        const t = await c.response;
-        if (t)
-          return t.ok && o && t.headers.has("Cache-Control") && i.waitUntil(o.put(l, t.clone())), t;
+        const response = await handledResponse.response;
+        if (response) {
+          if (response.ok && cache && response.headers.has("Cache-Control")) {
+            ctx.waitUntil(cache.put(cacheKey, response.clone()));
+          }
+          return response;
+        }
       }
-      const u = !n.headers.get("accept")?.includes("text/html") || h(n.method || "GET", e) ? "Not Found" : k(e.pathname);
-      return new Response(u, {
+      const notFoundHtml = !request.headers.get("accept")?.includes("text/html") || isStaticPath(request.method || "GET", url) ? "Not Found" : getNotFound(url.pathname);
+      return new Response(notFoundHtml, {
         status: 404,
-        headers: { "Content-Type": "text/html; charset=utf-8", "X-Not-Found": e.pathname }
+        headers: { "Content-Type": "text/html; charset=utf-8", "X-Not-Found": url.pathname }
       });
     } catch (e) {
-      return console.error(e), new Response(String(e || "Error"), {
+      console.error(e);
+      return new Response(String(e || "Error"), {
         status: 500,
         headers: { "Content-Type": "text/plain; charset=utf-8", "X-Error": "cloudflare-pages" }
       });
     }
   }
-  return m;
+  return onCloudflarePagesFetch;
 }
-const x = E;
-export {
-  x as createQwikCity,
-  E as createQwikRouter
-};
+const createQwikCity = createQwikRouter;
+
+export { createQwikCity, createQwikRouter };