@code-pushup/coverage-plugin 0.16.7 → 0.17.0

package/bin.js

@@ -0,0 +1,875 @@
+// packages/plugin-coverage/src/lib/runner/index.ts
+import chalk5 from "chalk";
+import { writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+
+// packages/models/src/lib/audit.ts
+import { z as z2 } from "zod";
+
+// packages/models/src/lib/implementation/schemas.ts
+import { MATERIAL_ICONS } from "vscode-material-icons";
+import { z } from "zod";
+
+// packages/models/src/lib/implementation/limits.ts
+var MAX_SLUG_LENGTH = 128;
+var MAX_TITLE_LENGTH = 256;
+var MAX_DESCRIPTION_LENGTH = 65536;
+var MAX_ISSUE_MESSAGE_LENGTH = 1024;
+
+// packages/models/src/lib/implementation/utils.ts
+var slugRegex = /^[a-z\d]+(?:-[a-z\d]+)*$/;
+var filenameRegex = /^(?!.*[ \\/:*?"<>|]).+$/;
+function hasDuplicateStrings(strings) {
+  const sortedStrings = [...strings].sort();
+  const duplStrings = sortedStrings.filter(
+    (item, index) => index !== 0 && item === sortedStrings[index - 1]
+  );
+  return duplStrings.length === 0 ? false : [...new Set(duplStrings)];
+}
+function hasMissingStrings(toCheck, existing) {
+  const nonExisting = toCheck.filter((s) => !existing.includes(s));
+  return nonExisting.length === 0 ? false : nonExisting;
+}
+function errorItems(items, transform = (itemArr) => itemArr.join(", ")) {
+  return transform(items || []);
+}
+function exists(value) {
+  return value != null;
+}
+function getMissingRefsForCategories(categories, plugins) {
+  if (categories.length === 0) {
+    return false;
+  }
+  const auditRefsFromCategory = categories.flatMap(
+    ({ refs }) => refs.filter(({ type }) => type === "audit").map(({ plugin, slug }) => `${plugin}/${slug}`)
+  );
+  const auditRefsFromPlugins = plugins.flatMap(
+    ({ audits, slug: pluginSlug }) => audits.map(({ slug }) => `${pluginSlug}/${slug}`)
+  );
+  const missingAuditRefs = hasMissingStrings(
+    auditRefsFromCategory,
+    auditRefsFromPlugins
+  );
+  const groupRefsFromCategory = categories.flatMap(
+    ({ refs }) => refs.filter(({ type }) => type === "group").map(({ plugin, slug }) => `${plugin}#${slug} (group)`)
+  );
+  const groupRefsFromPlugins = plugins.flatMap(
+    ({ groups, slug: pluginSlug }) => Array.isArray(groups) ? groups.map(({ slug }) => `${pluginSlug}#${slug} (group)`) : []
+  );
+  const missingGroupRefs = hasMissingStrings(
+    groupRefsFromCategory,
+    groupRefsFromPlugins
+  );
+  const missingRefs = [missingAuditRefs, missingGroupRefs].filter((refs) => Array.isArray(refs) && refs.length > 0).flat();
+  return missingRefs.length > 0 ? 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 = {
+  descriptionDate: "Execution start date and time",
+  descriptionDuration: "Execution duration in ms"
+}) {
+  return z.object({
+    date: z.string({ description: options.descriptionDate }),
+    duration: z.number({ description: options.descriptionDuration })
+  });
+}
+function slugSchema(description = "Unique ID (human-readable, URL-safe)") {
+  return z.string({ description }).regex(slugRegex, {
+    message: "The slug has to follow the pattern [0-9a-z] followed by multiple optional groups of -[0-9a-z]. e.g. my-slug"
+  }).max(MAX_SLUG_LENGTH, {
+    message: `slug can be max ${MAX_SLUG_LENGTH} characters long`
+  });
+}
+function descriptionSchema(description = "Description (markdown)") {
+  return z.string({ description }).max(MAX_DESCRIPTION_LENGTH).optional();
+}
+function docsUrlSchema(description = "Documentation site") {
+  return urlSchema(description).optional().or(z.string().max(0));
+}
+function urlSchema(description) {
+  return z.string({ description }).url();
+}
+function titleSchema(description = "Descriptive name") {
+  return z.string({ description }).max(MAX_TITLE_LENGTH);
+}
+function metaSchema(options) {
+  const {
+    descriptionDescription,
+    titleDescription,
+    docsUrlDescription,
+    description
+  } = options ?? {};
+  return z.object(
+    {
+      title: titleSchema(titleDescription),
+      description: descriptionSchema(descriptionDescription),
+      docsUrl: docsUrlSchema(docsUrlDescription)
+    },
+    { description }
+  );
+}
+function filePathSchema(description) {
+  return z.string({ description }).trim().min(1, { message: "path is invalid" });
+}
+function fileNameSchema(description) {
+  return z.string({ description }).trim().regex(filenameRegex, {
+    message: `The filename has to be valid`
+  }).min(1, { message: "file name is invalid" });
+}
+function positiveIntSchema(description) {
+  return z.number({ description }).int().nonnegative();
+}
+function packageVersionSchema(options) {
+  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: required ? packageSchema : packageSchema.optional(),
+      version: required ? versionSchema : versionSchema.optional()
+    },
+    { description: "NPM package name and version of a published package" }
+  );
+}
+function weightSchema(description = "Coefficient for the given score (use weight 0 if only for display)") {
+  return positiveIntSchema(description);
+}
+function weightedRefSchema(description, slugDescription) {
+  return z.object(
+    {
+      slug: slugSchema(slugDescription),
+      weight: weightSchema("Weight used to calculate score")
+    },
+    { description }
+  );
+}
+function scorableSchema(description, refSchema, duplicateCheckFn, duplicateMessageFn) {
+  return z.object(
+    {
+      slug: slugSchema('Human-readable unique ID, e.g. "performance"'),
+      refs: z.array(refSchema).min(1).refine(
+        (refs) => !duplicateCheckFn(refs),
+        (refs) => ({
+          message: duplicateMessageFn(refs)
+        })
+      ).refine(hasWeightedRefsInCategories, () => ({
+        message: `In a category there has to be at least one ref with weight > 0`
+      }))
+    },
+    { description }
+  );
+}
+var materialIconSchema = z.enum(MATERIAL_ICONS, {
+  description: "Icon from VSCode Material Icons extension"
+});
+function hasWeightedRefsInCategories(categoryRefs) {
+  return categoryRefs.reduce((acc, { weight }) => weight + acc, 0) !== 0;
+}
+
+// packages/models/src/lib/audit.ts
+var auditSchema = z2.object({
+  slug: slugSchema("ID (unique within plugin)")
+}).merge(
+  metaSchema({
+    titleDescription: "Descriptive name",
+    descriptionDescription: "Description (markdown)",
+    docsUrlDescription: "Link to documentation (rationale)",
+    description: "List of scorable metrics for the given plugin"
+  })
+);
+var pluginAuditsSchema = z2.array(auditSchema, {
+  description: "List of audits maintained in a plugin"
+}).min(1).refine(
+  (auditMetadata) => !getDuplicateSlugsInAudits(auditMetadata),
+  (auditMetadata) => ({
+    message: duplicateSlugsInAuditsErrorMsg(auditMetadata)
+  })
+);
+function duplicateSlugsInAuditsErrorMsg(audits) {
+  const duplicateRefs = getDuplicateSlugsInAudits(audits);
+  return `In plugin audits the following slugs are not unique: ${errorItems(
+    duplicateRefs
+  )}`;
+}
+function getDuplicateSlugsInAudits(audits) {
+  return hasDuplicateStrings(audits.map(({ slug }) => slug));
+}
+
+// packages/models/src/lib/audit-issue.ts
+import { z as z3 } from "zod";
+var sourceFileLocationSchema = z3.object(
+  {
+    file: filePathSchema("Relative path to source file in Git repo"),
+    position: z3.object(
+      {
+        startLine: positiveIntSchema("Start line"),
+        startColumn: positiveIntSchema("Start column").optional(),
+        endLine: positiveIntSchema("End line").optional(),
+        endColumn: positiveIntSchema("End column").optional()
+      },
+      { description: "Location in file" }
+    ).optional()
+  },
+  { description: "Source file location" }
+);
+var issueSeveritySchema = z3.enum(["info", "warning", "error"], {
+  description: "Severity level"
+});
+var issueSchema = z3.object(
+  {
+    message: z3.string({ description: "Descriptive error message" }).max(MAX_ISSUE_MESSAGE_LENGTH),
+    severity: issueSeveritySchema,
+    source: sourceFileLocationSchema.optional()
+  },
+  { description: "Issue information" }
+);
+
+// packages/models/src/lib/audit-output.ts
+import { z as z4 } from "zod";
+var auditOutputSchema = z4.object(
+  {
+    slug: slugSchema("Reference to audit"),
+    displayValue: z4.string({ description: "Formatted value (e.g. '0.9 s', '2.1 MB')" }).optional(),
+    value: positiveIntSchema("Raw numeric value"),
+    score: z4.number({
+      description: "Value between 0 and 1"
+    }).min(0).max(1),
+    details: z4.object(
+      {
+        issues: z4.array(issueSchema, { description: "List of findings" })
+      },
+      { description: "Detailed information" }
+    ).optional()
+  },
+  { description: "Audit information" }
+);
+var auditOutputsSchema = z4.array(auditOutputSchema, {
+  description: "List of JSON formatted audit output emitted by the runner process of a plugin"
+}).refine(
+  (audits) => !getDuplicateSlugsInAudits2(audits),
+  (audits) => ({ message: duplicateSlugsInAuditsErrorMsg2(audits) })
+);
+function duplicateSlugsInAuditsErrorMsg2(audits) {
+  const duplicateRefs = getDuplicateSlugsInAudits2(audits);
+  return `In plugin audits the slugs are not unique: ${errorItems(
+    duplicateRefs
+  )}`;
+}
+function getDuplicateSlugsInAudits2(audits) {
+  return hasDuplicateStrings(audits.map(({ slug }) => slug));
+}
+
+// packages/models/src/lib/category-config.ts
+import { z as z5 } from "zod";
+var categoryRefSchema = weightedRefSchema(
+  "Weighted references to audits and/or groups for the category",
+  "Slug of an audit or group (depending on `type`)"
+).merge(
+  z5.object({
+    type: z5.enum(["audit", "group"], {
+      description: "Discriminant for reference kind, affects where `slug` is looked up"
+    }),
+    plugin: slugSchema(
+      "Plugin slug (plugin should contain referenced audit or group)"
+    )
+  })
+);
+var categoryConfigSchema = scorableSchema(
+  "Category with a score calculated from audits and groups from various plugins",
+  categoryRefSchema,
+  getDuplicateRefsInCategoryMetrics,
+  duplicateRefsInCategoryMetricsErrorMsg
+).merge(
+  metaSchema({
+    titleDescription: "Category Title",
+    docsUrlDescription: "Category docs URL",
+    descriptionDescription: "Category description",
+    description: "Meta info for category"
+  })
+).merge(
+  z5.object({
+    isBinary: z5.boolean({
+      description: 'Is this a binary category (i.e. only a perfect score considered a "pass")?'
+    }).optional()
+  })
+);
+function duplicateRefsInCategoryMetricsErrorMsg(metrics) {
+  const duplicateRefs = getDuplicateRefsInCategoryMetrics(metrics);
+  return `In the categories, the following audit or group refs are duplicates: ${errorItems(
+    duplicateRefs
+  )}`;
+}
+function getDuplicateRefsInCategoryMetrics(metrics) {
+  return hasDuplicateStrings(
+    metrics.map(({ slug, type, plugin }) => `${type} :: ${plugin} / ${slug}`)
+  );
+}
+var categoriesSchema = z5.array(categoryConfigSchema, {
+  description: "Categorization of individual audits"
+}).refine(
+  (categoryCfg) => !getDuplicateSlugCategories(categoryCfg),
+  (categoryCfg) => ({
+    message: duplicateSlugCategoriesErrorMsg(categoryCfg)
+  })
+);
+function duplicateSlugCategoriesErrorMsg(categories) {
+  const duplicateStringSlugs = getDuplicateSlugCategories(categories);
+  return `In the categories, the following slugs are duplicated: ${errorItems(
+    duplicateStringSlugs
+  )}`;
+}
+function getDuplicateSlugCategories(categories) {
+  return hasDuplicateStrings(categories.map(({ slug }) => slug));
+}
+
+// packages/models/src/lib/core-config.ts
+import { z as z11 } from "zod";
+
+// packages/models/src/lib/persist-config.ts
+import { z as z6 } from "zod";
+var formatSchema = z6.enum(["json", "md"]);
+var persistConfigSchema = z6.object({
+  outputDir: filePathSchema("Artifacts folder").optional(),
+  filename: fileNameSchema(
+    "Artifacts file name (without extension)"
+  ).optional(),
+  format: z6.array(formatSchema).optional()
+});
+
+// packages/models/src/lib/plugin-config.ts
+import { z as z9 } from "zod";
+
+// packages/models/src/lib/group.ts
+import { z as z7 } from "zod";
+var groupRefSchema = weightedRefSchema(
+  "Weighted reference to a group",
+  "Reference slug to a group within this plugin (e.g. 'max-lines')"
+);
+var groupMetaSchema = metaSchema({
+  titleDescription: "Descriptive name for the group",
+  descriptionDescription: "Description of the group (markdown)",
+  docsUrlDescription: "Group documentation site",
+  description: "Group metadata"
+});
+var groupSchema = scorableSchema(
+  'A group aggregates a set of audits into a single score which can be referenced from a category. E.g. the group slug "performance" groups audits and can be referenced in a category',
+  groupRefSchema,
+  getDuplicateRefsInGroups,
+  duplicateRefsInGroupsErrorMsg
+).merge(groupMetaSchema);
+var groupsSchema = z7.array(groupSchema, {
+  description: "List of groups"
+}).optional().refine(
+  (groups) => !getDuplicateSlugsInGroups(groups),
+  (groups) => ({
+    message: duplicateSlugsInGroupsErrorMsg(groups)
+  })
+);
+function duplicateRefsInGroupsErrorMsg(groups) {
+  const duplicateRefs = getDuplicateRefsInGroups(groups);
+  return `In plugin groups the following references are not unique: ${errorItems(
+    duplicateRefs
+  )}`;
+}
+function getDuplicateRefsInGroups(groups) {
+  return hasDuplicateStrings(groups.map(({ slug: ref }) => ref).filter(exists));
+}
+function duplicateSlugsInGroupsErrorMsg(groups) {
+  const duplicateRefs = getDuplicateSlugsInGroups(groups);
+  return `In groups the following slugs are not unique: ${errorItems(
+    duplicateRefs
+  )}`;
+}
+function getDuplicateSlugsInGroups(groups) {
+  return Array.isArray(groups) ? hasDuplicateStrings(groups.map(({ slug }) => slug)) : false;
+}
+
+// packages/models/src/lib/runner-config.ts
+import { z as z8 } from "zod";
+var outputTransformSchema = z8.function().args(z8.unknown()).returns(z8.union([auditOutputsSchema, z8.promise(auditOutputsSchema)]));
+var runnerConfigSchema = z8.object(
+  {
+    command: z8.string({
+      description: "Shell command to execute"
+    }),
+    args: z8.array(z8.string({ description: "Command arguments" })).optional(),
+    outputFile: filePathSchema("Output path"),
+    outputTransform: outputTransformSchema.optional()
+  },
+  {
+    description: "How to execute runner"
+  }
+);
+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().merge(
+  metaSchema({
+    titleDescription: "Descriptive name",
+    descriptionDescription: "Description (markdown)",
+    docsUrlDescription: "Plugin documentation site",
+    description: "Plugin metadata"
+  })
+).merge(
+  z9.object({
+    slug: slugSchema("Unique plugin slug within core config"),
+    icon: materialIconSchema
+  })
+);
+var pluginDataSchema = z9.object({
+  runner: z9.union([runnerConfigSchema, runnerFunctionSchema]),
+  audits: pluginAuditsSchema,
+  groups: groupsSchema
+});
+var pluginConfigSchema = pluginMetaSchema.merge(pluginDataSchema).refine(
+  (pluginCfg) => !getMissingRefsFromGroups(pluginCfg),
+  (pluginCfg) => ({
+    message: missingRefsFromGroupsErrorMsg(pluginCfg)
+  })
+);
+function missingRefsFromGroupsErrorMsg(pluginCfg) {
+  const missingRefs = getMissingRefsFromGroups(pluginCfg);
+  return `The following group references need to point to an existing audit in this plugin config: ${errorItems(
+    missingRefs
+  )}`;
+}
+function getMissingRefsFromGroups(pluginCfg) {
+  return hasMissingStrings(
+    pluginCfg.groups?.flatMap(
+      ({ refs: audits }) => audits.map(({ slug: ref }) => ref)
+    ) ?? [],
+    pluginCfg.audits.map(({ slug }) => slug)
+  );
+}
+
+// packages/models/src/lib/upload-config.ts
+import { z as z10 } from "zod";
+var uploadConfigSchema = z10.object({
+  server: urlSchema("URL of deployed portal API"),
+  apiKey: z10.string({
+    description: "API key with write access to portal (use `process.env` for security)"
+  }),
+  organization: slugSchema("Organization slug from Code PushUp portal"),
+  project: slugSchema("Project slug from Code PushUp portal"),
+  timeout: z10.number({ description: "Request timeout in minutes (default is 5)" }).positive().int().optional()
+});
+
+// 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 */
+  upload: uploadConfigSchema.optional(),
+  categories: categoriesSchema.optional()
+});
+var coreConfigSchema = refineCoreConfig(unrefinedCoreConfigSchema);
+function refineCoreConfig(schema) {
+  return schema.refine(
+    (coreCfg) => !getMissingRefsForCategories(coreCfg.categories ?? [], coreCfg.plugins),
+    (coreCfg) => ({
+      message: missingRefsForCategoriesErrorMsg(
+        coreCfg.categories ?? [],
+        coreCfg.plugins
+      )
+    })
+  );
+}
+
+// packages/models/src/lib/report.ts
+import { z as z12 } from "zod";
+var auditReportSchema = auditSchema.merge(auditOutputSchema);
+var pluginReportSchema = pluginMetaSchema.merge(
+  executionMetaSchema({
+    descriptionDate: "Start date and time of plugin run",
+    descriptionDuration: "Duration of the plugin run in ms"
+  })
+).merge(
+  z12.object({
+    audits: z12.array(auditReportSchema).min(1),
+    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",
+  required: true
+}).merge(
+  executionMetaSchema({
+    descriptionDate: "Start date and time of the collect run",
+    descriptionDuration: "Duration of the collect run in ms"
+  })
+).merge(
+  z12.object(
+    {
+      categories: z12.array(categoryConfigSchema),
+      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/execute-process.ts
+import { spawn } from "node:child_process";
+
+// packages/utils/src/lib/file-system.ts
+import { bundleRequire } from "bundle-require";
+import chalk from "chalk";
+import { mkdir, readFile, readdir, rm, stat } from "node:fs/promises";
+import { join } from "node:path";
+async function readTextFile(path) {
+  const buffer = await readFile(path);
+  return buffer.toString();
+}
+async function readJsonFile(path) {
+  const text = await readTextFile(path);
+  return JSON.parse(text);
+}
+async function ensureDirectoryExists(baseDir) {
+  try {
+    await mkdir(baseDir, { recursive: true });
+    return;
+  } catch (error) {
+    console.error(error.message);
+    if (error.code !== "EEXIST") {
+      throw error;
+    }
+  }
+}
+function pluginWorkDir(slug) {
+  return join("node_modules", ".code-pushup", slug);
+}
+
+// packages/utils/src/lib/reports/utils.ts
+function calcDuration(start, stop) {
+  return Math.floor((stop ?? performance.now()) - start);
+}
+
+// packages/utils/src/lib/execute-process.ts
+var ProcessError = class extends Error {
+  code;
+  stderr;
+  stdout;
+  constructor(result) {
+    super(result.stderr);
+    this.code = result.code;
+    this.stderr = result.stderr;
+    this.stdout = result.stdout;
+  }
+};
+function executeProcess(cfg) {
+  const { observer, cwd, command, args } = cfg;
+  const { onStdout, onError, onComplete } = observer ?? {};
+  const date = (/* @__PURE__ */ new Date()).toISOString();
+  const start = performance.now();
+  return new Promise((resolve, reject) => {
+    const process2 = spawn(command, args, { cwd, shell: true });
+    let stdout = "";
+    let stderr = "";
+    process2.stdout.on("data", (data) => {
+      stdout += String(data);
+      onStdout?.(String(data));
+    });
+    process2.stderr.on("data", (data) => {
+      stderr += String(data);
+    });
+    process2.on("error", (err) => {
+      stderr += err.toString();
+    });
+    process2.on("close", (code) => {
+      const timings = { date, duration: calcDuration(start) };
+      if (code === 0) {
+        onComplete?.();
+        resolve({ code, stdout, stderr, ...timings });
+      } else {
+        const errorMsg = new ProcessError({ code, stdout, stderr, ...timings });
+        onError?.(errorMsg);
+        reject(errorMsg);
+      }
+    });
+  });
+}
+
+// packages/utils/src/lib/git.ts
+import { simpleGit } from "simple-git";
+var git = simpleGit();
+
+// packages/utils/src/lib/progress.ts
+import chalk2 from "chalk";
+import { MultiProgressBars } from "multi-progress-bars";
+
+// packages/utils/src/lib/reports/generate-stdout-summary.ts
+import cliui from "@isaacs/cliui";
+import chalk3 from "chalk";
+import CliTable3 from "cli-table3";
+
+// packages/utils/src/lib/transform.ts
+import { platform } from "node:os";
+function toUnixPath(path, options) {
+  const unixPath = path.replace(/\\/g, "/");
+  if (options?.toRelative) {
+    return unixPath.replace(`${process.cwd().replace(/\\/g, "/")}/`, "");
+  }
+  return unixPath;
+}
+function toUnixNewlines(text) {
+  return platform() === "win32" ? text.replace(/\r\n/g, "\n") : text;
+}
+function toNumberPrecision(value, decimalPlaces) {
+  return Number(
+    `${Math.round(
+      Number.parseFloat(`${value}e${decimalPlaces}`)
+    )}e-${decimalPlaces}`
+  );
+}
+function toOrdinal(value) {
+  if (value % 10 === 1 && value % 100 !== 11) {
+    return `${value}st`;
+  }
+  if (value % 10 === 2 && value % 100 !== 12) {
+    return `${value}nd`;
+  }
+  if (value % 10 === 3 && value % 100 !== 13) {
+    return `${value}rd`;
+  }
+  return `${value}th`;
+}
+
+// packages/utils/src/lib/logging.ts
+import chalk4 from "chalk";
+
+// packages/plugin-coverage/src/lib/runner/constants.ts
+import { join as join2 } from "node:path";
+var WORKDIR = pluginWorkDir("coverage");
+var RUNNER_OUTPUT_PATH = join2(WORKDIR, "runner-output.json");
+var PLUGIN_CONFIG_PATH = join2(
+  process.cwd(),
+  WORKDIR,
+  "plugin-config.json"
+);
+
+// packages/plugin-coverage/src/lib/runner/lcov/lcov-runner.ts
+import { join as join3 } from "node:path";
+
+// packages/plugin-coverage/src/lib/runner/lcov/parse-lcov.ts
+import parseLcovExport from "parse-lcov";
+var godKnows = parseLcovExport;
+var parseLcov = "default" in godKnows ? godKnows.default : godKnows;
+
+// packages/plugin-coverage/src/lib/runner/lcov/utils.ts
+function calculateCoverage(hit, found) {
+  return found > 0 ? hit / found : 1;
+}
+function mergeConsecutiveNumbers(numberArr) {
+  return [...numberArr].sort().reduce((acc, currValue) => {
+    const prevValue = acc.at(-1);
+    if (prevValue != null && (prevValue.start === currValue - 1 || prevValue.end === currValue - 1)) {
+      return [...acc.slice(0, -1), { start: prevValue.start, end: currValue }];
+    }
+    return [...acc, { start: currValue }];
+  }, []);
+}
+
+// packages/plugin-coverage/src/lib/runner/lcov/transform.ts
+function lcovReportToFunctionStat(record) {
+  return {
+    totalFound: record.functions.found,
+    totalHit: record.functions.hit,
+    issues: record.functions.hit < record.functions.found ? record.functions.details.filter((detail) => !detail.hit).map(
+      (detail) => ({
+        message: `Function ${detail.name} is not called in any test case.`,
+        severity: "error",
+        source: {
+          file: toUnixPath(record.file),
+          position: { startLine: detail.line }
+        }
+      })
+    ) : []
+  };
+}
+function lcovReportToLineStat(record) {
+  const missingCoverage = record.lines.hit < record.lines.found;
+  const lines = missingCoverage ? record.lines.details.filter((detail) => !detail.hit).map((detail) => detail.line) : [];
+  const linePositions = mergeConsecutiveNumbers(lines);
+  return {
+    totalFound: record.lines.found,
+    totalHit: record.lines.hit,
+    issues: missingCoverage ? linePositions.map((linePosition) => {
+      const lineReference = linePosition.end == null ? `Line ${linePosition.start} is` : `Lines ${linePosition.start}-${linePosition.end} are`;
+      return {
+        message: `${lineReference} not covered in any test case.`,
+        severity: "warning",
+        source: {
+          file: toUnixPath(record.file),
+          position: {
+            startLine: linePosition.start,
+            endLine: linePosition.end
+          }
+        }
+      };
+    }) : []
+  };
+}
+function lcovReportToBranchStat(record) {
+  return {
+    totalFound: record.branches.found,
+    totalHit: record.branches.hit,
+    issues: record.branches.hit < record.branches.found ? record.branches.details.filter((detail) => !detail.taken).map(
+      (detail) => ({
+        message: `${toOrdinal(
+          detail.branch + 1
+        )} branch is not taken in any test case.`,
+        severity: "error",
+        source: {
+          file: toUnixPath(record.file),
+          position: { startLine: detail.line }
+        }
+      })
+    ) : []
+  };
+}
+var recordToStatFunctionMapper = {
+  branch: lcovReportToBranchStat,
+  line: lcovReportToLineStat,
+  function: lcovReportToFunctionStat
+};
+function lcovCoverageToAuditOutput(stat2, coverageType) {
+  const coverage = calculateCoverage(stat2.totalHit, stat2.totalFound);
+  const MAX_DECIMAL_PLACES = 4;
+  const roundedIntValue = toNumberPrecision(coverage * 100, 0);
+  return {
+    slug: `${coverageType}-coverage`,
+    score: toNumberPrecision(coverage, MAX_DECIMAL_PLACES),
+    value: roundedIntValue,
+    displayValue: `${roundedIntValue} %`,
+    ...stat2.issues.length > 0 && { details: { issues: stat2.issues } }
+  };
+}
+
+// packages/plugin-coverage/src/lib/runner/lcov/lcov-runner.ts
+async function lcovResultsToAuditOutputs(results, coverageTypes) {
+  const lcovResults = await parseLcovFiles(results);
+  const totalCoverageStats = getTotalCoverageFromLcovRecords(
+    lcovResults,
+    coverageTypes
+  );
+  return coverageTypes.map((coverageType) => {
+    const stats = totalCoverageStats[coverageType];
+    if (!stats) {
+      return null;
+    }
+    return lcovCoverageToAuditOutput(stats, coverageType);
+  }).filter(exists);
+}
+async function parseLcovFiles(results) {
+  const parsedResults = await Promise.all(
+    results.map(async (result) => {
+      const lcovFileContent = await readTextFile(result.resultsPath);
+      const parsedRecords = parseLcov(toUnixNewlines(lcovFileContent));
+      return parsedRecords.map((record) => ({
+        ...record,
+        file: result.pathToProject == null ? record.file : join3(result.pathToProject, record.file)
+      }));
+    })
+  );
+  if (parsedResults.length !== results.length) {
+    throw new Error("Some provided LCOV results were not valid.");
+  }
+  const flatResults = parsedResults.flat();
+  if (flatResults.length === 0) {
+    throw new Error("All provided results are empty.");
+  }
+  return flatResults;
+}
+function getTotalCoverageFromLcovRecords(records, coverageTypes) {
+  return records.reduce(
+    (acc, report) => Object.fromEntries([
+      ...Object.entries(acc),
+      ...Object.entries(
+        getCoverageStatsFromLcovRecord(report, coverageTypes)
+      ).map(([type, stats]) => [
+        type,
+        {
+          totalFound: (acc[type]?.totalFound ?? 0) + stats.totalFound,
+          totalHit: (acc[type]?.totalHit ?? 0) + stats.totalHit,
+          issues: [...acc[type]?.issues ?? [], ...stats.issues]
+        }
+      ])
+    ]),
+    {}
+  );
+}
+function getCoverageStatsFromLcovRecord(record, coverageTypes) {
+  return Object.fromEntries(
+    coverageTypes.map((coverageType) => [
+      coverageType,
+      recordToStatFunctionMapper[coverageType](record)
+    ])
+  );
+}
+
+// packages/plugin-coverage/src/lib/runner/index.ts
+async function executeRunner() {
+  const { reports, coverageToolCommand, coverageTypes } = await readJsonFile(PLUGIN_CONFIG_PATH);
+  if (coverageToolCommand != null) {
+    const { command, args } = coverageToolCommand;
+    try {
+      await executeProcess({ command, args });
+    } catch (error) {
+      if (error instanceof ProcessError) {
+        console.info(chalk5.bold("stdout from failed process:"));
+        console.info(error.stdout);
+        console.error(chalk5.bold("stderr from failed process:"));
+        console.error(error.stderr);
+      }
+      throw new Error(
+        "Coverage plugin: Running coverage tool failed. Make sure all your provided tests are passing."
+      );
+    }
+  }
+  const auditOutputs = await lcovResultsToAuditOutputs(reports, coverageTypes);
+  await ensureDirectoryExists(dirname(RUNNER_OUTPUT_PATH));
+  await writeFile(RUNNER_OUTPUT_PATH, JSON.stringify(auditOutputs));
+}
+
+// packages/plugin-coverage/src/bin.ts
+await executeRunner().catch(console.error);