@dskripchenko/flow 0.0.0-stage → 1.0.1

package/dist/index.mjs

@@ -0,0 +1 @@
+export { nt as BUILTIN_TYPES, v as CommandError, t as DEFAULT_LIMITS, N as DESCRIPTION_FONT, P as EDGE_FONT, ft as GRAPH_VERSION, ct as GraphError, _ as History, F as LABEL_FONT, $ as LayoutError, Z as MAX_EDGES, Q as MAX_NODES, T as STATUS_TONES, u as alignNodes, y as applyCommand, Y as approximateMeasurer, C as backoffDelay, H as bezierPoint, I as boundsOf, n as centreOn, r as clampZoom, d as copyFragment, w as createPoller, rt as createRegistry, it as defaultRegistry, b as describeCommand, U as distanceToPolyline, f as distributeNodes, lt as emptyGraph, E as emptyMonitorState, W as facingSide, p as findFreeSpot, i as fitView, L as frameAround, pt as isEnabled, m as isFragment, at as isLocked, D as isStale, a as isVisible, et as issuesByElement, h as layoutCommand, R as layoutGraph, z as measureEdgeLabel, B as measureNode, O as mergeSnapshot, G as midpoint, o as nearestInDirection, x as nextId, ut as parseGraph, g as pasteFragment, k as pathEdges, ot as portsOf, A as reduceMonitor, K as route, V as routeEdges, q as sideNormal, J as sidePoint, S as snap, j as statusSummary, dt as stringifyGraph, M as toEpoch, s as toGraph, c as toScreen, st as typeOf, tt as validateGraph, X as wrapText, l as zoomAt } from "./core-DfJMfClV.js";

package/dist/mermaid.cjs

@@ -0,0 +1,222 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_core = require("./core-dyjNI9N1.cjs");
+let _dskripchenko_diagrams = require("@dskripchenko/diagrams");
+// src/mermaid/index.ts
+/**
+* @dskripchenko/flow/mermaid — a model from Mermaid `stateDiagram-v2` or
+* `flowchart` source, through the parser of @dskripchenko/diagrams (an
+* optional peer dependency: only this entry imports it).
+*
+*     import { fromMermaid } from '@dskripchenko/flow/mermaid'
+*     const graph = fromMermaid('stateDiagram-v2\n  [*] --> Idle')
+*
+* Composite states become sub-process nodes with their own inline graph;
+* flowchart subgraphs become groups.
+*/
+var flowDirection = (d) => d === "LR" || d === "RL" ? "LR" : "TB";
+/** Whether a source is one this importer reads. */
+function isMermaidFlow(source) {
+	const head = source.replace(/^\s*(%%[^\n]*\n\s*)*/, "").split(/\s/, 1)[0] ?? "";
+	return /^(stateDiagram(-v2)?|flowchart|graph)$/.test(head);
+}
+/**
+* Converts Mermaid source to a model.
+*
+* @throws GraphError for other diagram types; the diagrams parser's own
+*   `DiagramError` (with line and column) for syntax errors.
+*/
+function fromMermaid(source, options = {}) {
+	const ast = (0, _dskripchenko_diagrams.parse)(source);
+	if (ast && ast.type === "state" && ast.states instanceof Map) return fromState(ast, options);
+	if (ast && ast.type === "flowchart" && ast.nodes instanceof Map) return fromFlowchart(ast, options);
+	throw new require_core.GraphError(`Only stateDiagram-v2 and flowchart can be imported, not "${ast?.type ?? "unknown"}"`);
+}
+/** Readable ids for pseudo states: `\0start:root` → `start`, `\0end:Billing` → `Billing-end`. */
+function pseudoId(id) {
+	const m = /^\u0000(start|end):(.*)$/.exec(id);
+	if (!m) return id;
+	return m[2] === "root" ? m[1] : `${m[2]}-${m[1]}`;
+}
+function fromState(ast, options) {
+	const composites = ast.composites;
+	/** The graph a state belongs to: its nearest composite that is not a region (or the root). */
+	const scopeOf = (parent) => {
+		let p = parent;
+		while (p !== void 0) {
+			const c = composites.get(p);
+			if (!c) return "";
+			if (!c.region) return p;
+			p = c.parent;
+		}
+		return "";
+	};
+	/** The region (as a group) a state sits in directly, if any. */
+	const regionOf = (parent) => parent !== void 0 && composites.get(parent)?.region ? parent : void 0;
+	const parentOf = (id) => ast.states.get(id)?.parent ?? composites.get(id)?.parent;
+	/** The element that stands for `id` inside graph `scope`: itself, or its ancestor composite in that scope. */
+	const representative = (id, scope) => {
+		let cur = id;
+		for (let guard = 0; cur !== void 0 && guard < 1e3; guard++) {
+			if (!composites.get(cur)?.region && scopeOf(parentOf(cur)) === scope) return cur;
+			cur = parentOf(cur);
+		}
+	};
+	const graphs = /* @__PURE__ */ new Map();
+	const graphFor = (scope) => {
+		let g = graphs.get(scope);
+		if (!g) {
+			g = {
+				version: 1,
+				nodes: [],
+				edges: []
+			};
+			if (scope === "") g.meta = { direction: options.direction ?? flowDirection(ast.direction) };
+			else g.meta = {
+				title: composites.get(scope)?.name ?? scope,
+				direction: options.direction ?? flowDirection(ast.direction)
+			};
+			graphs.set(scope, g);
+		}
+		return g;
+	};
+	graphFor("");
+	const typeFor = {
+		state: "state",
+		start: "start",
+		end: "end",
+		choice: "decision",
+		fork: "state",
+		join: "state"
+	};
+	for (const s of ast.states.values()) {
+		const g = graphFor(scopeOf(s.parent));
+		const n = {
+			id: pseudoId(s.id),
+			type: typeFor[s.kind]
+		};
+		if (s.kind === "state" || s.kind === "choice") n.label = s.name;
+		if (s.kind === "fork" || s.kind === "join") {
+			n.label = s.name || s.kind;
+			n.data = { pseudo: s.kind };
+		}
+		if (s.descriptions.length) n.description = s.descriptions.join(" ");
+		const region = regionOf(s.parent);
+		if (region) n.group = region;
+		g.nodes.push(n);
+	}
+	for (const c of composites.values()) {
+		if (c.region) {
+			const g = graphFor(scopeOf(c.parent));
+			const group = { id: c.id };
+			const parentRegion = regionOf(c.parent);
+			if (parentRegion) group.parent = parentRegion;
+			(g.groups ??= []).push(group);
+			continue;
+		}
+		const g = graphFor(scopeOf(c.parent));
+		const n = {
+			id: c.id,
+			type: "subprocess",
+			label: c.name,
+			subgraph: graphFor(c.id)
+		};
+		const region = regionOf(c.parent);
+		if (region) n.group = region;
+		g.nodes.push(n);
+	}
+	let edgeNo = 0;
+	for (const t of ast.transitions) {
+		let scope = scopeOf(parentOf(t.from));
+		let from;
+		let to;
+		for (let guard = 0; scope !== void 0 && guard < 1e3; guard++) {
+			from = representative(t.from, scope);
+			to = representative(t.to, scope);
+			if (from !== void 0 && to !== void 0) break;
+			scope = scope === "" ? void 0 : scopeOf(composites.get(scope)?.parent);
+		}
+		if (scope === void 0 || from === void 0 || to === void 0) continue;
+		const e = {
+			id: `t${++edgeNo}`,
+			from: pseudoId(from),
+			to: pseudoId(to)
+		};
+		if (t.label) e.label = t.label;
+		graphFor(scope).edges.push(e);
+	}
+	let noteNo = 0;
+	for (const note of ast.notes) {
+		const g = graphFor(scopeOf(parentOf(note.target)));
+		const id = `note-${++noteNo}`;
+		g.nodes.push({
+			id,
+			type: "note",
+			label: note.text
+		});
+		g.edges.push({
+			id: `${id}-link`,
+			from: id,
+			to: pseudoId(note.target),
+			kind: "association"
+		});
+	}
+	return graphFor("");
+}
+function fromFlowchart(ast, options) {
+	const incoming = new Set(ast.edges.map((e) => e.to));
+	const outgoing = new Set(ast.edges.map((e) => e.from));
+	const typeFor = (id, shape) => {
+		switch (shape) {
+			case "rhombus":
+			case "choice":
+			case "hexagon": return "decision";
+			case "subroutine": return "subprocess";
+			case "doublecircle":
+			case "end": return "end";
+			case "start": return "start";
+			case "circle": return !incoming.has(id) ? "start" : !outgoing.has(id) ? "end" : "state";
+			case "round":
+			case "stadium": return "state";
+			case "asymmetric": return "note";
+			default: return "task";
+		}
+	};
+	const g = {
+		version: 1,
+		nodes: [],
+		edges: [],
+		meta: { direction: options.direction ?? flowDirection(ast.direction) }
+	};
+	for (const n of ast.nodes.values()) {
+		const node = {
+			id: n.id,
+			type: typeFor(n.id, n.shape)
+		};
+		if (n.text && !(node.type === "start" && n.text === n.id) && !(node.type === "end" && n.text === n.id)) node.label = n.text;
+		if (n.subgraph) node.group = n.subgraph;
+		g.nodes.push(node);
+	}
+	if (ast.subgraphs.size) g.groups = [...ast.subgraphs.values()].map((s) => {
+		const group = { id: s.id };
+		if (s.title) group.label = s.title;
+		if (s.parent) group.parent = s.parent;
+		return group;
+	});
+	let i = 0;
+	for (const e of ast.edges) {
+		if (e.stroke === "invisible") continue;
+		const edge = {
+			id: `e${++i}`,
+			from: e.from,
+			to: e.to
+		};
+		if (e.text) edge.label = e.text;
+		if (e.end === "none" && e.stroke === "dotted") edge.kind = "association";
+		g.edges.push(edge);
+	}
+	return g;
+}
+exports.fromMermaid = fromMermaid;
+exports.isMermaidFlow = isMermaidFlow;
+
+//# sourceMappingURL=mermaid.cjs.map

package/dist/mermaid.d.ts

@@ -0,0 +1,107 @@
+/** Built-in node types; any other string is a custom type from a registry. */
+declare type BuiltinNodeType = 'start' | 'end' | 'state' | 'task' | 'decision' | 'subprocess' | 'note';
+
+/** Data values a node or an edge carries for the host: shown as key/value. */
+declare type DataValue = string | number | boolean | null | DataValue[] | {
+    [key: string]: DataValue;
+};
+
+declare interface FlowEdge {
+    id: string;
+    from: string;
+    to: string;
+    fromPort?: string;
+    toPort?: string;
+    label?: string;
+    /** A guard or condition, shown in the details and, when there is no label, on the edge. */
+    condition?: string;
+    enabled?: boolean;
+    /** `association` is a dashed line without an arrow (a note to its node). */
+    kind?: 'transition' | 'association';
+    data?: Record<string, DataValue>;
+}
+
+declare interface FlowGroup {
+    id: string;
+    label?: string;
+    /** The enclosing group. */
+    parent?: string;
+}
+
+declare interface FlowNode {
+    id: string;
+    type: NodeType;
+    label?: string;
+    /** The node's centre. Nodes without one are placed by the auto layout. */
+    position?: Point;
+    /** The group (frame) the node sits in. */
+    group?: string;
+    data?: Record<string, DataValue>;
+    /** `false` disables the node: drawn dimmed and struck through. Enabled by default. */
+    enabled?: boolean;
+    /**
+     * The node's own process: an inline graph, or a reference the host resolves
+     * (`subgraphs` prop or `loadSubgraph`). Makes the node drillable.
+     */
+    subgraph?: string | Graph;
+    /** Overrides the type's ports. */
+    ports?: Port[];
+    /** A short secondary line under the label. */
+    description?: string;
+}
+
+/**
+ * Converts Mermaid source to a model.
+ *
+ * @throws GraphError for other diagram types; the diagrams parser's own
+ *   `DiagramError` (with line and column) for syntax errors.
+ */
+export declare function fromMermaid(source: string, options?: MermaidImportOptions): Graph;
+
+declare interface Graph {
+    version: typeof GRAPH_VERSION;
+    nodes: FlowNode[];
+    edges: FlowEdge[];
+    groups?: FlowGroup[];
+    meta?: GraphMeta;
+}
+
+/** The model format this package reads and writes. */
+declare const GRAPH_VERSION = 1;
+
+declare interface GraphMeta {
+    title?: string;
+    /** Auto-layout direction; `LR` by default. */
+    direction?: 'TB' | 'LR';
+    [key: string]: DataValue | undefined;
+}
+
+/** Whether a source is one this importer reads. */
+export declare function isMermaidFlow(source: string): boolean;
+
+export declare interface MermaidImportOptions {
+    /** Overrides the diagram's direction (TB/BT → TB, LR/RL → LR). */
+    direction?: 'TB' | 'LR';
+}
+
+declare type NodeType = BuiltinNodeType | (string & {});
+
+declare interface Point {
+    x: number;
+    y: number;
+}
+
+/** A named connection point on a node's side. */
+declare interface Port {
+    id: string;
+    side: PortSide;
+    /** Position along the side, 0…1 from its start (left or top); 0.5 by default. */
+    offset?: number;
+    /** `in` takes incoming edges only, `out` outgoing only; both by default. */
+    kind?: 'in' | 'out' | 'both';
+    label?: string;
+}
+
+declare type PortSide = 'top' | 'right' | 'bottom' | 'left';
+
+export { }

package/dist/mermaid.mjs

@@ -0,0 +1,220 @@
+import { ct as GraphError } from "./core-DfJMfClV.js";
+import { parse } from "@dskripchenko/diagrams";
+// src/mermaid/index.ts
+/**
+* @dskripchenko/flow/mermaid — a model from Mermaid `stateDiagram-v2` or
+* `flowchart` source, through the parser of @dskripchenko/diagrams (an
+* optional peer dependency: only this entry imports it).
+*
+*     import { fromMermaid } from '@dskripchenko/flow/mermaid'
+*     const graph = fromMermaid('stateDiagram-v2\n  [*] --> Idle')
+*
+* Composite states become sub-process nodes with their own inline graph;
+* flowchart subgraphs become groups.
+*/
+var flowDirection = (d) => d === "LR" || d === "RL" ? "LR" : "TB";
+/** Whether a source is one this importer reads. */
+function isMermaidFlow(source) {
+	const head = source.replace(/^\s*(%%[^\n]*\n\s*)*/, "").split(/\s/, 1)[0] ?? "";
+	return /^(stateDiagram(-v2)?|flowchart|graph)$/.test(head);
+}
+/**
+* Converts Mermaid source to a model.
+*
+* @throws GraphError for other diagram types; the diagrams parser's own
+*   `DiagramError` (with line and column) for syntax errors.
+*/
+function fromMermaid(source, options = {}) {
+	const ast = parse(source);
+	if (ast && ast.type === "state" && ast.states instanceof Map) return fromState(ast, options);
+	if (ast && ast.type === "flowchart" && ast.nodes instanceof Map) return fromFlowchart(ast, options);
+	throw new GraphError(`Only stateDiagram-v2 and flowchart can be imported, not "${ast?.type ?? "unknown"}"`);
+}
+/** Readable ids for pseudo states: `\0start:root` → `start`, `\0end:Billing` → `Billing-end`. */
+function pseudoId(id) {
+	const m = /^\u0000(start|end):(.*)$/.exec(id);
+	if (!m) return id;
+	return m[2] === "root" ? m[1] : `${m[2]}-${m[1]}`;
+}
+function fromState(ast, options) {
+	const composites = ast.composites;
+	/** The graph a state belongs to: its nearest composite that is not a region (or the root). */
+	const scopeOf = (parent) => {
+		let p = parent;
+		while (p !== void 0) {
+			const c = composites.get(p);
+			if (!c) return "";
+			if (!c.region) return p;
+			p = c.parent;
+		}
+		return "";
+	};
+	/** The region (as a group) a state sits in directly, if any. */
+	const regionOf = (parent) => parent !== void 0 && composites.get(parent)?.region ? parent : void 0;
+	const parentOf = (id) => ast.states.get(id)?.parent ?? composites.get(id)?.parent;
+	/** The element that stands for `id` inside graph `scope`: itself, or its ancestor composite in that scope. */
+	const representative = (id, scope) => {
+		let cur = id;
+		for (let guard = 0; cur !== void 0 && guard < 1e3; guard++) {
+			if (!composites.get(cur)?.region && scopeOf(parentOf(cur)) === scope) return cur;
+			cur = parentOf(cur);
+		}
+	};
+	const graphs = /* @__PURE__ */ new Map();
+	const graphFor = (scope) => {
+		let g = graphs.get(scope);
+		if (!g) {
+			g = {
+				version: 1,
+				nodes: [],
+				edges: []
+			};
+			if (scope === "") g.meta = { direction: options.direction ?? flowDirection(ast.direction) };
+			else g.meta = {
+				title: composites.get(scope)?.name ?? scope,
+				direction: options.direction ?? flowDirection(ast.direction)
+			};
+			graphs.set(scope, g);
+		}
+		return g;
+	};
+	graphFor("");
+	const typeFor = {
+		state: "state",
+		start: "start",
+		end: "end",
+		choice: "decision",
+		fork: "state",
+		join: "state"
+	};
+	for (const s of ast.states.values()) {
+		const g = graphFor(scopeOf(s.parent));
+		const n = {
+			id: pseudoId(s.id),
+			type: typeFor[s.kind]
+		};
+		if (s.kind === "state" || s.kind === "choice") n.label = s.name;
+		if (s.kind === "fork" || s.kind === "join") {
+			n.label = s.name || s.kind;
+			n.data = { pseudo: s.kind };
+		}
+		if (s.descriptions.length) n.description = s.descriptions.join(" ");
+		const region = regionOf(s.parent);
+		if (region) n.group = region;
+		g.nodes.push(n);
+	}
+	for (const c of composites.values()) {
+		if (c.region) {
+			const g = graphFor(scopeOf(c.parent));
+			const group = { id: c.id };
+			const parentRegion = regionOf(c.parent);
+			if (parentRegion) group.parent = parentRegion;
+			(g.groups ??= []).push(group);
+			continue;
+		}
+		const g = graphFor(scopeOf(c.parent));
+		const n = {
+			id: c.id,
+			type: "subprocess",
+			label: c.name,
+			subgraph: graphFor(c.id)
+		};
+		const region = regionOf(c.parent);
+		if (region) n.group = region;
+		g.nodes.push(n);
+	}
+	let edgeNo = 0;
+	for (const t of ast.transitions) {
+		let scope = scopeOf(parentOf(t.from));
+		let from;
+		let to;
+		for (let guard = 0; scope !== void 0 && guard < 1e3; guard++) {
+			from = representative(t.from, scope);
+			to = representative(t.to, scope);
+			if (from !== void 0 && to !== void 0) break;
+			scope = scope === "" ? void 0 : scopeOf(composites.get(scope)?.parent);
+		}
+		if (scope === void 0 || from === void 0 || to === void 0) continue;
+		const e = {
+			id: `t${++edgeNo}`,
+			from: pseudoId(from),
+			to: pseudoId(to)
+		};
+		if (t.label) e.label = t.label;
+		graphFor(scope).edges.push(e);
+	}
+	let noteNo = 0;
+	for (const note of ast.notes) {
+		const g = graphFor(scopeOf(parentOf(note.target)));
+		const id = `note-${++noteNo}`;
+		g.nodes.push({
+			id,
+			type: "note",
+			label: note.text
+		});
+		g.edges.push({
+			id: `${id}-link`,
+			from: id,
+			to: pseudoId(note.target),
+			kind: "association"
+		});
+	}
+	return graphFor("");
+}
+function fromFlowchart(ast, options) {
+	const incoming = new Set(ast.edges.map((e) => e.to));
+	const outgoing = new Set(ast.edges.map((e) => e.from));
+	const typeFor = (id, shape) => {
+		switch (shape) {
+			case "rhombus":
+			case "choice":
+			case "hexagon": return "decision";
+			case "subroutine": return "subprocess";
+			case "doublecircle":
+			case "end": return "end";
+			case "start": return "start";
+			case "circle": return !incoming.has(id) ? "start" : !outgoing.has(id) ? "end" : "state";
+			case "round":
+			case "stadium": return "state";
+			case "asymmetric": return "note";
+			default: return "task";
+		}
+	};
+	const g = {
+		version: 1,
+		nodes: [],
+		edges: [],
+		meta: { direction: options.direction ?? flowDirection(ast.direction) }
+	};
+	for (const n of ast.nodes.values()) {
+		const node = {
+			id: n.id,
+			type: typeFor(n.id, n.shape)
+		};
+		if (n.text && !(node.type === "start" && n.text === n.id) && !(node.type === "end" && n.text === n.id)) node.label = n.text;
+		if (n.subgraph) node.group = n.subgraph;
+		g.nodes.push(node);
+	}
+	if (ast.subgraphs.size) g.groups = [...ast.subgraphs.values()].map((s) => {
+		const group = { id: s.id };
+		if (s.title) group.label = s.title;
+		if (s.parent) group.parent = s.parent;
+		return group;
+	});
+	let i = 0;
+	for (const e of ast.edges) {
+		if (e.stroke === "invisible") continue;
+		const edge = {
+			id: `e${++i}`,
+			from: e.from,
+			to: e.to
+		};
+		if (e.text) edge.label = e.text;
+		if (e.end === "none" && e.stroke === "dotted") edge.kind = "association";
+		g.edges.push(edge);
+	}
+	return g;
+}
+export { fromMermaid, isMermaidFlow };
+
+//# sourceMappingURL=mermaid.mjs.map