@openshift-migration-advisor/shared-components 0.24.0 → 0.25.0-1701f64050d7

package/src/report/pdfExport.ts

@@ -0,0 +1,233 @@
+import jsPDF from "jspdf";
+import {
+  type ChartCaptureSource,
+  type PdfTextPage,
+  releaseCanvas,
+} from "./chartExport.js";
+import { fitPdfImageSize, placePdfBlock, sliceCanvas } from "./pdfPage.js";
+
+const MARGIN_MM = 10;
+const GAP_MM = 8;
+/** Flatten captures onto white; jsPDF cannot embed transparent PNG alpha cleanly. */
+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();
+  const pageHeight = pdf.internal.pageSize.getHeight();
+  const contentWidth = pageWidth - MARGIN_MM * 2;
+  const contentHeight = pageHeight - MARGIN_MM * 2;
+  const pageTop = MARGIN_MM;
+  const pageBottom = pageHeight - MARGIN_MM;
+
+  addCoverPage(
+    pdf,
+    documentTitle,
+    [...charts.map((chart) => chart.title), ...extraPages.map((p) => p.title)],
+    pageWidth,
+    pageHeight,
+  );
+
+  let cursorY: number | null = null;
+  for (const chart of charts) {
+    const canvas = await chart.capture();
+    try {
+      if (canvas.width < 1 || canvas.height < 1) {
+        throw new Error("Chart capture produced an empty image");
+      }
+      const size = fitPdfImageSize(
+        canvas.width,
+        canvas.height,
+        contentWidth,
+        contentHeight,
+      );
+      const placement = placePdfBlock(
+        cursorY,
+        size.heightMm,
+        pageTop,
+        pageBottom,
+      );
+      if (placement.needsNewPage) {
+        pdf.addPage();
+      }
+      addChartImage(
+        pdf,
+        canvas,
+        MARGIN_MM + (contentWidth - size.widthMm) / 2,
+        placement.y,
+        size.widthMm,
+        size.heightMm,
+      );
+      cursorY = placement.y + size.heightMm + GAP_MM;
+    } finally {
+      releaseCanvas(canvas);
+    }
+  }
+
+  if (extraPages.length > 0) {
+    addExtraPages(pdf, extraPages, pageWidth, pageHeight);
+  }
+
+  addPageNumbers(pdf, pageWidth, pageHeight);
+  return pdf.output("blob");
+}
+
+function addCoverPage(
+  pdf: jsPDF,
+  documentTitle: string,
+  tocItems: string[],
+  pageWidth: number,
+  pageHeight: number,
+): void {
+  const contentWidth = pageWidth - MARGIN_MM * 2;
+  pdf.setFontSize(18);
+  const titleLines = pdf.splitTextToSize(
+    documentTitle,
+    contentWidth,
+  ) as string[];
+  let titleY = MARGIN_MM + 8;
+  for (const line of titleLines) {
+    pdf.text(line, pageWidth / 2, titleY, { align: "center" });
+    titleY += 8;
+  }
+
+  pdf.setFontSize(11);
+  const generatedAt = new Date();
+  pdf.text(
+    `Generated: ${generatedAt.toLocaleDateString()} ${generatedAt.toLocaleTimeString()}`,
+    pageWidth / 2,
+    titleY + 4,
+    { align: "center" },
+  );
+
+  pdf.setFontSize(14);
+  pdf.text("Table of contents", MARGIN_MM, titleY + 16);
+  pdf.setFontSize(11);
+  let tocY = titleY + 26;
+  for (const item of tocItems) {
+    if (tocY > pageHeight - MARGIN_MM - 10) {
+      pdf.addPage();
+      tocY = MARGIN_MM;
+    }
+    pdf.text(`- ${item}`, MARGIN_MM, tocY);
+    tocY += 7;
+  }
+}
+
+function addChartImage(
+  pdf: jsPDF,
+  canvas: HTMLCanvasElement,
+  x: number,
+  y: number,
+  widthMm: number,
+  heightMm: number,
+): void {
+  const flattened = sliceCanvas(
+    canvas,
+    canvas.width,
+    canvas.height,
+    0,
+    PAGE_BACKGROUND,
+  );
+  try {
+    pdf.addImage(
+      flattened.toDataURL("image/jpeg", 0.92),
+      "JPEG",
+      x,
+      y,
+      widthMm,
+      heightMm,
+    );
+  } finally {
+    releaseCanvas(flattened);
+  }
+}
+
+/**
+ * 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,
+  pageHeight: number,
+): void {
+  const totalPages = pdf.getNumberOfPages();
+  pdf.setFontSize(9);
+  for (let page = 1; page <= totalPages; page++) {
+    pdf.setPage(page);
+    pdf.text(`Page ${page} of ${totalPages}`, pageWidth / 2, pageHeight - 6, {
+      align: "center",
+    });
+  }
+}

package/src/report/pdfPage.ts

@@ -0,0 +1,83 @@
+export interface PdfExportSegment {
+  top: number;
+  height: number;
+}
+
+export function splitSegmentForPageHeight(
+  segment: PdfExportSegment,
+  imgHeight: number,
+  pageHeightPx: number,
+): PdfExportSegment[] {
+  const total = Math.max(1, Math.min(segment.height, imgHeight - segment.top));
+  if (pageHeightPx <= 0 || total <= pageHeightPx) {
+    return [{ top: segment.top, height: total }];
+  }
+
+  const slices: PdfExportSegment[] = [];
+  let offset = 0;
+  while (offset < total) {
+    const height = Math.min(pageHeightPx, total - offset);
+    slices.push({ top: segment.top + offset, height });
+    offset += height;
+  }
+  return slices;
+}
+
+export function fitPdfImageSize(
+  pixelWidth: number,
+  pixelHeight: number,
+  maxWidthMm: number,
+  maxHeightMm: number,
+): { widthMm: number; heightMm: number } {
+  const safeWidth = Math.max(1, pixelWidth);
+  const safeHeight = Math.max(1, pixelHeight);
+  const widthScale = maxWidthMm / safeWidth;
+  const heightAtFullWidth = safeHeight * widthScale;
+  if (heightAtFullWidth <= maxHeightMm) {
+    return { widthMm: maxWidthMm, heightMm: heightAtFullWidth };
+  }
+  const scale = maxHeightMm / safeHeight;
+  return { widthMm: safeWidth * scale, heightMm: maxHeightMm };
+}
+
+export function placePdfBlock(
+  cursorY: number | null,
+  blockHeightMm: number,
+  pageTopMm: number,
+  pageBottomMm: number,
+): { y: number; needsNewPage: boolean } {
+  if (cursorY === null || cursorY + blockHeightMm > pageBottomMm) {
+    return { y: pageTopMm, needsNewPage: true };
+  }
+  return { y: cursorY, needsNewPage: false };
+}
+
+export function sliceCanvas(
+  sourceCanvas: HTMLCanvasElement,
+  width: number,
+  height: number,
+  offsetY: number,
+  backgroundColor: string,
+): HTMLCanvasElement {
+  const pageCanvas = document.createElement("canvas");
+  pageCanvas.width = width;
+  pageCanvas.height = height;
+  const context = pageCanvas.getContext("2d");
+  if (!context) {
+    throw new Error("Canvas 2D context unavailable");
+  }
+  context.fillStyle = backgroundColor;
+  context.fillRect(0, 0, width, height);
+  context.drawImage(
+    sourceCanvas,
+    0,
+    offsetY,
+    width,
+    height,
+    0,
+    0,
+    width,
+    height,
+  );
+  return pageCanvas;
+}

package/src/report/powerStates.ts

@@ -0,0 +1,169 @@
+import type { MigrationDonutChartDatum } from "../charts/MigrationDonutChart.js";
+
+export type PowerStateChartModel = {
+  slices: MigrationDonutChartDatum[];
+  legend: Record<string, string>;
+  total: number;
+};
+
+const HOST_POWER_CATEGORIES = [
+  "Powered on",
+  "Powered off",
+  "Standby",
+  "Not responding",
+  "Maintenance",
+] as const;
+
+type HostPowerCategory = (typeof HOST_POWER_CATEGORIES)[number];
+
+const HOST_POWER_KEY_ALIASES: Record<string, HostPowerCategory> = {
+  poweredon: "Powered on",
+  powered_on: "Powered on",
+  green: "Powered on",
+  poweredoff: "Powered off",
+  powered_off: "Powered off",
+  standby: "Standby",
+  stand_by: "Standby",
+  notresponding: "Not responding",
+  not_responding: "Not responding",
+  gray: "Not responding",
+  grey: "Not responding",
+  red: "Not responding",
+  maintenance: "Maintenance",
+  inmaintenance: "Maintenance",
+  inmaintenancemode: "Maintenance",
+};
+
+export const HOST_POWER_COLORS: Record<string, string> = {
+  "Powered on": "#0066cc",
+  "Powered off": "#dca614",
+  Standby: "#f0ab00",
+  "Not responding": "#c9190b",
+  Maintenance: "#002f5d",
+};
+
+const VM_POWER_CATEGORIES = ["Powered off", "Powered on", "Suspended"] as const;
+
+type VmPowerCategory = (typeof VM_POWER_CATEGORIES)[number];
+
+const VM_POWER_KEY_ALIASES: Record<string, VmPowerCategory> = {
+  poweredoff: "Powered off",
+  powered_off: "Powered off",
+  poweredon: "Powered on",
+  powered_on: "Powered on",
+  suspended: "Suspended",
+};
+
+export const VM_POWER_COLORS: Record<string, string> = {
+  "Powered off": "#0066cc",
+  "Powered on": "#dca614",
+  Suspended: "#5e40be",
+};
+
+const OTHER_COLOR = "#6a6e73";
+
+const normalizeKey = (key: string): string =>
+  key
+    .trim()
+    .toLowerCase()
+    .replace(/[\s-]+/g, "");
+
+const formatUnknownLabel = (key: string): string => {
+  const spaced = key
+    .replace(/[_-]+/g, " ")
+    .replace(/([a-z])([A-Z])/g, "$1 $2")
+    .trim();
+  if (!spaced) {
+    return "Unknown";
+  }
+  return spaced.charAt(0).toUpperCase() + spaced.slice(1);
+};
+
+const toSlice = (
+  name: string,
+  count: number,
+  unit: string,
+): MigrationDonutChartDatum => ({
+  name,
+  count,
+  legendCategory: name,
+  countDisplay: `${count} ${count === 1 ? unit.replace(/s$/, "") : unit}`,
+});
+
+const sumCounts = (counts: Record<string, number>): number =>
+  Object.values(counts).reduce((total, count) => total + (count || 0), 0);
+
+export const buildHostPowerStateChart = (
+  hostPowerStates?: Record<string, number>,
+): PowerStateChartModel => {
+  const counts: Record<string, number> = Object.fromEntries(
+    HOST_POWER_CATEGORIES.map((category) => [category, 0]),
+  );
+
+  for (const [key, count] of Object.entries(hostPowerStates ?? {})) {
+    const mapped = HOST_POWER_KEY_ALIASES[normalizeKey(key)];
+    const label = mapped ?? formatUnknownLabel(key);
+    counts[label] = (counts[label] ?? 0) + (count || 0);
+  }
+
+  const orderedLabels = [
+    ...HOST_POWER_CATEGORIES,
+    ...Object.keys(counts).filter(
+      (label) => !HOST_POWER_CATEGORIES.includes(label as HostPowerCategory),
+    ),
+  ];
+
+  const slices = orderedLabels.map((label) =>
+    toSlice(label, counts[label] ?? 0, "hosts"),
+  );
+
+  const legend: Record<string, string> = {};
+  for (const label of orderedLabels) {
+    legend[label] = HOST_POWER_COLORS[label] ?? OTHER_COLOR;
+  }
+
+  return {
+    slices,
+    legend,
+    total: sumCounts(counts),
+  };
+};
+
+export const buildVmPowerStateChart = (
+  powerStates?: Record<string, number>,
+): PowerStateChartModel => {
+  const counts: Record<string, number> = {
+    "Powered off": 0,
+    "Powered on": 0,
+  };
+
+  for (const [key, count] of Object.entries(powerStates ?? {})) {
+    const mapped = VM_POWER_KEY_ALIASES[normalizeKey(key)];
+    const label = mapped ?? formatUnknownLabel(key);
+    counts[label] = (counts[label] ?? 0) + (count || 0);
+  }
+
+  const orderedLabels = [
+    ...VM_POWER_CATEGORIES.filter(
+      (category) => category !== "Suspended" || (counts[category] ?? 0) > 0,
+    ),
+    ...Object.keys(counts).filter(
+      (label) => !VM_POWER_CATEGORIES.includes(label as VmPowerCategory),
+    ),
+  ];
+
+  const slices = orderedLabels.map((label) =>
+    toSlice(label, counts[label] ?? 0, "VMs"),
+  );
+
+  const legend: Record<string, string> = {};
+  for (const label of orderedLabels) {
+    legend[label] = VM_POWER_COLORS[label] ?? OTHER_COLOR;
+  }
+
+  return {
+    slices,
+    legend,
+    total: sumCounts(counts),
+  };
+};

package/src/report/reportExportOptions.ts

@@ -0,0 +1,53 @@
+export interface ReportExportOption {
+  key: string;
+  label: string;
+  description?: string;
+  onSelect: () => void;
+  isDisabled?: boolean;
+}
+
+export interface StandardReportExportHandlers {
+  onExportPdf?: () => void;
+  onExportPng?: () => void;
+  onExportHtml?: () => void;
+}
+
+/**
+ * Standard report-download actions. Omit a handler to hide that format.
+ */
+export const standardReportExportOptions = ({
+  onExportPdf,
+  onExportPng,
+  onExportHtml,
+}: StandardReportExportHandlers): ReportExportOption[] => {
+  const options: ReportExportOption[] = [];
+
+  if (onExportPdf) {
+    options.push({
+      key: "pdf",
+      label: "PDF",
+      description: "Export the report as a PDF",
+      onSelect: onExportPdf,
+    });
+  }
+
+  if (onExportHtml) {
+    options.push({
+      key: "html",
+      label: "HTML",
+      description: "Export the report as HTML",
+      onSelect: onExportHtml,
+    });
+  }
+
+  if (onExportPng) {
+    options.push({
+      key: "png",
+      label: "PNG",
+      description: "Download all charts as PNG files",
+      onSelect: onExportPng,
+    });
+  }
+
+  return options;
+};

package/src/report/zipChartPngs.ts

@@ -0,0 +1,10 @@
+import JSZip from "jszip";
+import type { ChartExportFile } from "./chartExport.js";
+
+export async function zipChartPngs(files: ChartExportFile[]): Promise<Blob> {
+  const zip = new JSZip();
+  for (const file of files) {
+    zip.file(file.filename, file.blob);
+  }
+  return zip.generateAsync({ type: "blob", compression: "STORE" });
+}