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

package/lib/middleware/cloudflare-pages/index.d.ts

@@ -0,0 +1,35 @@
+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: QwikRouterCloudflarePagesOptions): (request: PlatformCloudflarePages['request'], env: PlatformCloudflarePages['env'] & {
+    ASSETS: {
+        fetch: (req: Request) => Response;
+    };
+}, ctx: PlatformCloudflarePages['ctx']) => Promise<Response>;
+
+/** @public */
+export declare interface PlatformCloudflarePages {
+    request: Request;
+    env?: Record<string, any>;
+    ctx: {
+        waitUntil: (promise: Promise<any>) => void;
+    };
+}
+
+/**
+ * @deprecated Use `QwikRouterCloudflarePagesOptions` instead. Will be removed in V3
+ * @public
+ */
+export declare type QwikCityCloudflarePagesOptions = QwikRouterCloudflarePagesOptions;
+
+/** @public */
+export declare interface QwikRouterCloudflarePagesOptions extends ServerRenderOptions {
+}
+
+export { }

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

@@ -0,0 +1,107 @@
+// packages/qwik-router/src/middleware/cloudflare-pages/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";
+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 {
+    new globalThis.TextEncoderStream();
+  } catch (e) {
+    globalThis.TextEncoderStream = _TextEncoderStream_polyfill;
+  }
+  const qwikSerializer = { _deserialize, _serialize, _verifySerializable };
+  if (opts.manifest) {
+    setServerPlatform(opts.manifest);
+  }
+  async function onCloudflarePagesFetch(request, env, ctx) {
+    try {
+      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 serverRequestEv = {
+        mode: "server",
+        locale: void 0,
+        url,
+        request,
+        env: {
+          get(key) {
+            return env[key];
+          }
+        },
+        getWritableStream: (status, headers, cookies, resolve) => {
+          const { readable, writable } = new TransformStream();
+          const response = new Response(readable, {
+            status,
+            headers: mergeHeadersCookies(headers, cookies)
+          });
+          resolve(response);
+          return writable;
+        },
+        getClientConn: () => {
+          return {
+            ip: request.headers.get("CF-connecting-ip") || "",
+            country: request.headers.get("CF-IPCountry") || ""
+          };
+        },
+        platform: {
+          request,
+          env,
+          ctx
+        }
+      };
+      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) {
+          if (response.ok && cache && response.headers.has("Cache-Control")) {
+            ctx.waitUntil(cache.put(cacheKey, response.clone()));
+          }
+          return response;
+        }
+      }
+      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": "cloudflare-pages" }
+      });
+    }
+  }
+  return onCloudflarePagesFetch;
+}
+var createQwikCity = createQwikRouter;
+export {
+  createQwikCity,
+  createQwikRouter
+};

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

@@ -0,0 +1,47 @@
+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: QwikRouterDenoOptions): {
+    router: (request: Request, info: ServeHandlerInfo) => Promise<Response | null>;
+    notFound: (request: Request) => Promise<Response>;
+    staticFile: (request: Request) => Promise<Response | null>;
+};
+
+/** @public */
+export declare interface NetAddr {
+    transport: 'tcp' | 'udp';
+    hostname: string;
+    port: number;
+}
+
+/**
+ * @deprecated Use `QwikRouterDenoOptions` instead. Will be removed in V3
+ * @public
+ */
+export declare type QwikCityDenoOptions = QwikRouterDenoOptions;
+
+/** @public */
+export declare interface QwikRouterDenoOptions 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, info: ServeHandlerInfo) => ClientConn;
+}
+
+/** @public */
+export declare interface ServeHandlerInfo {
+    remoteAddr: NetAddr;
+}
+
+export { }

package/lib/middleware/deno/index.mjs

@@ -0,0 +1,195 @@
+// packages/qwik-router/src/middleware/deno/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 { mergeHeadersCookies, requestHandler } from "../request-handler/index.mjs";
+
+// 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/deno/index.ts
+import { extname, fromFileUrl, join } from "https://deno.land/std/path/mod.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.");
+  }
+  const qwikSerializer = {
+    _deserialize,
+    _serialize,
+    _verifySerializable
+  };
+  if (opts.manifest) {
+    setServerPlatform(opts.manifest);
+  }
+  const staticFolder = ((_a = opts.static) == null ? void 0 : _a.root) ?? join(fromFileUrl(import.meta.url), "..", "..", "dist");
+  async function router(request, info) {
+    try {
+      const url = new URL(request.url);
+      const serverRequestEv = {
+        mode: "server",
+        locale: void 0,
+        url,
+        // @ts-ignore
+        env: Deno.env,
+        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, info) : {
+            ip: info.remoteAddr.hostname
+          };
+        }
+      };
+      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) {
+          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": "deno-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": "deno-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,
+      // @ts-ignore
+      content: await Deno.open(filePath, { read: true })
+    };
+  };
+  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);
+        const ext = extname(filePath).replace(/^\./, "");
+        return new Response(content.readable, {
+          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": "deno-server" }
+      });
+    }
+  };
+  return {
+    router,
+    notFound,
+    staticFile
+  };
+}
+var createQwikCity = createQwikRouter;
+export {
+  createQwikCity,
+  createQwikRouter
+};

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

@@ -0,0 +1,26 @@
+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: QwikRouterFirebaseOptions): (req: any, res: any) => Promise<void>;
+
+/** @public */
+export declare interface PlatformFirebase extends Object {
+}
+
+/**
+ * @deprecated Use `QwikRouterFirebaseOptions` instead. Will be removed in V3
+ * @public
+ */
+export declare type QwikCityFirebaseOptions = QwikRouterFirebaseOptions;
+
+/** @public */
+export declare interface QwikRouterFirebaseOptions extends ServerRenderOptions {
+}
+
+export { }

package/lib/middleware/firebase/index.mjs

@@ -0,0 +1,36 @@
+// packages/qwik-router/src/middleware/firebase/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.");
+  }
+  const { staticFile, notFound, router } = createQwikRouterNode({
+    render: opts.render,
+    manifest: opts.manifest,
+    qwikRouterConfig: opts.qwikRouterConfig,
+    static: {
+      cacheControl: "public, max-age=31557600"
+    },
+    getOrigin(req) {
+      if (process.env.IS_OFFLINE) {
+        return `http://${req.headers.host}`;
+      }
+      return null;
+    }
+  });
+  const qwikApp = (req, res) => {
+    return staticFile(req, res, () => {
+      router(req, res, () => notFound(req, res, () => {
+      }));
+    });
+  };
+  return qwikApp;
+}
+var createQwikCity = createQwikRouter;
+export {
+  createQwikCity,
+  createQwikRouter
+};

package/lib/middleware/netlify-edge/index.d.ts

@@ -0,0 +1,27 @@
+import type { Context } from '@netlify/edge-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: QwikRouterNetlifyOptions): (request: Request, context: Context) => Promise<Response>;
+
+/** @public */
+export declare interface PlatformNetlify extends Partial<Omit<Context, 'next' | 'cookies'>> {
+}
+
+/**
+ * @deprecated Use `QwikRouterNetlifyOptions` instead. Will be removed in V3
+ * @public
+ */
+export declare type QwikCityNetlifyOptions = QwikRouterNetlifyOptions;
+
+/** @public */
+export declare interface QwikRouterNetlifyOptions extends ServerRenderOptions {
+}
+
+export { }

package/lib/middleware/netlify-edge/index.mjs

@@ -0,0 +1,83 @@
+// packages/qwik-router/src/middleware/netlify-edge/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 { mergeHeadersCookies, 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 onNetlifyEdgeRequest(request, context) {
+    try {
+      const url = new URL(request.url);
+      if (isStaticPath(request.method, url) || url.pathname.startsWith("/.netlify")) {
+        return context.next();
+      }
+      const serverRequestEv = {
+        mode: "server",
+        locale: void 0,
+        url,
+        env: Deno.env,
+        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;
+        },
+        getClientConn: () => {
+          var _a;
+          return {
+            ip: context.ip,
+            country: (_a = context.geo.country) == null ? void 0 : _a.code
+          };
+        },
+        platform: context
+      };
+      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) {
+          return response;
+        }
+      }
+      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": "netlify-edge" }
+      });
+    }
+  }
+  return onNetlifyEdgeRequest;
+}
+var createQwikCity = createQwikRouter;
+export {
+  createQwikCity,
+  createQwikRouter
+};