process-graph 1.0.6 → 1.1.1

package/dist/control-aDk9560d.js

@@ -0,0 +1,294 @@
+//#region ../../core/graph/dag/dist/errors.js
+/**
+* Thrown when an operation that is only defined on an acyclic graph is given one that contains a cycle.
+*/
+var CycleError = class extends Error {
+	/**
+	* One closed path per strongly connected component that contains a cycle, exactly as `findCycles` reports them.
+	*/
+	cycles;
+	/**
+	* @param cycles - The cycles found, as returned by `findCycles`. Must not be empty.
+	*/
+	constructor(cycles) {
+		super(`The graph contains a cycle: ${cycles.map((path) => path.join(" -> ")).join("; ")}`);
+		this.name = "CycleError";
+		this.cycles = cycles;
+	}
+};
+/**
+* Thrown when an operation is asked about an id that is not a node of the graph it was given.
+*/
+var UnknownNodeError = class extends Error {
+	/**
+	* The id that is not a node of the graph.
+	*/
+	id;
+	/**
+	* @param id - The id that is not a node of the graph.
+	*/
+	constructor(id) {
+		super(`"${String(id)}" is not a node of the graph`);
+		this.name = "UnknownNodeError";
+		this.id = id;
+	}
+};
+//#endregion
+//#region ../../core/graph/dag/dist/dag.js
+/**
+* Reads a value keyed by a node id out of a map built over a graph's nodes.
+* @throws UnknownNodeError when the id is not a node of that graph.
+*/
+function lookup(map, id) {
+	const value = map.get(id);
+	if (value === void 0) throw new UnknownNodeError(id);
+	return value;
+}
+/**
+* Assembles a graph from nodes and already-resolved direct needs, deriving the inverse relation. Internal: every needs target must be a node.
+*/
+function assembleDag(nodes, needs, unknownReferences) {
+	const dependents = new Map(nodes.map((id) => [id, []]));
+	for (const id of nodes) for (const target of lookup(needs, id)) lookup(dependents, target).push(id);
+	return {
+		nodes,
+		needs,
+		dependents,
+		unknownReferences
+	};
+}
+/**
+* Builds a graph once from a node set and a `needs` accessor.
+*
+* `nodes` is iterated once and duplicates are dropped, keeping the first occurrence. `needs` is called exactly once per distinct node, in node order, and its result is iterated once. A target that is not a node is recorded in `unknownReferences` and is not an edge. A node may need itself; that is a cycle of one, reported by `findCycles`.
+*
+* Never throws for malformed structure: cycles and unknown references are data on the result and in the analyses.
+* @param nodes - Every node of the graph.
+* @param needs - The direct needs of a node: the nodes that must come before it.
+*/
+function buildDag(nodes, needs) {
+	const ordered = [...new Set(nodes)];
+	const known = new Set(ordered);
+	const resolved = /* @__PURE__ */ new Map();
+	const unknownReferences = [];
+	for (const id of ordered) {
+		const direct = /* @__PURE__ */ new Set();
+		const missing = /* @__PURE__ */ new Set();
+		for (const target of needs(id)) if (known.has(target)) direct.add(target);
+		else missing.add(target);
+		resolved.set(id, [...direct]);
+		for (const target of missing) unknownReferences.push({
+			from: id,
+			missing: target
+		});
+	}
+	return assembleDag(ordered, resolved, unknownReferences);
+}
+//#endregion
+//#region ../../core/graph/dag/dist/reachability.js
+/**
+* Every node reachable from `from` by following `edges` one or more times, in node order.
+*/
+function reachable(dag, edges, from) {
+	const found = /* @__PURE__ */ new Set();
+	const pending = [...lookup(edges, from)];
+	for (let node = pending.pop(); node !== void 0; node = pending.pop()) {
+		if (found.has(node)) continue;
+		found.add(node);
+		pending.push(...lookup(edges, node));
+	}
+	return dag.nodes.filter((id) => found.has(id));
+}
+/**
+* Every node `id` depends on, directly or through other nodes: the transitive closure of `needs` from `id`, in node order.
+*
+* `id` itself is included exactly when it lies on a cycle, since it then depends on itself. Unknown references are not edges. Iterative, so depth cannot overflow the call stack.
+* @throws UnknownNodeError when `id` is not a node of the graph.
+*/
+function ancestorsOf(dag, id) {
+	return reachable(dag, dag.needs, id);
+}
+/**
+* Every node that depends on `id`, directly or through other nodes: the transitive closure of the inverse of `needs` from `id`, in node order.
+*
+* `id` itself is included exactly when it lies on a cycle. Iterative, so depth cannot overflow the call stack.
+* @throws UnknownNodeError when `id` is not a node of the graph.
+*/
+function descendantsOf(dag, id) {
+	return reachable(dag, dag.dependents, id);
+}
+//#endregion
+//#region ../../core/graph/dag/dist/cycles.js
+/**
+* Every strongly connected component of the graph: the maximal sets of nodes in which each node reaches every other along `needs` edges. Every node is in exactly one component, and a node on no cycle is a component of its own. Found by Tarjan's algorithm with an explicit stack, so depth is bounded by memory, not by the call stack, and each node and edge is visited once.
+*
+* A component lists its nodes in the order Tarjan's algorithm completes them, its root last. Components come out in reverse topological order of the condensed graph along `needs`: a component appears before every component that needs it. Since mutual reachability is symmetric, the components are the same whichever direction the edges are read in.
+* @param dag - The graph to partition.
+* @returns Every component, each a non-empty list of nodes.
+*/
+function stronglyConnectedComponents(dag) {
+	const index = /* @__PURE__ */ new Map();
+	const lowLink = /* @__PURE__ */ new Map();
+	const onStack = /* @__PURE__ */ new Set();
+	const stack = [];
+	const components = [];
+	const popComponent = (root) => {
+		const component = [];
+		for (let member = stack.pop(); member !== void 0; member = stack.pop()) {
+			onStack.delete(member);
+			component.push(member);
+			if (member === root) break;
+		}
+		return component;
+	};
+	const visit = (node) => {
+		index.set(node, index.size);
+		lowLink.set(node, lookup(index, node));
+		stack.push(node);
+		onStack.add(node);
+	};
+	for (const root of dag.nodes) {
+		if (index.has(root)) continue;
+		visit(root);
+		const frames = [{
+			node: root,
+			next: 0
+		}];
+		for (let frame = frames.at(-1); frame !== void 0; frame = frames.at(-1)) {
+			const target = lookup(dag.needs, frame.node)[frame.next];
+			if (target !== void 0) {
+				frame.next += 1;
+				if (!index.has(target)) {
+					visit(target);
+					frames.push({
+						node: target,
+						next: 0
+					});
+				} else if (onStack.has(target)) lowLink.set(frame.node, Math.min(lookup(lowLink, frame.node), lookup(index, target)));
+				continue;
+			}
+			frames.pop();
+			const parent = frames.at(-1);
+			if (parent !== void 0) lowLink.set(parent.node, Math.min(lookup(lowLink, parent.node), lookup(lowLink, frame.node)));
+			if (lookup(lowLink, frame.node) === lookup(index, frame.node)) components.push(popComponent(frame.node));
+		}
+	}
+	return components;
+}
+/**
+* The shortest closed path along `needs` edges from `start` back to itself, staying inside `members`. Ties between equally short paths go to the one found first when each node's needs are read in order.
+*/
+function shortestCycleThrough(dag, start, members) {
+	const parent = /* @__PURE__ */ new Map();
+	const queue = [start];
+	for (const current of queue) for (const target of lookup(dag.needs, current)) {
+		if (target === start) {
+			const between = [];
+			for (let node = current; node !== start; node = lookup(parent, node)) between.push(node);
+			return [
+				start,
+				...between.reverse(),
+				start
+			];
+		}
+		if (members.has(target) && !parent.has(target)) {
+			parent.set(target, current);
+			queue.push(target);
+		}
+	}
+	throw new Error(`Invariant violated: "${String(start)}" is in a strongly connected component but no cycle passes through it`);
+}
+/**
+* Reports every cycle in the graph: exactly one closed path per strongly connected component that contains a cycle (more than one node, or a node that needs itself).
+*
+* A path lists nodes such that each needs the next and the last needs the first, which is repeated at the end: `[a, b, c, a]` means a needs b, b needs c and c needs a. A self-loop is `[a, a]`. The path is a shortest cycle through the component's first node in node order, ties going to the earliest needs. Paths are ordered by the position of their first node. A component can contain more cycles than the one reported; removing the reported cycle's edges and calling again finds the rest.
+*
+* Returns an empty array exactly when the graph is acyclic. Iterative, so a deep graph cannot overflow the call stack.
+*/
+function findCycles(dag) {
+	const position = new Map(dag.nodes.map((id, order) => [id, order]));
+	const found = [];
+	for (const component of stronglyConnectedComponents(dag)) {
+		const [only] = component;
+		if (component.length === 1 && only !== void 0 && !lookup(dag.needs, only).includes(only)) continue;
+		const members = new Set(component);
+		const [earliest] = component.map((id) => ({
+			id,
+			order: lookup(position, id)
+		})).sort((a, b) => a.order - b.order);
+		if (earliest === void 0) continue;
+		found.push({
+			first: earliest.order,
+			path: shortestCycleThrough(dag, earliest.id, members)
+		});
+	}
+	return found.sort((a, b) => a.first - b.first).map(({ path }) => path);
+}
+/**
+* Throws a `CycleError` unless the graph is acyclic.
+* @throws CycleError carrying `findCycles(dag)` when the graph contains a cycle.
+*/
+function assertAcyclic(dag) {
+	const cycles = findCycles(dag);
+	if (cycles.length > 0) throw new CycleError(cycles);
+}
+//#endregion
+//#region ../../core/graph/domain/dist/control.js
+/**
+* Builds the dependency graph over every element, leaving out the transitions in `excluded`. A node needs the source of each remaining incoming transition and, for an activity, the producer of each artefact it consumes.
+*/
+const buildControl = (model, excluded) => {
+	const sources = new Map(model.elements.map(({ id }) => [id, []]));
+	for (const transition of model.transitions) {
+		const incoming = sources.get(transition.target);
+		if (incoming !== void 0 && !excluded.has(transition.id)) incoming.push(transition.source);
+	}
+	const producers = /* @__PURE__ */ new Map();
+	for (const element of model.elements) {
+		if (element.kind !== "activity") continue;
+		for (const artefact of element.produces ?? []) {
+			const known = producers.get(artefact);
+			if (known === void 0) producers.set(artefact, [element.id]);
+			else known.push(element.id);
+		}
+	}
+	const consumed = new Map(model.elements.flatMap((element) => element.kind === "activity" && element.consumes !== void 0 ? [[element.id, element.consumes]] : []));
+	return buildDag(model.elements.map(({ id }) => id), (id) => [...sources.get(id) ?? [], ...(consumed.get(id) ?? []).flatMap((artefact) => producers.get(artefact) ?? [])]);
+};
+/**
+* The transitions that re-enter earlier work: a transition leaving a `decision` element whose target can reach its source (or is its source), so that it closes a cycle through the decision.
+*
+* Reachability is over the whole graph, transitions and artefact dependencies alike. Only a decision's own outgoing transitions are candidates: a cycle that contains no decision has no loop edge and is illegal.
+* @param model - The model to read.
+* @returns The loop transitions, in transition order.
+* @throws UnknownNodeError when such a transition's target is not an element of the model.
+*/
+const loopTransitions = (model) => {
+	const decisions = new Set(model.elements.flatMap((element) => element.kind === "decision" ? [element.id] : []));
+	const whole = buildControl(model, /* @__PURE__ */ new Set());
+	return model.transitions.filter((transition) => decisions.has(transition.source) && (transition.target === transition.source || descendantsOf(whole, transition.target).includes(transition.source))).map(({ id }) => id);
+};
+/**
+* The control graph the whole analysis is computed on, with the loop edges removed.
+*
+* Its nodes are the element ids. A node needs the source of every incoming transition that is not a loop edge (see `loopTransitions`) and, for an activity, the producer of every artefact in `consumes`. Excluding loop edges makes a legal retry or review loop acyclic here, so readiness, layers and the critical path are well defined: a loop edge is a way back to earlier work, never a prerequisite of it. A node whose only incoming transitions are loop edges therefore has no needs.
+*
+* The graph is not guaranteed acyclic: cycles that no decision closes remain and are reported by `illegalCycles`. A transition whose source is not an element appears in `unknownReferences`.
+* @param model - The model to read.
+* @returns The graph over element ids, as a `graph-dag` `Dag`.
+* @throws UnknownNodeError when a decision's transition targets something that is not an element.
+*/
+const controlDag = (model) => buildControl(model, new Set(loopTransitions(model)));
+/**
+* The cycles of the control graph: every cycle that is not a legal decision loop.
+*
+* A cycle that passes through a `decision` element is a legal loop and is not reported; the loop edge that closes it is left out of `controlDag`. Any cycle that remains has no decision in it, so it can never make progress, and is reported with its path.
+*
+* A path follows `graph-dag`'s convention: each element needs the next one and the last needs the first, which is repeated at the end. `["a", "b", "a"]` means a needs b and b needs a. One path is reported per strongly connected component; break it and call again for the rest.
+* @param model - The model to read.
+* @returns The illegal cycles, empty exactly when every cycle is a legal decision loop.
+* @throws UnknownNodeError when a decision's transition targets something that is not an element.
+*/
+const illegalCycles = (model) => findCycles(controlDag(model));
+//#endregion
+export { findCycles as a, descendantsOf as c, lookup as d, CycleError as f, assertAcyclic as i, assembleDag as l, illegalCycles as n, stronglyConnectedComponents as o, UnknownNodeError as p, loopTransitions as r, ancestorsOf as s, controlDag as t, buildDag as u };

package/dist/detail-panel-B1ZmMuJT.js

@@ -0,0 +1,341 @@
+import { t as statuses } from "./status-Bm1CGu9C.js";
+import { useId } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+//#region ../../ui/graph/react/dist/labels.js
+/** The text each status is shown with, so every component names a status the same way. */
+const statusLabels = {
+	done: "Done",
+	ready: "Ready",
+	blocked: "Blocked",
+	skipped: "Skipped",
+	unknown: "Unknown"
+};
+/** One sentence per status rule, saying why an element has the status that rule decided. */
+const ruleDescriptions = {
+	"overlay-done": "The run reports it done.",
+	"overlay-unknown": "The run reports its state as unknown.",
+	"unknown-need": "Something it needs has an unknown state or an undecided condition.",
+	"all-cut": "Every path into it was cut, so it will not run.",
+	"needs-met": "Everything it needs is done.",
+	waiting: "It is still waiting on unfinished work."
+};
+/** The labels the projections give pseudo-states, which carry no label of their own. */
+const pseudoLabels = {
+	initial: "Start",
+	final: "End",
+	fork: "Fork",
+	join: "Join",
+	history: "History"
+};
+/**
+* The text an element is shown with: its own label, or for a pseudo-state the name of its role.
+* @param element - The element to name.
+* @returns The element's display label.
+*/
+const elementLabel = (element) => element.kind === "pseudo" ? pseudoLabels[element.role] : element.label;
+//#endregion
+//#region ../../ui/graph/react/dist/status-badge.js
+/**
+* A status as text, carrying the status in `data-status` so a stylesheet can colour it.
+* @param props - The status and an optional class.
+* @returns A `span` naming the status.
+*/
+const StatusBadge = (props) => {
+	const { status, className } = props;
+	return jsx("span", {
+		className,
+		"data-status": status,
+		children: statusLabels[status]
+	});
+};
+//#endregion
+//#region ../../ui/graph/react/dist/element-card.js
+/**
+* One element: its label, its status, whether it is on the critical path, and what it is blocked by. The root carries `data-element-id`, `data-kind`, `data-status` and, on the critical path, `data-critical`.
+* @param props - The element, its status and what to show beside it.
+* @returns The card.
+*/
+const ElementCard = (props) => {
+	const { element, status, critical = false, blockedBy = [], item, classNames = {} } = props;
+	return jsxs("div", {
+		...item,
+		className: classNames.root,
+		"data-element-id": element.id,
+		"data-kind": element.kind,
+		"data-status": status,
+		"data-critical": critical ? "" : void 0,
+		children: [
+			jsx("span", {
+				className: classNames.label,
+				"data-part": "label",
+				children: elementLabel(element)
+			}),
+			jsx(StatusBadge, {
+				status,
+				className: classNames.status
+			}),
+			critical ? jsx("span", {
+				className: classNames.critical,
+				"data-part": "critical",
+				children: "Critical path"
+			}) : null,
+			blockedBy.length > 0 ? jsxs("span", {
+				className: classNames.blockers,
+				"data-part": "blockers",
+				children: ["Blocked by ", blockedBy.map((blocker) => blocker.label).join(", ")]
+			}) : null
+		]
+	});
+};
+//#endregion
+//#region ../../ui/graph/react/dist/transition-item.js
+/**
+* One transition as a list item: where it comes from, where it goes and its label. The item carries `data-transition-id` and, as applicable, `data-handoff` and `data-critical`; a hand-off says so in its text.
+* @param props - The transition's ends and label.
+* @returns An `li`, to place in a list.
+*/
+const TransitionItem = (props) => {
+	const { id, from, to, label, handoff = false, critical = false, classNames = {} } = props;
+	return jsxs("li", {
+		className: classNames.root,
+		"data-transition-id": id,
+		"data-handoff": handoff ? "" : void 0,
+		"data-critical": critical ? "" : void 0,
+		children: [
+			jsx("span", {
+				className: classNames.from,
+				"data-part": "from",
+				children: from
+			}),
+			" ",
+			"to",
+			" ",
+			jsx("span", {
+				className: classNames.to,
+				"data-part": "to",
+				children: to
+			}),
+			label === void 0 ? null : jsxs("span", {
+				className: classNames.label,
+				"data-part": "label",
+				children: [
+					" ",
+					"(",
+					label,
+					")"
+				]
+			}),
+			handoff ? " (hand-off)" : null
+		]
+	});
+};
+//#endregion
+//#region ../../ui/graph/react/dist/lane.js
+/**
+* A swimlane: a group named by its heading, holding the work of one participant. The group carries `data-lane` with the participant's id.
+* @param props - The participant, its label and the lane's content.
+* @returns The lane.
+*/
+const Lane = (props) => {
+	const { participant, label, children, classNames = {} } = props;
+	const heading = useId();
+	return jsxs("div", {
+		role: "group",
+		"aria-labelledby": heading,
+		className: classNames.root,
+		"data-lane": participant,
+		children: [jsx("h3", {
+			id: heading,
+			className: classNames.heading,
+			"data-part": "heading",
+			children: label
+		}), jsx("div", {
+			className: classNames.body,
+			"data-part": "body",
+			children
+		})]
+	});
+};
+//#endregion
+//#region ../../ui/graph/react/dist/legend.js
+/**
+* A key to the statuses a view colours: a labelled list with a swatch per status. Each item and its swatch carry `data-status`, or `data-critical` for the critical path entry, so a stylesheet colours the swatch by attribute.
+* @param props - The statuses to list and the classes to give its parts.
+* @returns The legend.
+*/
+const Legend = (props) => {
+	const { statuses: shown = statuses, critical = false, classNames = {} } = props;
+	return jsxs("ul", {
+		"aria-label": "Legend",
+		className: classNames.root,
+		children: [shown.map((status) => jsxs("li", {
+			className: classNames.item,
+			"data-status": status,
+			children: [jsx("span", {
+				"aria-hidden": "true",
+				className: classNames.swatch,
+				"data-part": "swatch",
+				"data-status": status
+			}), jsx("span", {
+				className: classNames.label,
+				"data-part": "label",
+				children: statusLabels[status]
+			})]
+		}, status)), critical ? jsxs("li", {
+			className: classNames.item,
+			"data-critical": "",
+			children: [jsx("span", {
+				"aria-hidden": "true",
+				className: classNames.swatch,
+				"data-part": "swatch",
+				"data-critical": ""
+			}), jsx("span", {
+				className: classNames.label,
+				"data-part": "label",
+				children: "Critical path"
+			})]
+		}) : null]
+	});
+};
+//#endregion
+//#region ../../ui/graph/react/dist/filter-panel.js
+const Group = ({ name, legend, options, checked, onToggle, classNames }) => options.length === 0 ? null : jsxs("fieldset", {
+	className: classNames.group,
+	"data-filter": name,
+	children: [jsx("legend", {
+		className: classNames.legend,
+		children: legend
+	}), options.map((option) => jsxs("label", {
+		className: classNames.option,
+		children: [jsx("input", {
+			type: "checkbox",
+			className: classNames.checkbox,
+			value: option.value,
+			checked: checked.has(option.value),
+			onChange: () => {
+				onToggle(option.value);
+			}
+		}), option.label]
+	}, option.value))]
+});
+/**
+* Checkboxes for filtering a view by status, actor and source, and a button that clears them. Each group is a `fieldset` carrying `data-filter` with `status`, `actor` or `source`.
+* @param props - The current filter, what to offer, and the handlers that change it.
+* @returns A search form.
+*/
+const FilterPanel = (props) => {
+	const { filter, options, statuses: offered = statuses, onToggleStatus, onToggleActor, onToggleSource, onClear, classNames = {} } = props;
+	return jsxs("form", {
+		role: "search",
+		"aria-label": "Filter elements",
+		className: classNames.root,
+		onSubmit: (event) => {
+			event.preventDefault();
+		},
+		children: [
+			jsx(Group, {
+				name: "status",
+				legend: "Status",
+				options: offered.map((status) => ({
+					value: status,
+					label: statusLabels[status]
+				})),
+				checked: filter.statuses,
+				onToggle: onToggleStatus,
+				classNames
+			}),
+			jsx(Group, {
+				name: "actor",
+				legend: "Actor",
+				options: options.actors,
+				checked: filter.actors,
+				onToggle: onToggleActor,
+				classNames
+			}),
+			jsx(Group, {
+				name: "source",
+				legend: "Source",
+				options: options.sources,
+				checked: filter.sources,
+				onToggle: onToggleSource,
+				classNames
+			}),
+			jsx("button", {
+				type: "button",
+				className: classNames.clear,
+				onClick: onClear,
+				children: "Clear filters"
+			})
+		]
+	});
+};
+//#endregion
+//#region ../../ui/graph/react/dist/detail-panel.js
+const Section = ({ name, heading, items, classNames }) => {
+	const id = useId();
+	return items.length === 0 ? null : jsxs("section", {
+		"aria-labelledby": id,
+		className: classNames.section,
+		"data-section": name,
+		children: [jsx("h3", {
+			id,
+			className: classNames.sectionHeading,
+			children: heading
+		}), jsx("ul", {
+			className: classNames.list,
+			children: items.map((item) => jsx("li", {
+				"data-element-id": item.id,
+				children: item.label
+			}, item.id))
+		})]
+	});
+};
+/**
+* The details of one element: its status, the rule that decided it, what it is blocked by and what depends on it. The root is a complementary region named by the element's label; each list is a section carrying `data-section` with `blocked-by` or `impact`, shown only when it is not empty.
+* @param props - The element, its explanation, blockers and impact.
+* @returns The panel.
+*/
+const DetailPanel = (props) => {
+	const { element, explanation, blockers, impact, labelOf, classNames = {} } = props;
+	const heading = useId();
+	const named = (ids) => ids.map((id) => ({
+		id,
+		label: labelOf(id)
+	}));
+	return jsxs("aside", {
+		"aria-labelledby": heading,
+		className: classNames.root,
+		"data-element-id": element.id,
+		"data-status": explanation.status,
+		children: [
+			jsx("h2", {
+				id: heading,
+				className: classNames.heading,
+				children: elementLabel(element)
+			}),
+			jsx(StatusBadge, {
+				status: explanation.status,
+				className: classNames.status
+			}),
+			jsx("p", {
+				className: classNames.reason,
+				"data-rule": explanation.rule,
+				children: ruleDescriptions[explanation.rule]
+			}),
+			jsx(Section, {
+				name: "blocked-by",
+				heading: "Blocked by",
+				items: named(blockers),
+				classNames
+			}),
+			jsx(Section, {
+				name: "impact",
+				heading: "Impact",
+				items: named(impact),
+				classNames
+			})
+		]
+	});
+};
+//#endregion
+export { TransitionItem as a, elementLabel as c, Lane as i, ruleDescriptions as l, FilterPanel as n, ElementCard as o, Legend as r, StatusBadge as s, DetailPanel as t, statusLabels as u };