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

package/lib/adapters/static/vite/index.mjs

@@ -0,0 +1,324 @@
+// packages/qwik-router/src/adapters/shared/vite/index.ts
+import fs2 from "node:fs";
+import { basename, dirname, join as join2, resolve } from "node:path";
+
+// packages/qwik-router/src/adapters/shared/vite/post-build.ts
+import { getErrorHtml } from "@qwik.dev/router/middleware/request-handler";
+import fs from "node:fs";
+import { join } from "node:path";
+async function postBuild(clientOutDir, pathName, userStaticPaths, format, cleanStatic) {
+  if (pathName && !pathName.endsWith("/")) {
+    pathName += "/";
+  }
+  const ignorePathnames = /* @__PURE__ */ new Set([pathName + "build/", pathName + "assets/"]);
+  const staticPaths = new Set(userStaticPaths.map(normalizeTrailingSlash));
+  const notFounds = [];
+  const loadItem = async (fsDir, fsName, pathname) => {
+    pathname = normalizeTrailingSlash(pathname);
+    if (ignorePathnames.has(pathname)) {
+      return;
+    }
+    const fsPath = join(fsDir, fsName);
+    if (fsName === "index.html" || fsName === "q-data.json") {
+      if (!staticPaths.has(pathname) && cleanStatic) {
+        await fs.promises.unlink(fsPath);
+      }
+      return;
+    }
+    if (fsName === "404.html") {
+      const notFoundHtml = await fs.promises.readFile(fsPath, "utf-8");
+      notFounds.push([pathname, notFoundHtml]);
+      return;
+    }
+    const stat = await fs.promises.stat(fsPath);
+    if (stat.isDirectory()) {
+      await loadDir(fsPath, pathname + fsName + "/");
+    } else if (stat.isFile()) {
+      staticPaths.add(pathname + fsName);
+    }
+  };
+  const loadDir = async (fsDir, pathname) => {
+    const itemNames = await fs.promises.readdir(fsDir);
+    await Promise.all(itemNames.map((i) => loadItem(fsDir, i, pathname)));
+  };
+  if (fs.existsSync(clientOutDir)) {
+    await loadDir(clientOutDir, pathName);
+  }
+  const notFoundPathsCode = createNotFoundPathsModule(pathName, notFounds, format);
+  const staticPathsCode = createStaticPathsModule(pathName, staticPaths, format);
+  return {
+    notFoundPathsCode,
+    staticPathsCode
+  };
+}
+function normalizeTrailingSlash(pathname) {
+  if (!pathname.endsWith("/")) {
+    return pathname + "/";
+  }
+  return pathname;
+}
+function createNotFoundPathsModule(basePathname, notFounds, format) {
+  notFounds.sort((a, b) => {
+    if (a[0].length > b[0].length) {
+      return -1;
+    }
+    if (a[0].length < b[0].length) {
+      return 1;
+    }
+    if (a[0] < b[0]) {
+      return -1;
+    }
+    if (a[0] > b[0]) {
+      return 1;
+    }
+    return 0;
+  });
+  if (!notFounds.some((r) => r[0] === basePathname)) {
+    const html = getErrorHtml(404, "Resource Not Found");
+    notFounds.push([basePathname, html]);
+  }
+  const c = [];
+  c.push(`const notFounds = ${JSON.stringify(notFounds, null, 2)};`);
+  c.push(`function getNotFound(p) {`);
+  c.push(`  for (const r of notFounds) {`);
+  c.push(`    if (p.startsWith(r[0])) {`);
+  c.push(`      return r[1];`);
+  c.push(`    }`);
+  c.push(`  }`);
+  c.push(`  return "Resource Not Found";`);
+  c.push(`}`);
+  if (format === "cjs") {
+    c.push("exports.getNotFound = getNotFound;");
+  } else {
+    c.push("export { getNotFound };");
+  }
+  return c.join("\n");
+}
+function createStaticPathsModule(basePathname, staticPaths, format) {
+  const assetsPath = basePathname + "assets/";
+  const baseBuildPath = basePathname + "build/";
+  const c = [];
+  c.push(
+    `const staticPaths = new Set(${JSON.stringify(
+      Array.from(new Set(staticPaths)).sort()
+    )});`
+  );
+  c.push(`function isStaticPath(method, url) {`);
+  c.push(`  if (method.toUpperCase() !== 'GET') {`);
+  c.push(`    return false;`);
+  c.push(`  }`);
+  c.push(`  const p = url.pathname;`);
+  c.push(`  if (p.startsWith(${JSON.stringify(baseBuildPath)})) {`);
+  c.push(`    return true;`);
+  c.push(`  }`);
+  c.push(`  if (p.startsWith(${JSON.stringify(assetsPath)})) {`);
+  c.push(`    return true;`);
+  c.push(`  }`);
+  c.push(`  if (staticPaths.has(p)) {`);
+  c.push(`    return true;`);
+  c.push(`  }`);
+  c.push(`  if (p.endsWith('/q-data.json')) {`);
+  c.push(`    const pWithoutQdata = p.replace(/\\/q-data.json$/, '');`);
+  c.push(`    if (staticPaths.has(pWithoutQdata + '/')) {`);
+  c.push(`      return true;`);
+  c.push(`    }`);
+  c.push(`    if (staticPaths.has(pWithoutQdata)) {`);
+  c.push(`      return true;`);
+  c.push(`    }`);
+  c.push(`  }`);
+  c.push(`  return false;`);
+  c.push(`}`);
+  if (format === "cjs") {
+    c.push("exports.isStaticPath = isStaticPath;");
+  } else {
+    c.push("export { isStaticPath };");
+  }
+  return c.join("\n");
+}
+
+// packages/qwik-router/src/adapters/shared/vite/index.ts
+function viteAdapter(opts) {
+  let qwikRouterPlugin = null;
+  let qwikVitePlugin = null;
+  let serverOutDir = null;
+  let renderModulePath = null;
+  let qwikRouterConfigModulePath = null;
+  let isSsrBuild = false;
+  let format = "esm";
+  const outputEntries = [];
+  const plugin = {
+    name: `vite-plugin-qwik-router-${opts.name}`,
+    enforce: "post",
+    apply: "build",
+    config(config) {
+      if (typeof opts.config === "function") {
+        config = opts.config(config);
+      }
+      config.define = {
+        "process.env.NODE_ENV": JSON.stringify(process.env.NODE_ENV || "production"),
+        ...config.define
+      };
+      return config;
+    },
+    configResolved(config) {
+      var _a, _b, _c, _d;
+      isSsrBuild = !!config.build.ssr;
+      if (isSsrBuild) {
+        qwikRouterPlugin = config.plugins.find(
+          (p) => p.name === "vite-plugin-qwik-router"
+        );
+        if (!qwikRouterPlugin) {
+          throw new Error("Missing vite-plugin-qwik-router");
+        }
+        qwikVitePlugin = config.plugins.find(
+          (p) => p.name === "vite-plugin-qwik"
+        );
+        if (!qwikVitePlugin) {
+          throw new Error("Missing vite-plugin-qwik");
+        }
+        serverOutDir = config.build.outDir;
+        if (((_a = config.build) == null ? void 0 : _a.ssr) !== true) {
+          throw new Error(
+            `"build.ssr" must be set to "true" in order to use the "${opts.name}" adapter.`
+          );
+        }
+        if (!((_c = (_b = config.build) == null ? void 0 : _b.rollupOptions) == null ? void 0 : _c.input)) {
+          throw new Error(
+            `"build.rollupOptions.input" must be set in order to use the "${opts.name}" adapter.`
+          );
+        }
+        if (((_d = config.ssr) == null ? void 0 : _d.format) === "cjs") {
+          format = "cjs";
+        }
+      }
+    },
+    generateBundle(_, bundles) {
+      if (isSsrBuild) {
+        outputEntries.length = 0;
+        for (const fileName in bundles) {
+          const chunk = bundles[fileName];
+          if (chunk.type === "chunk" && chunk.isEntry) {
+            outputEntries.push(fileName);
+            if (chunk.name === "entry.ssr") {
+              renderModulePath = join2(serverOutDir, fileName);
+            } else if (chunk.name === "@qwik-router-config") {
+              qwikRouterConfigModulePath = join2(serverOutDir, fileName);
+            }
+          }
+        }
+        if (!renderModulePath) {
+          throw new Error(
+            'Unable to find "entry.ssr" entry point. Did you forget to add it to "build.rollupOptions.input"?'
+          );
+        }
+        if (!qwikRouterConfigModulePath) {
+          throw new Error(
+            'Unable to find "@qwik-router-config" entry point. Did you forget to add it to "build.rollupOptions.input"?'
+          );
+        }
+      }
+    },
+    closeBundle: {
+      sequential: true,
+      async handler() {
+        var _a;
+        if (isSsrBuild && opts.ssg !== null && serverOutDir && (qwikRouterPlugin == null ? void 0 : qwikRouterPlugin.api) && (qwikVitePlugin == null ? void 0 : qwikVitePlugin.api)) {
+          const staticPaths = opts.staticPaths || [];
+          const routes = qwikRouterPlugin.api.getRoutes();
+          const basePathname = qwikRouterPlugin.api.getBasePathname();
+          const clientOutDir = qwikVitePlugin.api.getClientOutDir();
+          const clientPublicOutDir = qwikVitePlugin.api.getClientPublicOutDir();
+          const assetsDir = qwikVitePlugin.api.getAssetsDir();
+          const rootDir = qwikVitePlugin.api.getRootDir() ?? void 0;
+          if (renderModulePath && qwikRouterConfigModulePath && clientOutDir && clientPublicOutDir) {
+            let ssgOrigin = ((_a = opts.ssg) == null ? void 0 : _a.origin) ?? opts.origin;
+            if (!ssgOrigin) {
+              ssgOrigin = `https://yoursite.qwik.dev`;
+            }
+            if (ssgOrigin.length > 0 && !/:\/\//.test(ssgOrigin)) {
+              ssgOrigin = `https://${ssgOrigin}`;
+            }
+            if (ssgOrigin.startsWith("//")) {
+              ssgOrigin = `https:${ssgOrigin}`;
+            }
+            try {
+              ssgOrigin = new URL(ssgOrigin).origin;
+            } catch (e) {
+              this.warn(
+                `Invalid "origin" option: "${ssgOrigin}". Using default origin: "https://yoursite.qwik.dev"`
+              );
+              ssgOrigin = `https://yoursite.qwik.dev`;
+            }
+            const staticGenerate = await import("../../../static/index.mjs");
+            const generateOpts = {
+              maxWorkers: opts.maxWorkers,
+              basePathname,
+              outDir: clientPublicOutDir,
+              rootDir,
+              ...opts.ssg,
+              origin: ssgOrigin,
+              renderModulePath,
+              qwikRouterConfigModulePath
+            };
+            const staticGenerateResult = await staticGenerate.generate(generateOpts);
+            if (staticGenerateResult.errors > 0) {
+              const err = new Error(
+                `Error while running SSG from "${opts.name}" adapter. At least one path failed to render.`
+              );
+              err.stack = void 0;
+              this.error(err);
+            }
+            staticPaths.push(...staticGenerateResult.staticPaths);
+            const { staticPathsCode, notFoundPathsCode } = await postBuild(
+              clientPublicOutDir,
+              assetsDir ? join2(basePathname, assetsDir) : basePathname,
+              staticPaths,
+              format,
+              !!opts.cleanStaticGenerated
+            );
+            await Promise.all([
+              fs2.promises.writeFile(join2(serverOutDir, RESOLVED_STATIC_PATHS_ID), staticPathsCode),
+              fs2.promises.writeFile(
+                join2(serverOutDir, RESOLVED_NOT_FOUND_PATHS_ID),
+                notFoundPathsCode
+              )
+            ]);
+            if (typeof opts.generate === "function") {
+              await opts.generate({
+                outputEntries,
+                serverOutDir,
+                clientOutDir,
+                clientPublicOutDir,
+                basePathname,
+                routes,
+                assetsDir,
+                warn: (message) => this.warn(message),
+                error: (message) => this.error(message)
+              });
+            }
+          }
+        }
+      }
+    }
+  };
+  return plugin;
+}
+var STATIC_PATHS_ID = "@qwik-router-static-paths";
+var RESOLVED_STATIC_PATHS_ID = `${STATIC_PATHS_ID}.js`;
+var NOT_FOUND_PATHS_ID = "@qwik-router-not-found-paths";
+var RESOLVED_NOT_FOUND_PATHS_ID = `${NOT_FOUND_PATHS_ID}.js`;
+
+// packages/qwik-router/src/adapters/static/vite/index.ts
+function staticAdapter(opts) {
+  return viteAdapter({
+    name: "static-generate",
+    origin: opts.origin,
+    ssg: {
+      include: ["/*"],
+      ...opts
+    }
+  });
+}
+export {
+  staticAdapter
+};

package/lib/adapters/vercel-edge/vite/index.cjs

@@ -0,0 +1,118 @@
+"use strict";
+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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// packages/qwik-router/src/adapters/vercel-edge/vite/index.ts
+var vite_exports = {};
+__export(vite_exports, {
+  vercelEdgeAdapter: () => vercelEdgeAdapter
+});
+module.exports = __toCommonJS(vite_exports);
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_path = require("node:path");
+var import_vite = require("../../shared/vite/index.cjs");
+function vercelEdgeAdapter(opts = {}) {
+  var _a;
+  return (0, import_vite.viteAdapter)({
+    name: "vercel-edge",
+    origin: ((_a = process == null ? void 0 : process.env) == null ? void 0 : _a.VERCEL_URL) || "https://yoursitename.vercel.app",
+    ssg: opts.ssg,
+    staticPaths: opts.staticPaths,
+    cleanStaticGenerated: true,
+    config(config) {
+      var _a2;
+      const outDir = ((_a2 = config.build) == null ? void 0 : _a2.outDir) || (0, import_node_path.join)(".vercel", "output", "functions", "_qwik-router.func");
+      return {
+        resolve: {
+          conditions: opts.target === "node" ? ["node", "import", "module", "browser", "default"] : ["edge-light", "webworker", "worker", "browser", "module", "main"]
+        },
+        ssr: {
+          target: opts.target === "node" ? "node" : "webworker",
+          noExternal: true
+        },
+        build: {
+          ssr: true,
+          outDir,
+          rollupOptions: {
+            output: {
+              format: "es",
+              hoistTransitiveImports: false
+            }
+          }
+        },
+        publicDir: false
+      };
+    },
+    async generate({ clientPublicOutDir, serverOutDir, basePathname, outputEntries }) {
+      const vercelOutputDir = (0, import_vite.getParentDir)(serverOutDir, "output");
+      if (opts.outputConfig !== false) {
+        const vercelOutputConfig = {
+          routes: [
+            { handle: "filesystem" },
+            {
+              src: basePathname + ".*",
+              dest: "/_qwik-router"
+            }
+          ],
+          version: 3
+        };
+        await import_node_fs.default.promises.writeFile(
+          (0, import_node_path.join)(vercelOutputDir, "config.json"),
+          JSON.stringify(vercelOutputConfig, null, 2)
+        );
+      }
+      let entrypoint = opts.vcConfigEntryPoint;
+      if (!entrypoint) {
+        if (outputEntries.some((n) => n === "entry.vercel-edge.mjs")) {
+          entrypoint = "entry.vercel-edge.mjs";
+        } else {
+          entrypoint = "entry.vercel-edge.js";
+        }
+      }
+      const vcConfigPath = (0, import_node_path.join)(serverOutDir, ".vc-config.json");
+      const vcConfig = {
+        runtime: "edge",
+        entrypoint,
+        envVarsInUse: opts.vcConfigEnvVarsInUse
+      };
+      await import_node_fs.default.promises.writeFile(vcConfigPath, JSON.stringify(vcConfig, null, 2));
+      let vercelStaticDir = (0, import_node_path.join)(vercelOutputDir, "static");
+      const basePathnameParts = basePathname.split("/").filter((p) => p.length > 0);
+      if (basePathnameParts.length > 0) {
+        vercelStaticDir = (0, import_node_path.join)(vercelStaticDir, ...basePathnameParts);
+      }
+      await import_node_fs.default.promises.rm(vercelStaticDir, { recursive: true, force: true });
+      await import_node_fs.default.promises.mkdir((0, import_node_path.dirname)(vercelStaticDir), { recursive: true });
+      await import_node_fs.default.promises.rename(clientPublicOutDir, vercelStaticDir);
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  vercelEdgeAdapter
+});

package/lib/adapters/vercel-edge/vite/index.d.ts

@@ -0,0 +1,45 @@
+import { ServerAdapterOptions } from '../../shared/vite';
+import type { StaticGenerateRenderOptions } from '@qwik.dev/router/static';
+
+export { StaticGenerateRenderOptions }
+
+/** @public */
+export declare function vercelEdgeAdapter(opts?: VercelEdgeAdapterOptions): any;
+
+/** @public */
+export declare interface VercelEdgeAdapterOptions extends ServerAdapterOptions {
+    /**
+     * Determines if the build should auto-generate the `.vercel/output/config.json` config.
+     *
+     * Defaults to `true`.
+     */
+    outputConfig?: boolean;
+    /**
+     * The `entrypoint` property in the `.vc-config.json` file. Indicates the initial file where code
+     * will be executed for the Edge Function.
+     *
+     * Defaults to `entry.vercel-edge.js`.
+     */
+    vcConfigEntryPoint?: string;
+    /**
+     * The `envVarsInUse` property in the `.vc-config.json` file. List of environment variable names
+     * that will be available for the Edge Function to utilize.
+     *
+     * Defaults to `undefined`.
+     */
+    vcConfigEnvVarsInUse?: string[];
+    /**
+     * Manually add pathnames that should be treated as static paths and not SSR. For example, when
+     * these pathnames are requested, their response should come from a static file, rather than a
+     * server-side rendered response.
+     */
+    staticPaths?: string[];
+    /**
+     * Define the `target` property in the `ssr` object in the `vite.config.mts` file.
+     *
+     * Defaults to `webworker`.
+     */
+    target?: 'webworker' | 'node';
+}
+
+export { }

package/lib/adapters/vercel-edge/vite/index.mjs

@@ -0,0 +1,83 @@
+// packages/qwik-router/src/adapters/vercel-edge/vite/index.ts
+import fs from "node:fs";
+import { dirname, join } from "node:path";
+import { getParentDir, viteAdapter } from "../../shared/vite/index.mjs";
+function vercelEdgeAdapter(opts = {}) {
+  var _a;
+  return viteAdapter({
+    name: "vercel-edge",
+    origin: ((_a = process == null ? void 0 : process.env) == null ? void 0 : _a.VERCEL_URL) || "https://yoursitename.vercel.app",
+    ssg: opts.ssg,
+    staticPaths: opts.staticPaths,
+    cleanStaticGenerated: true,
+    config(config) {
+      var _a2;
+      const outDir = ((_a2 = config.build) == null ? void 0 : _a2.outDir) || join(".vercel", "output", "functions", "_qwik-router.func");
+      return {
+        resolve: {
+          conditions: opts.target === "node" ? ["node", "import", "module", "browser", "default"] : ["edge-light", "webworker", "worker", "browser", "module", "main"]
+        },
+        ssr: {
+          target: opts.target === "node" ? "node" : "webworker",
+          noExternal: true
+        },
+        build: {
+          ssr: true,
+          outDir,
+          rollupOptions: {
+            output: {
+              format: "es",
+              hoistTransitiveImports: false
+            }
+          }
+        },
+        publicDir: false
+      };
+    },
+    async generate({ clientPublicOutDir, serverOutDir, basePathname, outputEntries }) {
+      const vercelOutputDir = getParentDir(serverOutDir, "output");
+      if (opts.outputConfig !== false) {
+        const vercelOutputConfig = {
+          routes: [
+            { handle: "filesystem" },
+            {
+              src: basePathname + ".*",
+              dest: "/_qwik-router"
+            }
+          ],
+          version: 3
+        };
+        await fs.promises.writeFile(
+          join(vercelOutputDir, "config.json"),
+          JSON.stringify(vercelOutputConfig, null, 2)
+        );
+      }
+      let entrypoint = opts.vcConfigEntryPoint;
+      if (!entrypoint) {
+        if (outputEntries.some((n) => n === "entry.vercel-edge.mjs")) {
+          entrypoint = "entry.vercel-edge.mjs";
+        } else {
+          entrypoint = "entry.vercel-edge.js";
+        }
+      }
+      const vcConfigPath = join(serverOutDir, ".vc-config.json");
+      const vcConfig = {
+        runtime: "edge",
+        entrypoint,
+        envVarsInUse: opts.vcConfigEnvVarsInUse
+      };
+      await fs.promises.writeFile(vcConfigPath, JSON.stringify(vcConfig, null, 2));
+      let vercelStaticDir = join(vercelOutputDir, "static");
+      const basePathnameParts = basePathname.split("/").filter((p) => p.length > 0);
+      if (basePathnameParts.length > 0) {
+        vercelStaticDir = join(vercelStaticDir, ...basePathnameParts);
+      }
+      await fs.promises.rm(vercelStaticDir, { recursive: true, force: true });
+      await fs.promises.mkdir(dirname(vercelStaticDir), { recursive: true });
+      await fs.promises.rename(clientPublicOutDir, vercelStaticDir);
+    }
+  });
+}
+export {
+  vercelEdgeAdapter
+};