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

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

@@ -101,12 +101,18 @@ function DownloadChartButton({ id }: { id: string }): JSX.Element {
   );
 }
 
-function DownloadPdfButton(): JSX.Element {
+function DownloadPdfButton({
+  extraPages,
+}: {
+  extraPages?: Parameters<
+    NonNullable<ReturnType<typeof useChartExport>>["downloadPdf"]
+  >[1];
+}): JSX.Element {
   const exportApi = useChartExport();
   return (
     <button
       type="button"
-      onClick={() => void exportApi?.downloadPdf("Overview")}
+      onClick={() => void exportApi?.downloadPdf("Overview", extraPages)}
     >
       Download pdf
     </button>
@@ -181,6 +187,46 @@ describe("ChartExportProvider", () => {
     expect(downloadFile).toHaveBeenCalledWith(expect.any(Blob), "disks.png");
   });
 
+  it("does not change the live theme while exporting", async () => {
+    const user = userEvent.setup();
+    document.documentElement.classList.add("pf-v6-theme-dark");
+    const capture = vi.fn(async () => {
+      expect(
+        document.documentElement.classList.contains("pf-v6-theme-dark"),
+      ).toBe(true);
+      return fakeCanvas();
+    });
+    const downloadFile = vi.fn();
+
+    render(
+      <ChartExportProvider
+        capture={capture}
+        encodePng={async () => new Blob(["png"])}
+        zipFiles={async () => new Blob(["zip"])}
+        downloadFile={downloadFile}
+        getZipFilename={() => "charts.zip"}
+      >
+        <RegisteredChart id="storage" title="Disks" />
+        <DownloadChartButton id="storage" />
+        <DownloadAllButton />
+      </ChartExportProvider>,
+    );
+
+    await user.click(screen.getByRole("button", { name: "Download storage" }));
+    await waitFor(() =>
+      expect(downloadFile).toHaveBeenCalledWith(expect.any(Blob), "disks.png"),
+    );
+    await user.click(screen.getByRole("button", { name: "Download all" }));
+    await waitFor(() =>
+      expect(downloadFile).toHaveBeenCalledWith(expect.any(Blob), "charts.zip"),
+    );
+
+    expect(
+      document.documentElement.classList.contains("pf-v6-theme-dark"),
+    ).toBe(true);
+    document.documentElement.classList.remove("pf-v6-theme-dark");
+  });
+
   it("re-registers charts after React Strict Mode's extra effect cycle", async () => {
     const user = userEvent.setup();
     const capture = vi.fn(async () => fakeCanvas());
@@ -236,6 +282,68 @@ describe("ChartExportProvider", () => {
     expect(downloadFile).toHaveBeenCalledWith(expect.any(Blob), "report.pdf");
   });
 
+  it("forwards extra text pages (e.g. cluster sizing recommendations) to the pdf builder", async () => {
+    const user = userEvent.setup();
+    const capture = vi.fn(async () => fakeCanvas());
+    const buildPdf = vi.fn(async () => new Blob(["pdf"]));
+    const downloadFile = vi.fn();
+    const extraPages = [
+      {
+        title: "Cluster sizing recommendations",
+        items: [
+          { label: "Cluster name", value: "cluster-1" },
+          { label: "Target platform", value: "Bare metal" },
+        ],
+        footer: "Note: estimates only.",
+      },
+    ];
+
+    render(
+      <ChartExportProvider
+        capture={capture}
+        zipFiles={vi.fn()}
+        buildPdf={buildPdf}
+        downloadFile={downloadFile}
+        getPdfFilename={() => "report.pdf"}
+      >
+        <RegisteredChart id="storage" title="Disks" />
+        <DownloadPdfButton extraPages={extraPages} />
+      </ChartExportProvider>,
+    );
+
+    await user.click(screen.getByRole("button", { name: "Download pdf" }));
+
+    expect(buildPdf).toHaveBeenCalledTimes(1);
+    expect(buildPdf.mock.calls[0]?.[2]).toEqual(extraPages);
+    expect(downloadFile).toHaveBeenCalledWith(expect.any(Blob), "report.pdf");
+  });
+
+  it("builds a PDF from extra text pages alone when no charts are registered", async () => {
+    const user = userEvent.setup();
+    const buildPdf = vi.fn(async () => new Blob(["pdf"]));
+    const downloadFile = vi.fn();
+    const extraPages = [{ title: "Cluster sizing recommendations", items: [] }];
+
+    render(
+      <ChartExportProvider
+        capture={vi.fn()}
+        zipFiles={vi.fn()}
+        buildPdf={buildPdf}
+        downloadFile={downloadFile}
+        getPdfFilename={() => "report.pdf"}
+      >
+        <DownloadPdfButton extraPages={extraPages} />
+      </ChartExportProvider>,
+    );
+
+    await user.click(screen.getByRole("button", { name: "Download pdf" }));
+
+    expect(buildPdf).toHaveBeenCalledTimes(1);
+    expect(buildPdf.mock.calls[0]?.[0]).toEqual([]);
+    expect(buildPdf.mock.calls[0]?.[2]).toEqual(extraPages);
+    expect(downloadFile).toHaveBeenCalledWith(expect.any(Blob), "report.pdf");
+  });
+
   it("builds HTML from the same captured canvases", async () => {
     const user = userEvent.setup();
     const capture = vi.fn(async () => fakeCanvas());

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;