@code-pushup/eslint-plugin 0.56.0 → 0.57.0

package/index.js

@@ -1,1413 +0,0 @@
-// packages/plugin-eslint/src/lib/eslint-plugin.ts
-import { dirname as dirname3, join as join4 } from "node:path";
-import { fileURLToPath } from "node:url";
-
-// packages/plugin-eslint/package.json
-var name = "@code-pushup/eslint-plugin";
-var version = "0.56.0";
-
-// packages/plugin-eslint/src/lib/config.ts
-import { z as z17 } 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.toSorted();
-  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 || 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
-var tableCellValueSchema = z.union([z.string(), z.number(), z.boolean(), z.null()]).default(null);
-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 })
-  });
-}
-var slugSchema = z.string({ description: "Unique ID (human-readable, URL-safe)" }).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`
-});
-var descriptionSchema = z.string({ description: "Description (markdown)" }).max(MAX_DESCRIPTION_LENGTH).optional();
-var urlSchema = z.string().url();
-var docsUrlSchema = urlSchema.optional().or(z.literal("")).describe("Documentation site");
-var titleSchema = z.string({ description: "Descriptive name" }).max(MAX_TITLE_LENGTH);
-var scoreSchema = z.number({
-  description: "Value between 0 and 1"
-}).min(0).max(1);
-function metaSchema(options) {
-  const {
-    descriptionDescription,
-    titleDescription,
-    docsUrlDescription,
-    description
-  } = options ?? {};
-  return z.object(
-    {
-      title: titleDescription ? titleSchema.describe(titleDescription) : titleSchema,
-      description: descriptionDescription ? descriptionSchema.describe(descriptionDescription) : descriptionSchema,
-      docsUrl: docsUrlDescription ? docsUrlSchema.describe(docsUrlDescription) : docsUrlSchema
-    },
-    { description }
-  );
-}
-var filePathSchema = z.string().trim().min(1, { message: "path is invalid" });
-var fileNameSchema = z.string().trim().regex(filenameRegex, {
-  message: `The filename has to be valid`
-}).min(1, { message: "file name is invalid" });
-var positiveIntSchema = z.number().int().positive();
-var nonnegativeNumberSchema = z.number().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" }
-  );
-}
-var weightSchema = nonnegativeNumberSchema.describe(
-  "Coefficient for the given score (use weight 0 if only for display)"
-);
-function weightedRefSchema(description, slugDescription) {
-  return z.object(
-    {
-      slug: slugSchema.describe(slugDescription),
-      weight: weightSchema.describe("Weight used to calculate score")
-    },
-    { description }
-  );
-}
-function scorableSchema(description, refSchema, duplicateCheckFn, duplicateMessageFn) {
-  return z.object(
-    {
-      slug: slugSchema.describe('Human-readable unique ID, e.g. "performance"'),
-      refs: z.array(refSchema).min(1).refine(
-        (refs) => !duplicateCheckFn(refs),
-        (refs) => ({
-          message: duplicateMessageFn(refs)
-        })
-      ).refine(hasNonZeroWeightedRef, () => ({
-        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 hasNonZeroWeightedRef(refs) {
-  return refs.reduce((acc, { weight }) => weight + acc, 0) !== 0;
-}
-
-// packages/models/src/lib/source.ts
-import { z as z2 } from "zod";
-var sourceFileLocationSchema = z2.object(
-  {
-    file: filePathSchema.describe("Relative path to source file in Git repo"),
-    position: z2.object(
-      {
-        startLine: positiveIntSchema.describe("Start line"),
-        startColumn: positiveIntSchema.describe("Start column").optional(),
-        endLine: positiveIntSchema.describe("End line").optional(),
-        endColumn: positiveIntSchema.describe("End column").optional()
-      },
-      { description: "Location in file" }
-    ).optional()
-  },
-  { description: "Source file location" }
-);
-
-// packages/models/src/lib/audit.ts
-import { z as z3 } from "zod";
-var auditSchema = z3.object({
-  slug: slugSchema.describe("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 = z3.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-output.ts
-import { z as z6 } from "zod";
-
-// packages/models/src/lib/issue.ts
-import { z as z4 } from "zod";
-var issueSeveritySchema = z4.enum(["info", "warning", "error"], {
-  description: "Severity level"
-});
-var issueSchema = z4.object(
-  {
-    message: z4.string({ description: "Descriptive error message" }).max(MAX_ISSUE_MESSAGE_LENGTH),
-    severity: issueSeveritySchema,
-    source: sourceFileLocationSchema.optional()
-  },
-  { description: "Issue information" }
-);
-
-// packages/models/src/lib/table.ts
-import { z as z5 } from "zod";
-var tableAlignmentSchema = z5.enum(["left", "center", "right"], {
-  description: "Cell alignment"
-});
-var tableColumnObjectSchema = z5.object({
-  key: z5.string(),
-  label: z5.string().optional(),
-  align: tableAlignmentSchema.optional()
-});
-var tableRowObjectSchema = z5.record(tableCellValueSchema, {
-  description: "Object row"
-});
-var tableRowPrimitiveSchema = z5.array(tableCellValueSchema, {
-  description: "Primitive row"
-});
-var tableSharedSchema = z5.object({
-  title: z5.string().optional().describe("Display title for table")
-});
-var tablePrimitiveSchema = tableSharedSchema.merge(
-  z5.object(
-    {
-      columns: z5.array(tableAlignmentSchema).optional(),
-      rows: z5.array(tableRowPrimitiveSchema)
-    },
-    { description: "Table with primitive rows and optional alignment columns" }
-  )
-);
-var tableObjectSchema = tableSharedSchema.merge(
-  z5.object(
-    {
-      columns: z5.union([
-        z5.array(tableAlignmentSchema),
-        z5.array(tableColumnObjectSchema)
-      ]).optional(),
-      rows: z5.array(tableRowObjectSchema)
-    },
-    {
-      description: "Table with object rows and optional alignment or object columns"
-    }
-  )
-);
-var tableSchema = (description = "Table information") => z5.union([tablePrimitiveSchema, tableObjectSchema], { description });
-
-// packages/models/src/lib/audit-output.ts
-var auditValueSchema = nonnegativeNumberSchema.describe("Raw numeric value");
-var auditDisplayValueSchema = z6.string({ description: "Formatted value (e.g. '0.9 s', '2.1 MB')" }).optional();
-var auditDetailsSchema = z6.object(
-  {
-    issues: z6.array(issueSchema, { description: "List of findings" }).optional(),
-    table: tableSchema("Table of related findings").optional()
-  },
-  { description: "Detailed information" }
-);
-var auditOutputSchema = z6.object(
-  {
-    slug: slugSchema.describe("Reference to audit"),
-    displayValue: auditDisplayValueSchema,
-    value: auditValueSchema,
-    score: scoreSchema,
-    details: auditDetailsSchema.optional()
-  },
-  { description: "Audit information" }
-);
-var auditOutputsSchema = z6.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 z7 } 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(
-  z7.object({
-    type: z7.enum(["audit", "group"], {
-      description: "Discriminant for reference kind, affects where `slug` is looked up"
-    }),
-    plugin: slugSchema.describe(
-      "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(
-  z7.object({
-    isBinary: z7.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 = z7.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/commit.ts
-import { z as z8 } from "zod";
-var commitSchema = z8.object(
-  {
-    hash: z8.string({ description: "Commit SHA (full)" }).regex(
-      /^[\da-f]{40}$/,
-      "Commit SHA should be a 40-character hexadecimal string"
-    ),
-    message: z8.string({ description: "Commit message" }),
-    date: z8.coerce.date({
-      description: "Date and time when commit was authored"
-    }),
-    author: z8.string({
-      description: "Commit author name"
-    }).trim()
-  },
-  { description: "Git commit" }
-);
-
-// packages/models/src/lib/core-config.ts
-import { z as z14 } from "zod";
-
-// packages/models/src/lib/persist-config.ts
-import { z as z9 } from "zod";
-var formatSchema = z9.enum(["json", "md"]);
-var persistConfigSchema = z9.object({
-  outputDir: filePathSchema.describe("Artifacts folder").optional(),
-  filename: fileNameSchema.describe("Artifacts file name (without extension)").optional(),
-  format: z9.array(formatSchema).optional()
-});
-
-// packages/models/src/lib/plugin-config.ts
-import { z as z12 } from "zod";
-
-// packages/models/src/lib/group.ts
-import { z as z10 } 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 = z10.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 z11 } from "zod";
-var outputTransformSchema = z11.function().args(z11.unknown()).returns(z11.union([auditOutputsSchema, z11.promise(auditOutputsSchema)]));
-var runnerConfigSchema = z11.object(
-  {
-    command: z11.string({
-      description: "Shell command to execute"
-    }),
-    args: z11.array(z11.string({ description: "Command arguments" })).optional(),
-    outputFile: filePathSchema.describe("Output path"),
-    outputTransform: outputTransformSchema.optional()
-  },
-  {
-    description: "How to execute runner"
-  }
-);
-var onProgressSchema = z11.function().args(z11.unknown()).returns(z11.void());
-var runnerFunctionSchema = z11.function().args(onProgressSchema.optional()).returns(z11.union([auditOutputsSchema, z11.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(
-  z12.object({
-    slug: slugSchema.describe("Unique plugin slug within core config"),
-    icon: materialIconSchema
-  })
-);
-var pluginDataSchema = z12.object({
-  runner: z12.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 z13 } from "zod";
-var uploadConfigSchema = z13.object({
-  server: urlSchema.describe("URL of deployed portal API"),
-  apiKey: z13.string({
-    description: "API key with write access to portal (use `process.env` for security)"
-  }),
-  organization: slugSchema.describe(
-    "Organization slug from Code PushUp portal"
-  ),
-  project: slugSchema.describe("Project slug from Code PushUp portal"),
-  timeout: z13.number({ description: "Request timeout in minutes (default is 5)" }).positive().int().optional()
-});
-
-// packages/models/src/lib/core-config.ts
-var unrefinedCoreConfigSchema = z14.object({
-  plugins: z14.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(
-    ({ categories, plugins }) => !getMissingRefsForCategories(categories, plugins),
-    ({ categories, plugins }) => ({
-      message: missingRefsForCategoriesErrorMsg(categories, plugins)
-    })
-  );
-}
-
-// packages/models/src/lib/report.ts
-import { z as z15 } 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(
-  z15.object({
-    audits: z15.array(auditReportSchema).min(1),
-    groups: z15.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(
-  z15.object(
-    {
-      plugins: z15.array(pluginReportSchema).min(1),
-      categories: z15.array(categoryConfigSchema).optional(),
-      commit: commitSchema.describe("Git commit for which report was collected").nullable()
-    },
-    { description: "Collect output data" }
-  )
-).refine(
-  ({ categories, plugins }) => !getMissingRefsForCategories(categories, plugins),
-  ({ categories, plugins }) => ({
-    message: missingRefsForCategoriesErrorMsg(categories, plugins)
-  })
-);
-
-// packages/models/src/lib/reports-diff.ts
-import { z as z16 } from "zod";
-function makeComparisonSchema(schema) {
-  const sharedDescription = schema.description || "Result";
-  return z16.object({
-    before: schema.describe(`${sharedDescription} (source commit)`),
-    after: schema.describe(`${sharedDescription} (target commit)`)
-  });
-}
-function makeArraysComparisonSchema(diffSchema, resultSchema, description) {
-  return z16.object(
-    {
-      changed: z16.array(diffSchema),
-      unchanged: z16.array(resultSchema),
-      added: z16.array(resultSchema),
-      removed: z16.array(resultSchema)
-    },
-    { description }
-  );
-}
-var scorableMetaSchema = z16.object({
-  slug: slugSchema,
-  title: titleSchema,
-  docsUrl: docsUrlSchema
-});
-var scorableWithPluginMetaSchema = scorableMetaSchema.merge(
-  z16.object({
-    plugin: pluginMetaSchema.pick({ slug: true, title: true, docsUrl: true }).describe("Plugin which defines it")
-  })
-);
-var scorableDiffSchema = scorableMetaSchema.merge(
-  z16.object({
-    scores: makeComparisonSchema(scoreSchema).merge(
-      z16.object({
-        diff: z16.number().min(-1).max(1).describe("Score change (`scores.after - scores.before`)")
-      })
-    ).describe("Score comparison")
-  })
-);
-var scorableWithPluginDiffSchema = scorableDiffSchema.merge(
-  scorableWithPluginMetaSchema
-);
-var categoryDiffSchema = scorableDiffSchema;
-var groupDiffSchema = scorableWithPluginDiffSchema;
-var auditDiffSchema = scorableWithPluginDiffSchema.merge(
-  z16.object({
-    values: makeComparisonSchema(auditValueSchema).merge(
-      z16.object({
-        diff: z16.number().describe("Value change (`values.after - values.before`)")
-      })
-    ).describe("Audit `value` comparison"),
-    displayValues: makeComparisonSchema(auditDisplayValueSchema).describe(
-      "Audit `displayValue` comparison"
-    )
-  })
-);
-var categoryResultSchema = scorableMetaSchema.merge(
-  z16.object({ score: scoreSchema })
-);
-var groupResultSchema = scorableWithPluginMetaSchema.merge(
-  z16.object({ score: scoreSchema })
-);
-var auditResultSchema = scorableWithPluginMetaSchema.merge(
-  auditOutputSchema.pick({ score: true, value: true, displayValue: true })
-);
-var reportsDiffSchema = z16.object({
-  commits: makeComparisonSchema(commitSchema).nullable().describe("Commits identifying compared reports"),
-  portalUrl: urlSchema.optional().describe("Link to comparison page in Code PushUp portal"),
-  label: z16.string().optional().describe("Label (e.g. project name)"),
-  categories: makeArraysComparisonSchema(
-    categoryDiffSchema,
-    categoryResultSchema,
-    "Changes affecting categories"
-  ),
-  groups: makeArraysComparisonSchema(
-    groupDiffSchema,
-    groupResultSchema,
-    "Changes affecting groups"
-  ),
-  audits: makeArraysComparisonSchema(
-    auditDiffSchema,
-    auditResultSchema,
-    "Changes affecting audits"
-  )
-}).merge(
-  packageVersionSchema({
-    versionDescription: "NPM version of the CLI (when `compare` was run)",
-    required: true
-  })
-).merge(
-  executionMetaSchema({
-    descriptionDate: "Start date and time of the compare run",
-    descriptionDuration: "Duration of the compare run in ms"
-  })
-);
-
-// packages/utils/src/lib/reports/utils.ts
-import ansis from "ansis";
-import { md } from "build-md";
-
-// packages/utils/src/lib/reports/constants.ts
-var TERMINAL_WIDTH = 80;
-
-// packages/utils/src/lib/file-system.ts
-import { bold, gray } from "ansis";
-import { bundleRequire } from "bundle-require";
-import { mkdir, readFile, readdir, rm, stat } from "node:fs/promises";
-import { dirname, join } from "node:path";
-
-// packages/utils/src/lib/formatting.ts
-function slugify(text) {
-  return text.trim().toLowerCase().replace(/\s+|\//g, "-").replace(/[^a-z\d-]/g, "");
-}
-function truncateText(text, options) {
-  const {
-    maxChars,
-    position = "end",
-    ellipsis = "..."
-  } = typeof options === "number" ? { maxChars: options } : options;
-  if (text.length <= maxChars) {
-    return text;
-  }
-  const maxLength = maxChars - ellipsis.length;
-  switch (position) {
-    case "start":
-      return ellipsis + text.slice(-maxLength).trim();
-    case "middle":
-      const halfMaxChars = Math.floor(maxLength / 2);
-      return text.slice(0, halfMaxChars).trim() + ellipsis + text.slice(-halfMaxChars).trim();
-    case "end":
-      return text.slice(0, maxLength).trim() + ellipsis;
-  }
-}
-function truncateTitle(text) {
-  return truncateText(text, MAX_TITLE_LENGTH);
-}
-function truncateDescription(text) {
-  return truncateText(text, MAX_DESCRIPTION_LENGTH);
-}
-
-// packages/utils/src/lib/logging.ts
-import isaacs_cliui from "@isaacs/cliui";
-import { cliui } from "@poppinss/cliui";
-import { underline } from "ansis";
-var singletonUiInstance;
-function ui() {
-  if (singletonUiInstance === void 0) {
-    singletonUiInstance = cliui();
-  }
-  return {
-    ...singletonUiInstance,
-    row: (args) => {
-      logListItem(args);
-    }
-  };
-}
-var singletonisaacUi;
-function logListItem(args) {
-  if (singletonisaacUi === void 0) {
-    singletonisaacUi = isaacs_cliui({ width: TERMINAL_WIDTH });
-  }
-  singletonisaacUi.div(...args);
-  const content = singletonisaacUi.toString();
-  singletonisaacUi.rows = [];
-  singletonUiInstance?.logger.log(content);
-}
-
-// packages/utils/src/lib/file-system.ts
-async function fileExists(path) {
-  try {
-    const stats = await stat(path);
-    return stats.isFile();
-  } catch {
-    return false;
-  }
-}
-async function ensureDirectoryExists(baseDir) {
-  try {
-    await mkdir(baseDir, { recursive: true });
-    return;
-  } catch (error) {
-    ui().logger.info(error.message);
-    if (error.code !== "EEXIST") {
-      throw error;
-    }
-  }
-}
-function pluginWorkDir(slug) {
-  return join("node_modules", ".code-pushup", slug);
-}
-async function findNearestFile(fileNames, cwd = process.cwd()) {
-  for (let directory = cwd; directory !== dirname(directory); directory = dirname(directory)) {
-    for (const file of fileNames) {
-      if (await fileExists(join(directory, file))) {
-        return join(directory, file);
-      }
-    }
-  }
-  return void 0;
-}
-function filePathToCliArg(path) {
-  return `"${path}"`;
-}
-
-// packages/utils/src/lib/git/git.ts
-import { simpleGit } from "simple-git";
-
-// packages/utils/src/lib/transform.ts
-function toArray(val) {
-  return Array.isArray(val) ? val : [val];
-}
-function objectToKeys(obj) {
-  return Object.keys(obj);
-}
-function distinct(array) {
-  return [...new Set(array)];
-}
-
-// packages/utils/src/lib/git/git.commits-and-tags.ts
-import { simpleGit as simpleGit2 } from "simple-git";
-
-// packages/utils/src/lib/semver.ts
-import { rcompare, valid } from "semver";
-
-// packages/utils/src/lib/progress.ts
-import { black, bold as bold2, gray as gray2, green } from "ansis";
-import { MultiProgressBars } from "multi-progress-bars";
-
-// packages/utils/src/lib/reports/generate-md-report.ts
-import { MarkdownDocument as MarkdownDocument3, md as md4 } from "build-md";
-
-// packages/utils/src/lib/reports/formatting.ts
-import {
-  MarkdownDocument,
-  md as md2
-} from "build-md";
-
-// packages/utils/src/lib/reports/generate-md-report-categoy-section.ts
-import { MarkdownDocument as MarkdownDocument2, md as md3 } from "build-md";
-
-// packages/utils/src/lib/reports/generate-md-reports-diff.ts
-import {
-  MarkdownDocument as MarkdownDocument5,
-  md as md6
-} from "build-md";
-
-// packages/utils/src/lib/reports/generate-md-reports-diff-utils.ts
-import { MarkdownDocument as MarkdownDocument4, md as md5 } from "build-md";
-
-// packages/utils/src/lib/reports/log-stdout-summary.ts
-import { bold as bold4, cyan, cyanBright, green as green2, red } from "ansis";
-
-// packages/plugin-eslint/src/lib/config.ts
-var patternsSchema = z17.union([z17.string(), z17.array(z17.string()).min(1)], {
-  description: "Lint target files. May contain file paths, directory paths or glob patterns"
-});
-var eslintrcSchema = z17.string({ description: "Path to ESLint config file" });
-var eslintTargetObjectSchema = z17.object({
-  eslintrc: eslintrcSchema.optional(),
-  patterns: patternsSchema
-});
-var eslintTargetSchema = z17.union([patternsSchema, eslintTargetObjectSchema]).transform(
-  (target) => typeof target === "string" || Array.isArray(target) ? { patterns: target } : target
-);
-var eslintPluginConfigSchema = z17.union([eslintTargetSchema, z17.array(eslintTargetSchema).min(1)]).transform(toArray);
-
-// packages/plugin-eslint/src/lib/meta/hash.ts
-import { createHash } from "node:crypto";
-function ruleIdToSlug(ruleId, options) {
-  const slug = slugify(ruleId);
-  if (!options?.length) {
-    return slug;
-  }
-  return `${slug}-${jsonHash(options)}`;
-}
-function jsonHash(data, bytes = 8) {
-  return createHash("shake256", { outputLength: bytes }).update(JSON.stringify(data) || "null").digest("hex");
-}
-
-// packages/plugin-eslint/src/lib/meta/parse.ts
-function parseRuleId(ruleId) {
-  const i = ruleId.lastIndexOf("/");
-  if (i < 0) {
-    return { name: ruleId };
-  }
-  return {
-    plugin: ruleId.slice(0, i),
-    name: ruleId.slice(i + 1)
-  };
-}
-function isRuleOff(entry) {
-  const level = Array.isArray(entry) ? entry[0] : entry;
-  switch (level) {
-    case 0:
-    case "off":
-      return true;
-    case 1:
-    case 2:
-    case "warn":
-    case "error":
-      return false;
-  }
-}
-function optionsFromRuleEntry(entry) {
-  return toArray(entry).slice(1);
-}
-
-// packages/plugin-eslint/src/lib/meta/groups.ts
-var typeGroups = {
-  problem: {
-    slug: "problems",
-    title: "Problems",
-    description: "Code that either will cause an error or may cause confusing behavior. Developers should consider this a high priority to resolve."
-  },
-  suggestion: {
-    slug: "suggestions",
-    title: "Suggestions",
-    description: "Something that could be done in a better way but no errors will occur if the code isn't changed."
-  },
-  layout: {
-    slug: "formatting",
-    title: "Formatting",
-    description: "Primarily about whitespace, semicolons, commas, and parentheses, all the parts of the program that determine how the code looks rather than how it executes."
-  }
-};
-function groupsFromRuleTypes(rules) {
-  const allTypes = objectToKeys(typeGroups);
-  const auditSlugsMap = rules.reduce(
-    (acc, { meta: { type }, ruleId, options }) => type == null ? acc : {
-      ...acc,
-      [type]: [...acc[type] ?? [], ruleIdToSlug(ruleId, options)]
-    },
-    {}
-  );
-  return allTypes.map((type) => ({
-    ...typeGroups[type],
-    refs: auditSlugsMap[type]?.map((slug) => ({ slug, weight: 1 })) ?? []
-  })).filter((group) => group.refs.length);
-}
-function groupsFromRuleCategories(rules) {
-  const categoriesMap = rules.reduce(
-    (acc, { meta: { docs }, ruleId, options }) => {
-      const category = docs?.category;
-      if (!category) {
-        return acc;
-      }
-      const { plugin = "" } = parseRuleId(ruleId);
-      return {
-        ...acc,
-        [plugin]: {
-          ...acc[plugin],
-          [category]: [
-            ...acc[plugin]?.[category] ?? [],
-            ruleIdToSlug(ruleId, options)
-          ]
-        }
-      };
-    },
-    {}
-  );
-  const groups = Object.entries(categoriesMap).flatMap(
-    ([plugin, categories]) => Object.entries(categories).map(
-      ([category, slugs]) => ({
-        slug: `${slugify(plugin)}-${slugify(category)}`,
-        title: `${category} (${plugin})`,
-        refs: slugs.map((slug) => ({ slug, weight: 1 }))
-      })
-    )
-  );
-  return groups.toSorted((a, b) => a.slug.localeCompare(b.slug));
-}
-
-// packages/plugin-eslint/src/lib/meta/versions/flat.ts
-import { builtinRules } from "eslint/use-at-your-own-risk";
-import { isAbsolute, join as join2 } from "node:path";
-import { pathToFileURL } from "node:url";
-async function loadRulesForFlatConfig({
-  eslintrc
-}) {
-  const config = eslintrc ? await loadConfigByPath(eslintrc) : await loadConfigByDefaultLocation();
-  const configs = toArray(config);
-  const rules = findEnabledRulesWithOptions(configs);
-  return rules.map((rule) => {
-    const meta = findRuleMeta(rule.ruleId, configs);
-    if (!meta) {
-      ui().logger.warning(`Cannot find metadata for rule ${rule.ruleId}`);
-      return null;
-    }
-    return { ...rule, meta };
-  }).filter(exists);
-}
-async function loadConfigByDefaultLocation() {
-  const flatConfigFileNames = [
-    "eslint.config.js",
-    "eslint.config.mjs",
-    "eslint.config.cjs"
-  ];
-  const configPath = await findNearestFile(flatConfigFileNames);
-  if (configPath) {
-    return loadConfigByPath(configPath);
-  }
-  throw new Error(
-    [
-      `ESLint config file not found - expected ${flatConfigFileNames.join("/")} in ${process.cwd()} or some parent directory`,
-      "If your ESLint config is in a non-standard location, use the `eslintrc` parameter to specify the path."
-    ].join("\n")
-  );
-}
-async function loadConfigByPath(path) {
-  const absolutePath = isAbsolute(path) ? path : join2(process.cwd(), path);
-  const url = pathToFileURL(absolutePath).toString();
-  const mod = await import(url);
-  return "default" in mod ? mod.default : mod;
-}
-function findEnabledRulesWithOptions(configs) {
-  const enabledRules = configs.flatMap(({ rules }) => Object.entries(rules ?? {})).filter(([, entry]) => entry != null && !isRuleOff(entry)).map(([ruleId, entry]) => ({
-    ruleId,
-    options: entry ? optionsFromRuleEntry(entry) : []
-  }));
-  const uniqueRulesMap = new Map(
-    enabledRules.map(({ ruleId, options }) => [
-      `${ruleId}::${jsonHash(options)}`,
-      { ruleId, options }
-    ])
-  );
-  return [...uniqueRulesMap.values()];
-}
-function findRuleMeta(ruleId, configs) {
-  const { plugin, name: name2 } = parseRuleId(ruleId);
-  if (!plugin) {
-    return findBuiltinRuleMeta(name2);
-  }
-  return findPluginRuleMeta(plugin, name2, configs);
-}
-function findBuiltinRuleMeta(name2) {
-  const rule = builtinRules.get(name2);
-  return rule?.meta;
-}
-function findPluginRuleMeta(plugin, name2, configs) {
-  const config = configs.find(({ plugins = {} }) => plugin in plugins);
-  const rule = config?.plugins?.[plugin]?.rules?.[name2];
-  if (typeof rule === "function") {
-    ui().logger.warning(
-      `Cannot parse metadata for rule ${plugin}/${name2}, plugin registers it as a function`
-    );
-    return void 0;
-  }
-  return rule?.meta;
-}
-
-// packages/plugin-eslint/src/lib/setup.ts
-import { ESLint } from "eslint";
-async function setupESLint(eslintrc) {
-  const eslintConstructor = await loadESLint();
-  return new eslintConstructor({
-    overrideConfigFile: eslintrc,
-    errorOnUnmatchedPattern: false
-  });
-}
-async function loadESLint() {
-  const eslint = await import("eslint");
-  if ("loadESLint" in eslint && typeof eslint.loadESLint === "function") {
-    return await eslint.loadESLint();
-  }
-  return ESLint;
-}
-
-// packages/plugin-eslint/src/lib/meta/versions/legacy.ts
-async function loadRulesForLegacyConfig({
-  eslintrc,
-  patterns
-}) {
-  const eslint = await setupESLint(eslintrc);
-  const configs = await toArray(patterns).reduce(
-    async (acc, pattern) => [
-      ...await acc,
-      await eslint.calculateConfigForFile(pattern)
-    ],
-    Promise.resolve([])
-  );
-  const rulesIds = distinct(
-    configs.flatMap((config) => Object.keys(config.rules ?? {}))
-  );
-  const rulesMeta = eslint.getRulesMetaForResults([
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    {
-      messages: rulesIds.map((ruleId) => ({ ruleId })),
-      suppressedMessages: []
-    }
-  ]);
-  return configs.flatMap((config) => Object.entries(config.rules ?? {})).map(([ruleId, ruleEntry]) => {
-    if (ruleEntry == null || isRuleOff(ruleEntry)) {
-      return null;
-    }
-    const meta = rulesMeta[ruleId];
-    if (!meta) {
-      ui().logger.warning(`Metadata not found for ESLint rule ${ruleId}`);
-      return null;
-    }
-    const options = optionsFromRuleEntry(ruleEntry);
-    return {
-      ruleId,
-      meta,
-      options
-    };
-  }).filter(exists);
-}
-
-// packages/plugin-eslint/src/lib/meta/versions/detect.ts
-import { ESLint as ESLint2 } from "eslint";
-async function detectConfigVersion() {
-  if (process.env["ESLINT_USE_FLAT_CONFIG"] === "true") {
-    return "flat";
-  }
-  if (process.env["ESLINT_USE_FLAT_CONFIG"] === "false") {
-    return "legacy";
-  }
-  if (ESLint2.version.startsWith("8.")) {
-    if (await fileExists("eslint.config.js")) {
-      return "flat";
-    }
-    return "legacy";
-  }
-  return "flat";
-}
-
-// packages/plugin-eslint/src/lib/meta/versions/index.ts
-function selectRulesLoader(version2) {
-  switch (version2) {
-    case "flat":
-      return loadRulesForFlatConfig;
-    case "legacy":
-      return loadRulesForLegacyConfig;
-  }
-}
-
-// packages/plugin-eslint/src/lib/meta/rules.ts
-async function listRules(targets) {
-  const version2 = await detectConfigVersion();
-  const loadRulesMap = selectRulesLoader(version2);
-  const rulesMap = await targets.reduce(async (acc, target) => {
-    const map = await acc;
-    const rules = await loadRulesMap(target);
-    return rules.reduce(mergeRuleIntoMap, map);
-  }, Promise.resolve({}));
-  return Object.values(rulesMap).flatMap(Object.values);
-}
-function mergeRuleIntoMap(map, rule) {
-  return {
-    ...map,
-    [rule.ruleId]: {
-      ...map[rule.ruleId],
-      [jsonHash(rule.options)]: rule
-    }
-  };
-}
-
-// packages/plugin-eslint/src/lib/meta/transform.ts
-function ruleToAudit({ ruleId, meta, options }) {
-  const name2 = ruleId.split("/").at(-1) ?? ruleId;
-  const plugin = name2 === ruleId ? null : ruleId.slice(0, ruleId.lastIndexOf("/"));
-  const pluginContext = plugin ? `, from _${plugin}_ plugin` : "";
-  const lines = [
-    `ESLint rule **${name2}**${pluginContext}.`,
-    ...options?.length ? ["Custom options:"] : [],
-    ...options?.map(
-      (option) => ["```json", JSON.stringify(option, null, 2), "```"].join("\n")
-    ) ?? []
-  ];
-  return {
-    slug: ruleIdToSlug(ruleId, options),
-    title: truncateTitle(meta.docs?.description ?? name2),
-    description: truncateDescription(lines.join("\n\n")),
-    ...meta.docs?.url && {
-      docsUrl: meta.docs.url
-    }
-  };
-}
-
-// packages/plugin-eslint/src/lib/meta/index.ts
-async function listAuditsAndGroups(targets) {
-  const rules = await listRules(targets);
-  const audits = rules.map(ruleToAudit);
-  const groups = [
-    ...groupsFromRuleTypes(rules),
-    ...groupsFromRuleCategories(rules)
-  ];
-  return { audits, groups };
-}
-
-// packages/plugin-eslint/src/lib/runner/index.ts
-import { writeFile } from "node:fs/promises";
-import { dirname as dirname2, join as join3 } from "node:path";
-var WORKDIR = pluginWorkDir("eslint");
-var RUNNER_OUTPUT_PATH = join3(WORKDIR, "runner-output.json");
-var PLUGIN_CONFIG_PATH = join3(
-  process.cwd(),
-  WORKDIR,
-  "plugin-config.json"
-);
-async function createRunnerConfig(scriptPath, audits, targets) {
-  const config = {
-    targets,
-    slugs: audits.map((audit) => audit.slug)
-  };
-  await ensureDirectoryExists(dirname2(PLUGIN_CONFIG_PATH));
-  await writeFile(PLUGIN_CONFIG_PATH, JSON.stringify(config));
-  return {
-    command: "node",
-    args: [filePathToCliArg(scriptPath)],
-    outputFile: RUNNER_OUTPUT_PATH
-  };
-}
-
-// packages/plugin-eslint/src/lib/eslint-plugin.ts
-async function eslintPlugin(config) {
-  const targets = eslintPluginConfigSchema.parse(config);
-  const { audits, groups } = await listAuditsAndGroups(targets);
-  const runnerScriptPath = join4(
-    fileURLToPath(dirname3(import.meta.url)),
-    "bin.js"
-  );
-  return {
-    slug: "eslint",
-    title: "ESLint",
-    icon: "eslint",
-    description: "Official Code PushUp ESLint plugin",
-    docsUrl: "https://www.npmjs.com/package/@code-pushup/eslint-plugin",
-    packageName: name,
-    version,
-    audits,
-    groups,
-    runner: await createRunnerConfig(runnerScriptPath, audits, targets)
-  };
-}
-
-// packages/plugin-eslint/src/lib/nx/filter-project-graph.ts
-function filterProjectGraph(projectGraph, exclude = []) {
-  const filteredNodes = Object.entries(
-    projectGraph.nodes
-  ).reduce(
-    (acc, [projectName, projectNode]) => exclude.includes(projectName) ? acc : { ...acc, [projectName]: projectNode },
-    {}
-  );
-  const filteredDependencies = Object.entries(projectGraph.dependencies).reduce(
-    (acc, [key, deps]) => exclude.includes(key) ? acc : { ...acc, [key]: deps },
-    {}
-  );
-  return {
-    nodes: filteredNodes,
-    dependencies: filteredDependencies,
-    version: projectGraph.version
-  };
-}
-
-// packages/plugin-eslint/src/lib/nx/utils.ts
-import { join as join5 } from "node:path";
-var ESLINT_CONFIG_EXTENSIONS = {
-  // https://eslint.org/docs/latest/use/configure/configuration-files#configuration-file-formats
-  flat: ["js", "mjs", "cjs"],
-  // https://eslint.org/docs/latest/use/configure/configuration-files-deprecated
-  legacy: ["json", "js", "cjs", "yml", "yaml"]
-};
-var ESLINT_CONFIG_NAMES = {
-  // https://eslint.org/docs/latest/use/configure/configuration-files#configuration-file-formats
-  flat: ["eslint.config"],
-  // https://eslint.org/docs/latest/use/configure/configuration-files-deprecated
-  legacy: [".eslintrc"]
-};
-var CP_ESLINT_CONFIG_NAMES = {
-  flat: [
-    "code-pushup.eslint.config",
-    "eslint.code-pushup.config",
-    "eslint.config.code-pushup",
-    "eslint.strict.config",
-    "eslint.config.strict"
-  ],
-  legacy: ["code-pushup.eslintrc", ".eslintrc.code-pushup", ".eslintrc.strict"]
-};
-async function findCodePushupEslintConfig(project, format) {
-  return findProjectFile(project, {
-    names: CP_ESLINT_CONFIG_NAMES[format],
-    extensions: ESLINT_CONFIG_EXTENSIONS[format]
-  });
-}
-async function findEslintConfig(project, format) {
-  const options = project.targets?.["lint"]?.options;
-  return options?.eslintConfig ?? await findProjectFile(project, {
-    names: ESLINT_CONFIG_NAMES[format],
-    extensions: ESLINT_CONFIG_EXTENSIONS[format]
-  });
-}
-function getLintFilePatterns(project, format) {
-  const options = project.targets?.["lint"]?.options;
-  const defaultPatterns = format === "legacy" ? `${project.root}/**/*` : project.root;
-  const patterns = options?.lintFilePatterns == null ? [defaultPatterns] : toArray(options.lintFilePatterns);
-  if (format === "legacy") {
-    return [
-      ...patterns,
-      // HACK: ESLint.calculateConfigForFile won't find rules included only for subsets of *.ts when globs used
-      // so we explicitly provide additional patterns used by @code-pushup/eslint-config to ensure those rules are included
-      // this workaround is only necessary for legacy configs (rules are detected more reliably in flat configs)
-      `${project.root}/*.spec.ts`,
-      // jest/* and vitest/* rules
-      `${project.root}/*.cy.ts`,
-      // cypress/* rules
-      `${project.root}/*.stories.ts`,
-      // storybook/* rules
-      `${project.root}/.storybook/main.ts`
-      // storybook/no-uninstalled-addons rule
-    ];
-  }
-  return patterns;
-}
-async function findProjectFile(project, file) {
-  for (const name2 of file.names) {
-    for (const ext of file.extensions) {
-      const filename = `./${project.root}/${name2}.${ext}`;
-      if (await fileExists(join5(process.cwd(), filename))) {
-        return filename;
-      }
-    }
-  }
-  return void 0;
-}
-
-// packages/plugin-eslint/src/lib/nx/projects-to-config.ts
-async function nxProjectsToConfig(projectGraph, predicate = () => true) {
-  const { readProjectsConfigurationFromProjectGraph } = await import("@nx/devkit");
-  const projectsConfiguration = readProjectsConfigurationFromProjectGraph(projectGraph);
-  const projects = Object.values(projectsConfiguration.projects).filter((project) => "lint" in (project.targets ?? {})).filter(predicate).sort((a, b) => a.root.localeCompare(b.root));
-  const format = await detectConfigVersion();
-  return Promise.all(
-    projects.map(
-      async (project) => ({
-        eslintrc: await findCodePushupEslintConfig(project, format) ?? await findEslintConfig(project, format),
-        patterns: getLintFilePatterns(project, format)
-      })
-    )
-  );
-}
-
-// packages/plugin-eslint/src/lib/nx/find-all-projects.ts
-async function eslintConfigFromAllNxProjects(options = {}) {
-  const { createProjectGraphAsync } = await import("@nx/devkit");
-  const projectGraph = await createProjectGraphAsync({ exitOnError: false });
-  const filteredProjectGraph = filterProjectGraph(
-    projectGraph,
-    options.exclude
-  );
-  return nxProjectsToConfig(filteredProjectGraph);
-}
-var eslintConfigFromNxProjects = eslintConfigFromAllNxProjects;
-
-// packages/plugin-eslint/src/lib/nx/find-project-without-deps.ts
-async function eslintConfigFromNxProject(projectName) {
-  const { createProjectGraphAsync } = await import("@nx/devkit");
-  const projectGraph = await createProjectGraphAsync({ exitOnError: false });
-  const [project] = await nxProjectsToConfig(
-    projectGraph,
-    ({ name: name2 }) => !!name2 && name2 === projectName
-  );
-  if (!project) {
-    throw new Error(`Couldn't find Nx project named "${projectName}"`);
-  }
-  return project;
-}
-
-// packages/plugin-eslint/src/lib/nx/traverse-graph.ts
-function findAllDependencies(entry, projectGraph) {
-  const results = /* @__PURE__ */ new Set();
-  const queue = [entry];
-  while (queue.length > 0) {
-    const source = queue.shift();
-    const dependencies = projectGraph.dependencies[source];
-    for (const { target } of dependencies ?? []) {
-      if (!results.has(target) && target !== entry) {
-        results.add(target);
-        queue.push(target);
-      }
-    }
-  }
-  return results;
-}
-
-// packages/plugin-eslint/src/lib/nx/find-project-with-deps.ts
-async function eslintConfigFromNxProjectAndDeps(projectName) {
-  const { createProjectGraphAsync } = await import("@nx/devkit");
-  const projectGraph = await createProjectGraphAsync({ exitOnError: false });
-  const dependencies = findAllDependencies(projectName, projectGraph);
-  return nxProjectsToConfig(
-    projectGraph,
-    (project) => !!project.name && (project.name === projectName || dependencies.has(project.name))
-  );
-}
-
-// packages/plugin-eslint/src/index.ts
-var src_default = eslintPlugin;
-export {
-  src_default as default,
-  eslintConfigFromAllNxProjects,
-  eslintConfigFromNxProject,
-  eslintConfigFromNxProjectAndDeps,
-  eslintConfigFromNxProjects
-};