import * as Schema from "effect/Schema"; import { PullRequestListEntry, PullRequestListResult } from "@t3tools/contracts";import type { PullRequestInvolvement, PullRequestListState } from "@t3tools/contracts"; export type PullRequestGroupKey = "reviewRequested" | "authored" | "others"; export interface PullRequestGroup {  readonly key: PullRequestGroupKey;  readonly label: string;  readonly entries: ReadonlyArray<PullRequestListEntry>;} /** The signed-in account per host, as the listing reports it. */export type PullRequestViewers = PullRequestListResult["viewers"]; const GROUP_LABELS: Record<PullRequestGroupKey, string> = {  reviewRequested: "Review requested",  authored: "Authored",  others: "Others",}; function normalize(value: string | null | undefined): string | null {  const trimmed = value?.trim().toLowerCase() ?? "";  return trimmed.length > 0 ? trimmed : null;} /** * Authorship is per host, not per provider kind: the same list can hold change requests from * GitHub, GitLab and a GitHub Enterprise install, and the account that owns one says nothing * about the others. */function isAuthoredByViewer(entry: PullRequestListEntry, viewers: PullRequestViewers): boolean {  const viewer = normalize(viewers[entry.host]);  return viewer !== null && normalize(entry.author?.login) === viewer;} /** Free-text filter over the fields a row actually shows, plus `#123` / `123`. */export function matchesPullRequestQuery(entry: PullRequestListEntry, query: string): boolean {  const normalizedQuery = query.trim().toLowerCase();  if (normalizedQuery.length === 0) return true;  return `#${entry.number} ${entry.title} ${entry.repository} ${entry.headBranch} ${entry.author?.login ?? ""}`    .toLowerCase()    .includes(normalizedQuery);} /** * The server returns the involvement superset for a state, so switching between the Reviewing * and Authored tabs never waits on the network. */export function filterPullRequestsByInvolvement(  entries: ReadonlyArray<PullRequestListEntry>,  viewers: PullRequestViewers,  involvement: PullRequestInvolvement,): ReadonlyArray<PullRequestListEntry> {  if (involvement === "reviewing") {    return entries.filter((entry) => entry.viewerReviewRequested);  }  if (involvement === "authored") {    return entries.filter((entry) => isAuthoredByViewer(entry, viewers));  }  return entries;} /** * The rows already read, kept only where the filters now being asked about would keep them. * * Every combination of filters is its own question to the hosts, and asking a new one is no * reason to blank the page: what has been read is narrowed here and stays until the answer for * the new question replaces it. So this may only ever drop rows — a merged pull request cannot * sit under "Open" for the round trip — and what it leaves is a subset of the answer rather than * the answer itself. * * Only the filters a row can be judged by from its own fields. Involvement is left out because * it needs to know who is signed in on each host, and the search text because searching is the * hosts' own answer; both are narrowed where that knowledge already lives. */export function narrowPullRequestsToFilters(  entries: ReadonlyArray<PullRequestListEntry>,  filters: {    readonly state: PullRequestListState;    readonly projectId: string | undefined;    readonly host: string | undefined;  },): ReadonlyArray<PullRequestListEntry> {  return entries.filter(    (entry) =>      (filters.state === "all" || entry.state === filters.state) &&      (filters.projectId === undefined || entry.projectId === filters.projectId) &&      (filters.host === undefined || entry.host === filters.host),  );} /** * Only relationships the list data actually carries: no "previously reviewed" bucket is * inferred, because the listing has no review history. */export function groupPullRequestsByInvolvement(  entries: ReadonlyArray<PullRequestListEntry>,  viewers: PullRequestViewers,): ReadonlyArray<PullRequestGroup> {  const buckets: Record<PullRequestGroupKey, PullRequestListEntry[]> = {    reviewRequested: [],    authored: [],    others: [],  };  for (const entry of entries) {    if (isAuthoredByViewer(entry, viewers)) {      buckets.authored.push(entry);    } else if (entry.viewerReviewRequested) {      buckets.reviewRequested.push(entry);    } else {      buckets.others.push(entry);    }  }  return (["reviewRequested", "authored", "others"] as const)    .filter((key) => buckets[key].length > 0)    .map((key) => ({ key, label: GROUP_LABELS[key], entries: buckets[key] }));} /** Repository plus number is unique on one host, so the host makes the key unique overall. */export function pullRequestEntryKey(entry: PullRequestListEntry): string {  return `${entry.host}:${entry.repository}#${entry.number}`;} /** * The priority groups built from the hosts' own answers rather than re-partitioned from the * paginated feed. The feed is sliced by recency, so an older authored or review-requested row * can be missing from its first page and arrive with a later one; grouping the loaded pages * would then move it above rows already read. Here the partitions come whole from their own * server-filtered reads, the feed fills "Others" in its own order, and a continuation can only * append — a row it carries that a partition already holds is dropped rather than moved. */export function partitionPullRequestsWithPriority(  entries: ReadonlyArray<PullRequestListEntry>,  authored: ReadonlyArray<PullRequestListEntry>,  reviewRequested: ReadonlyArray<PullRequestListEntry>,): ReadonlyArray<PullRequestGroup> {  const authoredByKey = new Map(authored.map((entry) => [pullRequestEntryKey(entry), entry]));  // A row can be both authored and review-requested; authored wins, as the local grouping has it.  const reviewByKey = new Map(    reviewRequested.flatMap((entry) => {      const key = pullRequestEntryKey(entry);      return authoredByKey.has(key) ? [] : [[key, entry] as const];    }),  );  const others: PullRequestListEntry[] = [];  for (const entry of entries) {    const key = pullRequestEntryKey(entry);    // The feed's copy of a partitioned row is at least as fresh — it replaces in place.    if (authoredByKey.has(key)) {      authoredByKey.set(key, entry);    } else if (reviewByKey.has(key)) {      reviewByKey.set(key, entry);    } else {      others.push(entry);    }  }  const byRecency = (left: PullRequestListEntry, right: PullRequestListEntry) =>    right.updatedAt.localeCompare(left.updatedAt);  return (    [      { key: "reviewRequested", entries: [...reviewByKey.values()].toSorted(byRecency) },      { key: "authored", entries: [...authoredByKey.values()].toSorted(byRecency) },      { key: "others", entries: others },    ] as const  )    .filter((group) => group.entries.length > 0)    .map((group) => ({ ...group, label: GROUP_LABELS[group.key] }));} export type PullRequestDiffStats = ReadonlyMap<  string,  { readonly additions: number; readonly deletions: number }>; /** * The line counts held so far, with a new batch merged on. The stats read is keyed by the rows * on screen, so adding or removing one row is a fresh query with nothing in it yet; replacing * the map would blank every count already showing for the round trip. Merging by row identity * keeps them until their replacements arrive. */export function mergePullRequestDiffStats(  previous: PullRequestDiffStats,  stats: ReadonlyArray<{    readonly projectId: string;    readonly number: number;    readonly additions: number;    readonly deletions: number;  }>,): PullRequestDiffStats {  if (stats.length === 0) return previous;  const next = new Map(previous);  for (const stat of stats) {    next.set(`${stat.projectId} ${stat.number}`, {      additions: stat.additions,      deletions: stat.deletions,    });  }  return next;} /** One page is what the list itself starts with, and all a cold start needs to look warm. */const SNAPSHOT_MAX_ENTRIES = 99; type SnapshotStorage = Pick<Storage, "getItem" | "setItem">; const snapshotStorageKey = (environmentId: string) => `t3.pullRequests.list:${environmentId}`; /** * The priority groups' own server-filtered answers, carried with the feed. An authored pull * request older than the feed's first page lives only in these, so a snapshot without them * cold-starts into an Authored group missing exactly the rows that made it worth having. */export interface PullRequestPartitionsSnapshot {  readonly authored: ReadonlyArray<PullRequestListEntry>;  readonly reviewing: ReadonlyArray<PullRequestListEntry>;} export interface PullRequestListSnapshot {  readonly scope: string;  readonly data: PullRequestListResult;  readonly partitions?: PullRequestPartitionsSnapshot | undefined;} /** * Decoded with the contract's own schema rather than trusted from a cast: storage is writable * by anything in the origin and by any past version of this app, and one malformed row would * otherwise crash the list on every reload until the key is cleared. A snapshot from before a * schema change is rejected the same way, which is exactly the cold start it would have broken. */const decodeSnapshot = Schema.decodeUnknownOption(  Schema.Struct({    scope: Schema.String,    data: PullRequestListResult,    // Optional so a snapshot written before the partitions existed still hydrates the feed.    partitions: Schema.optional(      Schema.Struct({        authored: Schema.Array(PullRequestListEntry),        reviewing: Schema.Array(PullRequestListEntry),      }),    ),  }),); /** * The last list answered for this environment, brought back across a reload. The registry the * queries live in is recreated with the renderer, so without this a revisit cold-starts into * skeletons even though almost every row is unchanged; hydrated, the stale rows render at once * and the live read reconciles them in place by key. Errors are not carried — a failure is * never cached, and yesterday's is not this morning's. */export function readPullRequestListSnapshot(  storage: SnapshotStorage | undefined,  environmentId: string,): PullRequestListSnapshot | null {  try {    const raw = storage?.getItem(snapshotStorageKey(environmentId));    if (!raw) return null;    const decoded = decodeSnapshot(JSON.parse(raw));    return decoded._tag === "Some" ? decoded.value : null;  } catch {    return null;  }} export function writePullRequestListSnapshot(  storage: SnapshotStorage | undefined,  environmentId: string,  snapshot: PullRequestListSnapshot,): void {  try {    storage?.setItem(      snapshotStorageKey(environmentId),      JSON.stringify({        scope: snapshot.scope,        data: {          ...snapshot.data,          entries: snapshot.data.entries.slice(0, SNAPSHOT_MAX_ENTRIES),          // A failure is never cached and yesterday's is not this morning's; a cursor names a          // position in a listing the host has long since forgotten.          errors: [],          nextCursors: {},        },        ...(snapshot.partitions === undefined          ? {}          : {              partitions: {                authored: snapshot.partitions.authored.slice(0, SNAPSHOT_MAX_ENTRIES),                reviewing: snapshot.partitions.reviewing.slice(0, SNAPSHOT_MAX_ENTRIES),              },            }),      }),    );  } catch {    // Storage can be full or denied; the snapshot is a convenience, not a record.  }} /** * The project scope to actually ask for. A `projectId` in the URL outlives the environment it * came from, and one from elsewhere narrows the listing to nothing — an empty page with no * visible filter explaining it, since the switcher has no such project to show as selected. So * an id the environment does not have is dropped. * * Until `projectsKnown`, the id is kept rather than dropped: an environment that has not * reported yet is not the same as one without the project, and dropping first would show every * project's pull requests for a moment before narrowing back down. */export function resolveProjectScope<Id extends string>(  projectId: Id | undefined,  projects: ReadonlyArray<{ readonly id: string }>,  projectsKnown: boolean,): Id | undefined {  if (projectId === undefined || !projectsKnown) return projectId;  return projects.some((project) => project.id === projectId) ? projectId : undefined;} /** * How well a row answers the text that was searched for, as a number to order by. * * Every host searches more than a row shows — GitHub reads bodies and commit messages, GitLab * and Bitbucket read descriptions — so a result can be a real match with nothing on the row to * show for it. Ordering those by recency alone is what puts an apparently unrelated pull request * between two obvious ones. They are still results, so they are still shown; they are shown last, * under the rows whose own words matched. * * The scale is deliberately coarse. It sorts rows into "this is the one", "this mentions it" and * "the host says so", which is as fine a judgement as the row's own fields support. */export function scorePullRequestMatch(entry: PullRequestListEntry, query: string): number {  const needle = query.trim().toLowerCase();  if (needle.length === 0) return 0;  const number = needle.replace(/^#/u, "");  // Asking for a number is asking for one pull request, and it is the answer or it is not.  if (/^\d+$/u.test(number)) return String(entry.number) === number ? 100 : 0;   const title = entry.title.toLowerCase();  const terms = needle.split(/\s+/u).filter((term) => term.length > 0);  if (title === needle) return 90;  if (title.includes(needle)) return 80;  // Every word, in any order: "wizard welcome" is still about the welcome wizard.  if (terms.length > 1 && terms.every((term) => title.includes(term))) return 70;  if (entry.headBranch.toLowerCase().includes(needle)) return 60;  if ((entry.author?.login ?? "").toLowerCase().includes(needle)) return 50;  if (entry.repository.toLowerCase().includes(needle)) return 40;  if (terms.some((term) => title.includes(term))) return 30;  // The host matched something this row does not show — a description, a comment, a commit.  return 10;} /** * Search results in the order they answer the question, most convincing first, and by recency * among equals. Only for a search: without one, a listing is a timeline and recency is the order. */export function rankPullRequestMatches(  entries: ReadonlyArray<PullRequestListEntry>,  query: string,): ReadonlyArray<PullRequestListEntry> {  if (query.trim().length === 0) return entries;  return entries.toSorted((left, right) => {    const byScore = scorePullRequestMatch(right, query) - scorePullRequestMatch(left, query);    return byScore !== 0 ? byScore : right.updatedAt.localeCompare(left.updatedAt);  });} /** * A row with the line counts that arrived after it did. Only where the host left them out — a * listing that carried them is not second-guessed — and only where they have arrived, since a row * draws perfectly well without them in the meantime. */export function withDiffStat(  entry: PullRequestListEntry,  statsByRow: ReadonlyMap<string, { readonly additions: number; readonly deletions: number }>,): PullRequestListEntry {  if (entry.additions !== 0 || entry.deletions !== 0) return entry;  const stat = statsByRow.get(`${entry.projectId} ${entry.number}`);  return stat === undefined ? entry : { ...entry, ...stat };}