@qwik.dev/router 2.0.0-beta.28 → 2.0.0-beta.29

package/lib/chunks/system.mjs

@@ -0,0 +1,328 @@
+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 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) => {
+      console.error(`worker error`, e);
+    });
+    nodeWorker.on("exit", (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 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">
+`);
+  }
+  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 createLogger = async () => {
+    if (threadId !== void 0) {
+      return {
+        debug: opts.log === "debug" ? console.debug.bind(console, `[${threadId}]`) : () => {
+        },
+        error: console.error.bind(console, `[${threadId}]`),
+        info: console.info.bind(console, `[${threadId}]`)
+      };
+    }
+    return {
+      debug: opts.log === "debug" ? console.debug.bind(console) : () => {
+      },
+      error: console.error.bind(console),
+      info: 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/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 };

package/lib/chunks/worker-thread.mjs

@@ -0,0 +1,271 @@
+import { _serialize } from '@qwik.dev/core/internal';
+import { RequestEvShareQData, requestHandler, RedirectMessage } from '@qwik.dev/router/middleware/request-handler';
+import { parentPort } from 'node:worker_threads';
+
+const createNoopWritableStream = () => new WritableStream();
+async function workerRender(sys, opts, staticRoute, pendingPromises, callback) {
+  const url = new URL(staticRoute.pathname, opts.origin);
+  const result = {
+    type: "render",
+    pathname: staticRoute.pathname,
+    url: url.href,
+    ok: false,
+    error: null,
+    filePath: null,
+    contentType: null,
+    resourceType: null
+  };
+  try {
+    let routeWriter = null;
+    let closeResolved;
+    const closePromise = new Promise((closePromiseResolve) => {
+      closeResolved = closePromiseResolve;
+    });
+    const request = new Request(url);
+    const requestCtx = {
+      mode: "static",
+      locale: void 0,
+      url,
+      request,
+      env: {
+        get(key) {
+          return sys.getEnv(key);
+        }
+      },
+      platform: sys.platform,
+      getClientConn: () => {
+        return {};
+      },
+      getWritableStream: (status, headers, _, _r, requestEv) => {
+        result.ok = status >= 200 && status < 300;
+        if (!result.ok) {
+          return createNoopWritableStream();
+        }
+        result.contentType = (headers.get("Content-Type") || "").toLowerCase();
+        const isHtml = result.contentType.includes("text/html");
+        const is404ErrorPage = url.pathname.endsWith("/404.html");
+        const routeFilePath = sys.getRouteFilePath(url.pathname, isHtml);
+        if (is404ErrorPage) {
+          result.resourceType = "404";
+        } else if (isHtml) {
+          result.resourceType = "page";
+        }
+        const hasRouteWriter = isHtml ? opts.emitHtml !== false : true;
+        const writeQDataEnabled = isHtml && opts.emitData !== false;
+        const stream = new WritableStream({
+          async start() {
+            try {
+              if (hasRouteWriter || writeQDataEnabled) {
+                await sys.ensureDir(routeFilePath);
+              }
+              if (hasRouteWriter) {
+                routeWriter = sys.createWriteStream(routeFilePath);
+                routeWriter.on("error", (e) => {
+                  console.error(e);
+                  routeWriter = null;
+                  result.error = {
+                    message: e.message,
+                    stack: e.stack
+                  };
+                });
+              }
+            } catch (e) {
+              console.error("Error during stream start", staticRoute.pathname, e);
+              routeWriter = null;
+              result.error = {
+                message: String(e),
+                stack: e.stack || ""
+              };
+            }
+          },
+          write(chunk) {
+            try {
+              if (routeWriter) {
+                routeWriter.write(Buffer.from(chunk.buffer));
+              }
+            } catch (e) {
+              console.error("Error during stream write", staticRoute.pathname, e);
+              routeWriter = null;
+              result.error = {
+                message: String(e),
+                stack: e.stack || ""
+              };
+            }
+          },
+          async close() {
+            const writePromises = [];
+            try {
+              if (writeQDataEnabled) {
+                const qData = requestEv.sharedMap.get(RequestEvShareQData);
+                if (qData && !is404ErrorPage) {
+                  const qDataFilePath = sys.getDataFilePath(url.pathname);
+                  const dataWriter = sys.createWriteStream(qDataFilePath);
+                  dataWriter.on("error", (e) => {
+                    console.error(e);
+                    result.error = {
+                      message: e.message,
+                      stack: e.stack
+                    };
+                  });
+                  const serialized = await _serialize(qData);
+                  dataWriter.write(serialized);
+                  writePromises.push(new Promise((resolve) => {
+                    result.filePath = routeFilePath;
+                    dataWriter.end(resolve);
+                  }));
+                }
+              }
+              if (routeWriter) {
+                writePromises.push(new Promise((resolve) => {
+                  result.filePath = routeFilePath;
+                  routeWriter.end(resolve);
+                }).finally(closeResolved));
+              }
+              if (writePromises.length > 0) {
+                await Promise.all(writePromises);
+              }
+            } catch (e) {
+              console.error("Error during stream close", staticRoute.pathname, e);
+              routeWriter = null;
+              result.error = {
+                message: String(e),
+                stack: e.stack || ""
+              };
+            }
+          }
+        });
+        return stream;
+      }
+    };
+    const promise = requestHandler(requestCtx, opts).then((rsp) => {
+      if (rsp != null) {
+        return rsp.completion.then((r) => {
+          if (routeWriter) {
+            return closePromise.then(() => r);
+          }
+          return r;
+        });
+      }
+    }).then((e) => {
+      if (e !== void 0) {
+        if (e instanceof RedirectMessage) {
+          return;
+        }
+        if (e instanceof Error) {
+          result.error = {
+            message: e.message,
+            stack: e.stack
+          };
+        } else {
+          result.error = {
+            message: String(e),
+            stack: void 0
+          };
+        }
+        console.error("Error during request handling", staticRoute.pathname, e);
+      }
+    }).catch((e) => {
+      console.error("Unhandled error during request handling", staticRoute.pathname, e);
+      result.error = {
+        message: String(e),
+        stack: e.stack || ""
+      };
+    }).finally(() => {
+      pendingPromises.delete(promise);
+      callback(result);
+    });
+    pendingPromises.add(promise);
+  } catch (e) {
+    console.error("Error during render", staticRoute.pathname, e);
+    if (e instanceof Error) {
+      result.error = {
+        message: e.message,
+        stack: e.stack
+      };
+    } else {
+      result.error = {
+        message: String(e),
+        stack: void 0
+      };
+    }
+    callback(result);
+  }
+}
+async function workerThread(sys) {
+  delete globalThis.__qwik;
+  const opts = sys.getOptions();
+  const pendingPromises = /* @__PURE__ */ new Set();
+  const log = await sys.createLogger();
+  process.on("uncaughtException", (e) => {
+    console.error("Worker uncaught exception (suppressed):", e.message);
+  });
+  process.on("unhandledRejection", (e) => {
+    console.error("Worker unhandled rejection (suppressed):", e instanceof Error ? e.message : e);
+  });
+  const onMessage = async (msg) => {
+    switch (msg.type) {
+      case "render": {
+        log.debug(`Worker thread rendering: ${msg.pathname}`);
+        return new Promise((resolve) => {
+          workerRender(sys, opts, msg, pendingPromises, resolve).catch((e) => {
+            console.error("Error during render", msg.pathname, e);
+            resolve({
+              type: "render",
+              pathname: msg.pathname,
+              url: "",
+              ok: false,
+              error: {
+                message: e instanceof Error ? e.message : String(e),
+                stack: e instanceof Error ? e.stack : void 0
+              },
+              filePath: null,
+              contentType: null,
+              resourceType: null
+            });
+          });
+        });
+      }
+      case "close": {
+        if (pendingPromises.size) {
+          log.debug(`Worker thread closing, waiting for ${pendingPromises.size} pending renders`);
+          const promises = Array.from(pendingPromises);
+          pendingPromises.clear();
+          await Promise.all(promises);
+        }
+        log.debug(`Worker thread closed`);
+        return {
+          type: "close"
+        };
+      }
+    }
+  };
+  parentPort?.on("message", async (msg) => {
+    try {
+      parentPort?.postMessage(await onMessage(msg));
+    } catch (e) {
+      if (msg.type === "render") {
+        const error = e instanceof Error ? e : new Error(String(e));
+        parentPort?.postMessage({
+          type: "render",
+          pathname: msg.pathname,
+          url: "",
+          ok: false,
+          error: {
+            message: error.message,
+            stack: error.stack
+          },
+          filePath: null,
+          contentType: null,
+          resourceType: null
+        });
+      } else {
+        console.error("Worker message handler error", e);
+      }
+    }
+    if (msg.type === "close") {
+      parentPort?.close();
+    }
+  });
+}
+
+export { workerThread };