@parallelworks/ui 0.36.0 → 0.38.0

package/dist/graph/inputPages.js

@@ -0,0 +1,186 @@
+import { inputLayout } from "./inputLayout.js";
+//#region src/graph/inputPages.ts
+var asRecord = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
+var isStep = (definition) => asRecord(definition)["type"] === "step";
+var inputNames = (list) => Object.keys(list).filter((name) => !name.startsWith("$"));
+/**
+* The wizard settings a list split into pages gets: what it had, and otherwise pages that can be
+* jumped between and, for the form itself, a Submit button.
+*/
+function wizardSettings(list, submitLabel) {
+	const wizard = asRecord(asRecord(asRecord(list)["$meta"])["wizard"]);
+	return {
+		...wizard,
+		mode: "wizard",
+		navigation: {
+			allowJump: true,
+			...asRecord(wizard["navigation"])
+		},
+		...submitLabel && wizard["submitLabel"] === void 0 ? { submitLabel } : {}
+	};
+}
+/**
+* What splitting the form into pages adds besides its `$meta`: a wizard draws only its pages, so the
+* inputs outside one go into a first page, and a form with no pages gets one to show.
+*/
+function firstPageEdits(editing, inputs, title) {
+	const names = inputNames(asRecord(inputs));
+	const loose = names.filter((name) => !isStep(asRecord(inputs)[name]));
+	if (loose.length === 0 && names.length > 0) return [];
+	const page = editing.nextName(names, "step_1");
+	const layout = asRecord(asRecord(inputs)["$meta"])["layout"];
+	return [
+		{
+			type: "addInput",
+			parent: [],
+			index: 0,
+			name: page,
+			definition: newStep(title)
+		},
+		...loose.length > 0 ? [{
+			type: "moveInputs",
+			paths: loose.map((name) => [name]),
+			parent: [page],
+			index: 0
+		}] : [],
+		...layout !== void 0 ? [{
+			type: "updateInput",
+			path: [page],
+			set: { options: {
+				...Object.fromEntries(loose.map((name) => [name, asRecord(inputs)[name]])),
+				$meta: { layout }
+			} }
+		}] : []
+	];
+}
+/**
+* The edits that split a list of inputs into pages: the form's (`parent` is `[]`), or those the group
+* or list at `parent` holds under `childKey`. Only the form's `$meta` is edited on its own, so a group's
+* or list's inputs are written whole.
+*/
+function splitIntoPagesEdits(editing, list, parent, childKey, title, submitLabel) {
+	if (parent.length === 0) return [{
+		type: "updateWorkflow",
+		inputsMeta: {
+			set: { wizard: wizardSettings(list, submitLabel) },
+			unset: ["layout"]
+		}
+	}, ...firstPageEdits(editing, list, title)];
+	const record = asRecord(list);
+	const names = inputNames(record);
+	const loose = names.filter((name) => !isStep(record[name]));
+	const pages = Object.fromEntries(names.filter((name) => isStep(record[name])).map((name) => [name, record[name]]));
+	const first = loose.length > 0 || names.length === 0 ? { [editing.nextName(names, "step_1")]: {
+		...newStep(title),
+		options: {
+			...Object.fromEntries(loose.map((name) => [name, record[name]])),
+			...asRecord(record["$meta"])["layout"] !== void 0 ? { $meta: { layout: asRecord(record["$meta"])["layout"] } } : {}
+		}
+	} } : {};
+	const { layout: _layout, ...previousMeta } = asRecord(record["$meta"]);
+	const meta = {
+		...previousMeta,
+		wizard: wizardSettings(record)
+	};
+	return [{
+		type: "updateInput",
+		path: parent,
+		set: { [childKey ?? "items"]: {
+			$meta: meta,
+			...first,
+			...pages
+		} }
+	}];
+}
+/** A page added after a wizard's last, titled by how many it then has. */
+function addPageEdit(editing, list, parent, title) {
+	const names = inputNames(asRecord(list));
+	const count = names.filter((name) => isStep(asRecord(list)[name])).length + 1;
+	return {
+		type: "addInput",
+		parent,
+		name: editing.nextName(names, `step_${count}`),
+		definition: newStep(title(count))
+	};
+}
+/**
+* What undoing pages adds besides dropping the wizard from `$meta`: each page's inputs go back where
+* the page was, in order, and the pages go. Moving them one by one refuses a name two pages share.
+*/
+function pagesBackEdits(list, parent) {
+	const record = asRecord(list);
+	const order = inputNames(record);
+	const edits = [];
+	for (const page of order.filter((name) => isStep(record[name]))) {
+		const fields = inputNames(asRecord(asRecord(record[page])["options"]));
+		const at = order.indexOf(page);
+		if (fields.length > 0) edits.push({
+			type: "moveInputs",
+			paths: fields.map((name) => [
+				...parent,
+				page,
+				name
+			]),
+			parent,
+			index: at
+		});
+		order.splice(at, 1, ...fields);
+		edits.push({
+			type: "deleteInput",
+			path: [...parent, page]
+		});
+	}
+	return edits;
+}
+/** The edits that turn a wizard back into a list of inputs drawn all at once. */
+function unsplitPagesEdits(list, parent, childKey) {
+	const record = asRecord(list);
+	const pageLayouts = inputNames(record).filter((name) => isStep(record[name])).map((name) => asRecord(asRecord(record[name])["options"]));
+	const layout = pageLayouts.some((options) => asRecord(options["$meta"])["layout"] !== void 0) ? {
+		type: "stack",
+		children: pageLayouts.map(inputLayout)
+	} : void 0;
+	if (parent.length === 0) return [...pagesBackEdits(list, []), {
+		type: "updateWorkflow",
+		inputsMeta: {
+			unset: ["wizard"],
+			...layout ? { set: { layout } } : {}
+		}
+	}];
+	const { wizard: _wizard, ...meta } = asRecord(record["$meta"]);
+	if (layout) meta["layout"] = layout;
+	const unpaged = Object.keys(meta).length > 0 ? { $meta: meta } : {};
+	for (const name of inputNames(record)) if (isStep(record[name])) {
+		const options = asRecord(asRecord(record[name])["options"]);
+		for (const field of inputNames(options)) unpaged[field] = options[field];
+	} else unpaged[name] = record[name];
+	return [...pagesBackEdits(list, parent), {
+		type: "updateInput",
+		path: parent,
+		set: { [childKey ?? "items"]: unpaged }
+	}];
+}
+/**
+* A wizard step added where the inputs aren't a wizard comes as a wizard of its own: a group whose
+* fields are read as the form's own, holding the step.
+*/
+function wizardGroupDefinition(label, title) {
+	return {
+		type: "group",
+		label,
+		flatten: true,
+		items: {
+			$meta: { wizard: wizardSettings(void 0) },
+			step_1: newStep(title)
+		}
+	};
+}
+function newStep(title) {
+	return {
+		type: "step",
+		title,
+		options: {}
+	};
+}
+//#endregion
+export { addPageEdit, firstPageEdits, pagesBackEdits, splitIntoPagesEdits, unsplitPagesEdits, wizardGroupDefinition, wizardSettings };

package/dist/graph/inputRefs.d.ts

@@ -0,0 +1,103 @@
+import type { WorkflowEditing } from '../editing.js';
+import { type Flag, type Json } from './editorFields.js';
+import type { ExpressionRef } from './expressionRefs.js';
+import { type Suggestion } from './SuggestionInput.js';
+/** An input a workflow expression can read, by its path under `inputs`. */
+export interface InputRef {
+    path: string[];
+    type: string;
+    label: string;
+    definition: Json;
+}
+/** Every input with a value, where a run reads it: groups nest unless flattened, lists hide their rows. */
+export declare function inputRefs(editing: WorkflowEditing, inputs: Json | undefined): InputRef[];
+export declare function refExpression(path: string[], suffix?: string): string;
+/** The input `value` reads when it is exactly `${{ inputs.PATH[.suffix] }}`. */
+export declare function readRef(value: unknown, suffix?: string): string[] | null;
+export declare function flagExpression(path: string[], negated: boolean): string;
+export declare function equalsExpression(path: string[], value: string, negated?: boolean): string;
+/** Picks an existing input of the given types, or asks for a new one. */
+export declare function InputRefSelect({ refs, types, value, onChange, onNew, newLabel, label, }: {
+    refs: InputRef[];
+    types: string[];
+    value: string[] | null;
+    onChange: (path: string[]) => void;
+    onNew?: (() => void) | undefined;
+    newLabel?: string;
+    label: string;
+}): import("react").JSX.Element;
+/** Where fields find inputs to read, and how they ask for a new one. */
+export interface InputSource {
+    refs: InputRef[];
+    /** Outputs, matrix values, variables, sessions and env an expression here can read. */
+    extras?: ExpressionRef[] | undefined;
+    /** Opens a dialog for a new input of `type`, then reports where it lives. */
+    create?: ((type: string, onCreated: (path: string[]) => void) => void) | undefined;
+}
+/** A text field that takes any value, expressions included, with suggestions to pick from. */
+export declare function ExpressionInput({ id, label, value, onChange, suggestions, placeholder, error, describedBy, required, }: {
+    id?: string;
+    label: string;
+    value: string;
+    onChange: (value: string) => void;
+    suggestions?: Suggestion[];
+    placeholder?: string | undefined;
+    error?: string | undefined;
+    describedBy?: string;
+    required?: boolean;
+}): import("react").JSX.Element;
+/** A switch, or an expression typed in its place, such as one that follows another input. */
+export declare function FlagField({ label, yamlKey, description, value, original, fallback, onChange, source, }: {
+    label: string;
+    yamlKey?: string;
+    description: string;
+    value: Flag;
+    original: unknown;
+    fallback?: boolean;
+    onChange: (value: Flag) => void;
+    source?: InputSource | undefined;
+}): import("react").JSX.Element;
+/** When a job or step runs: any condition, typed, with the executor's status checks and the form's switches offered. */
+export declare function ConditionField({ label, yamlKey, description, value, onChange, source, scope, }: {
+    label: string;
+    yamlKey?: string;
+    description: string;
+    value: string;
+    onChange: (value: string) => void;
+    source: InputSource;
+    /** A job's status checks read the jobs it needs; a step's, the steps before it. */
+    scope: 'job' | 'step';
+}): import("react").JSX.Element;
+/** A value typed in, with the form's inputs of the given types offered, or a new one made for it. */
+export declare function ValueOrInputField({ label, yamlKey, description, value, onChange, source, types, suffix, literal, required, error, suggestions, placeholder, }: {
+    label: string;
+    yamlKey?: string;
+    description: string;
+    value: string;
+    onChange: (value: string) => void;
+    source: InputSource;
+    types: string[];
+    /** A property of the input's value to read, such as a cluster's ip. */
+    suffix?: string;
+    /** False when the schema takes only an expression here. */
+    literal?: boolean;
+    required?: boolean;
+    error?: string | undefined;
+    suggestions?: string[];
+    placeholder?: string;
+}): import("react").JSX.Element;
+/** A script field with a menu that drops an input's reference at the cursor. */
+export declare function ScriptField({ label, yamlKey, description, value, onChange, source, rows, error, placeholder, }: {
+    label: string;
+    yamlKey?: string;
+    description: string;
+    value: string;
+    onChange: (value: string) => void;
+    source: InputSource;
+    /** Lines to show; without it the field starts one line tall and grows. */
+    rows?: number;
+    error?: string | undefined;
+    placeholder?: string;
+}): import("react").JSX.Element;
+/** References offered as suggestions on free-text values. */
+export declare function refSuggestions(source: InputSource): string[];

package/dist/graph/inputRefs.js

@@ -0,0 +1,196 @@
+import { FaPlus } from "../icons/fa/FaPlus.js";
+import { IconButton } from "../components/IconButton.js";
+import { Toggle } from "../components/Toggle.js";
+import { useGraphEditorStrings, useInputsEditorStrings } from "./editorStrings.js";
+import { useFieldLint } from "./fieldProblems.js";
+import { asRecord } from "./records.js";
+import { SuggestionInput } from "./SuggestionInput.js";
+import { ExpressionToggle, FieldError, FieldLabel, LabelledField, flagError, flagValue, text } from "./editorFields.js";
+import { useId, useState } from "react";
+import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
+//#region src/graph/inputRefs.tsx
+/** Every input with a value, where a run reads it: groups nest unless flattened, lists hide their rows. */
+function inputRefs(editing, inputs) {
+	const root = asRecord(inputs);
+	const flatSteps = editing.wizardFlattens(root);
+	const out = [];
+	const walk = (map, prefix) => {
+		for (const [name, raw] of Object.entries(map)) {
+			if (name === "$meta") continue;
+			const definition = asRecord(raw);
+			const type = text(definition["type"]);
+			const childKey = editing.inputChildrenKey(type);
+			if (type === "group" || type === "step") {
+				const flat = type === "step" ? flatSteps : definition["flatten"] === true;
+				walk(asRecord(childKey ? definition[childKey] : void 0), flat ? prefix : [...prefix, name]);
+				continue;
+			}
+			if (type === "header") continue;
+			out.push({
+				path: [...prefix, name],
+				type,
+				label: text(definition["label"]) || name,
+				definition
+			});
+		}
+	};
+	walk(root, []);
+	return out;
+}
+function refExpression(path, suffix) {
+	return `\${{ inputs.${[...path, ...suffix ? [suffix] : []].join(".")} }}`;
+}
+function flagExpression(path, negated) {
+	return `\${{ ${negated ? "!" : ""}inputs.${path.join(".")} }}`;
+}
+function equalsExpression(path, value, negated = false) {
+	const operator = negated ? "!=" : "==";
+	return `\${{ inputs.${path.join(".")} ${operator} '${value.replace(/'/g, "''")}' }}`;
+}
+/** The option values a dropdown input offers, for conditions on it. */
+function optionValues(definition) {
+	const options = definition["options"];
+	return Array.isArray(options) ? options.map((option) => typeof option === "object" && option !== null ? text(option["value"]) : text(option)) : [];
+}
+/** Makes a new input of `type` for the field, when the host can; `onCreated` gets where it went. */
+function NewInputButton({ type, source, onCreated }) {
+	const t = useGraphEditorStrings();
+	const inputsEditor = useInputsEditorStrings();
+	const create = source?.create;
+	if (!create) return null;
+	const types = inputsEditor.types;
+	return /* @__PURE__ */ jsx(IconButton, {
+		icon: /* @__PURE__ */ jsx(FaPlus, { className: "h-4 w-4" }),
+		label: t.newInputOf(types[type] ?? type),
+		size: "sm",
+		variant: "ghost",
+		onClick: () => create(type, onCreated)
+	});
+}
+var ONE_OF = ["dropdown", "radio"];
+/** A text field that takes any value, expressions included, with suggestions to pick from. */
+function ExpressionInput({ id, label, value, onChange, suggestions = [], placeholder, error, describedBy, required }) {
+	return /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx(SuggestionInput, {
+		id,
+		ariaLabel: label,
+		"aria-describedby": describedBy,
+		required,
+		value,
+		placeholder,
+		suggestions,
+		onChange
+	}), /* @__PURE__ */ jsx(FieldError, { message: error })] });
+}
+/** Conditions on the form's switches and choices, for fields that run on one. */
+function conditionSuggestions(source, t) {
+	return (source?.refs ?? []).flatMap((ref) => {
+		if (ref.type === "boolean") return [{
+			value: flagExpression(ref.path, false),
+			label: t.whenOn(ref.label)
+		}, {
+			value: flagExpression(ref.path, true),
+			label: t.whenOff(ref.label)
+		}];
+		return ONE_OF.includes(ref.type) ? optionValues(ref.definition).map((option) => ({
+			value: equalsExpression(ref.path, option),
+			label: t.whenIs(ref.label, option)
+		})) : [];
+	});
+}
+/** A switch, or an expression typed in its place, such as one that follows another input. */
+function FlagField({ label, yamlKey, description, value, original, fallback = false, onChange, source }) {
+	const t = useGraphEditorStrings();
+	const id = useId();
+	const [typed, setTyped] = useState(typeof value === "string");
+	const checked = typeof value === "boolean" ? value : fallback;
+	const setTypedValue = (next) => onChange(next.trim() ? next : void 0);
+	const lint = useFieldLint(yamlKey, id, typeof value === "string" ? value : "", setTypedValue);
+	return /* @__PURE__ */ jsxs("div", {
+		className: "flex flex-col gap-1.5",
+		children: [
+			/* @__PURE__ */ jsxs("div", {
+				className: "flex items-center justify-between gap-3",
+				children: [/* @__PURE__ */ jsx(FieldLabel, {
+					label,
+					yamlKey,
+					description
+				}), /* @__PURE__ */ jsxs("div", {
+					className: "flex shrink-0 items-center gap-1",
+					children: [!typed && /* @__PURE__ */ jsx(Toggle, {
+						checked,
+						onChange: (on) => onChange(flagValue(on, fallback, original)),
+						label
+					}), /* @__PURE__ */ jsx(ExpressionToggle, {
+						active: typed,
+						onChange: (on) => {
+							setTyped(on);
+							onChange(void 0);
+						}
+					})]
+				})]
+			}),
+			typed && /* @__PURE__ */ jsxs("div", {
+				className: "flex items-center gap-2",
+				children: [/* @__PURE__ */ jsx("div", {
+					className: "flex-1",
+					children: /* @__PURE__ */ jsx(ExpressionInput, {
+						id,
+						label,
+						value: typeof value === "string" ? value : "",
+						suggestions: conditionSuggestions(source, t),
+						error: flagError(value, t) ?? lint.message,
+						onChange: setTypedValue
+					})
+				}), /* @__PURE__ */ jsx(NewInputButton, {
+					type: "boolean",
+					source,
+					onCreated: (path) => onChange(flagExpression(path, false))
+				})]
+			}),
+			typed && lint.fixes
+		]
+	});
+}
+/** A value typed in, with the form's inputs of the given types offered, or a new one made for it. */
+function ValueOrInputField({ label, yamlKey, description, value, onChange, source, types, suffix, literal = true, required = false, error, suggestions = [], placeholder }) {
+	const t = useGraphEditorStrings();
+	const id = useId();
+	const lint = useFieldLint(yamlKey, id, value, onChange);
+	const firstType = types[0] ?? "string";
+	const offered = [...source.refs.filter((ref) => types.includes(ref.type)).map((ref) => ({
+		value: refExpression(ref.path, suffix),
+		label: ref.label
+	})), ...literal ? suggestions.map((suggestion) => ({ value: suggestion })) : []];
+	return /* @__PURE__ */ jsxs(LabelledField, {
+		label: required ? `${label} *` : label,
+		yamlKey,
+		description,
+		descriptionId: `${id}-help`,
+		children: [
+			/* @__PURE__ */ jsxs("div", {
+				className: "flex items-center gap-2",
+				children: [/* @__PURE__ */ jsx("div", {
+					className: "flex-1",
+					children: /* @__PURE__ */ jsx(ExpressionInput, {
+						id,
+						label,
+						describedBy: `${id}-help`,
+						required,
+						value,
+						placeholder: placeholder ?? (literal ? void 0 : t.chooseInput),
+						suggestions: offered,
+						onChange
+					})
+				}), /* @__PURE__ */ jsx(NewInputButton, {
+					type: firstType,
+					source,
+					onCreated: (path) => onChange(refExpression(path, suffix))
+				})]
+			}),
+			/* @__PURE__ */ jsx(FieldError, { message: error ?? lint.message }),
+			lint.fixes
+		]
+	});
+}
+//#endregion
+export { ExpressionInput, FlagField, ValueOrInputField, equalsExpression, flagExpression, inputRefs, refExpression };

package/dist/graph/inputRows.d.ts

@@ -0,0 +1,43 @@
+import type { InputPath } from '../editing.js';
+/** One input's row as drawn, with its place among its list's inputs. */
+export interface DrawnRow {
+    path: InputPath;
+    /** Which copy of the input this is, when a list draws it in each of its rows. */
+    instance: string;
+    index: number;
+    rect: DOMRect;
+    el: HTMLElement;
+    hidden: boolean;
+    /** A hidden input a list with widths draws after the inputs the form shows. */
+    trailing: boolean;
+}
+/** Inputs drawn one under another: an input and those `anchor-below` it, top to bottom. */
+export interface Column {
+    rows: DrawnRow[];
+    /** The cell a list with widths draws the column in. */
+    cell: HTMLElement | null;
+}
+/** The columns of one list drawn side by side on one line of the form, left to right. */
+export interface Line {
+    parent: InputPath;
+    columns: Column[];
+}
+/** Where dragged inputs land: before `index` of `parent`, as a column beside one, or in one. */
+export interface Drop {
+    parent: InputPath;
+    index: number;
+    beside?: {
+        path: InputPath;
+        side: 'left' | 'right';
+    };
+    stack?: {
+        path: InputPath;
+        side: 'above' | 'below';
+    };
+}
+export declare const rowsOf: (line: Line) => DrawnRow[];
+export declare function inputCell(el: HTMLElement): HTMLElement | null;
+/** The form's lines: a column is the rows one cell draws, and columns at one height share a line. */
+export declare function linesIn(root: HTMLElement): Line[];
+/** Neighbours on one line, split at `pointer` (a percent of their list's width), in 5% steps. */
+export declare function snapSplit(total: number, pointer: number): [left: number, right: number];

package/dist/graph/inputRows.js

@@ -0,0 +1,65 @@
+//#region src/graph/inputRows.ts
+var key = (path) => JSON.stringify(path);
+var samePath = (a, b) => a.length === b.length && a.every((name, i) => b[i] === name);
+var rowsOf = (line) => line.columns.flatMap((column) => column.rows);
+var topOf = (column) => Math.min(...column.rows.map((row) => row.rect.top));
+var leftOf = (column) => Math.min(...column.rows.map((row) => row.rect.left));
+function inputCell(el) {
+	let child = el;
+	for (let parent = el.parentElement; parent; parent = parent.parentElement) {
+		if (parent.hasAttribute("data-input-path")) return null;
+		if (parent.hasAttribute("data-input-cell")) return parent;
+		if (parent.parentElement?.hasAttribute("data-layout-grid")) return child;
+		if (parent.hasAttribute("data-layout-boundary")) return null;
+		child = parent;
+	}
+	return null;
+}
+/** The form's lines: a column is the rows one cell draws, and columns at one height share a line. */
+function linesIn(root) {
+	const columns = /* @__PURE__ */ new Map();
+	for (const el of root.querySelectorAll("[data-input-path]")) {
+		const path = JSON.parse(el.dataset["inputPath"] ?? "[]");
+		const cell = inputCell(el);
+		const owner = cell ?? el;
+		const entry = columns.get(owner) ?? {
+			parent: path.slice(0, -1),
+			column: {
+				rows: [],
+				cell
+			}
+		};
+		columns.set(owner, entry);
+		entry.column.rows.push({
+			path,
+			instance: el.dataset["inputInstance"] ?? key(path),
+			index: Number(el.dataset["inputIndex"] ?? 0),
+			rect: el.getBoundingClientRect(),
+			el,
+			hidden: el.dataset["inputHidden"] !== void 0,
+			trailing: false
+		});
+	}
+	const lines = [];
+	for (const { parent, column } of columns.values()) {
+		column.rows.sort((a, b) => a.rect.top - b.rect.top);
+		if (column.cell && column.rows.every((row) => row.hidden)) for (const row of column.rows) row.trailing = true;
+		const top = topOf(column);
+		const line = lines.find((other) => samePath(other.parent, parent) && Math.abs(topOf(other.columns[0]) - top) < 1);
+		if (line) line.columns.push(column);
+		else lines.push({
+			parent,
+			columns: [column]
+		});
+	}
+	for (const line of lines) line.columns.sort((a, b) => leftOf(a) - leftOf(b));
+	return lines;
+}
+/** Neighbours on one line, split at `pointer` (a percent of their list's width), in 5% steps. */
+function snapSplit(total, pointer) {
+	const floor = Math.min(10, total / 2);
+	const left = Math.min(Math.max(Math.round(pointer / 5) * 5, floor), total - floor);
+	return [left, total - left];
+}
+//#endregion
+export { inputCell, linesIn, rowsOf, snapSplit };

package/dist/graph/records.d.ts

@@ -0,0 +1,3 @@
+export type Json = Record<string, unknown>;
+/** `value` when it's a plain object, else an empty one, so its keys read without checks. */
+export declare function asRecord(value: unknown): Record<string, unknown>;

package/dist/graph/records.js

@@ -0,0 +1,7 @@
+//#region src/graph/records.ts
+/** `value` when it's a plain object, else an empty one, so its keys read without checks. */
+function asRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
+}
+//#endregion
+export { asRecord };

package/dist/graph/refusalText.d.ts

@@ -0,0 +1,6 @@
+import type { EditRefusalReason, WorkflowEditing } from '../editing.js';
+import { type GraphEditorStrings } from './editorStrings.js';
+/** A refusal in the host's words, or the engine's English when the host gives none. */
+export declare function refusalText(t: GraphEditorStrings, editing: WorkflowEditing, reason: EditRefusalReason): string;
+/** What to tell the person when an edit throws: why it was refused, or the error itself. */
+export declare function editErrorText(t: GraphEditorStrings, editing: WorkflowEditing, error: unknown): string;

package/dist/graph/settingsViews.d.ts

@@ -0,0 +1,26 @@
+import type { WorkflowEditing } from '../editing.js';
+import type { EditorMarker } from '../editor/Monaco.js';
+import type { NestedWorkflowText } from '../editor/nestedText.js';
+import { type Strings } from './editorFields.js';
+import { type ScopedProblem } from './fieldProblems.js';
+/** Which view the job, step, input and settings dialogs open in. */
+export type SettingsView = 'form' | 'yaml';
+export declare function yamlProblem(yaml: string, t: Strings, editing: WorkflowEditing): string | undefined;
+export declare function ViewSwitch({ yaml, onForm, onYaml, }: {
+    yaml: boolean;
+    onForm: () => void;
+    onYaml: () => void;
+}): import("react").JSX.Element;
+export interface ScopedProblems {
+    markers: EditorMarker[];
+    problems: ScopedProblem[];
+}
+export declare const NO_SCOPED: ScopedProblems;
+export declare function YamlPane({ path, value, onChange, problem, scoped, nested, }: {
+    path: string;
+    value: string;
+    onChange: (value: string) => void;
+    problem: string | undefined;
+    scoped: ScopedProblems;
+    nested?: NestedWorkflowText | undefined;
+}): import("react").JSX.Element;