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

package/lib/adapters/shared/vite/index.cjs

@@ -0,0 +1,371 @@
+"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/shared/vite/index.ts
+var vite_exports = {};
+__export(vite_exports, {
+  NOT_FOUND_PATHS_ID: () => NOT_FOUND_PATHS_ID,
+  RESOLVED_NOT_FOUND_PATHS_ID: () => RESOLVED_NOT_FOUND_PATHS_ID,
+  RESOLVED_STATIC_PATHS_ID: () => RESOLVED_STATIC_PATHS_ID,
+  STATIC_PATHS_ID: () => STATIC_PATHS_ID,
+  getParentDir: () => getParentDir,
+  viteAdapter: () => viteAdapter
+});
+module.exports = __toCommonJS(vite_exports);
+var import_node_fs2 = __toESM(require("node:fs"), 1);
+var import_node_path2 = require("node:path");
+
+// packages/qwik-router/src/adapters/shared/vite/post-build.ts
+var import_request_handler = require("../../../middleware/request-handler/index.cjs");
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_path = require("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 = (0, import_node_path.join)(fsDir, fsName);
+    if (fsName === "index.html" || fsName === "q-data.json") {
+      if (!staticPaths.has(pathname) && cleanStatic) {
+        await import_node_fs.default.promises.unlink(fsPath);
+      }
+      return;
+    }
+    if (fsName === "404.html") {
+      const notFoundHtml = await import_node_fs.default.promises.readFile(fsPath, "utf-8");
+      notFounds.push([pathname, notFoundHtml]);
+      return;
+    }
+    const stat = await import_node_fs.default.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 import_node_fs.default.promises.readdir(fsDir);
+    await Promise.all(itemNames.map((i) => loadItem(fsDir, i, pathname)));
+  };
+  if (import_node_fs.default.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 = (0, import_request_handler.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 = (0, import_node_path2.join)(serverOutDir, fileName);
+            } else if (chunk.name === "@qwik-router-config") {
+              qwikRouterConfigModulePath = (0, import_node_path2.join)(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.cjs");
+            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 ? (0, import_node_path2.join)(basePathname, assetsDir) : basePathname,
+              staticPaths,
+              format,
+              !!opts.cleanStaticGenerated
+            );
+            await Promise.all([
+              import_node_fs2.default.promises.writeFile((0, import_node_path2.join)(serverOutDir, RESOLVED_STATIC_PATHS_ID), staticPathsCode),
+              import_node_fs2.default.promises.writeFile(
+                (0, import_node_path2.join)(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;
+}
+function getParentDir(startDir, dirName) {
+  const root = (0, import_node_path2.resolve)("/");
+  let dir = startDir;
+  for (let i = 0; i < 20; i++) {
+    dir = (0, import_node_path2.dirname)(dir);
+    if ((0, import_node_path2.basename)(dir) === dirName) {
+      return dir;
+    }
+    if (dir === root) {
+      break;
+    }
+  }
+  throw new Error(`Unable to find "${dirName}" directory from "${startDir}"`);
+}
+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`;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NOT_FOUND_PATHS_ID,
+  RESOLVED_NOT_FOUND_PATHS_ID,
+  RESOLVED_STATIC_PATHS_ID,
+  STATIC_PATHS_ID,
+  getParentDir,
+  viteAdapter
+});

package/lib/adapters/shared/vite/index.d.ts

@@ -0,0 +1,114 @@
+import type { Plugin as Plugin_2 } from 'vite';
+import type { StaticGenerateRenderOptions } from '@qwik.dev/router/static';
+import type { UserConfig } from 'vite';
+
+/** @public */
+export declare interface AdapterSSGOptions extends Omit<StaticGenerateRenderOptions, 'outDir' | 'origin'> {
+    /** Defines routes that should be static generated. Accepts wildcard behavior. */
+    include: string[];
+    /**
+     * Defines routes that should not be static generated. Accepts wildcard behavior. `exclude` always
+     * take priority over `include`.
+     */
+    exclude?: string[];
+    /**
+     * The URL `origin`, which is a combination of the scheme (protocol) and hostname (domain). For
+     * example, `https://qwik.dev` has the protocol `https://` and domain `qwik.dev`. However, the
+     * `origin` does not include a `pathname`.
+     *
+     * The `origin` is used to provide a full URL during Static Site Generation (SSG), and to simulate
+     * a complete URL rather than just the `pathname`. For example, in order to render a correct
+     * canonical tag URL or URLs within the `sitemap.xml`, the `origin` must be provided too.
+     *
+     * If the site also starts with a pathname other than `/`, please use the `basePathname` option in
+     * the Qwik Router config options.
+     */
+    origin?: string;
+}
+
+declare interface BuildLayout {
+    filePath: string;
+    dirPath: string;
+    id: string;
+    layoutType: 'top' | 'nested';
+    layoutName: string;
+}
+
+declare interface BuildRoute extends ParsedPathname {
+    /** Unique id built from its relative file system path */
+    id: string;
+    /** Local file system path */
+    filePath: string;
+    ext: string;
+    /** URL Pathname */
+    pathname: string;
+    layouts: BuildLayout[];
+}
+
+/** @public */
+export declare function getParentDir(startDir: string, dirName: string): string;
+
+/** @public */
+export declare const NOT_FOUND_PATHS_ID = "@qwik-router-not-found-paths";
+
+declare interface ParsedPathname {
+    routeName: string;
+    pattern: RegExp;
+    paramNames: string[];
+    segments: PathnameSegment[];
+}
+
+declare type PathnameSegment = PathnameSegmentPart[];
+
+declare interface PathnameSegmentPart {
+    content: string;
+    dynamic: boolean;
+    rest: boolean;
+}
+
+/** @public */
+export declare const RESOLVED_NOT_FOUND_PATHS_ID = "@qwik-router-not-found-paths.js";
+
+/** @public */
+export declare const RESOLVED_STATIC_PATHS_ID = "@qwik-router-static-paths.js";
+
+/** @public */
+export declare interface ServerAdapterOptions {
+    /**
+     * Options the adapter should use when running Static Site Generation (SSG). Defaults the `filter`
+     * to "auto" which will attempt to automatically decides if a page can be statically generated and
+     * does not have dynamic data, or if it the page should instead be rendered on the server (SSR).
+     * Setting to `null` will prevent any pages from being statically generated.
+     */
+    ssg?: AdapterSSGOptions | null;
+}
+
+/** @public */
+export declare const STATIC_PATHS_ID = "@qwik-router-static-paths";
+
+/** @public */
+export declare function viteAdapter(opts: ViteAdapterPluginOptions): Plugin_2<never>;
+
+/** @public */
+declare interface ViteAdapterPluginOptions {
+    name: string;
+    origin: string;
+    staticPaths?: string[];
+    ssg?: AdapterSSGOptions | null;
+    cleanStaticGenerated?: boolean;
+    maxWorkers?: number;
+    config?: (config: UserConfig) => UserConfig;
+    generate?: (generateOpts: {
+        outputEntries: string[];
+        clientOutDir: string;
+        clientPublicOutDir: string;
+        serverOutDir: string;
+        basePathname: string;
+        routes: BuildRoute[];
+        assetsDir?: string;
+        warn: (message: string) => void;
+        error: (message: string) => void;
+    }) => Promise<void>;
+}
+
+export { }