process-graph 1.0.5 → 1.1.0

package/dist/store.js

@@ -0,0 +1,238 @@
+import { r as loopTransitions } from "./control-aDk9560d.js";
+import { C as modelSummarySchema, D as revisionSchema, E as relationSchema, O as storeChangeSchema, S as modelIdSchema, T as relationKinds, _ as GraphStoreError, a as ancestorsOf, b as changeKinds, c as mergeRelations, d as checkStored, f as emptyModel, g as defaultSubscriptionCapacity, h as ChangeFeed, i as serialised, k as storedModelSchema, l as relationIssues, m as overlayWithin, n as tables_exports, o as childrenOf, p as mergeBoundItems, r as migrate, s as descendantsOf, t as createSqliteGraphStore, u as relationsWithin, v as boundActivitySchema, w as reachSchema, x as issueSchema, y as boundItemsSchema } from "./store-BcR70CaO.js";
+import { n as graphStoreContract, t as createGraphStoreRouter } from "./router-D4gtTlXm.js";
+//#region ../../core/graph/store-contract/dist/structure.js
+/**
+* Whether an element is a pure control element: a `decision` or a pseudo-state. Control elements have no work of their own, so the structural queries pass through them and never report them.
+*/
+const isControl = (kind) => kind === "decision" || kind === "pseudo";
+/**
+* Reads a key every caller knows is present: the structural view has an entry for every element of a valid model.
+* @throws Error when the key is absent, which only an invalid model can cause.
+*/
+const lookup = (map, key) => {
+	const value = map.get(key);
+	if (value === void 0) throw new Error(`No element "${key}" in the structural view`);
+	return value;
+};
+/**
+* Builds the structural view of a model and its overlay.
+* @param model - A valid model.
+* @param overlay - Its run state.
+* @returns The view the queries below read.
+*/
+const structureOf = (model, overlay) => {
+	const loops = new Set(loopTransitions(model));
+	const upstream = new Map(model.elements.map(({ id }) => [id, []]));
+	const downstream = new Map(model.elements.map(({ id }) => [id, []]));
+	for (const { id, source, target } of model.transitions) if (!loops.has(id)) {
+		lookup(upstream, target).push(source);
+		lookup(downstream, source).push(target);
+	}
+	return {
+		order: new Map(model.elements.map(({ id }, index) => [id, index])),
+		control: new Set(model.elements.flatMap(({ id, kind }) => isControl(kind) ? [id] : [])),
+		done: new Set(model.elements.flatMap(({ id }) => overlay[id] === "done" ? [id] : [])),
+		open: new Set(model.elements.flatMap(({ id }) => overlay[id] === void 0 || overlay[id] === "open" ? [id] : [])),
+		upstream,
+		downstream
+	};
+};
+/**
+* Breadth-first traversal from `start` along non-loop transitions in one direction, expanding only elements that are not done. Returns every element reached that is neither done nor a control element, with the fewest transitions it takes to reach it, ordered by that distance and then by model order. `start` itself is not reported.
+*/
+const reach = (structure, start, direction) => {
+	const next = structure[direction];
+	const distance = /* @__PURE__ */ new Map([[start, 0]]);
+	let frontier = [start];
+	for (let depth = 1; frontier.length > 0; depth += 1) {
+		const reached = frontier.flatMap((element) => lookup(next, element)).filter((neighbour) => !distance.has(neighbour));
+		for (const neighbour of reached) distance.set(neighbour, depth);
+		frontier = [...new Set(reached)].filter((neighbour) => !structure.done.has(neighbour));
+	}
+	distance.delete(start);
+	return [...distance].filter(([element]) => !structure.done.has(element) && !structure.control.has(element)).map(([element, steps]) => ({
+		element,
+		distance: steps
+	})).sort((left, right) => left.distance - right.distance || lookup(structure.order, left.element) - lookup(structure.order, right.element));
+};
+/**
+* What still stands before an element: the unfinished work upstream of it. An element that is done waits on nothing.
+* @param structure - The structural view.
+* @param element - An element of the model.
+* @returns The upstream elements that are not done and are not control elements, by distance and then model order.
+*/
+const blockedChainOf = (structure, element) => structure.done.has(element) ? [] : reach(structure, element, "upstream");
+/**
+* What depends on an element: the unfinished work downstream of it, whatever the element's own state.
+* @param structure - The structural view.
+* @param element - An element of the model.
+* @returns The downstream elements that are not done and are not control elements, by distance and then model order.
+*/
+const impactOf = (structure, element) => reach(structure, element, "downstream");
+/**
+* The work that can start now: every open element (no run state, or `open`) that is not a control element and has nothing unfinished upstream.
+* @param structure - The structural view.
+* @returns The ready elements, in model order.
+*/
+const readyOf = (structure) => [...structure.order.keys()].filter((element) => structure.open.has(element) && !structure.control.has(element) && blockedChainOf(structure, element).length === 0);
+//#endregion
+//#region ../../core/graph/store-contract/dist/fake.js
+/** Runs a synchronous store operation as the async one the port expects; a throw becomes a rejection. */
+const later = (operation) => async (request) => Promise.resolve(request).then(operation);
+const encoder = new TextEncoder();
+/**
+* Orders strings by their UTF-8 bytes, which is Unicode code point order and the order SQLite's default `BINARY` collation gives text. JavaScript's own `<` compares UTF-16 code units, which puts characters outside the Basic Multilingual Plane before those from U+E000 up.
+*/
+const byCodePoint = (left, right) => {
+	const theirs = encoder.encode(right).values();
+	for (const byte of encoder.encode(left)) {
+		const other = theirs.next();
+		if (other.done === true) return 1;
+		if (byte !== other.value) return byte - other.value;
+	}
+	return theirs.next().done === true ? 0 : -1;
+};
+/**
+* The reference in-memory store: the behaviour every adapter's conformance run is compared with. Models are held as values and replaced on every write, so a failed check leaves the previous value in place.
+* @returns A store with no models, revisions starting after zero.
+*/
+const createFakeGraphStore = () => {
+	const feed = new ChangeFeed();
+	const entries = /* @__PURE__ */ new Map();
+	let sequence = 0;
+	const entryOf = (modelId) => {
+		const entry = entries.get(modelId);
+		if (entry === void 0) throw new GraphStoreError({
+			kind: "not-found",
+			modelId
+		});
+		return entry;
+	};
+	const elementOf = (modelId, element) => {
+		const entry = entryOf(modelId);
+		if (!entry.model.elements.some(({ id }) => id === element)) throw new GraphStoreError({
+			kind: "not-found",
+			modelId,
+			element
+		});
+		return entry;
+	};
+	const write = ({ modelId, kind, model, overlay, relations, signal }) => {
+		checkStored(model, overlay);
+		const issues = relationIssues(model, relations);
+		if (issues.length > 0) throw new GraphStoreError({
+			kind: "invalid",
+			issues
+		});
+		signal?.throwIfAborted();
+		sequence += 1;
+		entries.set(modelId, {
+			model,
+			overlay,
+			relations,
+			revision: sequence
+		});
+		feed.publish({
+			modelId,
+			kind,
+			revision: sequence
+		});
+		return sequence;
+	};
+	return {
+		feed,
+		listModels: later(() => [...entries].map(([modelId, { revision }]) => ({
+			modelId,
+			revision
+		})).sort((left, right) => byCodePoint(left.modelId, right.modelId))),
+		saveModel: later(({ modelId, model, signal }) => {
+			const existing = entries.get(modelId);
+			return write({
+				modelId,
+				kind: "saved",
+				model,
+				overlay: overlayWithin(model, existing?.overlay ?? {}),
+				relations: relationsWithin(model, existing?.relations ?? []),
+				signal
+			});
+		}),
+		loadModel: later(({ modelId }) => {
+			const { model, overlay, revision } = entryOf(modelId);
+			return {
+				modelId,
+				revision,
+				model,
+				overlay
+			};
+		}),
+		deleteModel: later(({ modelId, signal }) => {
+			if (!entries.has(modelId)) return;
+			signal?.throwIfAborted();
+			entries.delete(modelId);
+			sequence += 1;
+			feed.publish({
+				modelId,
+				kind: "deleted",
+				revision: sequence
+			});
+			return sequence;
+		}),
+		applyOverlay: later(({ modelId, overlay, signal }) => {
+			const entry = entryOf(modelId);
+			return write({
+				modelId,
+				kind: "overlay",
+				model: entry.model,
+				overlay: {
+					...entry.overlay,
+					...overlay
+				},
+				relations: entry.relations,
+				signal
+			});
+		}),
+		upsertItems: later(({ modelId, items, signal }) => {
+			const entry = entries.get(modelId) ?? {
+				model: emptyModel,
+				overlay: {},
+				relations: []
+			};
+			return write({
+				modelId,
+				kind: "items",
+				...mergeBoundItems(entry.model, entry.overlay, items),
+				relations: mergeRelations(entry.relations, items.relations ?? []),
+				signal
+			});
+		}),
+		relations: later(({ modelId }) => entryOf(modelId).relations),
+		children: later(({ modelId, element }) => {
+			const { model, relations } = elementOf(modelId, element);
+			return childrenOf(model, relations, element);
+		}),
+		descendants: later(({ modelId, element }) => {
+			const { model, relations } = elementOf(modelId, element);
+			return descendantsOf(model, relations, element);
+		}),
+		ancestors: later(({ modelId, element }) => {
+			const { model, relations } = elementOf(modelId, element);
+			return ancestorsOf(model, relations, element);
+		}),
+		ready: later(({ modelId }) => {
+			const { model, overlay } = entryOf(modelId);
+			return readyOf(structureOf(model, overlay));
+		}),
+		blockedChain: later(({ modelId, element }) => {
+			const { model, overlay } = elementOf(modelId, element);
+			return blockedChainOf(structureOf(model, overlay), element);
+		}),
+		impact: later(({ modelId, element }) => {
+			const { model, overlay } = elementOf(modelId, element);
+			return impactOf(structureOf(model, overlay), element);
+		}),
+		revisionOf: later(({ modelId }) => entries.get(modelId)?.revision)
+	};
+};
+//#endregion
+export { ChangeFeed, GraphStoreError, ancestorsOf, blockedChainOf, boundActivitySchema, boundItemsSchema, changeKinds, checkStored, childrenOf, createFakeGraphStore, createGraphStoreRouter, createSqliteGraphStore, defaultSubscriptionCapacity, descendantsOf, emptyModel, graphStoreContract, impactOf, issueSchema, mergeBoundItems, mergeRelations, migrate, modelIdSchema, modelSummarySchema, overlayWithin, reachSchema, readyOf, relationIssues, relationKinds, relationSchema, relationsWithin, revisionSchema, serialised, storeChangeSchema, storedModelSchema, structureOf, tables_exports as tables };

package/dist/ui/style.css

@@ -0,0 +1,351 @@
+._1pqhw58r {
+  --_1pqhw58e: 0.25rem;
+  --_1pqhw58f: 0.5rem;
+  --_1pqhw58g: 1rem;
+  --_1pqhw58h: 0.25rem;
+  --_1pqhw58i: 0.5rem;
+  --_1pqhw58j: system-ui, -apple-system, "Segoe UI", sans-serif;
+  --_1pqhw58k: ui-monospace, "SFMono-Regular", Menlo, monospace;
+  --_1pqhw58l: 0.75rem;
+  --_1pqhw58m: 0.875rem;
+  --_1pqhw58n: 1rem;
+  --_1pqhw58o: 600;
+  --_1pqhw58p: 1px;
+  --_1pqhw58q: 3px;
+  --_1pqhw580: #ffffff;
+  --_1pqhw581: #f6f8fa;
+  --_1pqhw582: #1f2328;
+  --_1pqhw583: #59636e;
+  --_1pqhw584: #d1d9e0;
+  --_1pqhw585: #0969da;
+  --_1pqhw586: #0969da;
+  --_1pqhw587: #9a6700;
+  --_1pqhw588: #6639ba;
+  --_1pqhw589: #1a7f37;
+  --_1pqhw58a: #0550ae;
+  --_1pqhw58b: #cf222e;
+  --_1pqhw58c: #59636e;
+  --_1pqhw58d: #6639ba;
+}
+._1pqhw58s {
+  --_1pqhw58e: 0.25rem;
+  --_1pqhw58f: 0.5rem;
+  --_1pqhw58g: 1rem;
+  --_1pqhw58h: 0.25rem;
+  --_1pqhw58i: 0.5rem;
+  --_1pqhw58j: system-ui, -apple-system, "Segoe UI", sans-serif;
+  --_1pqhw58k: ui-monospace, "SFMono-Regular", Menlo, monospace;
+  --_1pqhw58l: 0.75rem;
+  --_1pqhw58m: 0.875rem;
+  --_1pqhw58n: 1rem;
+  --_1pqhw58o: 600;
+  --_1pqhw58p: 1px;
+  --_1pqhw58q: 3px;
+  --_1pqhw580: #0d1117;
+  --_1pqhw581: #161b22;
+  --_1pqhw582: #e6edf3;
+  --_1pqhw583: #9198a1;
+  --_1pqhw584: #3d444d;
+  --_1pqhw585: #4493f8;
+  --_1pqhw586: #4493f8;
+  --_1pqhw587: #d29922;
+  --_1pqhw588: #ab7df8;
+  --_1pqhw589: #3fb950;
+  --_1pqhw58a: #58a6ff;
+  --_1pqhw58b: #f85149;
+  --_1pqhw58c: #9198a1;
+  --_1pqhw58d: #ab7df8;
+}.xk03iz0 {
+  background-color: var(--_1pqhw580);
+  color: var(--_1pqhw582);
+  font-family: var(--_1pqhw58j);
+  font-size: var(--_1pqhw58m);
+}
+.xk03iz1 {
+  position: absolute;
+  width: 1px;
+  height: 1px;
+  padding: 0;
+  margin: -1px;
+  overflow: hidden;
+  clip: rect(0, 0, 0, 0);
+  white-space: nowrap;
+  border: 0;
+}
+.xk03iz2:focus-visible {
+  outline: var(--_1pqhw58q) solid var(--_1pqhw586);
+  outline-offset: var(--_1pqhw58p);
+}
+.xk03iz0 *, .xk03iz0 *::before, .xk03iz0 *::after {
+  box-sizing: border-box;
+}._1qote9c0 {
+  display: inline-flex;
+  align-items: center;
+  padding: 0 var(--_1pqhw58e);
+  border: var(--_1pqhw58p) solid currentColor;
+  border-radius: var(--_1pqhw58h);
+  font-size: var(--_1pqhw58l);
+  font-weight: var(--_1pqhw58o);
+  white-space: nowrap;
+}
+._1qote9c1 {
+  color: var(--_1pqhw589);
+}
+._1qote9c2 {
+  color: var(--_1pqhw58a);
+}
+._1qote9c3 {
+  color: var(--_1pqhw58b);
+}
+._1qote9c4 {
+  color: var(--_1pqhw58c);
+}
+._1qote9c5 {
+  color: var(--_1pqhw58d);
+}
+._1qote9c6 {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: var(--_1pqhw58e);
+  padding: var(--_1pqhw58f);
+  background-color: var(--_1pqhw581);
+  border: var(--_1pqhw58p) solid var(--_1pqhw584);
+  border-left-width: var(--_1pqhw58q);
+  border-radius: var(--_1pqhw58i);
+  cursor: default;
+}
+._1qote9c6[aria-selected="true"] {
+  outline: var(--_1pqhw58q) solid var(--_1pqhw585);
+}
+._1qote9c7 {
+  border-left-color: var(--_1pqhw589);
+}
+._1qote9c8 {
+  border-left-color: var(--_1pqhw58a);
+}
+._1qote9c9 {
+  border-left-color: var(--_1pqhw58b);
+}
+._1qote9ca {
+  border-left-color: var(--_1pqhw58c);
+}
+._1qote9cb {
+  border-left-color: var(--_1pqhw58d);
+}
+._1qote9ce {
+  border-style: dashed;
+}
+._1qote9cf {
+  border-radius: var(--_1pqhw58g);
+}
+._1qote9cg {
+  font-style: italic;
+}
+._1qote9ch {
+  box-shadow: 0 0 0 var(--_1pqhw58q) var(--_1pqhw587);
+}
+._1qote9cj {
+  font-weight: var(--_1pqhw58o);
+}
+._1qote9ck {
+  color: var(--_1pqhw587);
+  font-size: var(--_1pqhw58l);
+  font-weight: var(--_1pqhw58o);
+}
+._1qote9cl {
+  flex-basis: 100%;
+  color: var(--_1pqhw583);
+  font-size: var(--_1pqhw58l);
+}
+._1qote9cm {
+  color: var(--_1pqhw583);
+}
+._1qote9cm[data-handoff] {
+  color: var(--_1pqhw588);
+}
+._1qote9cm[data-critical] {
+  color: var(--_1pqhw587);
+  font-weight: var(--_1pqhw58o);
+}
+._1qote9cn {
+  color: var(--_1pqhw582);
+}
+._1qote9co {
+  border: var(--_1pqhw58p) solid var(--_1pqhw584);
+  border-radius: var(--_1pqhw58i);
+  padding: var(--_1pqhw58f);
+}
+._1qote9cp {
+  margin: 0 0 var(--_1pqhw58f);
+  color: var(--_1pqhw583);
+  font-size: var(--_1pqhw58l);
+  text-transform: uppercase;
+}
+._1qote9cq {
+  display: flex;
+  flex-wrap: wrap;
+  gap: var(--_1pqhw58f);
+}
+._1qote9cr {
+  display: flex;
+  flex-wrap: wrap;
+  gap: var(--_1pqhw58g);
+  margin: 0;
+  padding: 0;
+  list-style: none;
+  font-size: var(--_1pqhw58l);
+}
+._1qote9cs {
+  display: inline-flex;
+  align-items: center;
+  gap: var(--_1pqhw58e);
+}
+._1qote9ct {
+  display: inline-block;
+  width: var(--_1pqhw58l);
+  height: var(--_1pqhw58l);
+  border-radius: var(--_1pqhw58h);
+}
+._1qote9ct[data-status="done"] {
+  background-color: var(--_1pqhw589);
+}
+._1qote9ct[data-status="ready"] {
+  background-color: var(--_1pqhw58a);
+}
+._1qote9ct[data-status="blocked"] {
+  background-color: var(--_1pqhw58b);
+}
+._1qote9ct[data-status="skipped"] {
+  background-color: var(--_1pqhw58c);
+}
+._1qote9ct[data-status="unknown"] {
+  background-color: var(--_1pqhw58d);
+}
+._1qote9ct[data-critical] {
+  background-color: var(--_1pqhw587);
+}
+._1qote9cu {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: flex-start;
+  gap: var(--_1pqhw58g);
+}
+._1qote9cv {
+  display: flex;
+  flex-wrap: wrap;
+  gap: var(--_1pqhw58f);
+  margin: 0;
+  border: var(--_1pqhw58p) solid var(--_1pqhw584);
+  border-radius: var(--_1pqhw58i);
+  padding: var(--_1pqhw58f);
+}
+._1qote9cw {
+  padding: 0 var(--_1pqhw58e);
+  color: var(--_1pqhw583);
+  font-size: var(--_1pqhw58l);
+}
+._1qote9cx {
+  display: inline-flex;
+  align-items: center;
+  gap: var(--_1pqhw58e);
+}
+._1qote9cy {
+  accent-color: var(--_1pqhw585);
+}
+._1qote9cz {
+  padding: var(--_1pqhw58e) var(--_1pqhw58f);
+  color: var(--_1pqhw585);
+  background-color: transparent;
+  border: var(--_1pqhw58p) solid var(--_1pqhw584);
+  border-radius: var(--_1pqhw58h);
+  font: inherit;
+  cursor: pointer;
+}
+._1qote9c10 {
+  display: flex;
+  flex-direction: column;
+  align-items: flex-start;
+  gap: var(--_1pqhw58f);
+  padding: var(--_1pqhw58g);
+  background-color: var(--_1pqhw581);
+  border: var(--_1pqhw58p) solid var(--_1pqhw584);
+  border-radius: var(--_1pqhw58i);
+}
+._1qote9c11 {
+  margin: 0;
+  font-size: var(--_1pqhw58n);
+}
+._1qote9c12 {
+  margin: 0;
+}
+._1qote9c13 {
+  margin: 0;
+  color: var(--_1pqhw583);
+  font-size: var(--_1pqhw58l);
+}
+._1qote9c14 {
+  margin: var(--_1pqhw58e) 0 0;
+  padding-left: var(--_1pqhw58g);
+}._1y9ef240 {
+  margin: 0;
+}
+._1y9ef241 {
+  margin-bottom: var(--_1pqhw58f);
+  font-weight: var(--_1pqhw58o);
+}
+._1y9ef242 {
+  display: block;
+  max-width: 100%;
+}
+._1y9ef243 {
+  fill: var(--_1pqhw581);
+  stroke: var(--_1pqhw584);
+  stroke-width: var(--_1pqhw58p);
+}
+._1y9ef244 {
+  stroke: var(--_1pqhw583);
+  stroke-width: var(--_1pqhw58p);
+  stroke-dasharray: 4 4;
+}
+._1y9ef245 {
+  fill: var(--_1pqhw582);
+  font-family: var(--_1pqhw58j);
+  font-size: var(--_1pqhw58m);
+}
+._1y9ef246 {
+  fill: var(--_1pqhw583);
+  font-family: var(--_1pqhw58j);
+  font-size: var(--_1pqhw58l);
+}
+._1y9ef247 {
+  fill: none;
+  stroke: var(--_1pqhw582);
+  stroke-width: var(--_1pqhw58p);
+}
+._1y9ef247[data-mode="reply"] {
+  stroke-dasharray: 4 4;
+}
+._1y9ef248 {
+  fill: var(--_1pqhw582);
+}
+._1y9ef249 {
+  fill: none;
+  stroke: var(--_1pqhw582);
+  stroke-width: var(--_1pqhw58p);
+}
+._1y9ef24a {
+  fill: none;
+  stroke: var(--_1pqhw584);
+  stroke-width: var(--_1pqhw58p);
+}
+._1y9ef24b {
+  stroke: var(--_1pqhw584);
+  stroke-width: var(--_1pqhw58p);
+  stroke-dasharray: 4 4;
+}
+._1y9ef24c {
+  fill: var(--_1pqhw581);
+  stroke: var(--_1pqhw584);
+  stroke-width: var(--_1pqhw58p);
+}/*$vite$:1*/