@code-pushup/lighthouse-plugin 0.47.0 → 0.48.0

package/index.js

@@ -1,6 +1,6 @@
 // packages/plugin-lighthouse/package.json
 var name = "@code-pushup/lighthouse-plugin";
-var version = "0.47.0";
+var version = "0.48.0";
 
 // packages/plugin-lighthouse/src/lib/constants.ts
 import { join } from "node:path";
@@ -711,7 +711,7 @@ var LIGHTHOUSE_OUTPUT_PATH = join(
 );
 
 // packages/plugin-lighthouse/src/lib/normalize-flags.ts
-import chalk8 from "chalk";
+import chalk9 from "chalk";
 
 // packages/utils/src/lib/file-system.ts
 import { bundleRequire } from "bundle-require";
@@ -1232,14 +1232,14 @@ var DEFAULT_CLI_FLAGS = {
 };
 
 // packages/plugin-lighthouse/src/lib/runner/utils.ts
-import chalk7 from "chalk";
+import chalk8 from "chalk";
 import log from "lighthouse-logger";
 import desktopConfig from "lighthouse/core/config/desktop-config.js";
 import experimentalConfig from "lighthouse/core/config/experimental-config.js";
 import perfConfig from "lighthouse/core/config/perf-config.js";
 
 // packages/plugin-lighthouse/src/lib/runner/details/details.ts
-import chalk6 from "chalk";
+import chalk7 from "chalk";
 
 // packages/plugin-lighthouse/src/lib/runner/details/item-value.ts
 import chalk5 from "chalk";
@@ -1301,11 +1301,8 @@ function formatTableItemPropertyValue(itemValue, itemValueFormat) {
         `Format type ${chalk5.bold("thumbnail")} is not implemented`
       );
       return "";
-    case null:
-      return "";
-    default:
-      return itemValue;
   }
+  return itemValue;
 }
 function parseSimpleItemValue(item) {
   if (typeof item === "object") {
@@ -1354,21 +1351,45 @@ function parseTableItemPropertyValue(itemValue) {
   return parseSimpleItemValue(objectValue);
 }
 
+// packages/plugin-lighthouse/src/lib/runner/details/utils.ts
+import chalk6 from "chalk";
+var LighthouseAuditDetailsParsingError = class extends Error {
+  constructor(type, rawTable, error) {
+    super(
+      `Parsing lighthouse report details ${chalk6.bold(
+        type
+      )} failed: 
+Raw data:
+ ${JSON.stringify(rawTable, null, 2)}
+${error}`
+    );
+  }
+};
+
 // packages/plugin-lighthouse/src/lib/runner/details/table.type.ts
 function parseTableToAuditDetailsTable(details4) {
   const { headings: rawHeadings, items } = details4;
   if (items.length === 0) {
     return void 0;
   }
-  return {
-    columns: parseTableColumns(rawHeadings),
-    rows: items.map((row) => parseTableRow(row, rawHeadings))
-  };
+  try {
+    return tableSchema().parse({
+      title: "Table",
+      columns: parseTableColumns(rawHeadings),
+      rows: items.map((row) => parseTableRow(row, rawHeadings))
+    });
+  } catch (error) {
+    throw new LighthouseAuditDetailsParsingError(
+      "table",
+      { items, headings: rawHeadings },
+      error.message.toString()
+    );
+  }
 }
 function parseTableColumns(rawHeadings) {
   return rawHeadings.map(({ key, label }) => ({
     key: key ?? "",
-    label: typeof label === "string" ? label : void 0,
+    ...typeof label === "string" && label.length > 0 ? { label } : {},
     align: "left"
   }));
 }
@@ -1391,40 +1412,73 @@ function parseTableEntry([key, value], valueType) {
   return [key, formatTableItemPropertyValue(value, valueType)];
 }
 
+// packages/plugin-lighthouse/src/lib/runner/details/opportunity.type.ts
+function parseOpportunityToAuditDetailsTable(details4) {
+  const { headings: rawHeadings, items } = details4;
+  if (items.length === 0) {
+    return void 0;
+  }
+  try {
+    return tableSchema().parse({
+      title: "Opportunity",
+      columns: parseTableColumns(rawHeadings),
+      rows: items.map((row) => parseOpportunityItemToTableRow(row, rawHeadings))
+    });
+  } catch (error) {
+    throw new LighthouseAuditDetailsParsingError(
+      "opportunity",
+      { items, headings: rawHeadings },
+      error.message.toString()
+    );
+  }
+}
+function parseOpportunityItemToTableRow(opportunityItem, headings) {
+  const keys = new Set(headings.map(({ key }) => key));
+  const valueTypesByKey = new Map(
+    headings.map(({ key, valueType }) => [key, valueType])
+  );
+  return {
+    ...Object.fromEntries(
+      Object.entries(opportunityItem).filter(([key]) => keys.has(key)).map(([key, value]) => {
+        const valueType = valueTypesByKey.get(key);
+        return parseOpportunityEntry([key, value], valueType);
+      })
+    )
+  };
+}
+function parseOpportunityEntry([key, value], valueType) {
+  switch (key) {
+    case "url":
+      return [key, html.link(String(value))];
+    case "wastedPercent":
+      return [key, `${Number(value).toFixed(2)} %`];
+    case "totalBytes":
+    case "wastedBytes":
+      return [key, formatBytes(Number(value))];
+    case "wastedMs":
+      return [key, formatDuration(Number(value))];
+    default:
+      return parseTableEntry([key, value], valueType);
+  }
+}
+
 // packages/plugin-lighthouse/src/lib/runner/details/details.ts
 function toAuditDetails(details4) {
   if (details4 == null) {
-    return void 0;
+    return {};
   }
   const { type } = details4;
-  if (type !== "table") {
-    return void 0;
-  }
-  const rawTable = parseTableToAuditDetailsTable(details4);
-  if (rawTable != null) {
-    const result = tableSchema().safeParse(rawTable);
-    if (result.success) {
-      return {
-        table: result.data
-      };
-    }
-    throw new Error(
-      `Parsing details ${chalk6.bold(
-        type
-      )} failed: 
-Raw data:
- ${JSON.stringify(
-        rawTable,
-        null,
-        2
-      )}
-${result.error.toString()}`
-    );
+  switch (type) {
+    case "table":
+      const table5 = parseTableToAuditDetailsTable(details4);
+      return table5 ? { table: table5 } : {};
+    case "opportunity":
+      const opportunity = parseOpportunityToAuditDetailsTable(details4);
+      return opportunity ? { table: opportunity } : {};
   }
-  return void 0;
+  return {};
 }
 var unsupportedDetailTypes = /* @__PURE__ */ new Set([
-  "opportunity",
   "debugdata",
   "treemap-data",
   "screenshot",
@@ -1442,9 +1496,9 @@ function logUnsupportedDetails(lhrAudits, { displayCount = 3 } = {}) {
   if (slugsWithDetailParsingErrors.length > 0) {
     const postFix = (count) => count > displayCount ? ` and ${count - displayCount} more.` : "";
     ui().logger.debug(
-      `${chalk6.yellow("\u26A0")} Plugin ${chalk6.bold(
+      `${chalk7.yellow("\u26A0")} Plugin ${chalk7.bold(
         PLUGIN_SLUG
-      )} skipped parsing of unsupported audit details: ${chalk6.bold(
+      )} skipped parsing of unsupported audit details: ${chalk7.bold(
         slugsWithDetailParsingErrors.slice(0, displayCount).join(", ")
       )}${postFix(slugsWithDetailParsingErrors.length)}`
     );
@@ -1458,9 +1512,9 @@ function normalizeAuditOutputs(auditOutputs, flags = { skipAudits: [] }) {
     const doSkip = toSkip.has(slug);
     if (doSkip) {
       ui().logger.info(
-        `Audit ${chalk7.bold(
+        `Audit ${chalk8.bold(
           slug
-        )} was included in audit outputs of lighthouse but listed under ${chalk7.bold(
+        )} was included in audit outputs of lighthouse but listed under ${chalk8.bold(
           "skipAudits"
         )}.`
       );
@@ -1468,6 +1522,15 @@ function normalizeAuditOutputs(auditOutputs, flags = { skipAudits: [] }) {
     return !doSkip;
   });
 }
+var LighthouseAuditParsingError = class extends Error {
+  constructor(slug, error) {
+    super(
+      `
+Audit ${chalk8.bold(slug)} failed parsing details: 
+${error.message}`
+    );
+  }
+};
 function toAuditOutputs(lhrAudits, { verbose = false } = {}) {
   if (verbose) {
     logUnsupportedDetails(lhrAudits);
@@ -1491,13 +1554,9 @@ function toAuditOutputs(lhrAudits, { verbose = false } = {}) {
       if (details4 != null) {
         try {
           const parsedDetails = toAuditDetails(details4);
-          return parsedDetails ? { ...auditOutput, details: parsedDetails } : auditOutput;
+          return Object.keys(parsedDetails).length > 0 ? { ...auditOutput, details: parsedDetails } : auditOutput;
         } catch (error) {
-          throw new Error(
-            `
-Audit ${chalk7.bold(slug)} failed parsing details: 
-${error.message}`
-          );
+          throw new LighthouseAuditParsingError(slug, error);
         }
       }
       return auditOutput;
@@ -1629,9 +1688,9 @@ function logUnsupportedFlagsInUse(flags, displayCount = 3) {
   if (unsupportedFlagsInUse.length > 0) {
     const postFix = (count) => count > displayCount ? ` and ${count - displayCount} more.` : "";
     ui().logger.debug(
-      `${chalk8.yellow("\u26A0")} Plugin ${chalk8.bold(
+      `${chalk9.yellow("\u26A0")} Plugin ${chalk9.bold(
         LIGHTHOUSE_PLUGIN_SLUG
-      )} used unsupported flags: ${chalk8.bold(
+      )} used unsupported flags: ${chalk9.bold(
         unsupportedFlagsInUse.slice(0, displayCount).join(", ")
       )}${postFix(unsupportedFlagsInUse.length)}`
     );

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@code-pushup/lighthouse-plugin",
-  "version": "0.47.0",
+  "version": "0.48.0",
   "license": "MIT",
   "dependencies": {
-    "@code-pushup/models": "0.47.0",
+    "@code-pushup/models": "0.48.0",
     "lighthouse": "^12.0.0",
-    "@code-pushup/utils": "0.47.0",
+    "@code-pushup/utils": "0.48.0",
     "lighthouse-logger": "2.0.1",
     "chalk": "^5.3.0"
   },

package/src/lib/runner/details/details.d.ts

@@ -2,7 +2,7 @@ import type { FormattedIcu } from 'lighthouse';
 import type Details from 'lighthouse/types/lhr/audit-details';
 import { Result } from 'lighthouse/types/lhr/audit-result';
 import { AuditDetails } from '@code-pushup/models';
-export declare function toAuditDetails<T extends FormattedIcu<Details>>(details: T | undefined): AuditDetails | undefined;
+export declare function toAuditDetails<T extends FormattedIcu<Details>>(details: T | undefined): AuditDetails;
 export declare const unsupportedDetailTypes: Set<string>;
 export declare function logUnsupportedDetails(lhrAudits: Result[], { displayCount }?: {
     displayCount?: number;

package/src/lib/runner/details/opportunity.type.d.ts

@@ -0,0 +1,8 @@
+import type Details from 'lighthouse/types/lhr/audit-details';
+import { Table, TableRowObject } from '@code-pushup/models';
+export declare function parseOpportunityToAuditDetailsTable(details: Details.Opportunity): Table | undefined;
+export declare function parseOpportunityItemToTableRow(opportunityItem: Details.OpportunityItem, headings: Details.TableColumnHeading[]): TableRowObject;
+export declare function parseOpportunityEntry([key, value]: [
+    keyof Details.OpportunityItem,
+    Details.OpportunityItem[string]
+], valueType: Details.ItemValueType): string[] | [keyof Details.TableItem, Details.ItemValue | undefined];

package/src/lib/runner/details/utils.d.ts

@@ -0,0 +1,4 @@
+import Details from 'lighthouse/types/lhr/audit-details';
+export declare class LighthouseAuditDetailsParsingError extends Error {
+    constructor(type: Details['type'], rawTable: Record<string, unknown>, error: string);
+}

package/src/lib/runner/utils.d.ts

@@ -4,10 +4,12 @@ import { AuditOutputs } from '@code-pushup/models';
 import type { LighthouseOptions } from '../types';
 import { LighthouseCliFlags } from './types';
 export declare function normalizeAuditOutputs(auditOutputs: AuditOutputs, flags?: LighthouseOptions): AuditOutputs;
+export declare class LighthouseAuditParsingError extends Error {
+    constructor(slug: string, error: Error);
+}
 export declare function toAuditOutputs(lhrAudits: Result[], { verbose }?: {
     verbose?: boolean;
 }): AuditOutputs;
-export declare const unsupportedDetailTypes: Set<string>;
 export type LighthouseLogLevel = 'verbose' | 'error' | 'info' | 'silent' | 'warn' | undefined;
 export declare function determineAndSetLogLevel({ verbose, quiet, }?: {
     verbose?: boolean;