process-graph 1.0.5 → 1.1.0

package/dist/layout-CCM-KBdp.js

@@ -0,0 +1,307 @@
+import ELK from "elkjs/lib/elk.bundled.js";
+//#region ../../core/graph/layout/dist/elk-engine.js
+/**
+* Fixes ELK's randomised tie-breaking, so the same graph always yields the same boxes. ELK's own default is the same value; it is set explicitly so a change of default cannot make output depend on the library version.
+*/
+const RANDOM_SEED = "1";
+const elkDirection = {
+	right: "RIGHT",
+	down: "DOWN",
+	left: "LEFT",
+	up: "UP"
+};
+const toElkNode = (node, groupPadding) => {
+	if (node.children === void 0) return {
+		id: node.id,
+		width: node.width,
+		height: node.height
+	};
+	const layoutOptions = {
+		"elk.padding": `[top=${groupPadding},left=${groupPadding},bottom=${groupPadding},right=${groupPadding}]`,
+		"elk.nodeSize.constraints": "MINIMUM_SIZE",
+		"elk.nodeSize.minimum": `(${node.width},${node.height})`
+	};
+	return {
+		id: node.id,
+		layoutOptions,
+		children: node.children.map((child) => toElkNode(child, groupPadding))
+	};
+};
+/** Flattens ELK's parent-relative coordinates into absolute boxes, outermost nodes first. */
+const flatten = (root) => {
+	const boxes = [];
+	const stack = [];
+	for (const child of root.children ?? []) stack.push({
+		node: child,
+		x: 0,
+		y: 0
+	});
+	for (let next = stack.pop(); next !== void 0; next = stack.pop()) {
+		const { node, x: originX, y: originY } = next;
+		const x = originX + (node.x ?? 0);
+		const y = originY + (node.y ?? 0);
+		boxes.push({
+			id: node.id,
+			x,
+			y,
+			width: node.width ?? 0,
+			height: node.height ?? 0
+		});
+		for (const child of node.children ?? []) stack.push({
+			node: child,
+			x,
+			y
+		});
+	}
+	return boxes;
+};
+/**
+* The default engine: elkjs's layered algorithm, run in the calling context from the bundled build so it needs neither a Worker nor Node-only modules. Groups are laid out together with their children (`INCLUDE_CHILDREN`), so an edge between lanes takes part in layer assignment.
+*/
+const createElkEngine = () => {
+	const elk = new ELK();
+	return { async arrange(graph) {
+		const edges = graph.edges.map((edge) => ({
+			id: edge.id,
+			sources: [edge.source],
+			targets: [edge.target]
+		}));
+		const root = {
+			id: "root",
+			layoutOptions: {
+				"elk.algorithm": "layered",
+				"elk.direction": elkDirection[graph.direction],
+				"elk.spacing.nodeNode": String(graph.nodeGap),
+				"elk.layered.spacing.nodeNodeBetweenLayers": String(graph.layerGap),
+				"elk.hierarchyHandling": "INCLUDE_CHILDREN",
+				"elk.randomSeed": RANDOM_SEED
+			},
+			children: graph.nodes.map((node) => toElkNode(node, graph.groupPadding)),
+			edges
+		};
+		return flatten(await elk.layout(root));
+	} };
+};
+//#endregion
+//#region ../../core/graph/layout/dist/metrics.js
+/**
+* The unit every dimension below is a multiple of, so nodes of different shapes and lanes align on one grid and a renderer that snaps to a grid snaps to the same points.
+*/
+const GRID = 8;
+/** A process step or state: wide enough for a short label on one line. */
+const PROCESS_UNITS = {
+	width: 20,
+	height: 8
+};
+/** A start or end terminator: a rounded box smaller than a step, so it reads as a boundary. */
+const TERMINATOR_UNITS = {
+	width: 12,
+	height: 6
+};
+/** A decision diamond: taller than a step, because a diamond has less usable width than the box that encloses it. */
+const DECISION_UNITS = {
+	width: 16,
+	height: 12
+};
+/** The initial and final pseudo-states of a state machine: a dot, as in the notation. */
+const PSEUDO_STATE_UNITS = {
+	width: 4,
+	height: 4
+};
+/** The least a lane may measure, so a lane with no nodes is still visible. */
+const LANE_MINIMUM_UNITS = {
+	width: 24,
+	height: 12
+};
+const sized = (units) => ({
+	width: units.width * GRID,
+	height: units.height * GRID
+});
+const PROCESS_SIZE = sized(PROCESS_UNITS);
+const TERMINATOR_SIZE = sized(TERMINATOR_UNITS);
+const DECISION_SIZE = sized(DECISION_UNITS);
+const PSEUDO_STATE_SIZE = sized(PSEUDO_STATE_UNITS);
+const LANE_MINIMUM_SIZE = sized(LANE_MINIMUM_UNITS);
+/**
+* The bar across the flow: a fork or join is drawn perpendicular to the edges it gathers or splits, so it is tall when edges run sideways and wide when they run vertically.
+*/
+const barSize = (direction) => {
+	const thickness = 8;
+	const length = 96;
+	return direction === "right" || direction === "left" ? {
+		width: thickness,
+		height: length
+	} : {
+		width: length,
+		height: thickness
+	};
+};
+//#endregion
+//#region ../../core/graph/layout/dist/layout.js
+const flowNodeSizes = {
+	process: PROCESS_SIZE,
+	terminator: TERMINATOR_SIZE,
+	decision: DECISION_SIZE
+};
+const flowNodeSize = (shape, direction) => shape === "bar" ? barSize(direction) : flowNodeSizes[shape];
+const stateSize = (role) => role === "state" ? PROCESS_SIZE : PSEUDO_STATE_SIZE;
+const prepare = (view, direction) => {
+	if ("states" in view) return {
+		notation: "stateMachine",
+		elements: view.states.map((state) => ({
+			id: state.id,
+			size: stateSize(state.role)
+		})),
+		edges: view.transitions.map((transition) => ({
+			from: transition.source,
+			to: transition.target
+		})),
+		lanes: []
+	};
+	const elements = view.nodes.map((node) => ({
+		id: node.id,
+		size: flowNodeSize(node.shape, direction)
+	}));
+	if ("lanes" in view) return {
+		notation: "swimlane",
+		elements,
+		edges: view.edges,
+		lanes: view.lanes
+	};
+	return {
+		notation: "flowchart",
+		elements,
+		edges: view.edges,
+		lanes: []
+	};
+};
+/**
+* Settles by throwing the signal's own reason once it aborts, and never settles if `stop` aborts first, which also removes the listener.
+*/
+const whenAborted = async (signal, stop) => {
+	await new Promise((resolve) => {
+		signal.addEventListener("abort", () => {
+			resolve();
+		}, {
+			once: true,
+			signal: stop
+		});
+	});
+	signal.throwIfAborted();
+	throw new Error("The signal aborted without a reason");
+};
+/**
+* Places a projected view with a layered layout and returns where each element goes, as the model's `views` shape.
+*
+* Pure with respect to the model: it reads only the view, never mutates it, and the model stores the result apart from its semantics, so no projection reads a coordinate. The same view and options give the same positions with the default engine. Swimlane lanes are groups, and every node lies inside its lane's bounds.
+* @param view - A flowchart, swimlane or state machine from the projection package.
+* @param options - Direction, spacing, abort signal and engine.
+* @returns Positions keyed by notation and element id, element sizes and lane bounds.
+* @throws The signal's reason when `options.signal` aborts before the layout completes.
+*/
+const layout = async (view, options = {}) => {
+	const { direction = "right", spacing, signal, engine = createElkEngine() } = options;
+	signal?.throwIfAborted();
+	const prepared = prepare(view, direction);
+	const elementIds = /* @__PURE__ */ new Map();
+	const leaves = /* @__PURE__ */ new Map();
+	prepared.elements.forEach((element, index) => {
+		const id = `n${index}`;
+		elementIds.set(element.id, id);
+		leaves.set(id, element);
+	});
+	const leafNode = (id, size) => ({
+		id,
+		...size
+	});
+	const nodeFor = (element) => {
+		const id = elementIds.get(element);
+		const leaf = id === void 0 ? void 0 : leaves.get(id);
+		return id === void 0 || leaf === void 0 ? void 0 : leafNode(id, leaf.size);
+	};
+	const placedInLane = /* @__PURE__ */ new Set();
+	const laneIds = [];
+	const nodes = [];
+	prepared.lanes.forEach((lane, index) => {
+		const id = `l${index}`;
+		laneIds.push(id);
+		const children = [];
+		for (const element of lane.nodes) {
+			const child = nodeFor(element);
+			if (child !== void 0) {
+				placedInLane.add(element);
+				children.push(child);
+			}
+		}
+		nodes.push({
+			id,
+			...LANE_MINIMUM_SIZE,
+			children
+		});
+	});
+	for (const element of prepared.elements) if (!placedInLane.has(element.id)) {
+		const node = nodeFor(element.id);
+		if (node !== void 0) nodes.push(node);
+	}
+	const edges = [];
+	prepared.edges.forEach((edge, index) => {
+		const source = elementIds.get(edge.from);
+		const target = elementIds.get(edge.to);
+		if (source !== void 0 && target !== void 0) edges.push({
+			id: `e${index}`,
+			source,
+			target
+		});
+	});
+	const request = engine.arrange({
+		direction,
+		nodeGap: spacing?.node ?? 32,
+		layerGap: spacing?.layer ?? 64,
+		groupPadding: 32,
+		nodes,
+		edges
+	}, signal);
+	let boxes;
+	if (signal === void 0) boxes = await request;
+	else {
+		const stop = new AbortController();
+		try {
+			boxes = await Promise.race([request, whenAborted(signal, stop.signal)]);
+		} finally {
+			stop.abort();
+		}
+	}
+	const byId = new Map(boxes.map((box) => [box.id, box]));
+	const positions = {};
+	const sizes = {};
+	for (const [id, element] of leaves) {
+		const box = byId.get(id);
+		if (box === void 0) throw new Error(`The layout engine returned no box for element "${element.id}"`);
+		positions[element.id] = {
+			x: box.x,
+			y: box.y
+		};
+		sizes[element.id] = {
+			width: box.width,
+			height: box.height
+		};
+	}
+	const lanes = prepared.lanes.map((lane, index) => {
+		const box = byId.get(laneIds[index] ?? "");
+		if (box === void 0) throw new Error(`The layout engine returned no box for lane "${lane.participant}"`);
+		return {
+			participant: lane.participant,
+			x: box.x,
+			y: box.y,
+			width: box.width,
+			height: box.height
+		};
+	});
+	return {
+		views: { [prepared.notation]: positions },
+		sizes,
+		lanes
+	};
+};
+//#endregion
+export { createElkEngine as n, layout as t };

package/dist/layout.d.ts

@@ -0,0 +1,8 @@
+import { a as layout, c as EngineBox, d as EngineGroup, f as EngineLeaf, i as LayoutView, l as EngineEdge, m as LayoutEngine, n as LayoutOptions, o as Size, p as EngineNode, r as LayoutResult, s as Direction, t as LaneBounds, u as EngineGraph } from "./index-CrM5qWUA.js";
+//#region ../../core/graph/layout/dist/elk-engine.d.ts
+/**
+ * The default engine: elkjs's layered algorithm, run in the calling context from the bundled build so it needs neither a Worker nor Node-only modules. Groups are laid out together with their children (`INCLUDE_CHILDREN`), so an edge between lanes takes part in layer assignment.
+ */
+export declare const createElkEngine: () => LayoutEngine;
+//#endregion
+export { type Direction, type EngineBox, type EngineEdge, type EngineGraph, type EngineGroup, type EngineLeaf, type EngineNode, type LaneBounds, type LayoutEngine, type LayoutOptions, type LayoutResult, type LayoutView, type Size, layout };

package/dist/layout.js

@@ -0,0 +1,2 @@
+import { n as createElkEngine, t as layout } from "./layout-CCM-KBdp.js";
+export { createElkEngine, layout };

package/dist/node-AchI1T-K.js

@@ -0,0 +1,40 @@
+import { t as GraphSourceError } from "./errors-BZe5WzCn.js";
+import { execFile } from "node:child_process";
+//#region ../../adapters/graph/source-github-issues/dist/node.js
+/** Runs `gh auth token` and resolves with its standard output. */
+const ghAuthToken = async () => new Promise((resolve, reject) => {
+	execFile("gh", ["auth", "token"], (error, stdout) => {
+		if (error === null) resolve(stdout);
+		else reject(new Error("gh auth token failed", { cause: error }));
+	});
+});
+/**
+* A token port for Node that uses `GITHUB_TOKEN` when it is set and not empty, and otherwise the token the GitHub CLI holds (`gh auth token`), asked for once and reused. The same token serves every owner. The token is never logged, and an error from the CLI is reported without its output.
+* @param options - The environment and the CLI runner, for tests.
+* @returns The token port.
+*/
+const githubTokenFromEnvironment = (options = {}) => {
+	const env = options.env ?? process.env;
+	const runGh = options.runGh ?? ghAuthToken;
+	const fromEnvironment = env.GITHUB_TOKEN;
+	let fromCli;
+	return async () => {
+		if (fromEnvironment !== void 0 && fromEnvironment !== "") return fromEnvironment;
+		fromCli ??= runGh().then((output) => {
+			const token = output.trim();
+			if (token === "") throw new GraphSourceError({
+				kind: "unauthorised",
+				message: "gh auth token printed no token; run gh auth login"
+			});
+			return token;
+		}, (error) => {
+			throw new GraphSourceError({
+				kind: "unauthorised",
+				message: "no GitHub token: GITHUB_TOKEN is not set and gh auth token failed; set GITHUB_TOKEN or run gh auth login"
+			}, { cause: error });
+		});
+		return fromCli;
+	};
+};
+//#endregion
+export { githubTokenFromEnvironment as t };

package/dist/open-CyRXJ4bt.js

@@ -0,0 +1,29 @@
+import { t as createSqliteGraphStore } from "./store-BcR70CaO.js";
+import { sql } from "drizzle-orm";
+import { DatabaseSync } from "node:sqlite";
+import { drizzle } from "drizzle-orm/node-sqlite";
+//#region ../../adapters/graph/sqlite-node/dist/open.js
+/** The path `node:sqlite` reads as a private database in memory rather than a file. */
+const inMemory = ":memory:";
+/**
+* Opens a graph store on a SQLite database file, creating the file when it does not exist. The schema is migrated on the store's first operation.
+*
+* A file database is switched to write-ahead logging, so readers in other processes (a command line beside a server) are not blocked by a writer. Each process's change feed sees only its own writes.
+* @param path - The database file, or `":memory:"` for a private database that lives as long as the store.
+* @param options - `node:sqlite` options passed through unchanged, such as `timeout` for how long a write waits for another process's lock.
+* @returns The store, its database and a way to close it.
+*/
+const openNodeGraphStore = (path, options = {}) => {
+	const client = new DatabaseSync(path, options);
+	const db = drizzle({ client });
+	if (path !== inMemory) db.run(sql`PRAGMA journal_mode = WAL`);
+	return {
+		store: createSqliteGraphStore({ db }),
+		db,
+		close: () => {
+			client.close();
+		}
+	};
+};
+//#endregion
+export { openNodeGraphStore as t };

package/dist/parse-CuipC_2K.js

@@ -0,0 +1,41 @@
+import { o as toPointer, t as modelSchema } from "./schema-CVnS6HiX.js";
+import { t as validate } from "./validate-DF3mQZww.js";
+//#region ../../core/graph/schema/dist/parse.js
+/** Thrown by `parseModel` when the input is not a valid model. */
+var ModelParseError = class extends Error {
+	/** Every problem found, in the order the schema and then `validate` reported them. Never empty. */
+	issues;
+	/**
+	* @param issues - The problems found. Must not be empty.
+	*/
+	constructor(issues) {
+		super(`Invalid model: ${issues.map((issue) => issue.source === "schema" ? `${issue.pointer === "" ? "/" : issue.pointer}: ${issue.message}` : issue.message).join("; ")}`);
+		this.name = "ModelParseError";
+		this.issues = issues;
+	}
+};
+/**
+* Loads a model from untrusted input, such as parsed JSON.
+*
+* The input is checked against the open schema first, so every shape problem is reported with the JSON pointer of the offending value. Only a well-shaped model is then passed to `validate`, whose issues are surfaced the same way.
+* @param input - The value to load.
+* @returns The validated model, with identifiers as plain strings.
+* @throws ModelParseError when the input is not a well-shaped model or fails `validate`.
+*/
+const parseModel = (input) => {
+	const parsed = modelSchema.safeParse(input);
+	if (!parsed.success) throw new ModelParseError(parsed.error.issues.map((issue) => ({
+		source: "schema",
+		pointer: toPointer(issue.path),
+		message: issue.message
+	})));
+	const issues = validate(parsed.data);
+	if (issues.length > 0) throw new ModelParseError(issues.map((issue) => ({
+		source: "validate",
+		code: issue.code,
+		message: issue.message
+	})));
+	return parsed.data;
+};
+//#endregion
+export { parseModel as n, ModelParseError as t };