feat(plugin-lighthouse): implement multiple URL support

Author: hanna-skryl

code-pushup.preset.ts

@@ -20,7 +20,9 @@ import {
 } from './packages/plugin-jsdocs/src/lib/constants.js';
 import { filterGroupsByOnlyAudits } from './packages/plugin-jsdocs/src/lib/utils.js';
 import lighthousePlugin, {
+  type LighthouseUrls,
   lighthouseGroupRef,
+  mergeLighthouseCategories,
 } from './packages/plugin-lighthouse/src/index.js';
 import typescriptPlugin, {
   type TypescriptPluginOptions,
@@ -135,11 +137,14 @@ export const jsPackagesCoreConfig = async (): Promise<CoreConfig> => ({
 });
 
 export const lighthouseCoreConfig = async (
-  url: string,
-): Promise<CoreConfig> => ({
-  plugins: [await lighthousePlugin(url)],
-  categories: lighthouseCategories,
-});
+  urls: LighthouseUrls,
+): Promise<CoreConfig> => {
+  const lhPlugin = await lighthousePlugin(urls);
+  return {
+    plugins: [lhPlugin],
+    categories: mergeLighthouseCategories(lhPlugin, lighthouseCategories),
+  };
+};
 
 export const jsDocsCoreConfig = (
   config: JsDocsPluginConfig | string[],

packages/plugin-lighthouse/src/index.ts

@@ -6,11 +6,12 @@ export {
   LIGHTHOUSE_PLUGIN_SLUG,
   LIGHTHOUSE_OUTPUT_PATH,
 } from './lib/constants.js';
-export {
-  lighthouseAuditRef,
-  lighthouseGroupRef,
-  type LighthouseGroupSlugs,
-} from './lib/utils.js';
-export type { LighthouseOptions } from './lib/types.js';
+export { lighthouseAuditRef, lighthouseGroupRef } from './lib/utils.js';
+export type {
+  LighthouseGroupSlugs,
+  LighthouseOptions,
+  LighthouseUrls,
+} from './lib/types.js';
 export { lighthousePlugin } from './lib/lighthouse-plugin.js';
 export default lighthousePlugin;
+export { mergeLighthouseCategories } from './lib/merge-categories.js';

packages/plugin-lighthouse/src/lib/constants.ts

@@ -10,3 +10,13 @@ export const LIGHTHOUSE_OUTPUT_PATH = path.join(
   DEFAULT_PERSIST_OUTPUT_DIR,
   LIGHTHOUSE_PLUGIN_SLUG,
 );
+
+export const LIGHTHOUSE_GROUP_SLUGS = [
+  'performance',
+  'accessibility',
+  'best-practices',
+  'seo',
+  'pwa',
+] as const;
+
+export const SINGLE_URL_THRESHOLD = 1;

packages/plugin-lighthouse/src/lib/lighthouse-plugin.ts

@@ -2,26 +2,24 @@ import { createRequire } from 'node:module';
 import type { PluginConfig } from '@code-pushup/models';
 import { LIGHTHOUSE_PLUGIN_SLUG } from './constants.js';
 import { normalizeFlags } from './normalize-flags.js';
-import {
-  LIGHTHOUSE_GROUPS,
-  LIGHTHOUSE_NAVIGATION_AUDITS,
-} from './runner/constants.js';
+import { normalizeUrlInput, processAuditsAndGroups } from './processing.js';
 import { createRunnerFunction } from './runner/runner.js';
-import type { LighthouseOptions } from './types.js';
-import { markSkippedAuditsAndGroups } from './utils.js';
+import type { LighthouseOptions, LighthouseUrls } from './types.js';
 
 export function lighthousePlugin(
-  url: string,
+  urls: LighthouseUrls,
   flags?: LighthouseOptions,
 ): PluginConfig {
   const { skipAudits, onlyAudits, onlyCategories, ...unparsedFlags } =
     normalizeFlags(flags ?? {});
 
-  const { audits, groups } = markSkippedAuditsAndGroups(
-    LIGHTHOUSE_NAVIGATION_AUDITS,
-    LIGHTHOUSE_GROUPS,
-    { skipAudits, onlyAudits, onlyCategories },
-  );
+  const normalizedUrls = normalizeUrlInput(urls);
+
+  const { audits, groups } = processAuditsAndGroups(normalizedUrls, {
+    skipAudits,
+    onlyAudits,
+    onlyCategories,
+  });
 
   const packageJson = createRequire(import.meta.url)(
     '../../package.json',
@@ -35,7 +33,7 @@ export function lighthousePlugin(
     icon: 'lighthouse',
     audits,
     groups,
-    runner: createRunnerFunction(url, {
+    runner: createRunnerFunction(normalizedUrls, {
       skipAudits,
       onlyAudits,
       onlyCategories,

packages/plugin-lighthouse/src/lib/lighthouse-plugin.unit.test.ts

@@ -18,6 +18,28 @@ describe('lighthousePlugin-config-object', () => {
     ]);
   });
 
+  it('should create valid plugin config with multiple URLs', () => {
+    const urls = [
+      'https://code-pushup-portal.com',
+      'https://code-pushup-portal.com/about',
+    ];
+    const pluginConfig = lighthousePlugin(urls);
+    expect(() => pluginConfigSchema.parse(pluginConfig)).not.toThrow();
+
+    const { audits, groups } = pluginConfig;
+    expect(audits.length).toBeGreaterThan(100);
+    expect(groups).toStrictEqual([
+      expect.objectContaining({ slug: 'performance-1' }),
+      expect.objectContaining({ slug: 'accessibility-1' }),
+      expect.objectContaining({ slug: 'best-practices-1' }),
+      expect.objectContaining({ slug: 'seo-1' }),
+      expect.objectContaining({ slug: 'performance-2' }),
+      expect.objectContaining({ slug: 'accessibility-2' }),
+      expect.objectContaining({ slug: 'best-practices-2' }),
+      expect.objectContaining({ slug: 'seo-2' }),
+    ]);
+  });
+
   it.each([
     [
       { onlyAudits: ['first-contentful-paint'] },

packages/plugin-lighthouse/src/lib/merge-categories.ts

@@ -0,0 +1,97 @@
+import type { CategoryConfig, Group, PluginConfig } from '@code-pushup/models';
+import { LIGHTHOUSE_GROUP_SLUGS, LIGHTHOUSE_PLUGIN_SLUG } from './constants.js';
+import { orderSlug, shouldExpandForUrls } from './processing.js';
+import { LIGHTHOUSE_GROUPS } from './runner/constants.js';
+import type { LighthouseGroupSlugs } from './types.js';
+import { isLighthouseGroupSlug } from './utils.js';
+
+export function mergeLighthouseCategories(
+  { groups }: Pick<PluginConfig, 'groups'>,
+  categories?: CategoryConfig[],
+): CategoryConfig[] {
+  if (!groups) {
+    return categories ?? [];
+  }
+  if (!categories) {
+    return createCategories(groups);
+  }
+  return expandCategories(categories, groups);
+}
+
+function createCategories(groups: Group[]): CategoryConfig[] {
+  const urlCount = countUrls(groups);
+  if (!shouldExpandForUrls(urlCount)) {
+    return [];
+  }
+  return extractGroupSlugs(groups)
+    .filter(isLighthouseGroupSlug)
+    .map(slug => createAggregatedCategory(slug, urlCount));
+}
+
+function expandCategories(
+  categories: CategoryConfig[],
+  groups: Group[],
+): CategoryConfig[] {
+  const urlCount = countUrls(groups);
+  if (!shouldExpandForUrls(urlCount)) {
+    return categories;
+  }
+  return categories.map(category =>
+    expandAggregatedCategory(category, urlCount),
+  );
+}
+
+export function createAggregatedCategory(
+  groupSlug: LighthouseGroupSlugs,
+  urlCount: number,
+): CategoryConfig {
+  const group = LIGHTHOUSE_GROUPS.find(({ slug }) => slug === groupSlug);
+  if (!group) {
+    const availableSlugs = LIGHTHOUSE_GROUP_SLUGS.join(', ');
+    throw new Error(
+      `Invalid Lighthouse group slug: "${groupSlug}". Available groups: ${availableSlugs}`,
+    );
+  }
+  return {
+    slug: group.slug,
+    title: group.title,
+    ...(group.description && { description: group.description }),
+    refs: Array.from({ length: urlCount }, (_, i) => ({
+      plugin: LIGHTHOUSE_PLUGIN_SLUG,
+      slug: orderSlug(group.slug, i),
+      type: 'group',
+      weight: 1,
+    })),
+  };
+}
+
+export function expandAggregatedCategory(
+  category: CategoryConfig,
+  urlCount: number,
+): CategoryConfig {
+  return {
+    ...category,
+    refs: category.refs.flatMap(ref => {
+      if (ref.plugin === LIGHTHOUSE_PLUGIN_SLUG) {
+        return Array.from({ length: urlCount }, (_, i) => ({
+          ...ref,
+          slug: orderSlug(ref.slug, i),
+        }));
+      }
+      return [ref];
+    }),
+  };
+}
+
+export function countUrls(groups: Group[]): number {
+  const suffixes = groups
+    .map(({ slug }) => slug.match(/-(\d+)$/)?.[1])
+    .filter(Boolean)
+    .map(Number)
+    .filter(n => !Number.isNaN(n));
+  return suffixes.length > 0 ? Math.max(...suffixes) : 1;
+}
+
+export function extractGroupSlugs(groups: Group[]): string[] {
+  return [...new Set(groups.map(({ slug }) => slug.replace(/-\d+$/, '')))];
+}