@openshift-migration-advisor/shared-components 0.25.0-fce5293f01c1 → 0.27.0-5d0cc20d809e

package/src/report/__tests__/HostsOverview.test.tsx

@@ -0,0 +1,145 @@
+import "@testing-library/jest-dom";
+import {
+  chart_color_blue_300,
+  chart_color_green_300,
+  chart_color_purple_100,
+  chart_color_purple_300,
+  chart_color_teal_200,
+  chart_color_yellow_400,
+} from "@patternfly/react-tokens";
+import { cleanup, render, screen } from "@testing-library/react";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import type { MigrationDonutChartProps } from "../../charts/MigrationDonutChart.js";
+import { HostsOverview } from "../HostsOverview.js";
+
+const donutProps = vi.hoisted(() => ({
+  current: null as MigrationDonutChartProps | null,
+}));
+
+vi.mock("../../charts/MigrationDonutChart.js", () => ({
+  MigrationDonutChart: (props: MigrationDonutChartProps): JSX.Element => {
+    donutProps.current = props;
+    return (
+      <div data-testid="hosts-donut">
+        {props.title} {props.subTitle}
+      </div>
+    );
+  },
+}));
+
+afterEach(() => {
+  donutProps.current = null;
+  cleanup();
+});
+
+const renderedDonut = (): MigrationDonutChartProps => {
+  const props = donutProps.current;
+  if (!props) {
+    throw new Error("expected the host model donut to render");
+  }
+  return props;
+};
+
+describe("HostsOverview", () => {
+  it("shows the shared empty state when no hosts are available", () => {
+    render(<HostsOverview />);
+
+    expect(screen.getByText("Host distribution by model")).toBeInTheDocument();
+    expect(screen.getByText("Top 5 models")).toBeInTheDocument();
+    expect(screen.getByText("Host data not collected")).toBeInTheDocument();
+    expect(screen.queryByTestId("hosts-donut")).not.toBeInTheDocument();
+  });
+
+  it("buckets host counts into the top 5 models plus Other models", () => {
+    render(
+      <HostsOverview
+        hosts={[
+          { model: "M1" },
+          { model: "M1" },
+          { model: "M1" },
+          { model: "M1" },
+          { model: "M1" },
+          { model: "M1" },
+          { model: "M2" },
+          { model: "M2" },
+          { model: "M2" },
+          { model: "M2" },
+          { model: "M2" },
+          { model: "M3" },
+          { model: "M3" },
+          { model: "M3" },
+          { model: "M3" },
+          { model: "M4" },
+          { model: "M4" },
+          { model: "M4" },
+          { model: "M5" },
+          { model: "M5" },
+          { model: "M6" },
+          { model: "M7" },
+        ]}
+      />,
+    );
+
+    expect(screen.getByTestId("hosts-donut")).toHaveTextContent("22 Hosts");
+
+    const props = renderedDonut();
+    expect(props.data.map((slice) => [slice.name, slice.count])).toEqual([
+      ["M1", 6],
+      ["M2", 5],
+      ["M3", 4],
+      ["M4", 3],
+      ["M5", 2],
+      ["Other models", 2],
+    ]);
+    expect(props.data[5]?.countDisplay).toBe("2 hosts");
+    expect(props.legend).toEqual({
+      M1: chart_color_blue_300.value,
+      M2: chart_color_purple_300.value,
+      M3: chart_color_purple_100.value,
+      M4: chart_color_teal_200.value,
+      M5: chart_color_yellow_400.value,
+      "Other models": chart_color_green_300.value,
+    });
+    expect(props.legendVariant).toBe("html");
+    expect(props.height).toBe(300);
+    expect(props.width).toBe(420);
+    expect(props.donutThickness).toBe(18);
+    expect(props.titleFontSize).toBe(34);
+    expect(props.legendWidth).toBe(680);
+    expect(props.itemsPerRow).toBe(2);
+    expect(props.labelFontSize).toBe(16);
+    expect(props.marginLeft).toBe("0%");
+    expect(props.subTitleColor).toBe(
+      "var(--pf-t--global--text--color--subtle)",
+    );
+    expect(
+      props.tooltipLabelFormatter?.({
+        datum: {
+          x: "M1",
+          y: 6,
+          countDisplay: "6 hosts",
+          legendCategory: "M1",
+        },
+        percent: 27.2727,
+        total: 22,
+      }),
+    ).toBe("6 hosts\n27.3%");
+  });
+
+  it("treats numeric models as labels and blank models as unknown", () => {
+    render(
+      <HostsOverview
+        legendVariant="chart"
+        hosts={[{ model: 42 }, { model: "   " }, { model: "  R640  " }]}
+      />,
+    );
+
+    expect(renderedDonut().data.map((slice) => slice.name)).toEqual([
+      "42",
+      "Unknown model",
+      "R640",
+    ]);
+    expect(renderedDonut().legendVariant).toBe("chart");
+    expect(renderedDonut().title).toBe("3");
+  });
+});

package/src/report/__tests__/captureChartElement.test.ts

@@ -16,6 +16,12 @@ const mockedHtml2Canvas = vi.mocked(html2canvas);
 afterEach(() => {
   mockedHtml2Canvas.mockClear();
   document.body.replaceChildren();
+  document.documentElement.classList.remove(
+    "pf-v6-theme-dark",
+    "pf-v5-theme-dark",
+  );
+  document.documentElement.style.colorScheme = "";
+  document.body.style.colorScheme = "";
 });
 
 describe("captureChartElement", () => {
@@ -129,4 +135,71 @@ describe("captureChartElement", () => {
 
     await captureChartElement(root);
   });
+
+  it("applies light theme on the clone and leaves the live document dark", async () => {
+    document.documentElement.classList.add("pf-v6-theme-dark");
+    const root = document.createElement("div");
+    const card = document.createElement("div");
+    card.className = "pf-v6-c-card";
+    card.style.backgroundColor = "rgb(30, 30, 30)";
+    card.style.border = "1px solid rgb(80, 80, 80)";
+    const svg = document.createElementNS("http://www.w3.org/2000/svg", "svg");
+    const text = document.createElementNS("http://www.w3.org/2000/svg", "text");
+    text.style.fill = "rgb(255, 255, 255)";
+    text.textContent = "42";
+    svg.append(text);
+    card.append(svg);
+    root.append(card);
+    document.body.append(root);
+
+    mockedHtml2Canvas.mockImplementation(async (_element, options) => {
+      expect(
+        document.documentElement.classList.contains("pf-v6-theme-dark"),
+      ).toBe(true);
+
+      const clonedDoc = document.implementation.createHTMLDocument("export");
+      clonedDoc.documentElement.classList.add("pf-v6-theme-dark");
+      const cloneRoot = clonedDoc.createElement("div");
+      const cloneCard = clonedDoc.createElement("div");
+      cloneCard.className = "pf-v6-c-card";
+      cloneCard.style.backgroundColor = "rgb(30, 30, 30)";
+      const cloneSvg = clonedDoc.createElementNS(
+        "http://www.w3.org/2000/svg",
+        "svg",
+      );
+      const cloneText = clonedDoc.createElementNS(
+        "http://www.w3.org/2000/svg",
+        "text",
+      );
+      cloneText.style.fill = "rgb(255, 255, 255)";
+      cloneSvg.append(cloneText);
+      cloneCard.append(cloneSvg);
+      cloneRoot.append(cloneCard);
+      clonedDoc.body.append(cloneRoot);
+
+      await options?.onclone?.(clonedDoc, cloneRoot);
+
+      expect(
+        clonedDoc.documentElement.classList.contains("pf-v6-theme-dark"),
+      ).toBe(false);
+      expect(
+        document.documentElement.classList.contains("pf-v6-theme-dark"),
+      ).toBe(true);
+      expect(cloneCard.style.backgroundColor).toBe("rgb(255, 255, 255)");
+      expect(cloneCard.style.borderColor).toBe("rgb(224, 224, 224)");
+      expect(cloneText.style.fill).toBe("rgb(21, 21, 21)");
+
+      const canvas = document.createElement("canvas");
+      canvas.width = 1;
+      canvas.height = 1;
+      return canvas;
+    });
+
+    await captureChartElement(root);
+
+    expect(
+      document.documentElement.classList.contains("pf-v6-theme-dark"),
+    ).toBe(true);
+    expect(card.style.backgroundColor).toBe("rgb(30, 30, 30)");
+  });
 });

package/src/report/__tests__/chartExportPackagers.test.ts

@@ -1,5 +1,6 @@
 import { describe, expect, it } from "vitest";
 import {
+  applyLightThemeToDocument,
   chartExportViewsFromLabels,
   restoreChartExportViews,
   sortRegisteredChartsByDocumentOrder,
@@ -7,6 +8,7 @@ import {
 } from "../chartExport.js";
 import { getChartExportFilename } from "../chartExportFilenames.js";
 import { buildHtmlReport, escapeHtml } from "../htmlExport.js";
+import { buildPdfFromCharts } from "../pdfExport.js";
 import {
   fitPdfImageSize,
   placePdfBlock,
@@ -198,6 +200,63 @@ describe("placePdfBlock", () => {
   });
 });
 
+describe("buildPdfFromCharts with extra text pages", () => {
+  it("appends a text page even when there are no chart captures", async () => {
+    const blob = await buildPdfFromCharts([], "Report", [
+      {
+        title: "Cluster sizing recommendations",
+        items: [
+          { label: "Cluster name", value: "cluster-1" },
+          { label: "Target platform", value: "Bare metal" },
+          {
+            label: "Total nodes",
+            value: "6 (3 workers + 3 control plane)",
+          },
+          { label: "Failover capacity", value: "1 failover nodes" },
+          { label: "Worker node size", value: "8 CPU, 32 GB memory" },
+          {
+            label: "Control plane node size",
+            value: "16 CPU, 64 GB memory",
+          },
+        ],
+        footer: "Note: estimates only.",
+      },
+    ]);
+
+    expect(blob).toBeInstanceOf(Blob);
+    expect(blob.size).toBeGreaterThan(0);
+    expect(blob.type).toBe("application/pdf");
+  });
+
+  it("paginates extra pages with many rows without throwing", async () => {
+    const manyItems = Array.from({ length: 60 }, (_, index) => ({
+      label: `Field ${index}`,
+      value: `Value ${index}`,
+    }));
+
+    const blob = await buildPdfFromCharts([], "Report", [
+      { title: "Cluster sizing recommendations", items: manyItems },
+    ]);
+
+    expect(blob.size).toBeGreaterThan(0);
+  });
+
+  it("supports multiple extra pages (e.g. one per sized cluster)", async () => {
+    const blob = await buildPdfFromCharts([], "Report", [
+      {
+        title: "Cluster sizing recommendations — cluster-a",
+        items: [{ label: "Cluster name", value: "cluster-a" }],
+      },
+      {
+        title: "Cluster sizing recommendations — cluster-b",
+        items: [{ label: "Cluster name", value: "cluster-b" }],
+      },
+    ]);
+
+    expect(blob.size).toBeGreaterThan(0);
+  });
+});
+
 describe("buildHtmlReport", () => {
   it("embeds captured chart images and escapes the title", () => {
     const html = buildHtmlReport(
@@ -222,3 +281,19 @@ describe("buildHtmlReport", () => {
     expect(escapeHtml("it's")).toBe("it's");
   });
 });
+
+describe("applyLightThemeToDocument", () => {
+  it("removes PatternFly dark theme classes from the given document", () => {
+    const clone = document.implementation.createHTMLDocument("export");
+    clone.documentElement.classList.add("pf-v6-theme-dark");
+    clone.body.style.colorScheme = "dark";
+
+    applyLightThemeToDocument(clone);
+
+    expect(clone.documentElement.classList.contains("pf-v6-theme-dark")).toBe(
+      false,
+    );
+    expect(clone.documentElement.style.colorScheme).toBe("light");
+    expect(clone.body.style.colorScheme).toBe("light");
+  });
+});

package/src/report/captureChartElement.ts

@@ -1,5 +1,11 @@
+import {
+  t_color_gray_20,
+  t_color_white,
+  t_global_text_color_regular,
+} from "@patternfly/react-tokens";
 import html2canvas from "html2canvas-pro";
 import {
+  applyLightThemeToDocument,
   CHART_EXPORT_CAPTURING_ATTR,
   CHART_EXPORT_SCROLL_ATTR,
   shouldIgnoreChartExportElement,
@@ -94,6 +100,10 @@ const PADDED_CAPTURE_SELECTOR =
   ".pf-v6-c-card__title, .pf-v6-c-card__header, .pf-v6-c-card__body";
 const CARD_CAPTURE_SELECTOR = ".pf-v6-c-card";
 const TRANSPARENT_FILLS = new Set(["", "transparent", "rgba(0, 0, 0, 0)"]);
+/** PatternFly light-theme chrome. html2canvas inlines live computed SVG styles. */
+const LIGHT_EXPORT_BACKGROUND = t_color_white.value;
+const LIGHT_EXPORT_BORDER = t_color_gray_20.value;
+const LIGHT_EXPORT_TEXT = t_global_text_color_regular.value;
 
 function queryCards(root: HTMLElement): HTMLElement[] {
   const cards = Array.from(
@@ -149,16 +159,34 @@ function readCardBorder(source: HTMLElement): {
   return { width, style, color };
 }
 
-function applyCardChrome(source: HTMLElement, dest: HTMLElement): void {
+function applyCardChrome(
+  source: HTMLElement,
+  dest: HTMLElement,
+  colors: "computed" | "light",
+): void {
   const computed = window.getComputedStyle(source);
   dest.style.borderRadius = computed.borderRadius;
-  dest.style.backgroundColor = resolvedFill(computed.backgroundColor);
   dest.style.overflow = "hidden";
+  dest.style.backgroundColor =
+    colors === "light"
+      ? LIGHT_EXPORT_BACKGROUND
+      : resolvedFill(computed.backgroundColor);
   const border = readCardBorder(source);
   if (border) {
     dest.style.borderWidth = border.width;
     dest.style.borderStyle = border.style;
-    dest.style.borderColor = border.color;
+    dest.style.borderColor =
+      colors === "light" ? LIGHT_EXPORT_BORDER : border.color;
+  }
+}
+
+function applyLightThemeSvgText(root: HTMLElement): void {
+  for (const node of root.querySelectorAll("text, tspan")) {
+    if (!(node instanceof SVGElement)) {
+      continue;
+    }
+    node.style.fill = LIGHT_EXPORT_TEXT;
+    node.style.color = LIGHT_EXPORT_TEXT;
   }
 }
 
@@ -218,7 +246,7 @@ function copyCardChrome(node: HTMLElement): {
     height: node.style.height,
     maxHeight: node.style.maxHeight,
   };
-  applyCardChrome(node, node);
+  applyCardChrome(node, node, "computed");
   node.style.minHeight = "0px";
   node.style.height = "auto";
   node.style.maxHeight = "none";
@@ -234,7 +262,7 @@ function applyComputedStylesToClone(
   sourceCards.forEach((source, index) => {
     const dest = cloneCards[index];
     if (dest) {
-      applyCardChrome(source, dest);
+      applyCardChrome(source, dest, "light");
     }
   });
 
@@ -348,15 +376,17 @@ export async function captureChartElement(
     }
     return html2canvas(element, {
       useCORS: true,
-      backgroundColor: null,
+      backgroundColor: LIGHT_EXPORT_BACKGROUND,
       logging: false,
       scale: CHART_CAPTURE_SCALE,
       imageTimeout: 0,
       ignoreElements: (node) =>
         node instanceof Element &&
         shouldIgnoreChartExportElement(node, element),
-      onclone: (_clonedDoc, clonedElement) => {
+      onclone: (clonedDoc, clonedElement) => {
+        applyLightThemeToDocument(clonedDoc);
         applyComputedStylesToClone(element, clonedElement);
+        applyLightThemeSvgText(clonedElement);
       },
     });
   } finally {

package/src/report/chartExport.ts

@@ -51,6 +51,24 @@ export type ChartCaptureSource = {
   capture: () => Promise<HTMLCanvasElement>;
 };
 
+/** One label/value row rendered on a {@link PdfTextPage}. */
+export type PdfTextPageItem = {
+  label: string;
+  value: string;
+};
+
+/**
+ * A native-text PDF page appended after the captured chart images.
+ *
+ * Used for content that is not a chart/card (e.g. calculated recommendations)
+ * but still needs to be part of the exported PDF.
+ */
+export type PdfTextPage = {
+  title: string;
+  items: PdfTextPageItem[];
+  footer?: string;
+};
+
 export function releaseCanvas(canvas: HTMLCanvasElement): void {
   canvas.width = 0;
   canvas.height = 0;
@@ -67,6 +85,28 @@ export function waitForChartExportPaint(): Promise<void> {
   });
 }
 
+/** PatternFly applies dark tokens when this class is on `:root`. */
+export const PATTERNFLY_DARK_THEME_CLASSES = [
+  "pf-v6-theme-dark",
+  "pf-v5-theme-dark",
+] as const;
+
+/**
+ * Force PatternFly light tokens on a document (the html2canvas clone).
+ * Does not touch the live page.
+ */
+export function applyLightThemeToDocument(root: Document): void {
+  for (const node of [root.documentElement, root.body]) {
+    if (!node) {
+      continue;
+    }
+    for (const className of PATTERNFLY_DARK_THEME_CLASSES) {
+      node.classList.remove(className);
+    }
+    node.style.colorScheme = "light";
+  }
+}
+
 export function chartExportViewsFromLabels(
   titlePrefix: string,
   labels: Record<string, string>,

package/src/report/chartExportContext.tsx

@@ -9,6 +9,7 @@ import {
   type ChartExportMeta,
   type ChartExportView,
   chartPngFilename,
+  type PdfTextPage,
   type RegisteredChart,
 } from "./chartExport.js";
 
@@ -17,7 +18,14 @@ export type ChartExportFormat = "pdf" | "png" | "html";
 export type ChartExportApi = {
   downloadChart: (id: string) => Promise<void>;
   downloadAll: () => Promise<void>;
-  downloadPdf: (documentTitle: string) => Promise<void>;
+  /**
+   * @param extraPages - Native-text pages appended after the captured chart
+   * images (e.g. calculated recommendations that aren't rendered as charts).
+   */
+  downloadPdf: (
+    documentTitle: string,
+    extraPages?: PdfTextPage[],
+  ) => Promise<void>;
   downloadHtml: (documentTitle: string) => Promise<void>;
   downloadingChartId: string | null;
   exportingFormat: ChartExportFormat | null;

package/src/report/constants.ts

@@ -25,6 +25,8 @@ export const REPORT_CARD_EMPTY_STATE_TITLES = {
   operatingSystems: "Operating system data not collected",
   migrationStatus: "Migration status data not collected",
   issuesBreakdown: "Issues breakdown data not collected",
+  errors: "Error data not collected",
+  warnings: "Warning data not collected",
   hostPowerStates: "Host power state data not collected",
   vmPowerStates: "VM power state data not collected",
 } as const;

package/src/report/index.ts

@@ -9,6 +9,7 @@ export {
 } from "./ChartDownloadButton.js";
 export {
   type BuildChartDocument,
+  type BuildPdfDocument,
   type CaptureChartElement,
   ChartExportProvider,
   type ChartExportProviderProps,
@@ -16,6 +17,10 @@ export {
   type ZipChartFiles,
 } from "./ChartExportProvider.js";
 export { ChartExportSurface } from "./ChartExportSurface.js";
+export {
+  CpuAndMemoryOverview,
+  type CpuAndMemoryOverviewProps,
+} from "./CpuAndMemoryOverview.js";
 export { captureChartElement } from "./captureChartElement.js";
 export {
   CHART_EXPORT_CAPTURING_ATTR,
@@ -32,6 +37,8 @@ export {
   chartExportViewsFromLabels,
   chartPngFilename,
   downloadBlob,
+  type PdfTextPage,
+  type PdfTextPageItem,
   type RegisteredChart,
   releaseCanvas,
   restoreChartExportViews,
@@ -65,6 +72,11 @@ export {
   EmptySearchResults,
   type EmptySearchResultsProps,
 } from "./EmptySearchResults.js";
+export {
+  ErrorTable,
+  type ErrorTableProps,
+  type MigrationIssueLike,
+} from "./ErrorTable.js";
 export {
   FeatureStatusBadge,
   type FeatureStatusBadgeProps,
@@ -73,6 +85,11 @@ export {
   HostPowerStates,
   type HostPowerStatesProps,
 } from "./HostPowerStates.js";
+export {
+  type HostLike,
+  HostsOverview,
+  type HostsOverviewProps,
+} from "./HostsOverview.js";
 export {
   buildHtmlFromCharts,
   buildHtmlReport,
@@ -167,6 +184,7 @@ export {
   ReportExportMenu,
   type ReportExportMenuProps,
 } from "./ReportExportMenu.js";
+export { ReportTable, type ReportTableProps } from "./ReportTable.js";
 export {
   type ReportExportOption,
   type StandardReportExportHandlers,
@@ -187,4 +205,8 @@ export {
   VmPowerStates,
   type VmPowerStatesProps,
 } from "./VmPowerStates.js";
+export {
+  WarningsTable,
+  type WarningsTableProps,
+} from "./WarningsTable.js";
 export { zipChartPngs } from "./zipChartPngs.js";

package/src/report/pdfExport.ts

@@ -1,5 +1,9 @@
 import jsPDF from "jspdf";
-import { type ChartCaptureSource, releaseCanvas } from "./chartExport.js";
+import {
+  type ChartCaptureSource,
+  type PdfTextPage,
+  releaseCanvas,
+} from "./chartExport.js";
 import { fitPdfImageSize, placePdfBlock, sliceCanvas } from "./pdfPage.js";
 
 const MARGIN_MM = 10;
@@ -10,6 +14,7 @@ const PAGE_BACKGROUND = "#ffffff";
 export async function buildPdfFromCharts(
   charts: ChartCaptureSource[],
   documentTitle: string,
+  extraPages: PdfTextPage[] = [],
 ): Promise<Blob> {
   const pdf = new jsPDF("p", "mm", "a4");
   const pageWidth = pdf.internal.pageSize.getWidth();
@@ -22,7 +27,7 @@ export async function buildPdfFromCharts(
   addCoverPage(
     pdf,
     documentTitle,
-    charts.map((chart) => chart.title),
+    [...charts.map((chart) => chart.title), ...extraPages.map((p) => p.title)],
     pageWidth,
     pageHeight,
   );
@@ -63,6 +68,10 @@ export async function buildPdfFromCharts(
     }
   }
 
+  if (extraPages.length > 0) {
+    addExtraPages(pdf, extraPages, pageWidth, pageHeight);
+  }
+
   addPageNumbers(pdf, pageWidth, pageHeight);
   return pdf.output("blob");
 }
@@ -138,6 +147,76 @@ function addChartImage(
   }
 }
 
+/**
+ * Append one native-text PDF page per entry in `extraPages`, rendered as
+ * label/value rows rather than a captured image. Each page starts fresh so
+ * its content never bleeds into a chart page.
+ */
+function addExtraPages(
+  pdf: jsPDF,
+  extraPages: PdfTextPage[],
+  pageWidth: number,
+  pageHeight: number,
+): void {
+  const LABEL_COL_WIDTH = 68; // mm — enough for the longest label
+  const VALUE_COL_X = MARGIN_MM + LABEL_COL_WIDTH;
+  const VALUE_COL_WIDTH = pageWidth - MARGIN_MM - LABEL_COL_WIDTH;
+  const LINE_HEIGHT = 7; // mm between rows
+
+  for (const page of extraPages) {
+    pdf.addPage();
+    let y = MARGIN_MM + 8;
+
+    pdf.setFontSize(16);
+    pdf.setFont("helvetica", "bold");
+    pdf.text(page.title, MARGIN_MM, y);
+    y += 10;
+
+    pdf.setDrawColor(0, 103, 187);
+    pdf.setLineWidth(0.5);
+    pdf.line(MARGIN_MM, y, pageWidth - MARGIN_MM, y);
+    y += 10;
+
+    pdf.setFontSize(11);
+
+    for (const item of page.items) {
+      pdf.setFont("helvetica", "bold");
+      const labelLines = pdf.splitTextToSize(
+        item.label,
+        LABEL_COL_WIDTH - 4,
+      ) as string[];
+      pdf.text(labelLines, MARGIN_MM, y);
+
+      pdf.setFont("helvetica", "normal");
+      const valueLines = pdf.splitTextToSize(
+        item.value,
+        VALUE_COL_WIDTH,
+      ) as string[];
+      pdf.text(valueLines, VALUE_COL_X, y);
+
+      y += LINE_HEIGHT * Math.max(labelLines.length, valueLines.length);
+
+      if (y > pageHeight - MARGIN_MM - 25) {
+        pdf.addPage();
+        y = MARGIN_MM + 10;
+      }
+    }
+
+    if (page.footer) {
+      y += 4;
+      pdf.setFontSize(9);
+      pdf.setFont("helvetica", "bolditalic");
+      const footerLines = pdf.splitTextToSize(
+        page.footer,
+        pageWidth - MARGIN_MM * 2,
+      ) as string[];
+      pdf.text(footerLines, MARGIN_MM, y);
+      pdf.setFont("helvetica", "normal");
+      pdf.setFontSize(11);
+    }
+  }
+}
+
 function addPageNumbers(
   pdf: jsPDF,
   pageWidth: number,