ownerlens 0.1.0

package/src/report/applyCollectionControls.ts

@@ -0,0 +1,289 @@
+import { hasSearchExpression, matchesSearchExpression } from "../lib/searchFilterUtils";
+import type { ReportDetailsValue, ReportFieldDescriptor } from "./reportTypes";
+
+export type SortDirection = "asc" | "desc";
+
+export type SortRule = {
+  columnId: string;
+  direction: SortDirection;
+};
+
+export type ColumnFilter =
+  | {
+      type: "text";
+      value: string;
+    }
+  | {
+      type: "values";
+      values: string[];
+    };
+
+export type ColumnFilters = Record<string, ColumnFilter>;
+export type ColumnFilterOptions = Record<string, string[]>;
+
+type ActiveFieldFilter<TRow> = {
+  field: ReportFieldDescriptor<TRow>;
+  filter: ColumnFilter;
+};
+
+const collator = new Intl.Collator(undefined, {
+  numeric: true,
+  sensitivity: "base"
+});
+
+export function applyCollectionControls<TRow>(
+  rows: TRow[],
+  fields: ReportFieldDescriptor<TRow>[],
+  {
+    query = "",
+    filters = {},
+    sortRules = []
+  }: {
+    query?: string;
+    filters?: ColumnFilters;
+    sortRules?: SortRule[];
+  } = {}
+) {
+  const filterOptions = getConfiguredFilterOptions(fields);
+  const searchedRows = applyCollectionSearch(rows, fields, query);
+  const activeFilters = buildActiveFieldFilters(fields, filters);
+  const filteredRows = applyCollectionFieldFilters(searchedRows, activeFilters);
+  const controlledRows = applyCollectionSort(filteredRows, fields, sortRules);
+
+  logCollectionControlDebug(rows, controlledRows, activeFilters, fields, filters);
+
+  return {
+    controlledRows,
+    filterOptions
+  };
+}
+
+export function getConfiguredFilterOptions<TRow>(fields: ReportFieldDescriptor<TRow>[]): ColumnFilterOptions {
+  return Object.fromEntries(
+    fields.map((field) => [field.id, field.filter?.options ? [...field.filter.options] : []])
+  );
+}
+
+export function applyCollectionSearch<TRow>(
+  rows: TRow[],
+  fields: ReportFieldDescriptor<TRow>[],
+  query: string
+): TRow[] {
+  if (!hasSearchExpression(query)) {
+    return rows;
+  }
+
+  const searchableFields = fields.filter((field) => field.searchable !== false);
+
+  return rows.filter((row) =>
+    matchesSearchExpression(
+      searchableFields.map((field) => formatReportSearchValue(field.getValue(row))).join(" "),
+      query
+    )
+  );
+}
+
+function applyCollectionFieldFilters<TRow>(
+  rows: TRow[],
+  activeFilters: ActiveFieldFilter<TRow>[]
+): TRow[] {
+  if (activeFilters.length === 0) {
+    return rows;
+  }
+
+  return rows.filter((row) =>
+    activeFilters.every(({ field, filter }) => {
+      const fieldValue = formatControlValue(getFieldFilterValue(field, row));
+
+      if (filter.type === "values") {
+        return filter.values.includes(fieldValue);
+      }
+
+      return matchesSearchExpression(fieldValue, filter.value);
+    })
+  );
+}
+
+function getFieldFilterValue<TRow>(field: ReportFieldDescriptor<TRow>, row: TRow): unknown {
+  return field.getFilterValue ? field.getFilterValue(row) : field.getValue(row);
+}
+
+function applyCollectionSort<TRow>(
+  rows: TRow[],
+  fields: ReportFieldDescriptor<TRow>[],
+  sortRules: SortRule[]
+): TRow[] {
+  if (sortRules.length === 0) {
+    return rows;
+  }
+
+  const fieldById = new Map(fields.map((field) => [field.id, field]));
+
+  return rows
+    .map((row, index) => ({ row, index }))
+    .sort((left, right) => {
+      for (const rule of sortRules) {
+        const field = fieldById.get(rule.columnId);
+        if (!field) {
+          continue;
+        }
+
+        const result = compareValues(field.getValue(left.row), field.getValue(right.row));
+        if (result !== 0) {
+          return rule.direction === "asc" ? result : -result;
+        }
+      }
+
+      return left.index - right.index;
+    })
+    .map(({ row }) => row);
+}
+
+function buildActiveFieldFilters<TRow>(
+  fields: ReportFieldDescriptor<TRow>[],
+  filters: ColumnFilters
+): ActiveFieldFilter<TRow>[] {
+  return fields
+    .map((field) => ({
+      field,
+      filter: filters[field.id]
+    }))
+    .filter((entry): entry is ActiveFieldFilter<TRow> => isActiveFilter(entry.filter));
+}
+
+function isActiveFilter(filter: ColumnFilter | undefined): boolean {
+  if (!filter) {
+    return false;
+  }
+
+  if (filter.type === "values") {
+    return filter.values.length > 0;
+  }
+
+  return hasSearchExpression(filter.value);
+}
+
+function compareValues(left: unknown, right: unknown): number {
+  const leftText = formatControlValue(left);
+  const rightText = formatControlValue(right);
+
+  if (!leftText && !rightText) {
+    return 0;
+  }
+
+  if (!leftText) {
+    return 1;
+  }
+
+  if (!rightText) {
+    return -1;
+  }
+
+  return collator.compare(leftText, rightText);
+}
+
+export function formatControlValue(value: unknown): string {
+  if (value === null || value === undefined || value === "") {
+    return "";
+  }
+
+  if (Array.isArray(value)) {
+    return value.map(formatControlValue).filter(Boolean).join(", ");
+  }
+
+  if (typeof value === "boolean") {
+    return value ? "Yes" : "No";
+  }
+
+  return String(value);
+}
+
+export function formatReportSearchValue(value: unknown): string {
+  if (value === null || value === undefined) {
+    return "";
+  }
+
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+
+  if (Array.isArray(value)) {
+    return value.map(formatReportSearchValue).filter(Boolean).join(", ");
+  }
+
+  if (isReportDetailsValue(value)) {
+    return [
+      value.searchText,
+      value.title,
+      ...value.details.flatMap((detail) => [detail.label, detail.value])
+    ]
+      .filter(Boolean)
+      .join(" ");
+  }
+
+  return JSON.stringify(value);
+}
+
+function isReportDetailsValue(value: unknown): value is ReportDetailsValue {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    "title" in value &&
+    "details" in value &&
+    Array.isArray((value as ReportDetailsValue).details)
+  );
+}
+
+function logCollectionControlDebug<TRow>(
+  rows: TRow[],
+  controlledRows: TRow[],
+  activeFilters: ActiveFieldFilter<TRow>[],
+  fields: ReportFieldDescriptor<TRow>[],
+  filters: ColumnFilters
+): void {
+  if (!isReportTableFilterDebugEnabled()) {
+    return;
+  }
+
+  const activeFieldIds = new Set(activeFilters.map(({ field }) => field.id));
+  const debugFields = fields.filter((field) => activeFieldIds.has(field.id));
+  const controlledRowSet = new Set(controlledRows);
+
+  console.groupCollapsed(
+    `[OwnerLens table filters] ${controlledRows.length}/${rows.length} rows after ${activeFilters.length} filters`
+  );
+  console.log("filters", filters);
+  console.log(
+    "activeFilters",
+    activeFilters.map(({ field, filter }) => ({
+      columnId: field.id,
+      label: field.label,
+      filter
+    }))
+  );
+  console.table(
+    rows.map((row) => {
+      const rowRecord = row as Record<string, unknown>;
+      const debugRow: Record<string, unknown> = {
+        included: controlledRowSet.has(row),
+        id: rowRecord.id,
+        displayName: rowRecord.displayName,
+        appId: rowRecord.appId
+      };
+
+      for (const field of debugFields) {
+        debugRow[field.id] = formatControlValue(field.getValue(row));
+      }
+
+      return debugRow;
+    })
+  );
+  console.groupEnd();
+}
+
+function isReportTableFilterDebugEnabled(): boolean {
+  return (
+    typeof window !== "undefined" &&
+    window.localStorage.getItem("ownerLensDebugTableFilters") === "1"
+  );
+}

package/src/report/buildCollectionColumns.tsx

@@ -0,0 +1,38 @@
+import type { ReactNode } from "react";
+
+import type { ReportColumnHelp, ReportFieldDescriptor } from "./reportTypes";
+import type { ReportTableColumn } from "./components/reportTableControls";
+import { renderReportValue } from "./reportValueRenderers";
+
+export type ReportColumnRenderers<TRow> = Partial<Record<string, (row: TRow) => ReactNode>>;
+
+export function buildCollectionColumns<TRow>(
+  fields: ReportFieldDescriptor<TRow>[],
+  {
+    columnHelp = {},
+    renderers = {}
+  }: {
+    columnHelp?: Record<string, ReportColumnHelp>;
+    renderers?: ReportColumnRenderers<TRow>;
+  } = {}
+): ReportTableColumn<TRow>[] {
+  return fields.map((field) => ({
+    id: field.id,
+    label: field.label,
+    help: field.help ?? columnHelp[field.id],
+    filter: getColumnFilterKind(field),
+    render: renderers[field.id] ?? ((row) => renderReportValue(field, row))
+  }));
+}
+
+function getColumnFilterKind<TRow>(field: ReportFieldDescriptor<TRow>): ReportTableColumn<TRow>["filter"] {
+  if (field.filter?.kind === "multiSelect") {
+    return "multiselect";
+  }
+
+  if (field.filter?.kind === "text") {
+    return "text";
+  }
+
+  return "auto";
+}

package/src/report/components/ConfidenceBadge.tsx

@@ -0,0 +1,10 @@
+import { Badge } from "./ui/badge";
+import type { OwnerConfidence } from "../../core/ownership/types";
+
+export function ConfidenceBadge({ confidence }: { confidence: OwnerConfidence }) {
+  return (
+    <Badge className="min-w-16 justify-center capitalize" variant={confidence}>
+      {confidence}
+    </Badge>
+  );
+}

package/src/report/components/EvidenceList.test.ts

@@ -0,0 +1,25 @@
+import React from "react";
+import { renderToStaticMarkup } from "react-dom/server";
+
+import { EvidenceList } from "./EvidenceList.tsx";
+
+test("renders evidence users and timestamps", () => {
+  const html = renderToStaticMarkup(
+    React.createElement(EvidenceList, {
+      evidence: [
+        {
+          user: "owner@example.com",
+          date: "2026-04-30T12:34:56.000Z"
+        },
+        {
+          user: "ownerGroup=platform@example.com",
+          date: null
+        }
+      ]
+    })
+  );
+
+  expect(html).toMatch(/owner@example\.com/);
+  expect(html).toMatch(/>2026-04-30T12:34:56\.000Z<\/time>/);
+  expect(html).toMatch(/ownerGroup=platform@example\.com/);
+});

package/src/report/components/EvidenceList.tsx

@@ -0,0 +1,52 @@
+import type { OwnerEvidence } from "../types";
+
+type EvidenceListProps = {
+  evidence: OwnerEvidence[];
+  canDisable?: boolean;
+  onDisabledChange?: (entry: OwnerEvidence, disabled: boolean) => void;
+};
+
+export function EvidenceList({ evidence, canDisable = false, onDisabledChange }: EvidenceListProps) {
+  if (evidence.length === 0) {
+    return "-";
+  }
+
+  return (
+    <div className="flex flex-col gap-1">
+      {evidence.map((entry) => {
+        const isEmailCandidate = entry.user.includes("@");
+
+        return (
+          <div
+            className={
+              entry.disabled
+                ? "flex flex-col gap-0.5 rounded bg-muted px-1.5 py-1 leading-snug text-muted-foreground"
+                : "flex flex-col gap-0.5 rounded bg-emerald-100 px-1.5 py-1 leading-snug text-emerald-800"
+            }
+            key={`${entry.user}:${entry.date ?? ""}`}
+          >
+            <div className="flex items-start gap-1.5">
+              {isEmailCandidate && canDisable && onDisabledChange ? (
+                <button
+                  aria-label={`${entry.disabled ? "Enable" : "Disable"} ${entry.user}`}
+                  className="mt-0.5 inline-flex h-5 w-5 shrink-0 items-center justify-center rounded border border-border bg-background text-xs leading-none text-muted-foreground hover:text-foreground"
+                  title={entry.disabled ? "Enable owner candidate" : "Disable owner candidate"}
+                  type="button"
+                  onClick={() => onDisabledChange(entry, !entry.disabled)}
+                >
+                  x
+                </button>
+              ) : null}
+              <span className={entry.disabled ? "line-through" : undefined}>{entry.user}</span>
+            </div>
+            {entry.date ? (
+              <time className="text-xs text-muted-foreground" dateTime={entry.date}>
+                {entry.date}
+              </time>
+            ) : null}
+          </div>
+        );
+      })}
+    </div>
+  );
+}