385 lines
12 KiB
JavaScript
385 lines
12 KiB
JavaScript
// The Templates gallery and detail, including the create-from-template dialog
|
|
// and its validate-then-submit flow. Pure wording/model helpers live in
|
|
// templates.js; this module owns the DOM and the page's template state.
|
|
|
|
import { h, kvMono } from "../dom.js";
|
|
import { describeError } from "../format.js";
|
|
import {
|
|
CREATE_ACTION_LABEL,
|
|
CREATE_NAME_LABEL,
|
|
CREATE_NOTE,
|
|
createConfirmLabel,
|
|
createDismissLabel,
|
|
createFormTitle,
|
|
createFormValid,
|
|
createSuccessMessage,
|
|
createdPipelineName,
|
|
effectiveStageType,
|
|
templateCard,
|
|
templateDetailName,
|
|
templateGalleryName,
|
|
templateGraphNote,
|
|
templateStageCountLabel,
|
|
templateStageSummary,
|
|
TEMPLATE_UNPARSED_SOURCE_NOTE,
|
|
} from "../templates.js";
|
|
|
|
export function createTemplatesView(rt) {
|
|
const { state, repo, modal } = rt;
|
|
const renderContent = (...args) => rt.renderContent(...args);
|
|
const focusDetailHeading = (...args) => rt.focusDetailHeading(...args);
|
|
const pushRoute = (...args) => rt.pushRoute(...args);
|
|
const setError = (...args) => rt.setError(...args);
|
|
const refreshPipelines = (...args) => rt.views.pipelines.refreshPipelines(...args);
|
|
|
|
/**
|
|
* Reset the template detail/create state that belongs to a selection. Shared by
|
|
* selecting a template and opening the gallery from Settings, so the two lists of
|
|
* fields can never drift.
|
|
*/
|
|
function resetTemplateCreateState() {
|
|
// The section is sticky across template selections (it is persisted by the shell).
|
|
// A different template reseeds the create dialog, so a name typed for one
|
|
// template can never be submitted against another.
|
|
state.templateCreateOpen = false;
|
|
state.templateCreateName = "";
|
|
state.templateCreateSending = false;
|
|
state.templateCreateError = "";
|
|
state.templateCreateCreated = null;
|
|
}
|
|
|
|
/** Clear the selection and everything that belongs to it. */
|
|
function resetTemplateSelection() {
|
|
state.selectedTemplateKey = null;
|
|
resetTemplateCreateState();
|
|
}
|
|
|
|
/** The cached parsed graph for a template key, or null when it did not parse. */
|
|
function templateGraphFor(key) {
|
|
return state.templateGraphs.has(key) ? state.templateGraphs.get(key) : null;
|
|
}
|
|
|
|
function renderTemplateGallery() {
|
|
const pane = h("div", { class: "list gallery" });
|
|
if (state.templateLoading && !state.templates.length) {
|
|
pane.append(h("div", { class: "muted pad", text: "Loading templates…" }));
|
|
return pane;
|
|
}
|
|
if (!state.templates.length) {
|
|
pane.append(h("div", { class: "muted pad", text: "No templates are available on this server." }));
|
|
return pane;
|
|
}
|
|
const cards = h("div", { class: "cards list-scroll" });
|
|
for (const entry of state.templates) {
|
|
const card = templateCard(entry, templateGraphFor(entry.key));
|
|
cards.append(
|
|
h(
|
|
"button",
|
|
{
|
|
class: `card${state.selectedTemplateKey === entry.key ? " selected" : ""}`,
|
|
"data-template-key": entry.key,
|
|
onclick: () => selectTemplate(entry.key),
|
|
},
|
|
h("span", { class: "card-name", text: templateGalleryName(card.name) }),
|
|
h("span", { class: "card-desc", text: card.description }),
|
|
h("span", { class: "card-meta", text: templateStageCountLabel(card.stageCount) }),
|
|
),
|
|
);
|
|
}
|
|
pane.append(cards);
|
|
return pane;
|
|
}
|
|
|
|
function renderTemplateDetail() {
|
|
const pane = h("div", { class: "detail" });
|
|
const entry = state.templates.find((t) => t.key === state.selectedTemplateKey);
|
|
if (!entry) {
|
|
pane.append(h("div", { class: "muted pad", text: "Select a template." }));
|
|
return pane;
|
|
}
|
|
const graph = templateGraphFor(entry.key);
|
|
pane.append(renderTemplateDetailActions());
|
|
pane.append(h("h1", { class: "detail-title", id: "detailTitle", tabindex: "-1", text: templateDetailName(entry) }));
|
|
if (state.templateTab === "graph") pane.append(renderTemplateGraphTab(graph));
|
|
else if (state.templateTab === "source") pane.append(renderTemplateSourceTab(entry, graph));
|
|
else pane.append(renderTemplateSummaryTab(entry, graph));
|
|
if (state.templateCreateOpen) pane.append(renderTemplateCreateDialog(entry));
|
|
return pane;
|
|
}
|
|
|
|
/**
|
|
* The template detail's action row: the one "Create pipeline from this
|
|
* template" action (P5), matching the app's top-bar add action. It opens the
|
|
* dialog; it never submits on its own.
|
|
*/
|
|
function renderTemplateDetailActions() {
|
|
return h(
|
|
"div",
|
|
{ class: "detail-actions" },
|
|
h("button", {
|
|
class: "ghost template-create-open",
|
|
type: "button",
|
|
text: CREATE_ACTION_LABEL,
|
|
onclick: () => openTemplateCreateDialog(),
|
|
}),
|
|
);
|
|
}
|
|
|
|
/** Open the create dialog with a fresh, empty name; nothing is sent until Create. */
|
|
function openTemplateCreateDialog() {
|
|
state.templateCreateOpen = true;
|
|
state.templateCreateName = "";
|
|
state.templateCreateSending = false;
|
|
state.templateCreateError = "";
|
|
state.templateCreateCreated = null;
|
|
renderContent();
|
|
}
|
|
|
|
/** Dismiss the create dialog (never while a validate+submit is in flight). */
|
|
function closeTemplateCreateDialog() {
|
|
if (state.templateCreateSending) return;
|
|
state.templateCreateOpen = false;
|
|
state.templateCreateName = "";
|
|
state.templateCreateError = "";
|
|
state.templateCreateCreated = null;
|
|
renderContent();
|
|
}
|
|
|
|
/**
|
|
* The create dialog (P5): the title, the one required name field, the note, the
|
|
* server's refusal text or the success line, and Create/Cancel (Cancel reads
|
|
* Close after a success). Create is disabled while the name is blank or while
|
|
* sending; the field locks while sending and after a success. Every server
|
|
* string is set with textContent.
|
|
*/
|
|
function renderTemplateCreateDialog(entry) {
|
|
const title = createFormTitle(entry);
|
|
const overlay = h("div", {
|
|
class: "template-create-dialog",
|
|
role: "dialog",
|
|
"aria-modal": "true",
|
|
"aria-label": title,
|
|
});
|
|
overlay.addEventListener("click", (event) => {
|
|
if (event.target === overlay) closeTemplateCreateDialog();
|
|
});
|
|
const panel = h("div", { class: "template-create-panel" });
|
|
panel.append(h("h2", { class: "template-create-title", text: title }));
|
|
|
|
const field = h("label", { class: "template-create-field" });
|
|
field.append(h("span", { class: "template-create-label", text: CREATE_NAME_LABEL }));
|
|
field.append(
|
|
h("input", {
|
|
class: "template-create-name",
|
|
type: "text",
|
|
value: state.templateCreateName,
|
|
spellcheck: "false",
|
|
autocomplete: "off",
|
|
disabled: state.templateCreateSending || state.templateCreateCreated != null,
|
|
oninput: (event) => {
|
|
// Update in place (no re-render) so the field keeps focus and its caret;
|
|
// only the confirm button's enabled state depends on the name.
|
|
state.templateCreateName = event.target.value;
|
|
const confirm = overlay.querySelector(".template-create-confirm");
|
|
if (confirm) {
|
|
confirm.disabled = !createFormValid(state.templateCreateName, {
|
|
sending: state.templateCreateSending,
|
|
created: state.templateCreateCreated,
|
|
});
|
|
}
|
|
},
|
|
}),
|
|
);
|
|
panel.append(field);
|
|
panel.append(h("p", { class: "template-create-note muted", text: CREATE_NOTE }));
|
|
if (state.templateCreateError) {
|
|
panel.append(h("div", { class: "template-create-error bad", text: state.templateCreateError }));
|
|
}
|
|
if (state.templateCreateCreated != null) {
|
|
panel.append(
|
|
h("div", {
|
|
class: "template-create-success",
|
|
text: createSuccessMessage(state.templateCreateCreated),
|
|
}),
|
|
);
|
|
}
|
|
|
|
const actions = h("div", { class: "template-create-actions" });
|
|
actions.append(
|
|
h("button", {
|
|
class: "ghost template-create-cancel",
|
|
type: "button",
|
|
text: createDismissLabel(state.templateCreateCreated),
|
|
disabled: state.templateCreateSending,
|
|
onclick: closeTemplateCreateDialog,
|
|
}),
|
|
);
|
|
actions.append(
|
|
h("button", {
|
|
class: "template-create-confirm",
|
|
type: "button",
|
|
text: createConfirmLabel(state.templateCreateSending),
|
|
disabled: !createFormValid(state.templateCreateName, {
|
|
sending: state.templateCreateSending,
|
|
created: state.templateCreateCreated,
|
|
}),
|
|
onclick: () => createFromTemplate(entry),
|
|
}),
|
|
);
|
|
panel.append(actions);
|
|
overlay.append(panel);
|
|
modal.stage("template-create", overlay, {
|
|
onClose: () => closeTemplateCreateDialog(),
|
|
triggerSelector: ".template-create-open",
|
|
fallbackSelectors: ["#detailTitle", "#pane-main"],
|
|
});
|
|
return overlay;
|
|
}
|
|
|
|
/**
|
|
* The P5 submit flow, exactly the app's: validate the template's source first
|
|
* and, when the server refuses to parse it, show its own error in the dialog and
|
|
* send nothing; otherwise submit the source create-only with the chosen name. On
|
|
* success remember the created name, refresh the pipeline list so the new row is
|
|
* visible and leave the dialog open (Cancel now reads Close); on failure show
|
|
* the server's error without closing.
|
|
*/
|
|
async function createFromTemplate(entry) {
|
|
if (
|
|
!createFormValid(state.templateCreateName, {
|
|
sending: state.templateCreateSending,
|
|
created: state.templateCreateCreated,
|
|
})
|
|
) {
|
|
return;
|
|
}
|
|
const name = state.templateCreateName;
|
|
state.templateCreateSending = true;
|
|
state.templateCreateError = "";
|
|
renderContent();
|
|
try {
|
|
await repo.validate(entry.source);
|
|
} catch (error) {
|
|
state.templateCreateSending = false;
|
|
state.templateCreateError = describeError(error);
|
|
renderContent();
|
|
return;
|
|
}
|
|
try {
|
|
const detail = await repo.submit(name, entry.source);
|
|
state.templateCreateSending = false;
|
|
state.templateCreateCreated = createdPipelineName(detail, name);
|
|
await refreshPipelines();
|
|
} catch (error) {
|
|
state.templateCreateSending = false;
|
|
state.templateCreateError = describeError(error);
|
|
}
|
|
renderContent();
|
|
}
|
|
|
|
function renderTemplateSummaryTab(entry, graph) {
|
|
const wrap = h("div", { class: "tabbody" });
|
|
if ((entry.description ?? "").trim()) {
|
|
wrap.append(h("p", { class: "body", text: entry.description }));
|
|
}
|
|
wrap.append(h("div", { class: "kv" }, kvMono("Key", entry.key)));
|
|
wrap.append(
|
|
h("div", { class: "meta-line", text: templateStageCountLabel(graph?.stages?.length ?? null) }),
|
|
);
|
|
if (entry.scheduled) wrap.append(h("div", { class: "meta-line", text: "Includes a schedule" }));
|
|
|
|
const summary = templateStageSummary(graph);
|
|
if (summary.note) {
|
|
wrap.append(h("div", { class: "muted pad", text: summary.note }));
|
|
return wrap;
|
|
}
|
|
wrap.append(h("h3", { text: "Stages" }));
|
|
const ul = h("ul", { class: "stages" });
|
|
for (const stage of summary.stages) {
|
|
ul.append(
|
|
h(
|
|
"li",
|
|
{},
|
|
h("code", { text: stage.key }),
|
|
h("span", { class: "chip", text: effectiveStageType(stage.type) }),
|
|
),
|
|
);
|
|
}
|
|
wrap.append(ul);
|
|
return wrap;
|
|
}
|
|
|
|
function renderTemplateGraphTab(graph) {
|
|
const wrap = h("div", { class: "tabbody" });
|
|
wrap.append(h("p", { class: "muted", text: templateGraphNote(graph) }));
|
|
return wrap;
|
|
}
|
|
|
|
function renderTemplateSourceTab(entry, graph) {
|
|
const wrap = h("div", { class: "tabbody" });
|
|
if (graph == null) {
|
|
wrap.append(h("p", { class: "muted", text: TEMPLATE_UNPARSED_SOURCE_NOTE }));
|
|
}
|
|
wrap.append(
|
|
h(
|
|
"div",
|
|
{ class: "codeblock" },
|
|
h("div", { class: "codeblock-label", text: "Definition source" }),
|
|
h("pre", { class: "codeblock-body", text: entry.source ?? "" }),
|
|
),
|
|
);
|
|
return wrap;
|
|
}
|
|
|
|
/**
|
|
* Loads the template catalogue, then validates each template's source once and
|
|
* caches the parsed graph (null when it did not parse) so a card's stage count
|
|
* and the detail's stage list read the same result and can never disagree.
|
|
*/
|
|
async function loadTemplates(force = false) {
|
|
state.templateLoading = true;
|
|
state.error = "";
|
|
renderContent();
|
|
try {
|
|
state.templates = await repo.listTemplates();
|
|
for (const entry of state.templates) {
|
|
if (force || !state.templateGraphs.has(entry.key)) {
|
|
state.templateGraphs.set(entry.key, await validateTemplate(entry));
|
|
}
|
|
}
|
|
state.templateLoading = false;
|
|
renderContent();
|
|
} catch (err) {
|
|
state.templateLoading = false;
|
|
setError(err);
|
|
}
|
|
}
|
|
|
|
/** The parsed graph for a template, or null when the server cannot parse its source. */
|
|
async function validateTemplate(entry) {
|
|
try {
|
|
return await repo.validate(entry.source);
|
|
} catch {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
function selectTemplate(key) {
|
|
if (key) pushRoute({ kind: "template", key });
|
|
else pushRoute({ kind: "templates" });
|
|
state.selectedTemplateKey = key || null;
|
|
resetTemplateCreateState();
|
|
renderContent();
|
|
if (key) focusDetailHeading();
|
|
}
|
|
|
|
return {
|
|
resetTemplateCreateState,
|
|
resetTemplateSelection,
|
|
renderTemplateGallery,
|
|
renderTemplateDetail,
|
|
loadTemplates,
|
|
selectTemplate,
|
|
};
|
|
}
|