@qwik.dev/router 0.0.0 → 2.0.0-alpha.1

package/lib/middleware/aws-lambda/index.d.ts

@@ -0,0 +1,50 @@
+/// <reference types="node" />
+
+import { Http2ServerRequest } from 'http2';
+import { IncomingMessage } from 'http';
+import { NodeRequestNextFunction } from '@qwik.dev/router/middleware/node';
+import type { QwikCityPlan } from '@qwik.dev/router';
+import type { QwikManifest } from '@qwik.dev/core/optimizer';
+import type { QwikRouterConfig } from '@qwik.dev/router';
+import type { Render } from '@qwik.dev/core/server';
+import type { ServerRenderOptions } from '@qwik.dev/router/middleware/request-handler';
+import { ServerResponse } from 'http';
+
+declare interface AwsOpt {
+    render: Render;
+    manifest: QwikManifest;
+    qwikRouterConfig: QwikRouterConfig;
+    /** @deprecated Use `QwikRouterConfig` instead. Will be removed in V3 */
+    qwikCityPlan?: QwikCityPlan;
+}
+
+/**
+ * @deprecated Use `createQwikRouter` instead. Will be removed in V3
+ * @public
+ */
+export declare const createQwikCity: typeof createQwikRouter;
+
+/** @public */
+export declare function createQwikRouter(opts: AwsOpt): {
+    fixPath: (pathT: string) => string;
+    router: (req: IncomingMessage | Http2ServerRequest, res: ServerResponse<IncomingMessage>, next: NodeRequestNextFunction) => Promise<void>;
+    staticFile: (req: IncomingMessage | Http2ServerRequest, res: ServerResponse<IncomingMessage>, next: (e?: any) => void) => Promise<void>;
+    notFound: (req: IncomingMessage | Http2ServerRequest, res: ServerResponse<IncomingMessage>, next: (e: any) => void) => Promise<void>;
+    handle: (req: any, res: any) => void;
+};
+
+/** @public */
+export declare interface PlatformAwsLambda extends Object {
+}
+
+/**
+ * @deprecated Use `QwikRouterAwsLambdaOptions` instead. Will be removed in V3
+ * @public
+ */
+export declare type QwikCityAwsLambdaOptions = QwikRouterAwsLambdaOptions;
+
+/** @public */
+export declare interface QwikRouterAwsLambdaOptions extends ServerRenderOptions {
+}
+
+export { }

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

@@ -0,0 +1,55 @@
+// packages/qwik-router/src/middleware/aws-lambda/index.ts
+import { createQwikRouter as createQwikRouterNode } from "@qwik.dev/router/middleware/node";
+function createQwikRouter(opts) {
+  if (opts.qwikCityPlan && !opts.qwikRouterConfig) {
+    console.warn("qwikCityPlan is deprecated. Use qwikRouterConfig instead.");
+    opts.qwikRouterConfig = opts.qwikCityPlan;
+  } else if (!opts.qwikRouterConfig) {
+    throw new Error("qwikRouterConfig is required.");
+  }
+  try {
+    const { router, staticFile, notFound } = createQwikRouterNode({
+      render: opts.render,
+      qwikRouterConfig: opts.qwikRouterConfig,
+      manifest: opts.manifest,
+      static: {
+        cacheControl: "public, max-age=31557600"
+      },
+      getOrigin(req) {
+        if (process.env.IS_OFFLINE) {
+          return `http://${req.headers.host}`;
+        }
+        return null;
+      }
+    });
+    const fixPath = (pathT) => {
+      if (opts.qwikRouterConfig.trailingSlash) {
+        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 pathT;
+    };
+    const handle = (req, res) => {
+      req.url = fixPath(req.url);
+      staticFile(req, res, () => {
+        router(req, res, () => {
+          notFound(req, res, () => {
+          });
+        });
+      });
+    };
+    return { fixPath, router, staticFile, notFound, handle };
+  } catch (err) {
+    throw new Error(err.message);
+  }
+}
+var createQwikCity = createQwikRouter;
+export {
+  createQwikCity,
+  createQwikRouter
+};

package/lib/middleware/azure-swa/index.d.ts

@@ -0,0 +1,28 @@
+import type { AzureFunction } from '@azure/functions';
+import type { Context } from '@azure/functions';
+import type { ServerRenderOptions } from '@qwik.dev/router/middleware/request-handler';
+
+/**
+ * @deprecated Use `createQwikRouter` instead. Will be removed in V3
+ * @public
+ */
+export declare const createQwikCity: typeof createQwikRouter;
+
+/** @public */
+export declare function createQwikRouter(opts: QwikRouterAzureOptions): AzureFunction;
+
+/** @public */
+export declare interface PlatformAzure extends Partial<Context> {
+}
+
+/**
+ * @deprecated Use `QwikRouterAzureOptions` instead. Will be removed in V3
+ * @public
+ */
+export declare type QwikCityAzureOptions = QwikRouterAzureOptions;
+
+/** @public */
+export declare interface QwikRouterAzureOptions extends ServerRenderOptions {
+}
+
+export { }

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

@@ -0,0 +1,297 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/.pnpm/set-cookie-parser@2.6.0/node_modules/set-cookie-parser/lib/set-cookie.js
+var require_set_cookie = __commonJS({
+  "node_modules/.pnpm/set-cookie-parser@2.6.0/node_modules/set-cookie-parser/lib/set-cookie.js"(exports, module) {
+    "use strict";
+    var defaultParseOptions = {
+      decodeValues: true,
+      map: false,
+      silent: false
+    };
+    function isNonEmptyString(str) {
+      return typeof str === "string" && !!str.trim();
+    }
+    function parseString2(setCookieValue, options) {
+      var parts = setCookieValue.split(";").filter(isNonEmptyString);
+      var nameValuePairStr = parts.shift();
+      var parsed = parseNameValuePair(nameValuePairStr);
+      var name = parsed.name;
+      var value = parsed.value;
+      options = options ? Object.assign({}, defaultParseOptions, options) : defaultParseOptions;
+      try {
+        value = options.decodeValues ? decodeURIComponent(value) : value;
+      } catch (e) {
+        console.error(
+          "set-cookie-parser encountered an error while decoding a cookie with value '" + value + "'. Set options.decodeValues to false to disable this feature.",
+          e
+        );
+      }
+      var cookie = {
+        name,
+        value
+      };
+      parts.forEach(function(part) {
+        var sides = part.split("=");
+        var key = sides.shift().trimLeft().toLowerCase();
+        var value2 = sides.join("=");
+        if (key === "expires") {
+          cookie.expires = new Date(value2);
+        } else if (key === "max-age") {
+          cookie.maxAge = parseInt(value2, 10);
+        } else if (key === "secure") {
+          cookie.secure = true;
+        } else if (key === "httponly") {
+          cookie.httpOnly = true;
+        } else if (key === "samesite") {
+          cookie.sameSite = value2;
+        } else {
+          cookie[key] = value2;
+        }
+      });
+      return cookie;
+    }
+    function parseNameValuePair(nameValuePairStr) {
+      var name = "";
+      var value = "";
+      var nameValueArr = nameValuePairStr.split("=");
+      if (nameValueArr.length > 1) {
+        name = nameValueArr.shift();
+        value = nameValueArr.join("=");
+      } else {
+        value = nameValuePairStr;
+      }
+      return { name, value };
+    }
+    function parse(input, options) {
+      options = options ? Object.assign({}, defaultParseOptions, options) : defaultParseOptions;
+      if (!input) {
+        if (!options.map) {
+          return [];
+        } else {
+          return {};
+        }
+      }
+      if (input.headers) {
+        if (typeof input.headers.getSetCookie === "function") {
+          input = input.headers.getSetCookie();
+        } else if (input.headers["set-cookie"]) {
+          input = input.headers["set-cookie"];
+        } else {
+          var sch = input.headers[Object.keys(input.headers).find(function(key) {
+            return key.toLowerCase() === "set-cookie";
+          })];
+          if (!sch && input.headers.cookie && !options.silent) {
+            console.warn(
+              "Warning: set-cookie-parser appears to have been called on a request object. It is designed to parse Set-Cookie headers from responses, not Cookie headers from requests. Set the option {silent: true} to suppress this warning."
+            );
+          }
+          input = sch;
+        }
+      }
+      if (!Array.isArray(input)) {
+        input = [input];
+      }
+      options = options ? Object.assign({}, defaultParseOptions, options) : defaultParseOptions;
+      if (!options.map) {
+        return input.filter(isNonEmptyString).map(function(str) {
+          return parseString2(str, options);
+        });
+      } else {
+        var cookies = {};
+        return input.filter(isNonEmptyString).reduce(function(cookies2, str) {
+          var cookie = parseString2(str, options);
+          cookies2[cookie.name] = cookie;
+          return cookies2;
+        }, cookies);
+      }
+    }
+    function splitCookiesString(cookiesString) {
+      if (Array.isArray(cookiesString)) {
+        return cookiesString;
+      }
+      if (typeof cookiesString !== "string") {
+        return [];
+      }
+      var cookiesStrings = [];
+      var pos = 0;
+      var start;
+      var ch;
+      var lastComma;
+      var nextStart;
+      var cookiesSeparatorFound;
+      function skipWhitespace() {
+        while (pos < cookiesString.length && /\s/.test(cookiesString.charAt(pos))) {
+          pos += 1;
+        }
+        return pos < cookiesString.length;
+      }
+      function notSpecialChar() {
+        ch = cookiesString.charAt(pos);
+        return ch !== "=" && ch !== ";" && ch !== ",";
+      }
+      while (pos < cookiesString.length) {
+        start = pos;
+        cookiesSeparatorFound = false;
+        while (skipWhitespace()) {
+          ch = cookiesString.charAt(pos);
+          if (ch === ",") {
+            lastComma = pos;
+            pos += 1;
+            skipWhitespace();
+            nextStart = pos;
+            while (pos < cookiesString.length && notSpecialChar()) {
+              pos += 1;
+            }
+            if (pos < cookiesString.length && cookiesString.charAt(pos) === "=") {
+              cookiesSeparatorFound = true;
+              pos = nextStart;
+              cookiesStrings.push(cookiesString.substring(start, lastComma));
+              start = pos;
+            } else {
+              pos = lastComma + 1;
+            }
+          } else {
+            pos += 1;
+          }
+        }
+        if (!cookiesSeparatorFound || pos >= cookiesString.length) {
+          cookiesStrings.push(cookiesString.substring(start, cookiesString.length));
+        }
+      }
+      return cookiesStrings;
+    }
+    module.exports = parse;
+    module.exports.parse = parse;
+    module.exports.parseString = parseString2;
+    module.exports.splitCookiesString = splitCookiesString;
+  }
+});
+
+// packages/qwik-router/src/middleware/azure-swa/index.ts
+var import_set_cookie_parser = __toESM(require_set_cookie(), 1);
+import { getNotFound } from "@qwik-router-not-found-paths";
+import { isStaticPath } from "@qwik-router-static-paths";
+import { _deserialize, _serialize, _verifySerializable } from "@qwik.dev/core/internal";
+import { setServerPlatform } from "@qwik.dev/core/server";
+import { requestHandler } from "../request-handler/index.mjs";
+function createQwikRouter(opts) {
+  if (opts.qwikCityPlan && !opts.qwikRouterConfig) {
+    console.warn("qwikCityPlan is deprecated. Use qwikRouterConfig instead.");
+    opts.qwikRouterConfig = opts.qwikCityPlan;
+  } else if (!opts.qwikRouterConfig) {
+    throw new Error("qwikRouterConfig is required.");
+  }
+  const qwikSerializer = {
+    _deserialize,
+    _serialize,
+    _verifySerializable
+  };
+  if (opts.manifest) {
+    setServerPlatform(opts.manifest);
+  }
+  async function onAzureSwaRequest(context, req) {
+    try {
+      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,
+        platform: context,
+        env: {
+          get(key) {
+            return process.env[key];
+          }
+        },
+        request: new Request(url, options),
+        getWritableStream: (status, headers, cookies, resolve) => {
+          const response = {
+            status,
+            body: new Uint8Array(),
+            headers: {},
+            cookies: cookies.headers().map((header) => (0, import_set_cookie_parser.parseString)(header))
+          };
+          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() {
+              resolve(response);
+            }
+          });
+        },
+        getClientConn: () => {
+          return {
+            ip: req.headers["x-forwarded-client-Ip"],
+            country: void 0
+          };
+        }
+      };
+      const handledResponse = await requestHandler(serverRequestEv, opts, qwikSerializer);
+      if (handledResponse) {
+        handledResponse.completion.then((err) => {
+          if (err) {
+            console.error(err);
+          }
+        });
+        const response = await handledResponse.response;
+        if (response) {
+          return response;
+        }
+      }
+      const notFoundHtml = isStaticPath(req.method || "GET", url) ? "Not Found" : getNotFound(url.pathname);
+      return {
+        status: 404,
+        headers: { "Content-Type": "text/html; charset=utf-8", "X-Not-Found": url.pathname },
+        body: notFoundHtml
+      };
+    } catch (e) {
+      console.error(e);
+      return {
+        status: 500,
+        headers: { "Content-Type": "text/plain; charset=utf-8" }
+      };
+    }
+  }
+  return onAzureSwaRequest;
+}
+var createQwikCity = createQwikRouter;
+export {
+  createQwikCity,
+  createQwikRouter
+};

package/lib/middleware/bun/index.d.ts

@@ -0,0 +1,35 @@
+import type { ClientConn } from '@qwik.dev/router/middleware/request-handler';
+import type { ServerRenderOptions } from '@qwik.dev/router/middleware/request-handler';
+
+/**
+ * @deprecated Use `createQwikRouter` instead. Will be removed in V3
+ * @public
+ */
+export declare const createQwikCity: typeof createQwikRouter;
+
+/** @public */
+export declare function createQwikRouter(opts: QwikRouterBunOptions): {
+    router: (request: Request) => Promise<Response | null>;
+    notFound: (request: Request) => Promise<Response>;
+    staticFile: (request: Request) => Promise<Response | null>;
+};
+
+/**
+ * @deprecated Use `QwikRouterBunOptions` instead. Will be removed in V3
+ * @public
+ */
+export declare type QwikCityBunOptions = QwikRouterBunOptions;
+
+/** @public */
+export declare interface QwikRouterBunOptions extends ServerRenderOptions {
+    /** Options for serving static files */
+    static?: {
+        /** The root folder for statics files. Defaults to /dist */
+        root?: string;
+        /** Set the Cache-Control header for all static files */
+        cacheControl?: string;
+    };
+    getClientConn?: (request: Request) => ClientConn;
+}
+
+export { }

package/lib/middleware/bun/index.mjs

@@ -0,0 +1,208 @@
+// packages/qwik-router/src/middleware/bun/index.ts
+import { getNotFound } from "@qwik-router-not-found-paths";
+import { isStaticPath } from "@qwik-router-static-paths";
+import { _deserialize, _serialize, _verifySerializable } from "@qwik.dev/core/internal";
+import { setServerPlatform } from "@qwik.dev/core/server";
+import {
+  _TextEncoderStream_polyfill,
+  mergeHeadersCookies,
+  requestHandler
+} from "../request-handler/index.mjs";
+import { extname, join } from "node:path";
+
+// packages/qwik-router/src/middleware/request-handler/mime-types.ts
+var MIME_TYPES = {
+  "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"
+};
+
+// packages/qwik-router/src/middleware/bun/index.ts
+function createQwikRouter(opts) {
+  var _a;
+  if (opts.qwikCityPlan && !opts.qwikRouterConfig) {
+    console.warn("qwikCityPlan is deprecated. Use qwikRouterConfig instead.");
+    opts.qwikRouterConfig = opts.qwikCityPlan;
+  } else if (!opts.qwikRouterConfig) {
+    throw new Error("qwikRouterConfig is required.");
+  }
+  globalThis.TextEncoderStream ||= _TextEncoderStream_polyfill;
+  const qwikSerializer = { _deserialize, _serialize, _verifySerializable };
+  if (opts.manifest) {
+    setServerPlatform(opts.manifest);
+  }
+  const staticFolder = ((_a = opts.static) == null ? void 0 : _a.root) ?? join(Bun.fileURLToPath(import.meta.url), "..", "..", "dist");
+  async function router(request) {
+    try {
+      const url = new URL(request.url);
+      const serverRequestEv = {
+        mode: "server",
+        locale: void 0,
+        url,
+        env: {
+          get(key) {
+            return Bun.env[key];
+          }
+        },
+        request,
+        getWritableStream: (status, headers, cookies, resolve) => {
+          const { readable, writable } = new TransformStream();
+          const response = new Response(readable, {
+            status,
+            headers: mergeHeadersCookies(headers, cookies)
+          });
+          resolve(response);
+          return writable;
+        },
+        platform: {
+          ssr: true
+        },
+        getClientConn: () => {
+          return opts.getClientConn ? opts.getClientConn(request) : {};
+        }
+      };
+      const handledResponse = await requestHandler(serverRequestEv, opts, qwikSerializer);
+      if (handledResponse) {
+        handledResponse.completion.then((v) => {
+          if (v) {
+            console.error(v);
+          }
+        });
+        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) {
+      console.error(e);
+      return new Response(String(e || "Error"), {
+        status: 500,
+        headers: { "Content-Type": "text/plain; charset=utf-8", "X-Error": "bun-server" }
+      });
+    }
+  }
+  const notFound = async (request) => {
+    try {
+      const url = new URL(request.url);
+      const notFoundHtml = 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": url.pathname }
+      });
+    } 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" }
+      });
+    }
+  };
+  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 (opts.qwikRouterConfig.trailingSlash) {
+      filePath = join(staticFolder, pathname + "index.html");
+    } else {
+      filePath = join(staticFolder, pathname, "index.html");
+    }
+    return {
+      filePath,
+      content: Bun.file(filePath)
+    };
+  };
+  const staticFile = async (request) => {
+    var _a2;
+    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 }
+          });
+        }
+        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": ((_a2 = opts.static) == null ? void 0 : _a2.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
+  };
+}
+var createQwikCity = createQwikRouter;
+export {
+  createQwikCity,
+  createQwikRouter
+};