@code-pushup/utils 0.8.9 → 0.8.11

package/index.js

@@ -38,6 +38,46 @@ function errorItems(items, transform = (items2) => items2.join(", ")) {
 function exists(value) {
   return value != null;
 }
+function getMissingRefsForCategories(categories, plugins) {
+  const missingRefs = [];
+  const auditRefsFromCategory = categories.flatMap(
+    ({ refs }) => refs.filter(({ type }) => type === "audit").map(({ plugin, slug }) => `${plugin}/${slug}`)
+  );
+  const auditRefsFromPlugins = plugins.flatMap(
+    ({ audits, slug: pluginSlug }) => {
+      return audits.map(({ slug }) => `${pluginSlug}/${slug}`);
+    }
+  );
+  const missingAuditRefs = hasMissingStrings(
+    auditRefsFromCategory,
+    auditRefsFromPlugins
+  );
+  if (Array.isArray(missingAuditRefs) && missingAuditRefs.length > 0) {
+    missingRefs.push(...missingAuditRefs);
+  }
+  const groupRefsFromCategory = categories.flatMap(
+    ({ refs }) => refs.filter(({ type }) => type === "group").map(({ plugin, slug }) => `${plugin}#${slug} (group)`)
+  );
+  const groupRefsFromPlugins = plugins.flatMap(
+    ({ groups, slug: pluginSlug }) => {
+      return Array.isArray(groups) ? groups.map(({ slug }) => `${pluginSlug}#${slug} (group)`) : [];
+    }
+  );
+  const missingGroupRefs = hasMissingStrings(
+    groupRefsFromCategory,
+    groupRefsFromPlugins
+  );
+  if (Array.isArray(missingGroupRefs) && missingGroupRefs.length > 0) {
+    missingRefs.push(...missingGroupRefs);
+  }
+  return missingRefs.length ? missingRefs : false;
+}
+function missingRefsForCategoriesErrorMsg(categories, plugins) {
+  const missingRefs = getMissingRefsForCategories(categories, plugins);
+  return `The following category references need to point to an audit or group: ${errorItems(
+    missingRefs
+  )}`;
+}
 
 // packages/models/src/lib/implementation/schemas.ts
 function executionMetaSchema(options = {
@@ -96,15 +136,13 @@ function positiveIntSchema(description) {
   return z.number({ description }).int().nonnegative();
 }
 function packageVersionSchema(options) {
-  let { versionDescription, optional } = options || {};
-  versionDescription = versionDescription || "NPM version of the package";
-  optional = !!optional;
+  const { versionDescription = "NPM version of the package", required } = options ?? {};
   const packageSchema = z.string({ description: "NPM package name" });
   const versionSchema = z.string({ description: versionDescription });
   return z.object(
     {
-      packageName: optional ? packageSchema.optional() : packageSchema,
-      version: optional ? versionSchema.optional() : versionSchema
+      packageName: required ? packageSchema : packageSchema.optional(),
+      version: required ? versionSchema : versionSchema.optional()
     },
     { description: "NPM package name and version of a published package" }
   );
@@ -166,7 +204,7 @@ var pluginAuditsSchema = z2.array(auditSchema, {
 );
 function duplicateSlugsInAuditsErrorMsg(audits) {
   const duplicateRefs = getDuplicateSlugsInAudits(audits);
-  return `In plugin audits the slugs are not unique: ${errorItems(
+  return `In plugin audits the following slugs are not unique: ${errorItems(
     duplicateRefs
   )}`;
 }
@@ -355,7 +393,9 @@ function getDuplicateRefsInGroups(groups) {
 }
 function duplicateSlugsInGroupsErrorMsg(groups) {
   const duplicateRefs = getDuplicateSlugsInGroups(groups);
-  return `In groups the slugs are not unique: ${errorItems(duplicateRefs)}`;
+  return `In groups the following slugs are not unique: ${errorItems(
+    duplicateRefs
+  )}`;
 }
 function getDuplicateSlugsInGroups(groups) {
   return Array.isArray(groups) ? hasDuplicateStrings(groups.map(({ slug }) => slug)) : false;
@@ -381,9 +421,7 @@ var onProgressSchema = z8.function().args(z8.unknown()).returns(z8.void());
 var runnerFunctionSchema = z8.function().args(onProgressSchema.optional()).returns(z8.union([auditOutputsSchema, z8.promise(auditOutputsSchema)]));
 
 // packages/models/src/lib/plugin-config.ts
-var pluginMetaSchema = packageVersionSchema({
-  optional: true
-}).merge(
+var pluginMetaSchema = packageVersionSchema().merge(
   metaSchema({
     titleDescription: "Descriptive name",
     descriptionDescription: "Description (markdown)",
@@ -392,7 +430,7 @@ var pluginMetaSchema = packageVersionSchema({
   })
 ).merge(
   z9.object({
-    slug: slugSchema("References plugin. ID (unique within core config)"),
+    slug: slugSchema("Unique plugin slug within core config"),
     icon: materialIconSchema
   })
 );
@@ -409,20 +447,17 @@ var pluginConfigSchema = pluginMetaSchema.merge(pluginDataSchema).refine(
 );
 function missingRefsFromGroupsErrorMsg(pluginCfg) {
   const missingRefs = getMissingRefsFromGroups(pluginCfg);
-  return `In the groups, the following audit ref's needs to point to a audit in this plugin config: ${errorItems(
+  return `The following group references need to point to an existing audit in this plugin config: ${errorItems(
     missingRefs
   )}`;
 }
 function getMissingRefsFromGroups(pluginCfg) {
-  if (pluginCfg?.groups?.length && pluginCfg?.audits?.length) {
-    const groups = pluginCfg?.groups || [];
-    const audits = pluginCfg?.audits || [];
-    return hasMissingStrings(
-      groups.flatMap(({ refs: audits2 }) => audits2.map(({ slug: ref }) => ref)),
-      audits.map(({ slug }) => slug)
-    );
-  }
-  return false;
+  return hasMissingStrings(
+    pluginCfg.groups?.flatMap(
+      ({ refs: audits }) => audits.map(({ slug: ref }) => ref)
+    ) ?? [],
+    pluginCfg.audits.map(({ slug }) => slug)
+  );
 }
 
 // packages/models/src/lib/upload-config.ts
@@ -432,19 +467,15 @@ var uploadConfigSchema = z10.object({
   apiKey: z10.string({
     description: "API key with write access to portal (use `process.env` for security)"
   }),
-  organization: z10.string({
-    description: "Organization in code versioning system"
-  }),
-  project: z10.string({
-    description: "Project in code versioning system"
-  })
+  organization: slugSchema("Organization slug from Code PushUp portal"),
+  project: slugSchema("Project slug from Code PushUp portal")
 });
 
 // packages/models/src/lib/core-config.ts
 var unrefinedCoreConfigSchema = z11.object({
   plugins: z11.array(pluginConfigSchema, {
     description: "List of plugins to be used (official, community-provided, or custom)"
-  }),
+  }).min(1),
   /** portal configuration for persisting results */
   persist: persistConfigSchema.optional(),
   /** portal configuration for uploading results */
@@ -454,52 +485,15 @@ var unrefinedCoreConfigSchema = z11.object({
 var coreConfigSchema = refineCoreConfig(unrefinedCoreConfigSchema);
 function refineCoreConfig(schema) {
   return schema.refine(
-    (coreCfg) => !getMissingRefsForCategories(coreCfg),
+    (coreCfg) => !getMissingRefsForCategories(coreCfg.categories, coreCfg.plugins),
     (coreCfg) => ({
-      message: missingRefsForCategoriesErrorMsg(coreCfg)
+      message: missingRefsForCategoriesErrorMsg(
+        coreCfg.categories,
+        coreCfg.plugins
+      )
     })
   );
 }
-function missingRefsForCategoriesErrorMsg(coreCfg) {
-  const missingRefs = getMissingRefsForCategories(coreCfg);
-  return `In the categories, the following plugin refs do not exist in the provided plugins: ${errorItems(
-    missingRefs
-  )}`;
-}
-function getMissingRefsForCategories(coreCfg) {
-  const missingRefs = [];
-  const auditRefsFromCategory = coreCfg.categories.flatMap(
-    ({ refs }) => refs.filter(({ type }) => type === "audit").map(({ plugin, slug }) => `${plugin}/${slug}`)
-  );
-  const auditRefsFromPlugins = coreCfg.plugins.flatMap(
-    ({ audits, slug: pluginSlug }) => {
-      return audits.map(({ slug }) => `${pluginSlug}/${slug}`);
-    }
-  );
-  const missingAuditRefs = hasMissingStrings(
-    auditRefsFromCategory,
-    auditRefsFromPlugins
-  );
-  if (Array.isArray(missingAuditRefs) && missingAuditRefs.length > 0) {
-    missingRefs.push(...missingAuditRefs);
-  }
-  const groupRefsFromCategory = coreCfg.categories.flatMap(
-    ({ refs }) => refs.filter(({ type }) => type === "group").map(({ plugin, slug }) => `${plugin}#${slug} (group)`)
-  );
-  const groupRefsFromPlugins = coreCfg.plugins.flatMap(
-    ({ groups, slug: pluginSlug }) => {
-      return Array.isArray(groups) ? groups.map(({ slug }) => `${pluginSlug}#${slug} (group)`) : [];
-    }
-  );
-  const missingGroupRefs = hasMissingStrings(
-    groupRefsFromCategory,
-    groupRefsFromPlugins
-  );
-  if (Array.isArray(missingGroupRefs) && missingGroupRefs.length > 0) {
-    missingRefs.push(...missingGroupRefs);
-  }
-  return missingRefs.length ? missingRefs : false;
-}
 
 // packages/models/src/lib/report.ts
 import { z as z12 } from "zod";
@@ -514,9 +508,32 @@ var pluginReportSchema = pluginMetaSchema.merge(
     audits: z12.array(auditReportSchema),
     groups: z12.array(groupSchema).optional()
   })
+).refine(
+  (pluginReport) => !getMissingRefsFromGroups2(pluginReport.audits, pluginReport.groups ?? []),
+  (pluginReport) => ({
+    message: missingRefsFromGroupsErrorMsg2(
+      pluginReport.audits,
+      pluginReport.groups ?? []
+    )
+  })
 );
+function missingRefsFromGroupsErrorMsg2(audits, groups) {
+  const missingRefs = getMissingRefsFromGroups2(audits, groups);
+  return `group references need to point to an existing audit in this plugin report: ${errorItems(
+    missingRefs
+  )}`;
+}
+function getMissingRefsFromGroups2(audits, groups) {
+  return hasMissingStrings(
+    groups.flatMap(
+      ({ refs: auditRefs }) => auditRefs.map(({ slug: ref }) => ref)
+    ),
+    audits.map(({ slug }) => slug)
+  );
+}
 var reportSchema = packageVersionSchema({
-  versionDescription: "NPM version of the CLI"
+  versionDescription: "NPM version of the CLI",
+  required: true
 }).merge(
   executionMetaSchema({
     descriptionDate: "Start date and time of the collect run",
@@ -526,10 +543,18 @@ var reportSchema = packageVersionSchema({
   z12.object(
     {
       categories: z12.array(categoryConfigSchema),
-      plugins: z12.array(pluginReportSchema)
+      plugins: z12.array(pluginReportSchema).min(1)
     },
     { description: "Collect output data" }
   )
+).refine(
+  (report) => !getMissingRefsForCategories(report.categories, report.plugins),
+  (report) => ({
+    message: missingRefsForCategoriesErrorMsg(
+      report.categories,
+      report.plugins
+    )
+  })
 );
 
 // packages/utils/src/lib/constants.ts
@@ -856,13 +881,13 @@ function getGroupWithAudits(refSlug, refPlugin, plugins) {
     },
     []
   );
-  const audits = groupAudits.sort(sortCategoryAudits);
+  const audits = groupAudits.sort(compareCategoryAudits);
   return {
     ...groupWithAudits,
     audits
   };
 }
-function sortCategoryAudits(a, b) {
+function compareCategoryAudits(a, b) {
   if (a.weight !== b.weight) {
     return b.weight - a.weight;
   }
@@ -874,7 +899,7 @@ function sortCategoryAudits(a, b) {
   }
   return a.title.localeCompare(b.title);
 }
-function sortAudits(a, b) {
+function compareAudits(a, b) {
   if (a.score !== b.score) {
     return a.score - b.score;
   }
@@ -1168,23 +1193,18 @@ function reportToCategoriesSection(report) {
       category.score
     )} Score:  ${style(formatReportScore(category.score))}`;
     const categoryDocs = getDocsAndDescription(category);
-    const auditsAndGroups = category.refs.reduce(
-      (acc2, ref) => ({
-        ...acc2,
-        ...ref.type === "group" ? {
-          groups: [
-            ...acc2.groups,
-            getGroupWithAudits(ref.slug, ref.plugin, plugins)
-          ]
-        } : {
-          audits: [...acc2.audits, getAuditByRef(ref, plugins)]
-        }
-      }),
-      { groups: [], audits: [] }
-    );
-    const audits = auditsAndGroups.audits.sort(sortCategoryAudits).map((audit) => auditItemToCategorySection(audit, plugins)).join(NEW_LINE);
-    const groups = auditsAndGroups.groups.map((group) => groupItemToCategorySection(group, plugins)).join("");
-    return acc + NEW_LINE + categoryTitle + NEW_LINE + NEW_LINE + categoryDocs + categoryScore + NEW_LINE + groups + NEW_LINE + audits;
+    const categoryMDItems = category.refs.reduce((acc2, ref) => {
+      if (ref.type === "group") {
+        const group = getGroupWithAudits(ref.slug, ref.plugin, plugins);
+        const mdGroupItem = groupItemToCategorySection(group, plugins);
+        return acc2 + mdGroupItem + NEW_LINE;
+      } else {
+        const audit = getAuditByRef(ref, plugins);
+        const mdAuditItem = auditItemToCategorySection(audit, plugins);
+        return acc2 + mdAuditItem + NEW_LINE;
+      }
+    }, "");
+    return acc + NEW_LINE + categoryTitle + NEW_LINE + NEW_LINE + categoryDocs + categoryScore + NEW_LINE + categoryMDItems;
   }, "");
   return h2("\u{1F3F7} Categories") + NEW_LINE + categoryDetails;
 }
@@ -1223,7 +1243,7 @@ function groupItemToCategorySection(group, plugins) {
 }
 function reportToAuditsSection(report) {
   const auditsSection = report.plugins.reduce((acc, plugin) => {
-    const auditsData = plugin.audits.sort(sortAudits).reduce((acc2, audit) => {
+    const auditsData = plugin.audits.reduce((acc2, audit) => {
       const auditTitle = `${audit.title} (${getPluginNameFromSlug(
         audit.plugin,
         report.plugins
@@ -1246,7 +1266,7 @@ function reportToAuditsSection(report) {
       }
       const detailsTableData = [
         detailsTableHeaders,
-        ...audit.details.issues.sort(compareIssues).map((issue) => {
+        ...audit.details.issues.map((issue) => {
           const severity = `${getSeverityIcon(issue.severity)} <i>${issue.severity}</i>`;
           const message = issue.message;
           if (!issue.source) {
@@ -1350,7 +1370,7 @@ function reportToDetailSection(report) {
     output += addLine(chalk3.magentaBright.bold(`${title} audits`));
     output += addLine();
     const ui = cliui({ width: 80 });
-    audits.sort(sortAudits).forEach(({ score, title: title2, displayValue, value }) => {
+    audits.forEach(({ score, title: title2, displayValue, value }) => {
       ui.div(
         {
           text: withColor({ score, text: "\u25CF" }),
@@ -1573,6 +1593,56 @@ var verboseUtils = (verbose) => ({
   log: getLogVerbose(verbose),
   exec: getExecVerbose(verbose)
 });
+
+// packages/utils/src/lib/sort-report.ts
+function sortReport(report) {
+  const { categories, plugins } = report;
+  const sortedCategories = categories.map((category) => {
+    const { audits, groups } = category.refs.reduce(
+      (acc, ref) => ({
+        ...acc,
+        ...ref.type === "group" ? {
+          groups: [
+            ...acc.groups,
+            getGroupWithAudits(ref.slug, ref.plugin, plugins)
+          ]
+        } : {
+          audits: [...acc.audits, getAuditByRef(ref, plugins)]
+        }
+      }),
+      { groups: [], audits: [] }
+    );
+    const sortedAuditsAndGroups = [
+      ...groups,
+      ...audits.sort(compareCategoryAudits)
+    ];
+    const sortedRefs = category.refs.slice().sort((a, b) => {
+      const aIndex = sortedAuditsAndGroups.findIndex(
+        (ref) => ref.slug === a.slug
+      );
+      const bIndex = sortedAuditsAndGroups.findIndex(
+        (ref) => ref.slug === b.slug
+      );
+      return aIndex - bIndex;
+    });
+    return { ...category, refs: sortedRefs };
+  });
+  const sortedPlugins = plugins.map((plugin) => ({
+    ...plugin,
+    audits: plugin.audits.sort(compareAudits).map((audit) => ({
+      ...audit,
+      details: {
+        ...audit.details,
+        issues: audit?.details?.issues.slice().sort(compareIssues) || []
+      }
+    }))
+  }));
+  return {
+    ...report,
+    categories: sortedCategories,
+    plugins: sortedPlugins
+  };
+}
 export {
   CODE_PUSHUP_DOMAIN,
   FOOTER_PREFIX,
@@ -1613,6 +1683,7 @@ export {
   reportToStdout,
   scoreReport,
   slugify,
+  sortReport,
   toArray,
   toUnixPath,
   truncateDescription,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@code-pushup/utils",
-  "version": "0.8.9",
+  "version": "0.8.11",
   "dependencies": {
     "@code-pushup/models": "*",
     "bundle-require": "^4.0.1",

package/src/index.d.ts

@@ -13,3 +13,4 @@ export { reportToStdout } from './lib/report-to-stdout';
 export { ScoredReport, scoreReport } from './lib/scoring';
 export { CliArgsObject, countOccurrences, distinct, factorOf, objectToCliArgs, objectToEntries, objectToKeys, toArray, toUnixPath, } from './lib/transform';
 export { verboseUtils } from './lib/verbose-utils';
+export { sortReport } from './lib/sort-report';

package/src/lib/report.d.ts

@@ -18,8 +18,8 @@ export declare function countWeightedRefs(refs: CategoryRef[]): number;
 export declare function countCategoryAudits(refs: CategoryRef[], plugins: ScoredReport['plugins']): number;
 export declare function getAuditByRef({ slug, weight, plugin }: CategoryRef, plugins: ScoredReport['plugins']): WeighedAuditReport;
 export declare function getGroupWithAudits(refSlug: string, refPlugin: string, plugins: ScoredReport['plugins']): EnrichedScoredGroupWithAudits;
-export declare function sortCategoryAudits(a: WeighedAuditReport, b: WeighedAuditReport): number;
-export declare function sortAudits(a: EnrichedAuditReport, b: EnrichedAuditReport): number;
+export declare function compareCategoryAudits(a: WeighedAuditReport, b: WeighedAuditReport): number;
+export declare function compareAudits(a: EnrichedAuditReport, b: EnrichedAuditReport): number;
 export declare function compareIssueSeverity(severity1: CliIssueSeverity, severity2: CliIssueSeverity): number;
 type LoadedReportFormat<T extends Format> = T extends 'json' ? Report : string;
 export declare function loadReport<T extends Format>(options: Required<Pick<PersistConfig, 'outputDir' | 'filename'>> & {

package/src/lib/scoring.d.ts

@@ -8,7 +8,7 @@ export type WeighedAuditReport = EnrichedAuditReport & {
 export type EnrichedScoredGroupWithAudits = EnrichedScoredGroup & {
     audits: AuditReport[];
 };
-type ScoredCategoryConfig = CategoryConfig & {
+export type ScoredCategoryConfig = CategoryConfig & {
     score: number;
 };
 export type EnrichedScoredGroup = Group & {
@@ -26,4 +26,3 @@ export declare function calculateScore<T extends {
     weight: number;
 }>(refs: T[], scoreFn: (ref: T) => number): number;
 export declare function scoreReport(report: Report): ScoredReport;
-export {};

package/src/lib/sort-report.d.ts

@@ -0,0 +1,2 @@
+import { ScoredReport } from './scoring';
+export declare function sortReport(report: ScoredReport): ScoredReport;