The projects table sits in a min-width-0 host so fitColumns can drop columns. A live refresh re-reads only the changed, expanded projects and keeps as many versions as were shown (Load more included). Version pages ask for the summary form, so the panel no longer downloads settings it never shows. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
255 lines
12 KiB
JavaScript
255 lines
12 KiB
JavaScript
// The projects of a sequence on the panel (owner review 2, R8): each project's name, Main marked, its newest version and who
|
|
// changed it last, its versions on demand, and Rename and Delete for the projects other than Main. Nothing here edits a
|
|
// project's settings: the desktop does, in its workspace, and pushes its versions here. The list follows projectChanged.
|
|
import { t, plural, applyStrings } from "../../i18n.js";
|
|
import { escapeHtml, attr, formatNumber, formatDateTime, toast, errorText, confirmDialog, formDialog, emptyState, markInvalid, redraw, fitColumns } from "../../ui.js";
|
|
|
|
/** Versions read at a time when a project is opened, and with each Load more. */
|
|
const VERSION_PAGE = 20;
|
|
/** The most versions one read of them gives (ProjectEndpoints.MaxPage): a refresh reads again as many as are shown, up to this. */
|
|
const MAX_PAGE = 200;
|
|
/** A project name, as the server takes it (ProjectService.MaxNameLength). */
|
|
const MAX_NAME = 60;
|
|
/** The name every sequence's Main project is made with; shown in the panel's language. */
|
|
const MAIN_NAME = "Main";
|
|
/** How long after a projectChanged the projects are read again; one read covers every change meanwhile. */
|
|
const AFTER_CHANGE_MS = 500;
|
|
/** Version kinds the panel names (ProjectVersionKinds). */
|
|
const KINDS = { commit: "Commit", merge: "Merge", restore: "Restore", imported: "Imported", external: "External" };
|
|
|
|
/**
|
|
* Draws the Projects section of sequence sequenceId into host (its count into meta) and keeps it current. Returns
|
|
* onEvent(e), which the sequence page passes every server event to.
|
|
*/
|
|
export function projectsSection(host, meta, { api, sequenceId }) {
|
|
const base = `/api/v1/sequences/${encodeURIComponent(sequenceId)}/projects`;
|
|
let projects = [];
|
|
/** The versions read of each project opened: { items, more }. */
|
|
const versions = new Map();
|
|
const expanded = new Set();
|
|
let timer = null;
|
|
let failed = null;
|
|
/** The projects a projectChanged named since the last read; null after a reconnection, when any may have changed. */
|
|
let changed = new Set();
|
|
|
|
host.innerHTML = `
|
|
<div class="table projects" data-levels="1" role="table" aria-labelledby="projects-title">
|
|
<div class="thead" role="row"><span role="columnheader" data-i18n="Admin.Projects.Name"></span>
|
|
<span role="columnheader" class="end" data-i18n="Admin.Projects.Head"></span>
|
|
<span role="columnheader" class="col-changed" data-i18n="Admin.Projects.Changed"></span>
|
|
<span role="columnheader"><span class="sr-only" data-i18n="Admin.Common.Actions"></span></span></div>
|
|
<div role="rowgroup" id="project-rows"></div>
|
|
</div>`;
|
|
applyStrings(host);
|
|
const table = host.querySelector(".table");
|
|
const rows = host.querySelector("#project-rows");
|
|
|
|
/**
|
|
* Reads the projects again, and the versions of those opened that may have changed (every one when stale is null): as
|
|
* many as are shown, so the pages Load more read stay.
|
|
*/
|
|
async function load(stale = null) {
|
|
try {
|
|
projects = await api.get(base);
|
|
failed = null;
|
|
// A project deleted meanwhile (here or elsewhere) closes; the versions of the others that changed are read again.
|
|
for (const id of expanded) {
|
|
if (!projects.some((p) => p.id === id)) forget(id);
|
|
}
|
|
const again = [...expanded].filter((id) => stale === null || stale.has(id));
|
|
await Promise.all(again.map((id) => reloadVersions(id).catch(() => forget(id))));
|
|
} catch (err) {
|
|
projects = [];
|
|
failed = errorText(err);
|
|
}
|
|
if (!host.isConnected) return;
|
|
meta.textContent = failed ? "" : plural("Admin.Projects.Count", projects.length);
|
|
draw();
|
|
}
|
|
|
|
/**
|
|
* The newest versions of a project, or with more the next page after those shown. Read without their settings
|
|
* (summary): the panel shows none, and a large sequence's versions are megabytes each.
|
|
*/
|
|
async function loadVersions(id, more = false, limit = VERSION_PAGE) {
|
|
const known = versions.get(id);
|
|
const before = more && known?.items.length ? `&before=${known.items[known.items.length - 1].number}` : "";
|
|
const page = await api.get(`${base}/${encodeURIComponent(id)}/versions?limit=${limit}${before}&summary=true`);
|
|
versions.set(id, { items: more && known ? known.items.concat(page.items) : page.items, more: page.more });
|
|
}
|
|
|
|
/** The newest versions of a project read again, as many as are shown (at least a page, at most MAX_PAGE). */
|
|
function reloadVersions(id) {
|
|
const shown = versions.get(id)?.items.length ?? 0;
|
|
return loadVersions(id, false, Math.min(MAX_PAGE, Math.max(VERSION_PAGE, shown)));
|
|
}
|
|
|
|
function forget(id) {
|
|
expanded.delete(id);
|
|
versions.delete(id);
|
|
}
|
|
|
|
function draw() {
|
|
redraw(rows, () => {
|
|
rows.innerHTML = failed
|
|
? `<div class="row" role="row"><div class="wide empty" role="cell">${escapeHtml(failed)}</div></div>`
|
|
: projects.map(rowHtml).join("") || `<div class="row" role="row"><div class="wide" role="cell">${emptyState("Admin.Projects.Empty")}</div></div>`;
|
|
applyStrings(rows);
|
|
});
|
|
rows.querySelectorAll("[data-toggle]").forEach((b) => b.addEventListener("click", () => toggle(b.dataset.toggle)));
|
|
rows.querySelectorAll("[data-act]").forEach((b) => b.addEventListener("click", () => act(b.dataset.act, find(b.closest("[data-key]").dataset.key))));
|
|
rows.querySelectorAll("[data-more-versions]").forEach((b) => b.addEventListener("click", () => moreVersions(b.dataset.moreVersions)));
|
|
fitColumns(table);
|
|
}
|
|
|
|
function find(id) {
|
|
return projects.find((p) => p.id === id);
|
|
}
|
|
|
|
/** Main keeps the name it was made with in the panel's language; a Main renamed shows its name and the Main mark. */
|
|
function projectName(p) {
|
|
return p.isMain && p.name === MAIN_NAME ? t("Admin.Projects.Main") : p.name;
|
|
}
|
|
|
|
function rowHtml(p) {
|
|
const name = projectName(p);
|
|
const mark = p.isMain && p.name !== MAIN_NAME
|
|
? `<span class="pill" data-i18n="Admin.Projects.Main" data-i18n-title="Admin.Projects.Main.Tip"></span>` : "";
|
|
const who = p.headAuthor ?? p.headClientName ?? "";
|
|
const when = p.headStoredAt ?? p.updatedAt;
|
|
const actions = p.isMain ? "" : `
|
|
<button class="btn small" data-act="rename" data-i18n="Admin.Projects.Rename" data-i18n-title="Admin.Projects.Rename.Tip"></button>
|
|
<button class="btn small destructive" data-act="delete" data-i18n="Admin.Projects.Delete" data-i18n-title="Admin.Projects.Delete.Tip"></button>`;
|
|
return `
|
|
<div class="row" role="row" data-key="${attr(p.id)}">
|
|
<span class="name-cell" role="cell"><button class="link ellipsis" data-toggle="${attr(p.id)}" aria-expanded="${expanded.has(p.id)}"
|
|
aria-controls="versions-${attr(p.id)}" dir="auto" title="${attr(p.isMain ? `${t("Admin.Projects.Main.Tip")}\n${t("Admin.Projects.Versions.Tip")}` : t("Admin.Projects.Versions.Tip"))}">${escapeHtml(name)}</button>${mark}</span>
|
|
<span class="num end nowrap" role="cell" title="${attr(t("Admin.Projects.Head.Tip"))}">${escapeHtml(formatNumber(p.headNumber))}</span>
|
|
<span class="col-changed ellipsis" role="cell" title="${attr([kindTip(p.headKind), p.headClientName].filter(Boolean).join("\n"))}"><span dir="auto">${escapeHtml(who)}</span>${who ? " · " : ""}<span class="muted nowrap">${escapeHtml(formatDateTime(when))}</span></span>
|
|
<span class="row-actions" role="cell">${actions}</span>
|
|
</div>
|
|
${expanded.has(p.id) ? `<div class="row log-row" role="row"><div class="wide" role="cell" id="versions-${attr(p.id)}">${versionsHtml(p)}</div></div>` : ""}`;
|
|
}
|
|
|
|
function versionsHtml(p) {
|
|
const page = versions.get(p.id);
|
|
if (!page) return "";
|
|
if (page.items.length === 0) return emptyState("Admin.Projects.NoVersions");
|
|
return `<div class="versions" role="list" aria-label="${attr(t("Admin.Projects.VersionsOf", projectName(p)))}">${page.items.map((v) => `
|
|
<div class="version" role="listitem">
|
|
<span class="num nowrap">${escapeHtml(t("Admin.Projects.Number", formatNumber(v.number)))}${v.id === p.headVersionId
|
|
? ` <span class="pill" data-i18n="Admin.Projects.Current" data-i18n-title="Admin.Projects.Current.Tip"></span>` : ""}</span>
|
|
<span class="nowrap" title="${attr(kindTip(v.kind))}">${escapeHtml(kindLabel(v.kind))}</span>
|
|
<span class="ellipsis" dir="auto" title="${attr([v.author, v.clientName].filter(Boolean).join(" · "))}">${escapeHtml(v.author ?? v.clientName ?? "")}</span>
|
|
<span class="ellipsis muted" dir="auto" title="${attr(v.note ?? "")}">${escapeHtml(v.note ?? "")}</span>
|
|
<span class="muted nowrap num">${escapeHtml(formatDateTime(v.storedAt ?? v.createdAt))}</span>
|
|
</div>`).join("")}
|
|
${page.more ? `<button class="btn small more" data-more-versions="${attr(p.id)}" data-i18n="Admin.Common.More" data-i18n-title="Admin.Common.More.Tip"></button>` : ""}</div>`;
|
|
}
|
|
|
|
function kindLabel(kind) {
|
|
return KINDS[kind] ? t(`Admin.Projects.Kind.${KINDS[kind]}`) : String(kind ?? "");
|
|
}
|
|
|
|
function kindTip(kind) {
|
|
return KINDS[kind] ? t(`Admin.Projects.Kind.${KINDS[kind]}.Tip`) : "";
|
|
}
|
|
|
|
async function toggle(id) {
|
|
if (expanded.delete(id)) {
|
|
versions.delete(id);
|
|
draw();
|
|
return;
|
|
}
|
|
expanded.add(id);
|
|
try {
|
|
await loadVersions(id);
|
|
} catch (err) {
|
|
forget(id);
|
|
toast(errorText(err), true);
|
|
}
|
|
draw();
|
|
}
|
|
|
|
async function moreVersions(id) {
|
|
try {
|
|
await loadVersions(id, true);
|
|
} catch (err) {
|
|
toast(errorText(err), true);
|
|
return;
|
|
}
|
|
draw();
|
|
}
|
|
|
|
async function act(action, project) {
|
|
if (!project || project.isMain) return;
|
|
if (action === "rename") return rename(project);
|
|
if (action === "delete") return remove(project);
|
|
}
|
|
|
|
async function rename(project) {
|
|
const data = await formDialog({
|
|
title: t("Admin.Projects.RenameTitle", project.name),
|
|
fields: `<label><span data-i18n="Admin.Projects.NewName"></span><input class="input" name="name" dir="auto" maxlength="${MAX_NAME}" autocomplete="off"
|
|
value="${attr(project.name)}" data-i18n-title="Admin.Projects.NewName.Tip"></label>`,
|
|
confirm: t("Admin.Projects.RenameConfirm"),
|
|
confirmTip: t("Admin.Projects.RenameConfirm.Tip"),
|
|
cancel: t("Admin.Common.Cancel"),
|
|
cancelTip: t("Admin.Common.Cancel.Tip"),
|
|
check: (form) => {
|
|
const name = form.elements.name.value.trim();
|
|
if (name.length > 0 && name.length <= MAX_NAME) return true;
|
|
markInvalid(form.elements.name, t("Admin.Projects.NameInvalid"));
|
|
form.elements.name.focus();
|
|
return false;
|
|
},
|
|
});
|
|
const name = String(data?.get("name") ?? "").trim();
|
|
if (!data || name === project.name) return;
|
|
try {
|
|
await api.patch(`${base}/${encodeURIComponent(project.id)}`, { name });
|
|
toast(t("Admin.Projects.Renamed", name));
|
|
} catch (err) {
|
|
toast(errorText(err), true);
|
|
}
|
|
await load();
|
|
}
|
|
|
|
/** Delete, after a confirmation that names the project: it and its versions move to the sequence's project trash. */
|
|
async function remove(project) {
|
|
const confirmed = await confirmDialog({
|
|
title: t("Admin.Projects.DeleteTitle", project.name),
|
|
body: t("Admin.Projects.DeleteBody", formatNumber(project.headNumber)),
|
|
confirm: t("Admin.Projects.DeleteConfirm"),
|
|
confirmTip: t("Admin.Projects.DeleteConfirm.Tip"),
|
|
cancel: t("Admin.Common.Keep"),
|
|
cancelTip: t("Admin.Common.Keep.Tip"),
|
|
});
|
|
if (!confirmed) return;
|
|
try {
|
|
await api.del(`${base}/${encodeURIComponent(project.id)}`);
|
|
toast(t("Admin.Projects.Deleted", project.name));
|
|
forget(project.id);
|
|
} catch (err) {
|
|
toast(errorText(err), true);
|
|
}
|
|
await load();
|
|
}
|
|
|
|
load();
|
|
return {
|
|
onEvent(e) {
|
|
if ((e.type === "projectChanged" && e.sequenceId === sequenceId) || e.type === "reconnected") {
|
|
if (e.type === "reconnected") changed = null;
|
|
else changed?.add(e.projectId);
|
|
clearTimeout(timer);
|
|
timer = setTimeout(() => {
|
|
const stale = changed;
|
|
changed = new Set();
|
|
if (host.isConnected) load(stale);
|
|
}, AFTER_CHANGE_MS);
|
|
}
|
|
},
|
|
};
|
|
}
|