@dou-ui/flow 0.0.0-stage → 0.1.0-alpha.1

package/dist/core/clipboard.js

@@ -0,0 +1,37 @@
+// src/core/clipboard.ts
+var MARK = "dou-flow";
+var copied = null;
+/** Remembers `data` and returns the text to put on the system clipboard. */
+function writeClipboard(data) {
+	const text = JSON.stringify({
+		[MARK]: 1,
+		nodes: data.nodes,
+		edges: data.edges
+	});
+	copied = {
+		data,
+		text
+	};
+	return text;
+}
+/**
+* The nodes to paste: from the system clipboard's `text` when it holds a
+* copy, else the last copy made on this page. `null` when `text` is
+* something else.
+*/
+function readClipboard(text) {
+	if (text == null || text === "") return copied?.data ?? null;
+	if (copied && text === copied.text) return copied.data;
+	try {
+		const value = JSON.parse(text);
+		if (value?.[MARK] && Array.isArray(value.nodes) && Array.isArray(value.edges)) return {
+			version: 1,
+			nodes: value.nodes,
+			edges: value.edges
+		};
+	} catch {}
+	return null;
+}
+export { readClipboard, writeClipboard };
+
+//# sourceMappingURL=clipboard.js.map

package/dist/core/clipboard.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"clipboard.js","names":[],"sources":["../../src/core/clipboard.ts"],"sourcesContent":["import type { FlowDocument } from './model'\n\n/*\n * Copied nodes go to the system clipboard as JSON, so they paste into another\n * tab or a text box too. The last copy is also kept here as is: node data can\n * hold things JSON can't, and it is what a paste uses when the clipboard\n * still holds that same copy.\n */\n\nconst MARK = 'dou-flow'\n\nlet copied: { data: FlowDocument; text: string } | null = null\n\n/** Remembers `data` and returns the text to put on the system clipboard. */\nexport function writeClipboard(data: FlowDocument) {\n  const text = JSON.stringify({ [MARK]: 1, nodes: data.nodes, edges: data.edges })\n  copied = { data, text }\n  return text\n}\n\n/**\n * The nodes to paste: from the system clipboard's `text` when it holds a\n * copy, else the last copy made on this page. `null` when `text` is\n * something else.\n */\nexport function readClipboard(text?: string | null): FlowDocument | null {\n  if (text == null || text === '') return copied?.data ?? null\n  if (copied && text === copied.text) return copied.data\n  try {\n    const value = JSON.parse(text)\n    if (value?.[MARK] && Array.isArray(value.nodes) && Array.isArray(value.edges))\n      return { version: 1, nodes: value.nodes, edges: value.edges }\n  } catch {\n    // Not ours.\n  }\n  return null\n}\n"],"mappings":";AASA,IAAM,OAAO;AAEb,IAAI,SAAsD;;AAG1D,SAAgB,eAAe,MAAoB;CACjD,MAAM,OAAO,KAAK,UAAU;GAAG,OAAO;EAAG,OAAO,KAAK;EAAO,OAAO,KAAK;CAAM,CAAC;CAC/E,SAAS;EAAE;EAAM;CAAK;CACtB,OAAO;AACT;;;;;;AAOA,SAAgB,cAAc,MAA2C;CACvE,IAAI,QAAQ,QAAQ,SAAS,IAAI,OAAO,QAAQ,QAAQ;CACxD,IAAI,UAAU,SAAS,OAAO,MAAM,OAAO,OAAO;CAClD,IAAI;EACF,MAAM,QAAQ,KAAK,MAAM,IAAI;EAC7B,IAAI,QAAQ,SAAS,MAAM,QAAQ,MAAM,KAAK,KAAK,MAAM,QAAQ,MAAM,KAAK,GAC1E,OAAO;GAAE,SAAS;GAAG,OAAO,MAAM;GAAO,OAAO,MAAM;EAAM;CAChE,QAAQ,CAER;CACA,OAAO;AACT"}

package/dist/core/connect.js

@@ -0,0 +1,74 @@
+// src/core/connect.ts
+var typesOf = (port) => port.dataType == null ? [] : Array.isArray(port.dataType) ? port.dataType : [port.dataType];
+/** The first type of a port, which decides its look. */
+var primaryType = (port) => typesOf(port)[0];
+/** Whether data of the output's types may flow into the input. */
+function typesMatch(output, input, portTypes = {}) {
+	const from = typesOf(output);
+	const to = typesOf(input);
+	if (!from.length || !to.length || from.includes("any") || to.includes("any")) return true;
+	return to.some((type) => from.includes(type) || from.some((other) => portTypes[type]?.accepts?.includes(other)));
+}
+/** Whether `to` can be reached from `from` along edges. */
+function reaches(doc, from, to) {
+	const next = /* @__PURE__ */ new Map();
+	for (const edge of doc.edges) {
+		const list = next.get(edge.source.node);
+		if (list) list.push(edge.target.node);
+		else next.set(edge.source.node, [edge.target.node]);
+	}
+	const seen = /* @__PURE__ */ new Set();
+	const stack = [from];
+	while (stack.length) {
+		const id = stack.pop();
+		if (id === to) return true;
+		if (seen.has(id)) continue;
+		seen.add(id);
+		stack.push(...next.get(id) ?? []);
+	}
+	return false;
+}
+var edgesAt = (doc, end, at) => doc.edges.filter((edge) => edge[end].node === at.node && edge[end].port === at.port);
+/**
+* Checks a connection between two ports and says why it is refused, or
+* `null` when it is fine. `ignore` is an edge being moved, left out. A port
+* that is full still takes the edge: the oldest of its edges makes way.
+*/
+function joinRefusal(doc, connection, ports, options = {}, ignore) {
+	const { source, target } = connection;
+	if (ports.source.kind !== "output" || ports.target.kind !== "input") return { reason: "direction" };
+	if (source.node === target.node) return { reason: "self" };
+	if (!typesMatch(ports.source, ports.target, options.portTypes)) return { reason: "type" };
+	const others = {
+		...doc,
+		edges: doc.edges.filter((edge) => edge.id !== ignore)
+	};
+	if (edgesAt(others, "target", target).some((edge) => edge.source.node === source.node && edge.source.port === source.port)) return { reason: "duplicate" };
+	if (options.acyclic && reaches(others, target.node, source.node)) return { reason: "cycle" };
+	const verdict = options.canConnect ? options.canConnect(connection, doc) : true;
+	if (verdict === true) return null;
+	return {
+		reason: "custom",
+		message: typeof verdict === "string" ? verdict : void 0
+	};
+}
+/** Whether two ports may be joined; see `joinRefusal`. */
+var canJoin = (...args) => !joinRefusal(...args);
+/**
+* The edges that make way when an edge joins two full ports: the oldest at
+* each end, beyond `max` (1 for inputs, unlimited for outputs by default).
+*/
+function displacedEdges(doc, connection, ports, ignore) {
+	const out = /* @__PURE__ */ new Set();
+	const trim = (end, max) => {
+		if (max == null) return;
+		const edges = edgesAt(doc, end, connection[end]).filter((edge) => edge.id !== ignore);
+		for (const edge of edges.slice(0, Math.max(0, edges.length - max + 1))) out.add(edge.id);
+	};
+	trim("target", ports.target.max ?? 1);
+	trim("source", ports.source.max);
+	return [...out];
+}
+export { canJoin, displacedEdges, joinRefusal, primaryType, reaches, typesMatch };
+
+//# sourceMappingURL=connect.js.map

package/dist/core/connect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"connect.js","names":[],"sources":["../../src/core/connect.ts"],"sourcesContent":["import type { Tone } from 'dou-ui'\nimport type { FlowDocument, FlowEndpoint, FlowPortSpec } from './model'\n\n/*\n * Whether two ports may be joined. The rules come in layers, each one\n * optional, so a flow without types works without any of them:\n *\n * 1. Ports without a `dataType` take anything.\n * 2. Ports with types join when they share one, or either is `'any'`.\n * 3. A registered port type can accept other types too, and has its own look.\n * 4. `canConnect` has the last word.\n */\n\nexport type PortShape = 'circle' | 'square' | 'diamond' | 'triangle'\n\nexport interface PortTypeSpec {\n  /** Shown to screen readers and in tooltips. */\n  label?: string\n  shape?: PortShape\n  /** A theme tone, or any CSS color. Also colors the edges leaving the port. */\n  color?: Tone | (string & {})\n  /** Edge width in px; 1 by default. */\n  edgeWidth?: number\n  /** Draw edges of this type dashed. */\n  dashed?: boolean\n  /** Other types a port of this type takes. */\n  accepts?: string[]\n}\n\nexport type PortTypes = Record<string, PortTypeSpec>\n\nexport interface FlowConnection {\n  source: Required<FlowEndpoint>\n  target: Required<FlowEndpoint>\n}\n\nexport interface ConnectOptions {\n  portTypes?: PortTypes\n  /** Refuse edges that would close a cycle. */\n  acyclic?: boolean\n  /**\n   * The last check. Return `false` to refuse, or a sentence saying why, which\n   * is announced to screen readers. Called for every port while dragging.\n   */\n  canConnect?: (connection: FlowConnection, doc: FlowDocument) => boolean | string\n}\n\n/** Why two ports can't be joined. */\nexport type JoinRefusal =\n  | { reason: 'direction' | 'self' | 'type' | 'duplicate' | 'cycle' }\n  | { reason: 'custom'; message?: string }\n\nconst typesOf = (port: FlowPortSpec) =>\n  port.dataType == null ? [] : Array.isArray(port.dataType) ? port.dataType : [port.dataType]\n\n/** The first type of a port, which decides its look. */\nexport const primaryType = (port: FlowPortSpec) => typesOf(port)[0]\n\n/** Whether data of the output's types may flow into the input. */\nexport function typesMatch(output: FlowPortSpec, input: FlowPortSpec, portTypes: PortTypes = {}) {\n  const from = typesOf(output)\n  const to = typesOf(input)\n  if (!from.length || !to.length || from.includes('any') || to.includes('any')) return true\n  return to.some(\n    (type) =>\n      from.includes(type) || from.some((other) => portTypes[type]?.accepts?.includes(other)),\n  )\n}\n\n/** Whether `to` can be reached from `from` along edges. */\nexport function reaches(doc: FlowDocument, from: string, to: string) {\n  const next = new Map<string, string[]>()\n  for (const edge of doc.edges) {\n    const list = next.get(edge.source.node)\n    if (list) list.push(edge.target.node)\n    else next.set(edge.source.node, [edge.target.node])\n  }\n  const seen = new Set<string>()\n  const stack = [from]\n  while (stack.length) {\n    const id = stack.pop()!\n    if (id === to) return true\n    if (seen.has(id)) continue\n    seen.add(id)\n    stack.push(...(next.get(id) ?? []))\n  }\n  return false\n}\n\nconst edgesAt = (doc: FlowDocument, end: 'source' | 'target', at: Required<FlowEndpoint>) =>\n  doc.edges.filter((edge) => edge[end].node === at.node && edge[end].port === at.port)\n\n/**\n * Checks a connection between two ports and says why it is refused, or\n * `null` when it is fine. `ignore` is an edge being moved, left out. A port\n * that is full still takes the edge: the oldest of its edges makes way.\n */\nexport function joinRefusal(\n  doc: FlowDocument,\n  connection: FlowConnection,\n  ports: { source: FlowPortSpec; target: FlowPortSpec },\n  options: ConnectOptions = {},\n  ignore?: string,\n): JoinRefusal | null {\n  const { source, target } = connection\n  if (ports.source.kind !== 'output' || ports.target.kind !== 'input')\n    return { reason: 'direction' }\n  if (source.node === target.node) return { reason: 'self' }\n  if (!typesMatch(ports.source, ports.target, options.portTypes)) return { reason: 'type' }\n  const others = { ...doc, edges: doc.edges.filter((edge) => edge.id !== ignore) }\n  const into = edgesAt(others, 'target', target)\n  if (into.some((edge) => edge.source.node === source.node && edge.source.port === source.port))\n    return { reason: 'duplicate' }\n  if (options.acyclic && reaches(others, target.node, source.node)) return { reason: 'cycle' }\n  const verdict = options.canConnect ? options.canConnect(connection, doc) : true\n  if (verdict === true) return null\n  return { reason: 'custom', message: typeof verdict === 'string' ? verdict : undefined }\n}\n\n/** Whether two ports may be joined; see `joinRefusal`. */\nexport const canJoin = (...args: Parameters<typeof joinRefusal>) => !joinRefusal(...args)\n\n/**\n * The edges that make way when an edge joins two full ports: the oldest at\n * each end, beyond `max` (1 for inputs, unlimited for outputs by default).\n */\nexport function displacedEdges(\n  doc: FlowDocument,\n  connection: FlowConnection,\n  ports: { source: FlowPortSpec; target: FlowPortSpec },\n  ignore?: string,\n) {\n  const out = new Set<string>()\n  const trim = (end: 'source' | 'target', max: number | undefined) => {\n    if (max == null) return\n    const edges = edgesAt(doc, end, connection[end]).filter((edge) => edge.id !== ignore)\n    for (const edge of edges.slice(0, Math.max(0, edges.length - max + 1))) out.add(edge.id)\n  }\n  trim('target', ports.target.max ?? 1)\n  trim('source', ports.source.max)\n  return [...out]\n}\n"],"mappings":"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"}

package/dist/core/edge-types.js

@@ -0,0 +1,240 @@
+// src/core/edge-types.ts
+/** Declares an edge type, with `edge.data` typed. */
+function defineEdgeType(spec) {
+	return spec;
+}
+var direction = {
+	left: {
+		x: -1,
+		y: 0
+	},
+	right: {
+		x: 1,
+		y: 0
+	},
+	top: {
+		x: 0,
+		y: -1
+	},
+	bottom: {
+		x: 0,
+		y: 1
+	}
+};
+var round = (value) => Math.round(value * 100) / 100;
+var fmt = (p) => `${round(p.x)} ${round(p.y)}`;
+var isVertical = (side) => side === "top" || side === "bottom";
+/**
+* A cubic curve leaving `from` and entering `to` straight out of their
+* sides. The handles are equally long, half the distance along the axis
+* they point in (at least `min`), so a fan of edges from one port is
+* mirror-symmetric and a straight run stays a straight line.
+*/
+function bezierControls(from, to, min = 40) {
+	const a = direction[from.side];
+	const b = direction[to.side];
+	const span = (dir) => Math.abs(dir.x ? to.x - from.x : to.y - from.y);
+	const lenA = Math.max(min, span(a) / 2);
+	const lenB = Math.max(min, span(b) / 2);
+	return [{
+		x: from.x + a.x * lenA,
+		y: from.y + a.y * lenA
+	}, {
+		x: to.x + b.x * lenB,
+		y: to.y + b.y * lenB
+	}];
+}
+function bezierPath(from, fromSide, to, toSide, min = 40) {
+	const [c1, c2] = bezierControls({
+		...from,
+		side: fromSide
+	}, {
+		...to,
+		side: toSide
+	}, min);
+	return `M${fmt(from)}C${fmt(c1)} ${fmt(c2)} ${fmt(to)}`;
+}
+/** The default: a smooth curve out of and into the ports' sides. */
+var bezierEdge = defineEdgeType({
+	type: "bezier",
+	route(source, target) {
+		const [c1, c2] = bezierControls(source, target);
+		return {
+			path: `M${fmt(source)}C${fmt(c1)} ${fmt(c2)} ${fmt(target)}`,
+			label: {
+				x: (source.x + 3 * c1.x + 3 * c2.x + target.x) / 8,
+				y: (source.y + 3 * c1.y + 3 * c2.y + target.y) / 8
+			}
+		};
+	}
+});
+var straightEdge = defineEdgeType({
+	type: "straight",
+	route: (source, target) => ({
+		path: `M${fmt(source)}L${fmt(target)}`,
+		label: {
+			x: (source.x + target.x) / 2,
+			y: (source.y + target.y) / 2
+		}
+	})
+});
+/** How far a step edge runs out of a port before its first turn. */
+var STUB = 20;
+var RADIUS = 6;
+/** A polyline with its corners rounded. */
+function rounded(points, radius = RADIUS) {
+	const pts = [];
+	for (const p of points) {
+		const last = pts[pts.length - 1];
+		if (last && Math.abs(last.x - p.x) < .01 && Math.abs(last.y - p.y) < .01) continue;
+		const before = pts[pts.length - 2];
+		if (before && last && (Math.abs(before.x - last.x) < .01 && Math.abs(last.x - p.x) < .01 || Math.abs(before.y - last.y) < .01 && Math.abs(last.y - p.y) < .01)) pts.pop();
+		pts.push(p);
+	}
+	let d = `M${fmt(pts[0])}`;
+	for (let i = 1; i < pts.length - 1; i++) {
+		const [a, b, c] = [
+			pts[i - 1],
+			pts[i],
+			pts[i + 1]
+		];
+		const lenIn = Math.hypot(b.x - a.x, b.y - a.y);
+		const lenOut = Math.hypot(c.x - b.x, c.y - b.y);
+		const r = Math.min(radius, lenIn / 2, lenOut / 2);
+		const p1 = {
+			x: b.x - (b.x - a.x) / lenIn * r,
+			y: b.y - (b.y - a.y) / lenIn * r
+		};
+		const p2 = {
+			x: b.x + (c.x - b.x) / lenOut * r,
+			y: b.y + (c.y - b.y) / lenOut * r
+		};
+		d += `L${fmt(p1)}Q${fmt(b)} ${fmt(p2)}`;
+	}
+	return d + `L${fmt(pts[pts.length - 1])}`;
+}
+var flip = (p) => ({
+	x: p.y,
+	y: p.x
+});
+var flipSide = {
+	left: "top",
+	right: "bottom",
+	top: "left",
+	bottom: "right"
+};
+/**
+* Right angles with rounded corners. Between ports that face each other the
+* middle segment can be dragged; its place is kept in `edge.data.bend`.
+*/
+var stepEdge = defineEdgeType({
+	type: "step",
+	route(source, target, edge) {
+		const turned = isVertical(source.side) && isVertical(target.side);
+		const s = turned ? {
+			...flip(source),
+			side: flipSide[source.side]
+		} : source;
+		const t = turned ? {
+			...flip(target),
+			side: flipSide[target.side]
+		} : target;
+		const back = (p) => turned ? flip(p) : p;
+		const ds = direction[s.side];
+		const dt = direction[t.side];
+		const s1 = {
+			x: s.x + ds.x * STUB,
+			y: s.y + ds.y * STUB
+		};
+		const t1 = {
+			x: t.x + dt.x * STUB,
+			y: t.y + dt.y * STUB
+		};
+		let points;
+		let label;
+		let handle;
+		if (ds.x && dt.x && ds.x === -dt.x && (t.x - s.x) * ds.x > 0) {
+			const bend = Math.min(.95, Math.max(.05, edge?.data?.bend ?? .5));
+			const mid = s.x + (t.x - s.x) * bend;
+			points = [
+				s,
+				{
+					x: mid,
+					y: s.y
+				},
+				{
+					x: mid,
+					y: t.y
+				},
+				t
+			];
+			label = {
+				x: mid,
+				y: (s.y + t.y) / 2
+			};
+			if (t.x !== s.x && Math.abs(t.y - s.y) >= 1) {
+				const span = t.x - s.x;
+				handle = {
+					at: back(label),
+					axis: turned ? "y" : "x",
+					move: (point) => {
+						const v = turned ? point.y : point.x;
+						return { bend: Math.min(.95, Math.max(.05, (v - s.x) / span)) };
+					}
+				};
+			}
+		} else if (ds.x && dt.x) {
+			const my = Math.abs(s.y - t.y) >= 40 ? (s.y + t.y) / 2 : Math.max(s.y, t.y) + 40;
+			const x1 = ds.x === dt.x ? ds.x > 0 ? Math.max(s1.x, t1.x) : Math.min(s1.x, t1.x) : s1.x;
+			const x2 = ds.x === dt.x ? x1 : t1.x;
+			points = [
+				s,
+				{
+					x: x1,
+					y: s.y
+				},
+				{
+					x: x1,
+					y: my
+				},
+				{
+					x: x2,
+					y: my
+				},
+				{
+					x: x2,
+					y: t.y
+				},
+				t
+			];
+			label = {
+				x: (x1 + x2) / 2,
+				y: my
+			};
+		} else {
+			const corner = ds.x ? {
+				x: t1.x,
+				y: s1.y
+			} : {
+				x: s1.x,
+				y: t1.y
+			};
+			points = [
+				s,
+				s1,
+				corner,
+				t1,
+				t
+			];
+			label = corner;
+		}
+		return {
+			path: rounded(points.map(back)),
+			label: back(label),
+			handle
+		};
+	}
+});
+export { bezierEdge, bezierPath, defineEdgeType, stepEdge, straightEdge };
+
+//# sourceMappingURL=edge-types.js.map

package/dist/core/edge-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"edge-types.js","names":[],"sources":["../../src/core/edge-types.ts"],"sourcesContent":["import type { CSSProperties } from 'vue'\nimport type { FlowData, FlowEdge, Point, PortSide } from './model'\n\n/** Where an edge leaves or enters a node: a point and the side it faces. */\nexport interface EdgeAnchor extends Point {\n  side: PortSide\n}\n\nexport interface EdgeRoute {\n  /** The SVG path, in canvas coordinates. */\n  path: string\n  /** Where the label sits. */\n  label: Point\n  /**\n   * A handle shown on the selected edge that moves part of it, e.g. the\n   * middle of a step edge. `axis` is the way it moves; `move` turns the\n   * pointer's canvas point into a patch for `edge.data`.\n   */\n  handle?: { at: Point; axis: 'x' | 'y'; move: (point: Point) => FlowData }\n  /**\n   * Marks drawn with the edge's stroke but never dashed, e.g. arrowheads:\n   * an SVG path in canvas coordinates.\n   */\n  marks?: string\n}\n\nexport interface EdgeTypeSpec<Data extends FlowData = FlowData> {\n  type: string\n  /** The edge's path between two anchors. `edge` is absent while one is being drawn. */\n  route: (source: EdgeAnchor, target: EdgeAnchor, edge?: FlowEdge<Data>) => EdgeRoute\n  /** The edge's own look, e.g. `strokeDasharray`, over what its port type gives it. */\n  style?: (edge: FlowEdge<Data>) => CSSProperties | undefined\n}\n\n/** Declares an edge type, with `edge.data` typed. */\nexport function defineEdgeType<Data extends FlowData = FlowData>(\n  spec: EdgeTypeSpec<Data>,\n): EdgeTypeSpec<Data> {\n  return spec\n}\n\nconst direction: Record<PortSide, Point> = {\n  left: { x: -1, y: 0 },\n  right: { x: 1, y: 0 },\n  top: { x: 0, y: -1 },\n  bottom: { x: 0, y: 1 },\n}\n\nconst round = (value: number) => Math.round(value * 100) / 100\nconst fmt = (p: Point) => `${round(p.x)} ${round(p.y)}`\nconst isVertical = (side: PortSide) => side === 'top' || side === 'bottom'\n\n/**\n * A cubic curve leaving `from` and entering `to` straight out of their\n * sides. The handles are equally long, half the distance along the axis\n * they point in (at least `min`), so a fan of edges from one port is\n * mirror-symmetric and a straight run stays a straight line.\n */\nfunction bezierControls(from: EdgeAnchor, to: EdgeAnchor, min = 40) {\n  const a = direction[from.side]\n  const b = direction[to.side]\n  const span = (dir: Point) => Math.abs(dir.x ? to.x - from.x : to.y - from.y)\n  const lenA = Math.max(min, span(a) / 2)\n  const lenB = Math.max(min, span(b) / 2)\n  return [\n    { x: from.x + a.x * lenA, y: from.y + a.y * lenA },\n    { x: to.x + b.x * lenB, y: to.y + b.y * lenB },\n  ] as const\n}\n\nexport function bezierPath(from: Point, fromSide: PortSide, to: Point, toSide: PortSide, min = 40) {\n  const [c1, c2] = bezierControls({ ...from, side: fromSide }, { ...to, side: toSide }, min)\n  return `M${fmt(from)}C${fmt(c1)} ${fmt(c2)} ${fmt(to)}`\n}\n\n/** The default: a smooth curve out of and into the ports' sides. */\nexport const bezierEdge = defineEdgeType({\n  type: 'bezier',\n  route(source, target) {\n    const [c1, c2] = bezierControls(source, target)\n    return {\n      path: `M${fmt(source)}C${fmt(c1)} ${fmt(c2)} ${fmt(target)}`,\n      // The curve at its middle.\n      label: {\n        x: (source.x + 3 * c1.x + 3 * c2.x + target.x) / 8,\n        y: (source.y + 3 * c1.y + 3 * c2.y + target.y) / 8,\n      },\n    }\n  },\n})\n\nexport const straightEdge = defineEdgeType({\n  type: 'straight',\n  route: (source, target) => ({\n    path: `M${fmt(source)}L${fmt(target)}`,\n    label: { x: (source.x + target.x) / 2, y: (source.y + target.y) / 2 },\n  }),\n})\n\n/** How far a step edge runs out of a port before its first turn. */\nconst STUB = 20\nconst RADIUS = 6\n\n/** A polyline with its corners rounded. */\nfunction rounded(points: Point[], radius = RADIUS) {\n  // Drop repeated points and points in the middle of a straight run.\n  const pts: Point[] = []\n  for (const p of points) {\n    const last = pts[pts.length - 1]\n    if (last && Math.abs(last.x - p.x) < 0.01 && Math.abs(last.y - p.y) < 0.01) continue\n    const before = pts[pts.length - 2]\n    if (\n      before &&\n      last &&\n      ((Math.abs(before.x - last.x) < 0.01 && Math.abs(last.x - p.x) < 0.01) ||\n        (Math.abs(before.y - last.y) < 0.01 && Math.abs(last.y - p.y) < 0.01))\n    )\n      pts.pop()\n    pts.push(p)\n  }\n  let d = `M${fmt(pts[0]!)}`\n  for (let i = 1; i < pts.length - 1; i++) {\n    const [a, b, c] = [pts[i - 1]!, pts[i]!, pts[i + 1]!]\n    const lenIn = Math.hypot(b.x - a.x, b.y - a.y)\n    const lenOut = Math.hypot(c.x - b.x, c.y - b.y)\n    const r = Math.min(radius, lenIn / 2, lenOut / 2)\n    const p1 = { x: b.x - ((b.x - a.x) / lenIn) * r, y: b.y - ((b.y - a.y) / lenIn) * r }\n    const p2 = { x: b.x + ((c.x - b.x) / lenOut) * r, y: b.y + ((c.y - b.y) / lenOut) * r }\n    d += `L${fmt(p1)}Q${fmt(b)} ${fmt(p2)}`\n  }\n  return d + `L${fmt(pts[pts.length - 1]!)}`\n}\n\nconst flip = (p: Point): Point => ({ x: p.y, y: p.x })\nconst flipSide: Record<PortSide, PortSide> = {\n  left: 'top',\n  right: 'bottom',\n  top: 'left',\n  bottom: 'right',\n}\n\ninterface StepData extends FlowData {\n  /** Where the middle segment sits between the two ends, from 0 to 1. */\n  bend?: number\n}\n\n/**\n * Right angles with rounded corners. Between ports that face each other the\n * middle segment can be dragged; its place is kept in `edge.data.bend`.\n */\nexport const stepEdge = defineEdgeType<StepData>({\n  type: 'step',\n  route(source, target, edge) {\n    // Work as if the ports faced left and right, then turn the result back.\n    const turned = isVertical(source.side) && isVertical(target.side)\n    const s = turned ? { ...flip(source), side: flipSide[source.side] } : source\n    const t = turned ? { ...flip(target), side: flipSide[target.side] } : target\n    const back = (p: Point) => (turned ? flip(p) : p)\n    const ds = direction[s.side]\n    const dt = direction[t.side]\n    const s1 = { x: s.x + ds.x * STUB, y: s.y + ds.y * STUB }\n    const t1 = { x: t.x + dt.x * STUB, y: t.y + dt.y * STUB }\n    let points: Point[]\n    let label: Point\n    let handle: EdgeRoute['handle']\n\n    if (ds.x && dt.x && ds.x === -dt.x && (t.x - s.x) * ds.x > 0) {\n      // Facing each other: across, along, across.\n      const bend = Math.min(0.95, Math.max(0.05, edge?.data?.bend ?? 0.5))\n      const mid = s.x + (t.x - s.x) * bend\n      points = [s, { x: mid, y: s.y }, { x: mid, y: t.y }, t]\n      label = { x: mid, y: (s.y + t.y) / 2 }\n      // No handle when the ends line up: the middle segment has no length.\n      if (t.x !== s.x && Math.abs(t.y - s.y) >= 1) {\n        const span = t.x - s.x\n        const at = back(label)\n        handle = {\n          at,\n          axis: turned ? 'y' : 'x',\n          move: (point) => {\n            const v = turned ? point.y : point.x\n            return { bend: Math.min(0.95, Math.max(0.05, (v - s.x) / span)) }\n          },\n        }\n      }\n    } else if (ds.x && dt.x) {\n      // Facing away, or the same way: out, around through the middle, in.\n      const gap = Math.abs(s.y - t.y)\n      const my = gap >= STUB * 2 ? (s.y + t.y) / 2 : Math.max(s.y, t.y) + STUB * 2\n      const x1 = ds.x === dt.x ? (ds.x > 0 ? Math.max(s1.x, t1.x) : Math.min(s1.x, t1.x)) : s1.x\n      const x2 = ds.x === dt.x ? x1 : t1.x\n      points = [s, { x: x1, y: s.y }, { x: x1, y: my }, { x: x2, y: my }, { x: x2, y: t.y }, t]\n      label = { x: (x1 + x2) / 2, y: my }\n    } else {\n      // One across, one along: a single corner when the ends allow it.\n      const corner = ds.x ? { x: t1.x, y: s1.y } : { x: s1.x, y: t1.y }\n      points = [s, s1, corner, t1, t]\n      label = corner\n    }\n    return { path: rounded(points.map(back)), label: back(label), handle }\n  },\n})\n"],"mappings":"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"}

package/dist/core/extension.js

@@ -0,0 +1,63 @@
+// src/core/extension.ts
+/** Declares an extension; only gives it a type. */
+function defineFlowExtension(extension) {
+	return extension;
+}
+function flatten(list) {
+	const out = [];
+	for (const item of list) if (Array.isArray(item)) out.push(...flatten(item));
+	else out.push(item);
+	return out;
+}
+/** Sorts the extensions by priority and collects what they add. */
+function resolveFlowExtensions(list) {
+	const extensions = flatten(list).map((extension, index) => ({
+		extension,
+		index
+	})).sort((a, b) => (b.extension.priority ?? 100) - (a.extension.priority ?? 100) || a.index - b.index).map((entry) => entry.extension);
+	const names = /* @__PURE__ */ new Set();
+	const nodeTypes = /* @__PURE__ */ new Map();
+	const edgeTypes = /* @__PURE__ */ new Map();
+	const portTypes = {};
+	for (const extension of extensions) {
+		if (names.has(extension.name)) throw new Error(`[@dou-ui/flow] the extension "${extension.name}" is added twice`);
+		names.add(extension.name);
+		for (const spec of extension.nodeTypes ?? []) {
+			if (nodeTypes.has(spec.type)) throw new Error(`[@dou-ui/flow] node type "${spec.type}" from "${extension.name}" is already defined`);
+			nodeTypes.set(spec.type, spec);
+		}
+		for (const spec of extension.edgeTypes ?? []) {
+			if (edgeTypes.has(spec.type)) throw new Error(`[@dou-ui/flow] edge type "${spec.type}" from "${extension.name}" is already defined`);
+			edgeTypes.set(spec.type, spec);
+		}
+		for (const [name, spec] of Object.entries(extension.portTypes ?? {})) {
+			if (name in portTypes) throw new Error(`[@dou-ui/flow] port type "${name}" from "${extension.name}" is already defined`);
+			portTypes[name] = spec;
+		}
+	}
+	const pick = (key) => extensions.flatMap((e) => e[key] ? [e[key]] : []);
+	return {
+		extensions,
+		nodeTypes,
+		edgeTypes,
+		edgeType: extensions.reduce((type, e) => e.edgeType ?? type, void 0),
+		portTypes,
+		rules: pick("canConnect"),
+		keymaps: pick("keymap"),
+		pasteTransforms: pick("transformPaste"),
+		below: extensions.flatMap((e) => e.layers?.below ?? []),
+		above: extensions.flatMap((e) => e.layers?.above ?? []),
+		overlays: extensions.flatMap((e) => e.overlays ?? []),
+		menus: pick("contextMenu"),
+		presses: pick("press"),
+		toolbars: pick("toolbarItems"),
+		edgeToolbars: pick("edgeToolbarItems"),
+		drawLayers: pick("drawLayer"),
+		setups: pick("setup"),
+		transactions: pick("transaction"),
+		history: extensions.find((e) => e.history)?.history
+	};
+}
+export { defineFlowExtension, resolveFlowExtensions };
+
+//# sourceMappingURL=extension.js.map

package/dist/core/extension.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"extension.js","names":[],"sources":["../../src/core/extension.ts"],"sourcesContent":["import type { ContextMenuItem } from 'dou-ui'\nimport type { Component } from 'vue'\nimport type { FlowEditorContext } from '../context'\nimport type { FlowDrawContext } from '../export/context'\nimport type { FlowConnection, PortTypes } from './connect'\nimport type { EdgeTypeSpec } from './edge-types'\nimport type { FlowMenuTarget, FlowToolbarItem } from './menu'\nimport type { FlowDocument, FlowEdge, FlowNode, Point } from './model'\nimport type { NodeTypeSpec } from './node-types'\nimport type { FlowTransaction } from './transaction'\n\n/** What an extension's hooks receive; the same as `useFlowEditor()`. */\nexport type FlowExtensionContext = FlowEditorContext\n\n/**\n * A key handler: return `false` to let the key through to the next handler\n * and the editor's own keys; anything else means it was handled.\n */\nexport type FlowKeyHandler = (event: KeyboardEvent) => boolean | void\n\n/** An undo history that replaces the editor's own, e.g. one that only undoes this user's changes. */\nexport interface FlowHistoryHandler {\n  /** `false` when there is nothing to undo. */\n  undo: () => boolean\n  redo: () => boolean\n  canUndo: () => boolean\n  canRedo: () => boolean\n}\n\n/** A press on the editor that an extension may take over, e.g. a drawing tool. */\nexport interface FlowPress {\n  /** Where it was pressed, in canvas coordinates. */\n  point: Point\n  /** The node under the pointer, if any. */\n  node: FlowNode | null\n  event: PointerEvent\n}\n\n/** Follows a press an extension took over, until the pointer is let go. */\nexport interface FlowPressHandler {\n  move?: (point: Point, event: PointerEvent) => void\n  end?: (point: Point, event: PointerEvent) => void\n  /** Escape, a second finger, or the browser took the pointer. */\n  cancel?: () => void\n}\n\n/**\n * A piece of the editor: node types, port types, connection rules, keys and\n * extra layers. The default node type comes as an extension too (see\n * `flowKit`), so a third-party extension stands on equal footing with it.\n */\nexport interface FlowExtension {\n  name: string\n  /** Higher runs first: its keys and rules are asked before others. Defaults to 100. */\n  priority?: number\n  nodeTypes?: NodeTypeSpec<any>[]\n  /** Edge types, used by `edge.type`; `flowKit` brings `bezier`, `step` and `straight`. */\n  edgeTypes?: EdgeTypeSpec<any>[]\n  /**\n   * The edge type of edges without a `type`, unless the editor's `edge-type`\n   * prop says otherwise. The last extension that sets it wins.\n   */\n  edgeType?: string\n  /** Looks and connection rules of port types; see the `portTypes` prop. */\n  portTypes?: PortTypes\n  /**\n   * A connection rule, asked after the built-in ones. Return `false` to\n   * refuse, or a sentence saying why. Called for every port while dragging.\n   */\n  canConnect?: (connection: FlowConnection, doc: FlowDocument) => boolean | string\n  /** Keys, written as in `useHotkey` (e.g. `mod+g`, `shift+t`), while the canvas has focus. */\n  keymap?: (context: FlowExtensionContext) => Record<string, FlowKeyHandler>\n  /** Rewrites nodes and edges before they are pasted, e.g. to reset run state. */\n  transformPaste?: (data: FlowDocument, context: FlowExtensionContext) => FlowDocument\n  /**\n   * Components drawn in canvas coordinates: `below` under the edges, `above`\n   * over the nodes. They move and zoom with the canvas.\n   */\n  layers?: { below?: Component[]; above?: Component[] }\n  /**\n   * What `layers.above` shows, for `exportSVG` and `exportPNG`: SVG markup\n   * in canvas coordinates, drawn over the nodes. `nodes` are the ones in the\n   * picture; `draw.width` and `draw.height` are the picture's size.\n   */\n  drawLayer?: (context: FlowExtensionContext, draw: FlowDrawContext, nodes: FlowNode[]) => string\n  /**\n   * Components drawn over the editor in screen space, e.g. a panel or a\n   * popup. They can call `useFlowEditor()`.\n   */\n  overlays?: Component[]\n  /**\n   * Items for the menu opened by a right click, a long press on the empty\n   * canvas, or the context menu key. Extensions' items follow each other\n   * in priority order; an empty list leaves them out.\n   */\n  contextMenu?: (context: FlowExtensionContext, target: FlowMenuTarget) => ContextMenuItem[]\n  /** Buttons for the toolbar that floats above the selected nodes. */\n  toolbarItems?: (context: FlowExtensionContext, nodes: FlowNode[]) => FlowToolbarItem[]\n  /** Buttons for the toolbar that floats above the selected edges, when no node is selected. */\n  edgeToolbarItems?: (context: FlowExtensionContext, edges: FlowEdge[]) => FlowToolbarItem[]\n  /**\n   * Asked first when the canvas or a node is pressed with the main button or\n   * one finger, in priority order. Return handlers to take the press over;\n   * the editor then doesn't select, drag or pan for it.\n   */\n  press?: (context: FlowExtensionContext, press: FlowPress) => FlowPressHandler | void\n  /** Runs once the editor is mounted. Return a function to run when it unmounts. */\n  setup?: (context: FlowExtensionContext) => void | (() => void)\n  /**\n   * Sees every change before it reaches the document, in priority order,\n   * and may add steps to it. Undo and redo come through here too.\n   */\n  transaction?: (tr: FlowTransaction, context: FlowExtensionContext) => void\n  /** Replaces the editor's undo history; the first extension that has one wins. */\n  history?: (context: FlowExtensionContext) => FlowHistoryHandler\n}\n\n/** Declares an extension; only gives it a type. */\nexport function defineFlowExtension(extension: FlowExtension): FlowExtension {\n  return extension\n}\n\n/** Everything the extensions contribute, gathered once per list. */\nexport interface ResolvedFlowExtensions {\n  extensions: FlowExtension[]\n  nodeTypes: Map<string, NodeTypeSpec>\n  edgeTypes: Map<string, EdgeTypeSpec>\n  edgeType: string | undefined\n  portTypes: PortTypes\n  rules: NonNullable<FlowExtension['canConnect']>[]\n  keymaps: NonNullable<FlowExtension['keymap']>[]\n  pasteTransforms: NonNullable<FlowExtension['transformPaste']>[]\n  below: Component[]\n  above: Component[]\n  overlays: Component[]\n  menus: NonNullable<FlowExtension['contextMenu']>[]\n  toolbars: NonNullable<FlowExtension['toolbarItems']>[]\n  edgeToolbars: NonNullable<FlowExtension['edgeToolbarItems']>[]\n  drawLayers: NonNullable<FlowExtension['drawLayer']>[]\n  setups: NonNullable<FlowExtension['setup']>[]\n  transactions: NonNullable<FlowExtension['transaction']>[]\n  history: FlowExtension['history']\n  presses: NonNullable<FlowExtension['press']>[]\n}\n\ntype ExtensionList = readonly (FlowExtension | readonly FlowExtension[])[]\n\nfunction flatten(list: ExtensionList): FlowExtension[] {\n  const out: FlowExtension[] = []\n  for (const item of list) {\n    if (Array.isArray(item)) out.push(...flatten(item))\n    else out.push(item as FlowExtension)\n  }\n  return out\n}\n\n/** Sorts the extensions by priority and collects what they add. */\nexport function resolveFlowExtensions(list: ExtensionList): ResolvedFlowExtensions {\n  const extensions = flatten(list)\n    .map((extension, index) => ({ extension, index }))\n    // oxlint-disable-next-line unicorn/no-array-sort -- sorts a fresh array\n    .sort(\n      (a, b) => (b.extension.priority ?? 100) - (a.extension.priority ?? 100) || a.index - b.index,\n    )\n    .map((entry) => entry.extension)\n\n  const names = new Set<string>()\n  const nodeTypes = new Map<string, NodeTypeSpec>()\n  const edgeTypes = new Map<string, EdgeTypeSpec>()\n  const portTypes: PortTypes = {}\n  for (const extension of extensions) {\n    if (names.has(extension.name))\n      throw new Error(`[@dou-ui/flow] the extension \"${extension.name}\" is added twice`)\n    names.add(extension.name)\n    for (const spec of extension.nodeTypes ?? []) {\n      if (nodeTypes.has(spec.type))\n        throw new Error(\n          `[@dou-ui/flow] node type \"${spec.type}\" from \"${extension.name}\" is already defined`,\n        )\n      nodeTypes.set(spec.type, spec)\n    }\n    for (const spec of extension.edgeTypes ?? []) {\n      if (edgeTypes.has(spec.type))\n        throw new Error(\n          `[@dou-ui/flow] edge type \"${spec.type}\" from \"${extension.name}\" is already defined`,\n        )\n      edgeTypes.set(spec.type, spec)\n    }\n    for (const [name, spec] of Object.entries(extension.portTypes ?? {})) {\n      if (name in portTypes)\n        throw new Error(\n          `[@dou-ui/flow] port type \"${name}\" from \"${extension.name}\" is already defined`,\n        )\n      portTypes[name] = spec\n    }\n  }\n\n  const pick = <K extends keyof FlowExtension>(key: K) =>\n    extensions.flatMap((e) => (e[key] ? [e[key]] : [])) as NonNullable<FlowExtension[K]>[]\n\n  return {\n    extensions,\n    nodeTypes,\n    edgeTypes,\n    edgeType: extensions.reduce<string | undefined>((type, e) => e.edgeType ?? type, undefined),\n    portTypes,\n    rules: pick('canConnect'),\n    keymaps: pick('keymap'),\n    pasteTransforms: pick('transformPaste'),\n    below: extensions.flatMap((e) => e.layers?.below ?? []),\n    above: extensions.flatMap((e) => e.layers?.above ?? []),\n    overlays: extensions.flatMap((e) => e.overlays ?? []),\n    menus: pick('contextMenu'),\n    presses: pick('press'),\n    toolbars: pick('toolbarItems'),\n    edgeToolbars: pick('edgeToolbarItems'),\n    drawLayers: pick('drawLayer'),\n    setups: pick('setup'),\n    transactions: pick('transaction'),\n    history: extensions.find((e) => e.history)?.history,\n  }\n}\n"],"mappings":";;AAsHA,SAAgB,oBAAoB,WAAyC;CAC3E,OAAO;AACT;AA2BA,SAAS,QAAQ,MAAsC;CACrD,MAAM,MAAuB,CAAC;CAC9B,KAAK,MAAM,QAAQ,MACjB,IAAI,MAAM,QAAQ,IAAI,GAAG,IAAI,KAAK,GAAG,QAAQ,IAAI,CAAC;MAC7C,IAAI,KAAK,IAAqB;CAErC,OAAO;AACT;;AAGA,SAAgB,sBAAsB,MAA6C;CACjF,MAAM,aAAa,QAAQ,IAAI,CAAC,CAC7B,KAAK,WAAW,WAAW;EAAE;EAAW;CAAM,EAAE,CAAC,CAEjD,MACE,GAAG,OAAO,EAAE,UAAU,YAAY,QAAQ,EAAE,UAAU,YAAY,QAAQ,EAAE,QAAQ,EAAE,KACzF,CAAC,CACA,KAAK,UAAU,MAAM,SAAS;CAEjC,MAAM,wBAAQ,IAAI,IAAY;CAC9B,MAAM,4BAAY,IAAI,IAA0B;CAChD,MAAM,4BAAY,IAAI,IAA0B;CAChD,MAAM,YAAuB,CAAC;CAC9B,KAAK,MAAM,aAAa,YAAY;EAClC,IAAI,MAAM,IAAI,UAAU,IAAI,GAC1B,MAAM,IAAI,MAAM,iCAAiC,UAAU,KAAK,iBAAiB;EACnF,MAAM,IAAI,UAAU,IAAI;EACxB,KAAK,MAAM,QAAQ,UAAU,aAAa,CAAC,GAAG;GAC5C,IAAI,UAAU,IAAI,KAAK,IAAI,GACzB,MAAM,IAAI,MACR,6BAA6B,KAAK,KAAK,UAAU,UAAU,KAAK,qBAClE;GACF,UAAU,IAAI,KAAK,MAAM,IAAI;EAC/B;EACA,KAAK,MAAM,QAAQ,UAAU,aAAa,CAAC,GAAG;GAC5C,IAAI,UAAU,IAAI,KAAK,IAAI,GACzB,MAAM,IAAI,MACR,6BAA6B,KAAK,KAAK,UAAU,UAAU,KAAK,qBAClE;GACF,UAAU,IAAI,KAAK,MAAM,IAAI;EAC/B;EACA,KAAK,MAAM,CAAC,MAAM,SAAS,OAAO,QAAQ,UAAU,aAAa,CAAC,CAAC,GAAG;GACpE,IAAI,QAAQ,WACV,MAAM,IAAI,MACR,6BAA6B,KAAK,UAAU,UAAU,KAAK,qBAC7D;GACF,UAAU,QAAQ;EACpB;CACF;CAEA,MAAM,QAAuC,QAC3C,WAAW,SAAS,MAAO,EAAE,OAAO,CAAC,EAAE,IAAI,IAAI,CAAC,CAAE;CAEpD,OAAO;EACL;EACA;EACA;EACA,UAAU,WAAW,QAA4B,MAAM,MAAM,EAAE,YAAY,MAAM,KAAA,CAAS;EAC1F;EACA,OAAO,KAAK,YAAY;EACxB,SAAS,KAAK,QAAQ;EACtB,iBAAiB,KAAK,gBAAgB;EACtC,OAAO,WAAW,SAAS,MAAM,EAAE,QAAQ,SAAS,CAAC,CAAC;EACtD,OAAO,WAAW,SAAS,MAAM,EAAE,QAAQ,SAAS,CAAC,CAAC;EACtD,UAAU,WAAW,SAAS,MAAM,EAAE,YAAY,CAAC,CAAC;EACpD,OAAO,KAAK,aAAa;EACzB,SAAS,KAAK,OAAO;EACrB,UAAU,KAAK,cAAc;EAC7B,cAAc,KAAK,kBAAkB;EACrC,YAAY,KAAK,WAAW;EAC5B,QAAQ,KAAK,OAAO;EACpB,cAAc,KAAK,aAAa;EAChC,SAAS,WAAW,MAAM,MAAM,EAAE,OAAO,CAAC,EAAE;CAC9C;AACF"}