@ng-doc/builder 22.0.0-beta.1 → 22.0.0

package/generator/vite/prerender-entry.js

@@ -0,0 +1,395 @@
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+
+// libs/builder/generator/vite/mime.ts
+import path from "node:path";
+function contentType(file) {
+  return TYPES[path.extname(file).toLowerCase()] ?? "application/octet-stream";
+}
+var TYPES;
+var init_mime = __esm({
+  "libs/builder/generator/vite/mime.ts"() {
+    "use strict";
+    TYPES = {
+      ".aac": "audio/aac",
+      ".apng": "image/apng",
+      ".avif": "image/avif",
+      ".bmp": "image/bmp",
+      ".cjs": "text/javascript; charset=utf-8",
+      ".css": "text/css; charset=utf-8",
+      ".csv": "text/csv; charset=utf-8",
+      ".eot": "application/vnd.ms-fontobject",
+      ".flac": "audio/flac",
+      ".gif": "image/gif",
+      ".gz": "application/gzip",
+      ".htm": "text/html; charset=utf-8",
+      ".html": "text/html; charset=utf-8",
+      ".ico": "image/x-icon",
+      ".ics": "text/calendar; charset=utf-8",
+      ".jpeg": "image/jpeg",
+      ".jpg": "image/jpeg",
+      ".js": "text/javascript; charset=utf-8",
+      ".json": "application/json; charset=utf-8",
+      ".jsonld": "application/ld+json; charset=utf-8",
+      ".map": "application/json; charset=utf-8",
+      ".md": "text/markdown; charset=utf-8",
+      ".mjs": "text/javascript; charset=utf-8",
+      ".mp3": "audio/mpeg",
+      ".mp4": "video/mp4",
+      ".oga": "audio/ogg",
+      ".ogg": "audio/ogg",
+      ".ogv": "video/ogg",
+      ".otf": "font/otf",
+      ".pdf": "application/pdf",
+      ".png": "image/png",
+      ".svg": "image/svg+xml; charset=utf-8",
+      ".tif": "image/tiff",
+      ".tiff": "image/tiff",
+      ".ttf": "font/ttf",
+      ".txt": "text/plain; charset=utf-8",
+      ".wasm": "application/wasm",
+      ".wav": "audio/wav",
+      ".weba": "audio/webm",
+      ".webm": "video/webm",
+      ".webmanifest": "application/manifest+json; charset=utf-8",
+      ".webp": "image/webp",
+      ".woff": "font/woff",
+      ".woff2": "font/woff2",
+      ".xml": "application/xml; charset=utf-8",
+      ".zip": "application/zip"
+    };
+  }
+});
+
+// libs/builder/generator/vite/route-inventory.ts
+async function enumerateRoutes(routes, { invoke }) {
+  if (!Array.isArray(routes)) {
+    throw new TypeError("routes must be an Angular Routes array");
+  }
+  if (typeof invoke !== "function") {
+    throw new TypeError("invoke must be a function");
+  }
+  const found = [];
+  const excluded = [];
+  const emitted = /* @__PURE__ */ new Set();
+  const addRoute = (path3, base, route) => {
+    const redirectTo = typeof route.redirectTo === "string" ? resolveRedirect(base, route.redirectTo) : void 0;
+    const key = `${path3}\0${redirectTo ?? ""}`;
+    if (emitted.has(key)) return;
+    emitted.add(key);
+    found.push(redirectTo === void 0 ? { path: path3 } : { path: path3, redirectTo });
+  };
+  const exclude = (path3, reason) => {
+    excluded.push({ path: path3, reason });
+  };
+  async function visit(siblings, base, ancestors) {
+    if (ancestors.has(siblings)) {
+      exclude(base, "cycle");
+      return;
+    }
+    const branch = new Set(ancestors);
+    branch.add(siblings);
+    const claimedTerminals = /* @__PURE__ */ new Set();
+    for (const candidate of siblings) {
+      if (!candidate || typeof candidate !== "object") continue;
+      const route = candidate;
+      if (route.outlet && route.outlet !== "primary") {
+        exclude(join(base, typeof route.path === "string" ? route.path : ""), "non-primary-outlet");
+        continue;
+      }
+      if (typeof route.path !== "string") {
+        exclude(base, route.matcher ? "matcher" : "missing-path");
+        continue;
+      }
+      const path3 = join(base, route.path);
+      if (typeof route.redirectTo === "function") {
+        exclude(path3, "function-redirect");
+        continue;
+      }
+      if (route.path === "**") {
+        exclude(path3, "wildcard");
+        continue;
+      }
+      if (route.path.split("/").some((segment) => segment.startsWith(":"))) {
+        exclude(path3, "parameter");
+        continue;
+      }
+      if (isTerminal(route)) {
+        if (claimedTerminals.has(path3)) {
+          exclude(path3, "shadowed");
+        } else {
+          addRoute(path3, base, route);
+          claimedTerminals.add(path3);
+        }
+      }
+      if (Array.isArray(route.children)) {
+        await visit(route.children, path3, branch);
+      }
+      if (typeof route.loadChildren === "function") {
+        const factory = route.loadChildren;
+        await visit(unwrapLazyRoutes(await invoke(factory)), path3, branch);
+      }
+    }
+  }
+  await visit(routes, "/", /* @__PURE__ */ new Set());
+  found.sort(
+    (left, right) => compareText(left.path, right.path) || compareText(left.redirectTo ?? "", right.redirectTo ?? "")
+  );
+  excluded.sort(
+    (left, right) => compareText(left.path, right.path) || compareText(left.reason, right.reason)
+  );
+  return { routes: found, excluded };
+}
+function isTerminal(route) {
+  return typeof route.redirectTo === "string" || "component" in route || "loadComponent" in route;
+}
+function unwrapLazyRoutes(value) {
+  if (Array.isArray(value)) return value;
+  if (value && typeof value.subscribe === "function") {
+    throw new TypeError("loadChildren Observable results are not supported");
+  }
+  const module = value;
+  if (module && Array.isArray(module.default)) return module.default;
+  throw new TypeError(
+    "loadChildren must resolve to a Routes array or a module with a default Routes array"
+  );
+}
+function join(base, child) {
+  const pieces = [base, child].flatMap((part) => part.split("/")).filter(Boolean);
+  return `/${pieces.join("/")}`;
+}
+function resolveRedirect(base, redirectTo) {
+  return normalize(redirectTo.startsWith("/") ? redirectTo : `${base}/${redirectTo}`);
+}
+function normalize(path3) {
+  const pieces = [];
+  for (const segment of path3.split("/")) {
+    if (!segment || segment === ".") continue;
+    if (segment === "..") pieces.pop();
+    else pieces.push(segment);
+  }
+  return `/${pieces.join("/")}`;
+}
+function compareText(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+var init_route_inventory = __esm({
+  "libs/builder/generator/vite/route-inventory.ts"() {
+    "use strict";
+  }
+});
+
+// libs/builder/generator/vite/prerender-runtime.ts
+import { existsSync } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path2 from "node:path";
+import { pathToFileURL } from "node:url";
+import { format } from "node:util";
+function prerenderError(code, message) {
+  return new Error(`[${code}] ${message}`);
+}
+function serverEntry(value) {
+  const module = value;
+  const missing = ["bootstrap", "renderApplication", "Router", "runInInjectionContext"].filter((name) => typeof module?.[name] !== "function").sort();
+  if (missing.length) {
+    throw prerenderError(
+      "NGDOC_PRERENDER_SERVER_ENTRY",
+      `The server bundle does not export ${missing.join(", ")}; build it from the server entry of createNgDocApplicationPlugin.`
+    );
+  }
+  return module;
+}
+function documentBase(document) {
+  const href = /<base\s[^>]*href\s*=\s*["']([^"']*)["']/i.exec(document)?.[1];
+  if (!href?.startsWith("/")) return "/";
+  return href.endsWith("/") ? href : `${href}/`;
+}
+function routeFile(route) {
+  if (!route.startsWith("/") || /[?#\\\0]/.test(route) || route.split("/").some((segment) => segment === "." || segment === "..")) {
+    throw prerenderError("NGDOC_PRERENDER_ROUTE", `Unsupported route path: ${route}`);
+  }
+  const segments = route.split("/").filter(Boolean);
+  return [...segments, "index.html"].join("/");
+}
+function localFetch(browserDir, base, fallback) {
+  return async (input, init) => {
+    const target = new URL(
+      typeof input === "string" ? input : input instanceof URL ? input.href : input.url,
+      `http://${HOST}`
+    );
+    if (target.origin !== `http://${HOST}`) return fallback(input, init);
+    let relative;
+    try {
+      const pathname = decodeURIComponent(target.pathname);
+      relative = pathname.startsWith(base) ? pathname.slice(base.length) : void 0;
+    } catch {
+      relative = void 0;
+    }
+    const file = relative && !relative.includes("\\") && !relative.includes("\0") && !relative.split("/").some((segment) => segment === ".." || segment === "") ? await readFile(path2.join(browserDir, relative)).catch(() => void 0) : void 0;
+    if (!file) return new Response("Not found", { status: 404, statusText: "Not Found" });
+    return new Response(new Uint8Array(file), {
+      status: 200,
+      headers: { "content-type": contentType(relative) }
+    });
+  };
+}
+function routeWarningsToStderr(port = process) {
+  const previous = port.listeners("warning");
+  port.removeAllListeners("warning");
+  const write = (warning) => {
+    port.stderr.write(`(node:${port.pid}) ${warning.name}: ${warning.message}
+`);
+  };
+  port.on("warning", write);
+  return () => {
+    port.removeAllListeners("warning");
+    for (const listener of previous) port.on("warning", listener);
+  };
+}
+function withTimeout(work, milliseconds, route) {
+  if (milliseconds === void 0) return work;
+  let timer;
+  return Promise.race([
+    work,
+    new Promise((_resolve, reject) => {
+      timer = setTimeout(
+        () => reject(
+          prerenderError(
+            "NGDOC_PRERENDER_TIMEOUT",
+            `${route} did not render within ${milliseconds} ms.`
+          )
+        ),
+        milliseconds
+      );
+    })
+  ]).finally(() => clearTimeout(timer));
+}
+async function runPrerender(request, options = {}) {
+  const importModule = options.importModule ?? ((url2) => import(url2));
+  const browserDir = path2.resolve(request.browserDir);
+  const shellFile = path2.join(browserDir, SHELL);
+  const document = await readFile(
+    existsSync(shellFile) ? shellFile : path2.join(browserDir, "index.html"),
+    "utf8"
+  );
+  const base = documentBase(document);
+  const originalFetch = globalThis.fetch;
+  globalThis.fetch = localFetch(browserDir, base, originalFetch);
+  let entry;
+  try {
+    entry = serverEntry(await importModule(pathToFileURL(path2.resolve(request.serverEntry)).href));
+  } catch (error) {
+    globalThis.fetch = originalFetch;
+    throw error;
+  }
+  const url = (route) => new URL(`${base}${route.replace(/^\//, "")}`, `http://${HOST}`).href;
+  const render = (route, bootstrap = entry.bootstrap) => withTimeout(
+    entry.renderApplication(bootstrap, { document, url: url(route), allowedHosts: [HOST] }),
+    request.routeTimeoutMs,
+    route
+  );
+  const errors = [];
+  let current = "/";
+  const log = console.error;
+  const restoreWarnings = routeWarningsToStderr();
+  console.error = (...args) => {
+    errors.push({ route: current, message: format(...args) });
+    log.apply(console, args);
+  };
+  try {
+    return { ...await renderRoutes(), errors };
+  } finally {
+    console.error = log;
+    restoreWarnings();
+    globalThis.fetch = originalFetch;
+  }
+  async function renderRoutes() {
+    const discovered = [];
+    const excluded = [];
+    if (request.discoverRoutes) {
+      let inventory;
+      await render("/", async (context) => {
+        const application = await entry.bootstrap(context);
+        const router = application.injector.get(entry.Router);
+        inventory = await enumerateRoutes(Array.isArray(router?.config) ? router.config : [], {
+          invoke: (factory) => entry.runInInjectionContext(application.injector, factory)
+        });
+        return application;
+      });
+      discovered.push(...inventory.routes);
+      excluded.push(...inventory.excluded);
+    }
+    const byPath = /* @__PURE__ */ new Map();
+    for (const route of discovered) if (!byPath.has(route.path)) byPath.set(route.path, route);
+    for (const route of request.routes) {
+      const normalized = `/${route.split("/").filter(Boolean).join("/")}`;
+      if (!byPath.has(normalized)) byPath.set(normalized, { path: normalized });
+    }
+    const routes = [...byPath.values()].sort(
+      (left, right) => left.path < right.path ? -1 : left.path > right.path ? 1 : 0
+    );
+    for (const route of routes) routeFile(route.path);
+    await writeFile(shellFile, document);
+    const rendered = [];
+    const failures = [];
+    for (const route of routes) {
+      const file = routeFile(route.path);
+      current = route.path;
+      try {
+        const html = await render(route.path);
+        await mkdir(path2.dirname(path2.join(browserDir, file)), { recursive: true });
+        await writeFile(path2.join(browserDir, file), html);
+        rendered.push({ ...route, file });
+      } catch (error) {
+        failures.push(`${route.path}: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+    if (failures.length) {
+      throw prerenderError(
+        "NGDOC_PRERENDER_FAILED",
+        `${failures.length} of ${routes.length} route(s) failed to render:
+${failures.slice(0, 10).join("\n")}`
+      );
+    }
+    return { routes: rendered, excluded, shell: SHELL };
+  }
+}
+function runPrerenderChild(port, run = runPrerender) {
+  port.once("disconnect", () => port.exit(1));
+  port.once("message", (message) => {
+    const finish = (reply, code) => {
+      port.send(reply, void 0, void 0, () => port.exit(code));
+    };
+    void run(message).then(
+      (report) => finish({ type: "result", report }, 0),
+      (error) => finish(
+        { type: "error", message: error instanceof Error ? error.message : String(error) },
+        1
+      )
+    );
+  });
+}
+var SHELL, HOST;
+var init_prerender_runtime = __esm({
+  "libs/builder/generator/vite/prerender-runtime.ts"() {
+    "use strict";
+    init_mime();
+    init_route_inventory();
+    SHELL = "index.csr.html";
+    HOST = "localhost";
+  }
+});
+
+// libs/builder/generator/vite/prerender-entry.ts
+var require_prerender_entry = __commonJS({
+  "libs/builder/generator/vite/prerender-entry.ts"() {
+    init_prerender_runtime();
+    runPrerenderChild(process);
+  }
+});
+export default require_prerender_entry();

package/generator/vite/prerender-runtime.d.ts

@@ -0,0 +1,66 @@
+import { type NgDocExcludedRoute, type NgDocPrerenderRoute } from './route-inventory.js';
+/** The prerender work of one child process. Only JSON values: it crosses the IPC channel. */
+export interface PrerenderRequest {
+    /** The browser output: its `index.html` is the document every route is rendered into. */
+    browserDir: string;
+    /** The server bundle built from the application plugin's server entry. */
+    serverEntry: string;
+    /** Routes rendered in addition to the discovered ones. */
+    routes: string[];
+    /** Enumerate the application's `Router.config` (default in the callers: true). */
+    discoverRoutes: boolean;
+    /** Fails a route that takes longer to render, in milliseconds. */
+    routeTimeoutMs?: number;
+}
+export interface PrerenderReport {
+    /** Every rendered route, in code-unit order, with the file written for it. */
+    routes: Array<NgDocPrerenderRoute & {
+        file: string;
+    }>;
+    /** Route candidates without a concrete URL (parameters, wildcards, ...), which were skipped. */
+    excluded: NgDocExcludedRoute[];
+    /** The client-rendered shell, kept next to the prerendered `index.html` of `/`. */
+    shell: string;
+    /** What the application logged with `console.error` while rendering a route. */
+    errors: Array<{
+        route: string;
+        message: string;
+    }>;
+}
+export interface PrerenderRuntimeOptions {
+    /** Imports the server bundle; tests replace it. */
+    importModule?: (url: string) => Promise<unknown>;
+}
+/**
+ * The `<base href>` of the document, which every request URL starts with.
+ */
+export declare function documentBase(document: string): string;
+/**
+ * Validates a route path and returns the file it is prerendered into, relative to the browser output.
+ */
+export declare function routeFile(route: string): string;
+/**
+ * A `fetch` that answers requests for the prerender host from the browser output, as the Angular
+ * CLI prerender does: the application loads its own assets (search index, keywords, icons) over
+ * HTTP while it renders, and no server listens during a build. Other origins go to `fallback`.
+ */
+export declare function localFetch(browserDir: string, base: string, fallback: typeof fetch): typeof fetch;
+/**
+ * Sends Node's process warnings (deprecations and the like) straight to stderr until the returned
+ * function restores the previous listeners. Node prints them through `console.error`, which the
+ * prerender captures as the application's errors.
+ */
+export declare function routeWarningsToStderr(port?: Pick<NodeJS.Process, 'listeners' | 'removeAllListeners' | 'on' | 'pid' | 'stderr'>): () => void;
+/**
+ * Renders every route of the application into `<browserDir>/<route>/index.html`.
+ *
+ * The routes are the application's own `Router.config` (lazy children included), plus the
+ * explicit ones. The client shell `index.html` is kept as `index.csr.html` before `/` replaces
+ * it; a later run over the same output renders into that shell again. All routes are rendered
+ * before a failure is reported, and every failed route is named.
+ */
+export declare function runPrerender(request: PrerenderRequest, options?: PrerenderRuntimeOptions): Promise<PrerenderReport>;
+/**
+ * Child-process side: one request in, one report (or error) out, then exit.
+ */
+export declare function runPrerenderChild(port: Pick<NodeJS.Process, 'once' | 'send' | 'exit'>, run?: typeof runPrerender): void;

package/generator/vite/prerender.d.ts

@@ -0,0 +1,27 @@
+import type { PrerenderReport } from './prerender-runtime.js';
+export type { PrerenderReport as NgDocPrerenderReport } from './prerender-runtime.js';
+export type { NgDocExcludedRoute, NgDocPrerenderRoute } from './route-inventory.js';
+export interface NgDocPrerenderOptions {
+    /** The browser output of the client build (it holds `index.html`). */
+    browserDir: string;
+    /** The server bundle of the server build (`server.mjs`). */
+    serverEntry: string;
+    /** Routes rendered in addition to the discovered ones, for example parameterized pages. */
+    routes?: readonly string[];
+    /** Enumerate the application's `Router.config`, lazy children included (default true). */
+    discoverRoutes?: boolean;
+    /** Fails a route that takes longer to render, in milliseconds (default: no limit). */
+    routeTimeoutMs?: number;
+    signal?: AbortSignal;
+    /** The child process entry; tests replace it. */
+    entryUrl?: URL;
+}
+/** The V8 heap and stack limits of the host's `execArgv`, which the child keeps. */
+export declare function heapArguments(execArgv: readonly string[]): string[];
+/**
+ * Prerenders every route of a built application into its browser output.
+ *
+ * Rendering runs in a child process: the server bundle carries its own Angular and zone.js,
+ * which patch the process's globals, so they never share a process with the Vite builds.
+ */
+export declare function prerenderNgDoc(options: NgDocPrerenderOptions): Promise<PrerenderReport>;

package/generator/vite/production.d.ts

@@ -0,0 +1,66 @@
+import { type InlineConfig } from 'vite';
+import type { BuildResult, PublishedGeneratorConfiguration } from '../contracts.js';
+import { type NgDocPrerenderOptions } from './prerender.js';
+import type { PrerenderReport } from './prerender-runtime.js';
+export interface NgDocViteBuildOptions {
+    /** The Vite configuration file of the application (the one `vite build` would load). */
+    configFile: string;
+    /**
+     * The output directory: the client build goes to `browser/`, the server bundle to
+     * `server/server.mjs`, the prerendered route list to `prerendered-routes.json`.
+     */
+    outputPath: string;
+    /** The Vite mode (default `production`). */
+    mode?: string;
+    /** Build the server bundle (default: when the application plugin has a `server` entry). */
+    ssr?: boolean;
+    /** Prerender every route into `browser/` (default: when the server bundle is built). */
+    prerender?: boolean;
+    /** Routes prerendered in addition to the discovered ones. */
+    routes?: readonly string[];
+    /** Enumerate the application's routes (default true). */
+    discoverRoutes?: boolean;
+    /** Skip the client and server builds and prerender an existing output. */
+    skipBuild?: boolean;
+    /** Fails a route that takes longer to render, in milliseconds (default: no limit). */
+    routeTimeoutMs?: number;
+    /** Progress lines (one per step). */
+    log?: (message: string) => void;
+    signal?: AbortSignal;
+}
+export interface NgDocViteBuildResult {
+    browser: string;
+    server?: string;
+    prerendered?: PrerenderReport;
+}
+/** @internal Injectable host ports for tests. */
+export interface NgDocViteBuildDependencies {
+    build(config: InlineConfig): Promise<unknown>;
+    prerender(options: NgDocPrerenderOptions): Promise<PrerenderReport>;
+}
+/**
+ * @internal The NgDoc generation of one production pipeline, shared by its builds through a
+ * plugin's `api.ngDocGeneration` (see `buildNgDocViteApplication`). The NgDoc plugin of the first
+ * build records the result it published; the plugin of a later build of the same pipeline, with
+ * the same generator options (`key`), publishes that result again instead of generating.
+ */
+export interface NgDocGenerationHandoff {
+    readonly schemaVersion: 1;
+    recorded?: {
+        key: string;
+        result: Extract<BuildResult, {
+            status: 'success';
+        }>;
+        configuration: PublishedGeneratorConfiguration;
+    };
+}
+/**
+ * The production build of a Vite + NgDoc application, as the Angular CLI application builder
+ * lays it out: the client build, then (with a server entry) a self-contained server bundle, then
+ * every route prerendered into the client output.
+ *
+ * Each step loads `configFile` again, but NgDoc generates once: the server build publishes the
+ * browser build's generation again (`NgDocGenerationHandoff`), so both bundles are built from the
+ * same generated sources.
+ */
+export declare function buildNgDocViteApplication(options: NgDocViteBuildOptions, dependencies?: NgDocViteBuildDependencies): Promise<NgDocViteBuildResult>;

package/generator/vite/progress.d.ts

@@ -0,0 +1,33 @@
+import type { Logger, ResolvedConfig } from 'vite';
+import type { GeneratorBootstrapOptions } from '../bootstrap/index.js';
+import type { ProgressStream } from '../progress/detect.js';
+import { type HostProgress } from '../progress/host.js';
+import type { LiveStream } from '../progress/live.js';
+import { type ProgressOptionSetting } from '../progress/settings.js';
+export interface ViteProgressOptions {
+    /** The logger to write to at the time of writing: the dev server's, else the resolved config's. */
+    logger(): Logger | undefined;
+    /** The plugin option `progress`. */
+    option?: ProgressOptionSetting;
+    /** Vite `logLevel`: `warn`, `error` and `silent` turn progress off unless a setting asks for it. */
+    logLevel?: ResolvedConfig['logLevel'];
+    generator: GeneratorBootstrapOptions;
+    /** The terminal (`process.stderr`): the live line, and every line when the log level hides info. */
+    stderr?: LiveStream & ProgressStream;
+}
+/**
+ * NgDoc progress in Vite: lines through the Vite logger (never with `clear`, so Vite keeps the
+ * screen and its banner follows the NgDoc summary), the live line on stderr until the dev server
+ * serves, and timestamped lines after that (`3:04:27 PM [vite] NgDoc: updated …`).
+ *
+ * - A Vite `logLevel` that hides info (`warn`, `error`, `silent`) turns progress off. A setting
+ *   that asks for progress anyway (`NGDOC_PROGRESS` or the plugin option, other than `auto`) is
+ *   honoured: its lines go straight to stderr, untimestamped, since the logger would drop them.
+ * - Vite's logger clears the screen for a message identical to the one before it and prints
+ *   `(xN)`. An NgDoc line identical to NgDoc's previous one therefore says how often it repeated
+ *   (`… (2 in a row)`), which keeps the terminal history.
+ * - A writer that throws stops progress and logs one `SESSION_PROGRESS_FAILED` warning.
+ */
+export declare function createViteProgress(options: ViteProgressOptions): HostProgress | undefined;
+/** The generator options with `progress` as the session's progress consumer. */
+export declare function withProgress(generator: GeneratorBootstrapOptions, progress: HostProgress | undefined): GeneratorBootstrapOptions;

package/generator/vite/restore-theme.js

@@ -0,0 +1,13 @@
+// Restores the reader's theme before the application starts. An empty stored id is the light
+// theme: it removes a `data-theme` that index.html sets by default.
+const themeId = localStorage.getItem('ng-doc-theme-id');
+
+if (themeId !== null) {
+  const documentElement = document.documentElement;
+
+  if (themeId) {
+    documentElement.setAttribute('data-theme', themeId);
+  } else {
+    documentElement.removeAttribute('data-theme');
+  }
+}

package/generator/vite/route-inventory.d.ts

@@ -0,0 +1,24 @@
+/** A concrete primary-outlet URL of the application, with its redirect target when it redirects. */
+export interface NgDocPrerenderRoute {
+    path: string;
+    redirectTo?: string;
+}
+/** A route candidate that has no single concrete URL, and why. */
+export interface NgDocExcludedRoute {
+    path: string;
+    reason: 'cycle' | 'function-redirect' | 'matcher' | 'missing-path' | 'non-primary-outlet' | 'parameter' | 'shadowed' | 'wildcard';
+}
+export interface NgDocRouteInventory {
+    routes: NgDocPrerenderRoute[];
+    excluded: NgDocExcludedRoute[];
+}
+/**
+ * Enumerates the concrete primary-outlet URLs of an Angular `Router.config`.
+ *
+ * `invoke` runs a lazy `loadChildren` factory; the caller wraps it in the application's injection
+ * context, because a factory may call `inject()`. Parameterized, wildcard, matcher and
+ * function-redirect routes have no single URL and are reported as excluded, never guessed.
+ */
+export declare function enumerateRoutes(routes: readonly unknown[], { invoke }: {
+    invoke: (factory: () => unknown) => unknown;
+}): Promise<NgDocRouteInventory>;

package/generator/vite/ssr-renderer-control.d.ts

@@ -0,0 +1 @@
+export declare function renderSsrControlModule(epoch: string): string;