@qwik.dev/router 2.0.0-beta.3 → 2.0.0-beta.31

package/lib/chunks/system.mjs

@@ -0,0 +1,333 @@
+import fs from 'node:fs';
+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';
+
+function ssgWorkerCompare(a, b) {
+  if (a.activeTasks < b.activeTasks) {
+    return -1;
+  }
+  if (a.activeTasks > b.activeTasks) {
+    return 1;
+  }
+  return a.totalTasks < b.totalTasks ? -1 : 1;
+}
+async function createWorkerPool(sys, opts) {
+  const log = await sys.createLogger();
+  const ssgWorkers = [];
+  const sitemapBuffer = [];
+  let sitemapStream = null;
+  opts = {
+    ...opts
+  };
+  let outDir = opts.outDir;
+  if (typeof outDir !== "string") {
+    throw new Error(`Missing "outDir" option`);
+  }
+  if (!isAbsolute(outDir)) {
+    throw new Error(`"outDir" must be an absolute file path, received: ${outDir}`);
+  }
+  outDir = normalizePath(outDir);
+  let maxWorkers = cpus().length;
+  if (typeof opts.maxWorkers === "number") {
+    maxWorkers = Math.max(1, Math.min(opts.maxWorkers, maxWorkers));
+  }
+  let maxTasksPerWorker = 20;
+  if (typeof opts.maxTasksPerWorker === "number") {
+    maxTasksPerWorker = Math.max(1, Math.min(opts.maxTasksPerWorker, 50));
+  }
+  let sitemapOutFile = opts.sitemapOutFile;
+  if (sitemapOutFile !== null) {
+    if (typeof sitemapOutFile !== "string") {
+      sitemapOutFile = "sitemap.xml";
+    }
+    if (!isAbsolute(sitemapOutFile)) {
+      sitemapOutFile = resolve(outDir, sitemapOutFile);
+    }
+  }
+  if (!opts.workerFilePath) {
+    throw new Error('Missing "workerFilePath" option for SSG worker creation');
+  }
+  const workerFilePath = typeof opts.workerFilePath === "string" && opts.workerFilePath.startsWith("file://") ? new URL(opts.workerFilePath) : opts.workerFilePath;
+  const { render: _r, qwikRouterConfig: _c, workerFilePath: _w, ...workerData } = opts;
+  const createWorker = () => {
+    let terminateResolve = null;
+    const mainTasks = /* @__PURE__ */ new Map();
+    let terminateTimeout = null;
+    const nodeWorker = new Worker(workerFilePath, {
+      workerData
+    });
+    nodeWorker.unref();
+    const ssgWorker = {
+      activeTasks: 0,
+      totalTasks: 0,
+      render: (staticRoute) => {
+        return new Promise((resolve2, reject) => {
+          try {
+            ssgWorker.activeTasks++;
+            ssgWorker.totalTasks++;
+            mainTasks.set(staticRoute.pathname, resolve2);
+            nodeWorker.postMessage(staticRoute);
+          } catch (e) {
+            ssgWorker.activeTasks--;
+            mainTasks.delete(staticRoute.pathname);
+            reject(e);
+          }
+        });
+      },
+      terminate: async () => {
+        mainTasks.clear();
+        const msg = {
+          type: "close"
+        };
+        await new Promise((resolve2) => {
+          terminateResolve = () => {
+            resolve2();
+          };
+          terminateTimeout = setTimeout(async () => {
+            terminateTimeout = null;
+            terminateResolve = null;
+            await nodeWorker.terminate();
+            resolve2();
+          }, 1e3);
+          nodeWorker.postMessage(msg);
+        });
+        if (terminateTimeout) {
+          clearTimeout(terminateTimeout);
+          terminateTimeout = null;
+        }
+      }
+    };
+    nodeWorker.on("message", (msg) => {
+      switch (msg.type) {
+        case "render": {
+          const mainTask = mainTasks.get(msg.pathname);
+          if (mainTask) {
+            mainTasks.delete(msg.pathname);
+            ssgWorker.activeTasks--;
+            mainTask(msg);
+          }
+          break;
+        }
+        case "close": {
+          if (terminateResolve) {
+            terminateResolve();
+            terminateResolve = null;
+          }
+          break;
+        }
+      }
+    });
+    nodeWorker.on("error", (e) => {
+      log.error(`worker error`, e);
+    });
+    nodeWorker.on("exit", (code) => {
+      log.debug(`worker exit code=${code}`);
+      if (terminateTimeout) {
+        clearTimeout(terminateTimeout);
+        terminateTimeout = null;
+      }
+      if (mainTasks.size > 0) {
+        for (const [pathname, resolve2] of mainTasks) {
+          ssgWorker.activeTasks--;
+          resolve2({
+            type: "render",
+            pathname,
+            url: "",
+            ok: false,
+            error: {
+              message: `Worker exited with code ${code}`,
+              stack: void 0
+            },
+            filePath: null,
+            contentType: null,
+            resourceType: null
+          });
+        }
+        mainTasks.clear();
+      }
+      if (terminateResolve) {
+        terminateResolve();
+        terminateResolve = null;
+      }
+      if (code !== 0) {
+        console.error(`worker exit ${code}`);
+      }
+    });
+    return ssgWorker;
+  };
+  const getNextWorker = () => ssgWorkers.sort(ssgWorkerCompare)[0];
+  const hasAvailableWorker = () => {
+    const ssgWorker = getNextWorker();
+    return ssgWorker.activeTasks < maxTasksPerWorker;
+  };
+  const render = async (ssgRoute) => {
+    const ssgWorker = getNextWorker();
+    const result = await ssgWorker.render(ssgRoute);
+    if (sitemapOutFile && result.ok && result.resourceType === "page") {
+      sitemapBuffer.push(`<url><loc>${result.url}</loc></url>`);
+      if (sitemapBuffer.length > 50) {
+        const siteMapUrls = sitemapBuffer.join("\n") + "\n";
+        sitemapBuffer.length = 0;
+        if (sitemapStream) {
+          sitemapStream.write(siteMapUrls);
+        }
+      }
+    }
+    return result;
+  };
+  const close = async () => {
+    const promises = [];
+    if (sitemapStream) {
+      sitemapBuffer.push(`</urlset>`);
+      sitemapStream.write(sitemapBuffer.join("\n"));
+      sitemapBuffer.length = 0;
+      await new Promise((resolve2, reject) => {
+        if (sitemapStream) {
+          sitemapStream.end((err) => {
+            if (err) {
+              reject(err);
+            } else {
+              resolve2();
+            }
+          });
+        } else {
+          resolve2();
+        }
+      });
+      sitemapStream = null;
+    }
+    for (const ssgWorker of ssgWorkers) {
+      try {
+        promises.push(ssgWorker.terminate());
+      } catch (e) {
+        console.error(e);
+      }
+    }
+    await Promise.all(promises);
+    ssgWorkers.length = 0;
+    if (process.platform === "win32") {
+      await new Promise((resolve2) => setTimeout(resolve2, 300));
+    }
+  };
+  if (sitemapOutFile) {
+    await sys.ensureDir(sitemapOutFile);
+    sitemapStream = fs.createWriteStream(sitemapOutFile, {
+      flags: "w"
+    });
+    sitemapStream.write(`<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+`);
+  }
+  log.debug(`creating ${maxWorkers} workers, ${maxTasksPerWorker} tasks each`);
+  for (let i = 0; i < maxWorkers; i++) {
+    ssgWorkers.push(createWorker());
+    if (process.platform === "win32" && i < maxWorkers - 1) {
+      await new Promise((resolve2) => setTimeout(resolve2, 100));
+    }
+  }
+  const mainCtx = {
+    hasAvailableWorker,
+    render,
+    close
+  };
+  return mainCtx;
+}
+
+const ensureDir = async (filePath) => {
+  await fs.promises.mkdir(dirname(filePath), {
+    recursive: true
+  });
+};
+const access = async (path) => {
+  try {
+    await fs.promises.access(path);
+    return true;
+  } catch {
+    return false;
+  }
+};
+async function createSystem(opts, threadId) {
+  const createWriteStream = (filePath) => {
+    return fs.createWriteStream(filePath, {
+      flags: "w"
+    });
+  };
+  const NS_PER_SEC = 1e9;
+  const MS_PER_NS = 1e-6;
+  const createTimer = () => {
+    const start = process.hrtime();
+    return () => {
+      const diff = process.hrtime(start);
+      return (diff[0] * NS_PER_SEC + diff[1]) * MS_PER_NS;
+    };
+  };
+  const noop = () => {
+  };
+  const createLogger = async () => {
+    const isQuiet = opts.log === "quiet";
+    const isDebug = opts.log === "debug";
+    if (threadId !== void 0) {
+      return {
+        debug: isDebug ? console.debug.bind(console, `[${threadId}]`) : noop,
+        error: console.error.bind(console, `[${threadId}]`),
+        info: isQuiet ? noop : console.info.bind(console, `[${threadId}]`)
+      };
+    }
+    return {
+      debug: isDebug ? console.debug.bind(console) : noop,
+      error: console.error.bind(console),
+      info: isQuiet ? noop : console.info.bind(console)
+    };
+  };
+  const outDir = normalizePath(opts.outDir);
+  const basePathname = opts.basePathname || "/";
+  const basenameLen = basePathname.length;
+  const getRouteFilePath = (pathname, isHtml) => {
+    pathname = decodeURIComponent(pathname.slice(basenameLen));
+    if (isHtml) {
+      if (!pathname.endsWith(".html")) {
+        if (pathname.endsWith("/")) {
+          pathname += "index.html";
+        } else {
+          pathname += "/index.html";
+        }
+      }
+    } else {
+      if (pathname.endsWith("/")) {
+        pathname = pathname.slice(0, -1);
+      }
+    }
+    return join(outDir, pathname);
+  };
+  const getDataFilePath = (pathname) => {
+    pathname = decodeURIComponent(pathname.slice(basenameLen));
+    if (pathname.endsWith("/")) {
+      pathname += "q-data.json";
+    } else {
+      pathname += "/q-data.json";
+    }
+    return join(outDir, pathname);
+  };
+  const sys = {
+    createMainProcess: null,
+    createLogger,
+    getOptions: () => opts,
+    ensureDir,
+    createWriteStream,
+    createTimer,
+    access,
+    getRouteFilePath,
+    getDataFilePath,
+    getEnv: (key) => process.env[key],
+    platform: {
+      static: true,
+      node: process.versions.node
+    }
+  };
+  sys.createMainProcess = () => createWorkerPool(sys, opts);
+  return sys;
+}
+
+export { access, createSystem, ensureDir };

package/lib/chunks/url.mjs

@@ -0,0 +1,61 @@
+const 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"
+};
+
+const LEADING_DOUBLE_SLASH_REG = /^[\\/]{2,}/;
+function normalizeRequestUrl(url, base) {
+  const DOUBLE_SLASH_REG = /\/\/|\\\\/g;
+  const queryOrHashIndex = url.search(/[?#]/);
+  const path = queryOrHashIndex === -1 ? url : url.slice(0, queryOrHashIndex);
+  const suffix = queryOrHashIndex === -1 ? "" : url.slice(queryOrHashIndex);
+  return new URL(`${path.replace(LEADING_DOUBLE_SLASH_REG, "/").replace(DOUBLE_SLASH_REG, "/")}${suffix}`, base);
+}
+
+export { MIME_TYPES as M, normalizeRequestUrl as n };

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

@@ -0,0 +1,35 @@
+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");
+
+const useHttpStatus = () => useContext(HttpStatusContext).value;
+const useContent = () => useContext(ContentContext);
+const useDocumentHead = () => useContext(DocumentHeadContext);
+const useLocation = () => useContext(RouteLocationContext);
+const useNavigate = () => useContext(RouteNavigateContext);
+const usePreventNavigateQrl = (fn) => {
+  if (!__EXPERIMENTAL__.preventNavigate) {
+    throw new Error('usePreventNavigate$ is experimental and must be enabled with `experimental: ["preventNavigate"]` in the `qwikVite` plugin.');
+  }
+  const registerPreventNav = useContext(RoutePreventNavigateContext);
+  useVisibleTaskQrl(/* @__PURE__ */ inlinedQrl(() => {
+    const fn2 = _captures[0], registerPreventNav2 = _captures[1];
+    return registerPreventNav2(fn2);
+  }, "usePreventNavigateQrl_useVisibleTask_BsYUaz9XhUs", [
+    fn,
+    registerPreventNav
+  ]));
+};
+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 };