dslinter 0.1.0 → 0.1.2

package/src/playground/buildPlaygroundEntriesFromReport.test.ts

@@ -0,0 +1,53 @@
+import { describe, expect, it } from "vitest";
+import type { PlaygroundEntry } from "../types/playground";
+import type { WorkspaceReport } from "../types/report";
+import { resolvePlaygroundEntry } from "./buildPlaygroundEntriesFromReport";
+
+const entries: PlaygroundEntry[] = [
+  {
+    id: "PrimaryButton",
+    meta: { id: "PrimaryButton", title: "PrimaryButton" },
+    modulePath: "@dslint-scan/src/components/PrimaryButton.tsx",
+    controls: [],
+    Preview: () => null,
+  },
+];
+
+describe("resolvePlaygroundEntry", () => {
+  it("finds by catalog export name id", () => {
+    expect(resolvePlaygroundEntry(entries, "PrimaryButton")).toBe(entries[0]);
+  });
+
+  it("returns undefined for unknown name", () => {
+    expect(resolvePlaygroundEntry(entries, "Missing")).toBeUndefined();
+  });
+});
+
+describe("playground catalog id alignment", () => {
+  it("report playgrounds use export_name as id", () => {
+    const report: WorkspaceReport = {
+      root: "/repo",
+      files: [],
+      findings: [],
+      scores: {
+        system_health: 0,
+        token_adoption: 0,
+        component_adoption: 0,
+        ux_consistency: 0,
+      },
+      ownership: [],
+      duplicate_components: [],
+      usage_by_component: [],
+      playgrounds: [
+        {
+          id: "Card",
+          export_name: "Card",
+          rel_path: "src/components/nested/DuplicateCardA.tsx",
+          declared_props: [],
+        },
+      ],
+    };
+    expect(report.playgrounds?.[0]?.id).toBe("Card");
+    expect(report.playgrounds?.[0]?.export_name).toBe("Card");
+  });
+});

package/src/playground/buildPlaygroundEntriesFromReport.ts

@@ -0,0 +1,389 @@
+import { createElement, type ComponentType } from "react";
+import type { PlaygroundArgs, PlaygroundControl } from "../types/controls";
+import type { DeclaredPropKind, PlaygroundSpec, WorkspaceReport } from "../types/report";
+import type { PlaygroundEntry, PlaygroundMeta, PlaygroundPreviewComponent } from "../types/playground";
+import {
+  defaultEmbedGlobKeyFromRelPath,
+  diagnosePlaygroundJoinSkips,
+  logPlaygroundJoinSkips,
+  type PlaygroundJoinSkip,
+} from "./playgroundJoin";
+
+export type BuildPlaygroundModules = Record<string, Record<string, unknown>>;
+
+export type BuildPlaygroundOptions = {
+  /** Maps report `rel_path` to a key in `modules` (from `import.meta.glob`). */
+  globKeyFromRelPath?: (relPath: string) => string;
+  controlOverrides?: Record<string, PlaygroundControl[]>;
+  staticDefaults?: Record<string, Record<string, unknown>>;
+  /** When true (default in Vite dev), log specs that failed to join to `modules`. */
+  logJoinSkips?: boolean;
+};
+
+export type BuildPlaygroundResult = {
+  entries: PlaygroundEntry[];
+  skipped: PlaygroundJoinSkip[];
+};
+
+function defaultGlobKeyFromRelPath(relPath: string): string {
+  return defaultEmbedGlobKeyFromRelPath(relPath);
+}
+
+export type { PlaygroundJoinSkip, PlaygroundJoinSkipReason } from "./playgroundJoin";
+export {
+  defaultConsumerGlobKeyFromRelPath,
+  defaultEmbedGlobKeyFromRelPath,
+  diagnosePlaygroundJoinSkips,
+  findPlaygroundJoinSkip,
+  findPlaygroundSpec,
+  logPlaygroundJoinSkips,
+} from "./playgroundJoin";
+
+function coerceDeclaredPropKind(v: unknown): DeclaredPropKind | undefined {
+  if (v === "boolean" || v === "string" || v === "number" || v === "unknown")
+    return v;
+  return undefined;
+}
+
+function normalizedPropKinds(
+  raw: PlaygroundSpec["declared_prop_kinds"],
+): Partial<Record<string, DeclaredPropKind>> | undefined {
+  if (!raw || typeof raw !== "object") return undefined;
+  const out: Partial<Record<string, DeclaredPropKind>> = {};
+  for (const [k, v] of Object.entries(raw as Record<string, unknown>)) {
+    const ck = coerceDeclaredPropKind(v);
+    if (ck && ck !== "unknown") out[k] = ck;
+  }
+  return Object.keys(out).length ? out : undefined;
+}
+
+function isLikelyBooleanProp(name: string): boolean {
+  const n = name.toLowerCase();
+  if (n === "disabled" || n === "loading") return true;
+  if (n.startsWith("is") || n.startsWith("has")) return true;
+  if (n.startsWith("show") || n.startsWith("hide")) return true;
+  return false;
+}
+
+function defaultStringForProp(key: string): string {
+  if (key === "href") return "#!/governance";
+  const k = key.toLowerCase();
+  if (
+    k === "title" ||
+    k === "label" ||
+    k === "text" ||
+    k === "name" ||
+    k === "heading"
+  ) {
+    return "Label";
+  }
+  return key;
+}
+
+function controlsFromDeclaredProps(
+  declaredProps: string[],
+  propKinds?: Partial<Record<string, DeclaredPropKind>>,
+): PlaygroundControl[] {
+  const skip = new Set(["key", "ref"]);
+  const out: PlaygroundControl[] = [];
+  for (const key of declaredProps) {
+    if (skip.has(key)) continue;
+    if (key === "children") {
+      out.push({
+        key: "children",
+        label: "children",
+        type: "string",
+        default: "",
+        placeholder: "Preview if empty",
+      });
+      continue;
+    }
+    const kind = propKinds?.[key];
+    if (kind === "boolean") {
+      out.push({ key, label: key, type: "boolean", default: false });
+    } else if (kind === "number") {
+      out.push({ key, label: key, type: "number", default: 0 });
+    } else if (kind === "string") {
+      out.push({
+        key,
+        label: key,
+        type: "string",
+        default: defaultStringForProp(key),
+        placeholder: key,
+      });
+    } else if (isLikelyBooleanProp(key)) {
+      out.push({ key, label: key, type: "boolean", default: false });
+    } else {
+      out.push({
+        key,
+        label: key,
+        type: "string",
+        default: defaultStringForProp(key),
+        placeholder: key,
+      });
+    }
+  }
+  return out;
+}
+
+function controlsForSpec(
+  catalogId: string,
+  declaredProps: string[],
+  propKinds: Partial<Record<string, DeclaredPropKind>> | undefined,
+  controlOverrides: Record<string, PlaygroundControl[]>,
+): PlaygroundControl[] {
+  const override = controlOverrides[catalogId];
+  if (override) return override;
+  return controlsFromDeclaredProps(declaredProps, propKinds);
+}
+
+function valuesToComponentProps(
+  declaredProps: string[],
+  values: PlaygroundArgs,
+  propKinds?: Partial<Record<string, DeclaredPropKind>>,
+): Record<string, unknown> {
+  const o: Record<string, unknown> = {};
+  for (const key of declaredProps) {
+    if (key === "key" || key === "ref") continue;
+    if (key === "children") {
+      const v = values.children;
+      o[key] =
+        v !== undefined && v !== null && String(v).length > 0
+          ? String(v)
+          : "Preview";
+      continue;
+    }
+    const kind = propKinds?.[key];
+    if (kind === "boolean") {
+      o[key] = Boolean(values[key]);
+      continue;
+    }
+    if (kind === "number") {
+      const raw = values[key];
+      const n = typeof raw === "number" ? raw : Number(raw);
+      o[key] = Number.isFinite(n) ? n : 0;
+      continue;
+    }
+    if (kind === "string") {
+      o[key] = values[key];
+      continue;
+    }
+    if (isLikelyBooleanProp(key)) {
+      o[key] = Boolean(values[key]);
+      continue;
+    }
+    o[key] = values[key];
+  }
+  return o;
+}
+
+function mergeStaticDefaults(
+  fromValues: Record<string, unknown>,
+  staticDefaults: Record<string, unknown>,
+): Record<string, unknown> {
+  const o = { ...fromValues };
+  for (const [k, v] of Object.entries(staticDefaults)) {
+    const cur = o[k];
+    if (cur === undefined || cur === "") o[k] = v;
+  }
+  return o;
+}
+
+function getExport(
+  mod: Record<string, unknown>,
+  exportName: string,
+): ComponentType<Record<string, unknown>> | undefined {
+  const x = mod[exportName];
+  if (typeof x === "function")
+    return x as ComponentType<Record<string, unknown>>;
+  return undefined;
+}
+
+function jsxTextOrStringifyExpression(text: string): string {
+  if (!/[<>{}&]/.test(text)) return text;
+  return `{JSON.stringify(${JSON.stringify(text)})}`;
+}
+
+function valueMatchesPlaygroundDefault(
+  control: PlaygroundControl,
+  value: string | number | boolean | undefined,
+): boolean {
+  switch (control.type) {
+    case "boolean":
+      return Boolean(value) === control.default;
+    case "number": {
+      const n = typeof value === "number" ? value : Number(value);
+      return Number.isFinite(n) && n === control.default;
+    }
+    case "string":
+    case "select":
+      return String(value ?? "") === String(control.default);
+    default:
+      return false;
+  }
+}
+
+function genericUsageSnippet(
+  exportName: string,
+  values: PlaygroundArgs,
+  controls: PlaygroundControl[],
+): string {
+  const controlByKey = new Map(controls.map((c) => [c.key, c] as const));
+
+  const emitPropKey = (key: string): boolean => {
+    const c = controlByKey.get(key);
+    if (!c) return true;
+    return !valueMatchesPlaygroundDefault(c, values[key]);
+  };
+
+  const hasChildrenKey = Object.prototype.hasOwnProperty.call(
+    values,
+    "children",
+  );
+  const childVal = hasChildrenKey ? values.children : undefined;
+
+  const propKeys = Object.keys(values)
+    .filter((k) => k !== "children")
+    .filter(emitPropKey)
+    .sort((a, b) => a.localeCompare(b));
+  const propsStr = propKeys
+    .map((k) => `${k}={${JSON.stringify(values[k])}}`)
+    .join(" ");
+
+  const openWithProps =
+    propKeys.length === 0 ? `<${exportName}` : `<${exportName} ${propsStr}`;
+
+  if (!hasChildrenKey) {
+    return propKeys.length === 0 ? `<${exportName} />` : `${openWithProps} />`;
+  }
+
+  if (typeof childVal === "boolean") {
+    const allKeys = Object.keys(values)
+      .filter(emitPropKey)
+      .sort((a, b) => a.localeCompare(b));
+    const allProps = allKeys
+      .map((k) => `${k}={${JSON.stringify(values[k])}}`)
+      .join(" ");
+    return allKeys.length === 0
+      ? `<${exportName} />`
+      : `<${exportName} ${allProps} />`;
+  }
+
+  const asText =
+    typeof childVal === "number" ? String(childVal) : String(childVal ?? "");
+  if (asText.length === 0) {
+    return propKeys.length === 0 ? `<${exportName} />` : `${openWithProps} />`;
+  }
+
+  const body = jsxTextOrStringifyExpression(asText);
+  return propKeys.length === 0
+    ? `<${exportName}>${body}</${exportName}>`
+    : `${openWithProps}>${body}</${exportName}>`;
+}
+
+/** Sidebar / URL id — matches catalog component names (`export_name`). */
+export function playgroundCatalogId(spec: PlaygroundSpec): string {
+  return spec.export_name;
+}
+
+/** Resolve a catalog name to a loaded playground entry. */
+export function resolvePlaygroundEntry(
+  entries: PlaygroundEntry[],
+  catalogName: string,
+): PlaygroundEntry | undefined {
+  const byId = entries.find((e) => e.id === catalogName);
+  if (byId) return byId;
+  return entries.find(
+    (e) =>
+      e.meta.title === catalogName ||
+      e.modulePath.includes(`/${catalogName}.`) ||
+      e.modulePath.endsWith(`/${catalogName}.tsx`) ||
+      e.modulePath.endsWith(`/${catalogName}.jsx`),
+  );
+}
+
+/** Build playground entries from report specs + eager Vite modules. */
+export function buildPlaygroundEntriesFromReportWithSkips(
+  report: WorkspaceReport | null | undefined,
+  modules: BuildPlaygroundModules,
+  options: BuildPlaygroundOptions = {},
+): BuildPlaygroundResult {
+  const specs = report?.playgrounds;
+  if (!specs?.length) return { entries: [], skipped: [] };
+
+  const globKeyFromRelPath =
+    options.globKeyFromRelPath ?? defaultGlobKeyFromRelPath;
+  const controlOverrides = options.controlOverrides ?? {};
+  const staticDefaultsMap = options.staticDefaults ?? {};
+
+  const skipped = diagnosePlaygroundJoinSkips(report, modules, {
+    globKeyFromRelPath,
+  });
+  const shouldLog =
+    options.logJoinSkips ??
+    (typeof import.meta !== "undefined" && Boolean(import.meta.env?.DEV));
+  if (shouldLog) logPlaygroundJoinSkips(skipped);
+
+  const out: PlaygroundEntry[] = [];
+  for (const spec of specs) {
+    const globKey = globKeyFromRelPath(spec.rel_path);
+    const mod = modules[globKey];
+    if (!mod) continue;
+    const Cmp = getExport(mod, spec.export_name);
+    if (!Cmp) continue;
+
+    const catalogId = playgroundCatalogId(spec);
+    const declared = spec.declared_props ?? [];
+    const propKinds = normalizedPropKinds(spec.declared_prop_kinds);
+    const controls = controlsForSpec(
+      catalogId,
+      declared,
+      propKinds,
+      controlOverrides,
+    );
+    const staticDefaults =
+      staticDefaultsMap[catalogId] ??
+      staticDefaultsMap[spec.id] ??
+      {};
+
+    function Preview({ values }: { values: PlaygroundArgs }) {
+      const fromValues = valuesToComponentProps(declared, values, propKinds);
+      const merged = mergeStaticDefaults(fromValues, staticDefaults);
+      return createElement(Cmp, merged);
+    }
+
+    const meta: PlaygroundMeta = {
+      id: catalogId,
+      title: catalogId,
+      ...(spec.group ? { group: spec.group } : {}),
+    };
+
+    out.push({
+      id: catalogId,
+      meta,
+      modulePath: globKey,
+      controls,
+      usageSnippet: (values) =>
+        genericUsageSnippet(spec.export_name, values, controls),
+      Preview: Preview as PlaygroundPreviewComponent,
+    });
+  }
+
+  out.sort((a, b) => {
+    const ga = a.meta.group ?? "";
+    const gb = b.meta.group ?? "";
+    if (ga !== gb) return ga.localeCompare(gb);
+    return a.meta.title.localeCompare(b.meta.title);
+  });
+  return { entries: out, skipped };
+}
+
+/** Build playground entries from report specs + eager Vite modules. */
+export function buildPlaygroundEntriesFromReport(
+  report: WorkspaceReport | null | undefined,
+  modules: BuildPlaygroundModules,
+  options: BuildPlaygroundOptions = {},
+): PlaygroundEntry[] {
+  return buildPlaygroundEntriesFromReportWithSkips(report, modules, options)
+    .entries;
+}

package/src/playground/createPlaygroundRegistry.ts

@@ -0,0 +1,48 @@
+import type { PlaygroundEntry } from "../types/playground";
+import type { WorkspaceReport } from "../types/report";
+import {
+  buildPlaygroundEntriesFromReportWithSkips,
+  type BuildPlaygroundModules,
+  type BuildPlaygroundOptions,
+  type BuildPlaygroundResult,
+} from "./buildPlaygroundEntriesFromReport";
+import { defaultConsumerGlobKeyFromRelPath } from "./playgroundJoin";
+
+export type CreatePlaygroundRegistryOptions = Omit<
+  BuildPlaygroundOptions,
+  "globKeyFromRelPath"
+> & {
+  /** Defaults to {@link defaultConsumerGlobKeyFromRelPath} (`src/playground` → `src/components`). */
+  globKeyFromRelPath?: (relPath: string) => string;
+};
+
+/**
+ * Factory for consumer apps: pass eager `import.meta.glob` modules from your Vite app.
+ *
+ * @example
+ * ```ts
+ * const modules = import.meta.glob("../components/**\/*.{tsx,jsx}", { eager: true });
+ * export const buildPlaygroundEntries = createPlaygroundRegistry(modules);
+ * ```
+ */
+export function createPlaygroundRegistry(
+  modules: BuildPlaygroundModules,
+  options: CreatePlaygroundRegistryOptions = {},
+): (report: WorkspaceReport | null | undefined) => BuildPlaygroundResult {
+  const globKeyFromRelPath =
+    options.globKeyFromRelPath ?? defaultConsumerGlobKeyFromRelPath;
+  return (report) =>
+    buildPlaygroundEntriesFromReportWithSkips(report, modules, {
+      ...options,
+      globKeyFromRelPath,
+    });
+}
+
+/** Convenience when you only need entries (skips are still logged in dev). */
+export function createPlaygroundRegistryEntriesOnly(
+  modules: BuildPlaygroundModules,
+  options: CreatePlaygroundRegistryOptions = {},
+): (report: WorkspaceReport | null | undefined) => PlaygroundEntry[] {
+  const build = createPlaygroundRegistry(modules, options);
+  return (report) => build(report).entries;
+}

package/src/playground/playgroundJoin.test.ts

@@ -0,0 +1,74 @@
+import { describe, expect, it } from "vitest";
+import type { WorkspaceReport } from "../types/report";
+import {
+  defaultConsumerGlobKeyFromRelPath,
+  diagnosePlaygroundJoinSkips,
+} from "./playgroundJoin";
+import { buildPlaygroundEntriesFromReportWithSkips } from "./buildPlaygroundEntriesFromReport";
+
+describe("defaultConsumerGlobKeyFromRelPath", () => {
+  it("maps nested ui paths for src/playground registry", () => {
+    expect(defaultConsumerGlobKeyFromRelPath("src/components/ui/button.tsx")).toBe(
+      "../components/ui/button.tsx",
+    );
+  });
+
+  it("maps flat component paths", () => {
+    expect(defaultConsumerGlobKeyFromRelPath("src/components/Button.tsx")).toBe(
+      "../components/Button.tsx",
+    );
+  });
+});
+
+describe("diagnosePlaygroundJoinSkips", () => {
+  const report: WorkspaceReport = {
+    root: "/repo",
+    files: [],
+    findings: [],
+    scores: {
+      system_health: 0,
+      token_adoption: 0,
+      component_adoption: 0,
+      ux_consistency: 0,
+    },
+    ownership: [],
+    duplicate_components: [],
+    usage_by_component: [],
+    playgrounds: [
+      {
+        id: "Button",
+        export_name: "Button",
+        rel_path: "src/components/ui/button.tsx",
+        declared_props: [],
+      },
+    ],
+  };
+
+  it("flags module_not_found when glob key is missing", () => {
+    const skipped = diagnosePlaygroundJoinSkips(report, {}, {
+      globKeyFromRelPath: defaultConsumerGlobKeyFromRelPath,
+    });
+    expect(skipped).toHaveLength(1);
+    expect(skipped[0]?.reason).toBe("module_not_found");
+    expect(skipped[0]?.globKey).toBe("../components/ui/button.tsx");
+  });
+
+  it("joins when module and export exist", () => {
+    const key = defaultConsumerGlobKeyFromRelPath("src/components/ui/button.tsx");
+    const modules = {
+      [key]: {
+        Button: function Button() {
+          return null;
+        },
+      },
+    };
+    const { entries, skipped } = buildPlaygroundEntriesFromReportWithSkips(
+      report,
+      modules,
+      { globKeyFromRelPath: defaultConsumerGlobKeyFromRelPath, logJoinSkips: false },
+    );
+    expect(skipped).toHaveLength(0);
+    expect(entries).toHaveLength(1);
+    expect(entries[0]?.id).toBe("Button");
+  });
+});

package/src/playground/playgroundJoin.ts

@@ -0,0 +1,116 @@
+import type { PlaygroundSpec, WorkspaceReport } from "../types/report";
+import type { BuildPlaygroundModules, BuildPlaygroundOptions } from "./buildPlaygroundEntriesFromReport";
+
+export type PlaygroundJoinSkipReason = "module_not_found" | "export_not_found";
+
+export type PlaygroundJoinSkip = {
+  export_name: string;
+  rel_path: string;
+  globKey: string;
+  reason: PlaygroundJoinSkipReason;
+};
+
+/**
+ * Maps report `rel_path` to a Vite `import.meta.glob` key when the registry lives in
+ * `src/playground/` and components live under `src/components/`.
+ *
+ * Example: `src/components/ui/button.tsx` → `../components/ui/button.tsx`
+ */
+export function defaultConsumerGlobKeyFromRelPath(relPath: string): string {
+  const trimmed = relPath.replace(/^\/+/, "").replace(/^src\//, "");
+  return `../${trimmed}`;
+}
+
+export function defaultEmbedGlobKeyFromRelPath(relPath: string): string {
+  const trimmed = relPath.replace(/^\/+/, "");
+  return `@dslint-scan/${trimmed}`;
+}
+
+function getExport(
+  mod: Record<string, unknown>,
+  exportName: string,
+): unknown {
+  const x = mod[exportName];
+  return typeof x === "function" ? x : undefined;
+}
+
+/**
+ * For each playground spec, explain why it would not join to `modules`.
+ */
+export function diagnosePlaygroundJoinSkips(
+  report: WorkspaceReport | null | undefined,
+  modules: BuildPlaygroundModules,
+  options: Pick<BuildPlaygroundOptions, "globKeyFromRelPath"> = {},
+): PlaygroundJoinSkip[] {
+  const specs = report?.playgrounds;
+  if (!specs?.length) return [];
+
+  const globKeyFromRelPath =
+    options.globKeyFromRelPath ?? defaultEmbedGlobKeyFromRelPath;
+
+  const skipped: PlaygroundJoinSkip[] = [];
+  for (const spec of specs) {
+    const globKey = globKeyFromRelPath(spec.rel_path);
+    const mod = modules[globKey];
+    if (!mod) {
+      skipped.push({
+        export_name: spec.export_name,
+        rel_path: spec.rel_path,
+        globKey,
+        reason: "module_not_found",
+      });
+      continue;
+    }
+    if (!getExport(mod, spec.export_name)) {
+      skipped.push({
+        export_name: spec.export_name,
+        rel_path: spec.rel_path,
+        globKey,
+        reason: "export_not_found",
+      });
+    }
+  }
+  return skipped;
+}
+
+/**
+ * Dev-only: log skipped playground joins (module glob / export name mismatches).
+ */
+export function logPlaygroundJoinSkips(
+  skipped: PlaygroundJoinSkip[],
+  options?: { label?: string },
+): void {
+  if (!skipped.length) return;
+  if (typeof import.meta !== "undefined" && !import.meta.env?.DEV) return;
+
+  const label = options?.label ?? "[dslinter] playground preview";
+  console.warn(
+    `${label}: ${skipped.length} component(s) have a scan row but no live preview.`,
+  );
+  for (const s of skipped.slice(0, 12)) {
+    const hint =
+      s.reason === "module_not_found"
+        ? `add import.meta.glob key "${s.globKey}" (from rel_path "${s.rel_path}")`
+        : `export function ${s.export_name} from "${s.rel_path}"`;
+    console.warn(`  - ${s.export_name}: ${hint}`);
+  }
+  if (skipped.length > 12) {
+    console.warn(`  … and ${skipped.length - 12} more`);
+  }
+}
+
+export function findPlaygroundSpec(
+  report: WorkspaceReport | null | undefined,
+  componentId: string,
+): PlaygroundSpec | undefined {
+  return report?.playgrounds?.find(
+    (p) => p.export_name === componentId || p.id === componentId,
+  );
+}
+
+export function findPlaygroundJoinSkip(
+  skipped: PlaygroundJoinSkip[] | undefined,
+  componentId: string,
+): PlaygroundJoinSkip | undefined {
+  return skipped?.find((s) => s.export_name === componentId);
+}

package/src/report/findingsForComponent.ts

@@ -0,0 +1,24 @@
+import { aggregateDefinitions } from "../dashboard/aggregate";
+import type { LintFinding, WorkspaceReport } from "../types/report";
+import { pathsMatch } from "./modulePathMatch";
+
+/** Findings on any file where the component is defined. */
+export function findingsForComponent(
+  report: WorkspaceReport | null | undefined,
+  componentName: string,
+): LintFinding[] {
+  if (!report) return [];
+  const defs = aggregateDefinitions(report);
+  const sites = defs.get(componentName) ?? [];
+  if (sites.length === 0) return [];
+
+  const rows = report.findings.filter((f) =>
+    sites.some((site) => pathsMatch(f.path, site.path)),
+  );
+  return [...rows].sort(
+    (a, b) =>
+      a.path.localeCompare(b.path) ||
+      (a.line ?? 0) - (b.line ?? 0) ||
+      a.rule_id.localeCompare(b.rule_id),
+  );
+}