@lupinum/board-connections 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026-present Lupinum OG and contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,63 @@
+<p align="center"><img src="https://raw.githubusercontent.com/lupinum-dev/nuxt-board/main/docs/public/app-icon.svg" width="128" alt="Nuxt Board icon"></p>
+
+<h1 align="center">@lupinum/board-connections</h1>
+
+<p align="center">Add typed edges, anchors, labels, routing, and connection rendering to a board.</p>
+
+<p align="center">
+  <a href="https://www.npmjs.com/package/@lupinum/board-connections"><img src="https://img.shields.io/npm/v/@lupinum/board-connections?label=npm" alt="npm version"></a>
+  <a href="https://github.com/lupinum-dev/nuxt-board/actions/workflows/ci.yml"><img src="https://github.com/lupinum-dev/nuxt-board/actions/workflows/ci.yml/badge.svg" alt="CI status"></a>
+  <a href="https://github.com/lupinum-dev/nuxt-board/blob/main/LICENSE"><img src="https://img.shields.io/badge/license-MIT-blue.svg" alt="MIT license"></a>
+</p>
+
+> [!WARNING]
+> This package has not reached a stable release. Review the changelog before each upgrade.
+
+## Purpose
+
+Use this plugin when nodes must connect to each other. The plugin owns connection state and provides a Vue SVG layer for rendering.
+
+## Requirements
+
+Install the same version of this package, `@lupinum/board-core`, and `@lupinum/vue-board`. The fixed-version release keeps the plugin ABI aligned.
+
+## Installation
+
+```bash
+pnpm add @lupinum/board-connections @lupinum/board-core @lupinum/vue-board
+```
+
+## Quick start
+
+```ts
+import { connectionsPlugin } from '@lupinum/board-connections'
+import { createBoardEngine } from '@lupinum/board-core'
+
+const engine = createBoardEngine({ plugins: [connectionsPlugin()] })
+const first = engine.createNode({ type: 'text', text: 'First' })
+const second = engine.createNode({ type: 'text', x: 280, text: 'Second' })
+
+engine.plugins.connections.createEdge({
+  from: first.id,
+  to: second.id,
+  data: {},
+})
+```
+
+Render `BoardConnectionLayer` below `BoardRoot`. It reads the board context and positions its SVG layer against the board root.
+
+## Exports
+
+The package exports the connections plugin and the Vue connection layer.
+
+## Documentation
+
+Read the [connections reference](https://nuxt-board.lupinum.com/docs/reference/connections).
+
+## Support and security
+
+Open a [GitHub issue](https://github.com/lupinum-dev/nuxt-board/issues) for support. Report vulnerabilities through the [private security process](https://github.com/lupinum-dev/nuxt-board/security/policy).
+
+## License
+
+This package uses the [MIT License](https://github.com/lupinum-dev/nuxt-board/blob/main/LICENSE).

package/dist/colors-CI4AZ9tI.js

@@ -0,0 +1,553 @@
+import { boundsIntersect as bt, BOARD_COLOR_PRESETS as $t, colorForPreset as St } from "@lupinum/board-core";
+function Kt(t) {
+  switch (t) {
+    case "start":
+      return { fromEnd: "arrow", toEnd: "none" };
+    case "both":
+      return { fromEnd: "arrow", toEnd: "arrow" };
+    case "none":
+      return { fromEnd: "none", toEnd: "none" };
+    case "end":
+      return { fromEnd: "none", toEnd: "arrow" };
+  }
+}
+const R = Math.PI;
+function Et(t, n, e, o = !1) {
+  const [s, r] = n, [i, u] = e, c = i + (t - s) / (r - s) * (u - i);
+  return o ? i < u ? Math.max(Math.min(c, u), i) : Math.max(Math.min(c, i), u) : c;
+}
+function B(t, n, e, o) {
+  return Math.atan2(o - n, e - t);
+}
+function Pt(t, n, e, o) {
+  return Math.hypot(e - t, o - n);
+}
+function z(t, n, e) {
+  return t + (n - t) * e;
+}
+function wt(t, n) {
+  return !(t.x > n.x + n.w || t.x + t.w < n.x || t.y > n.y + n.h || t.y + t.h < n.y);
+}
+function tt(t, n) {
+  return {
+    x: t.x - n,
+    y: t.y - n,
+    w: t.w + n * 2,
+    h: t.h + n * 2
+  };
+}
+function At(t, n, e, o, s, r, i, u, c = {}) {
+  const f = c.bow ?? 0, x = c.stretch ?? 0.25, y = c.stretchMin ?? 50, P = c.stretchMax ?? 420, l = c.padStart ?? 0, p = c.padEnd ?? 20, C = c.flip ?? !1, O = c.straights ?? !0, w = { x: t, y: n, w: e, h: o }, A = { x: s, y: r, w: i, h: u }, H = tt(w, l), q = tt(A, p), d = t + e / 2, a = n + o / 2, g = s + i / 2, M = r + u / 2, j = B(d, a, g, M);
+  let [b, $] = [d, a], [S, E] = [g, M];
+  if (wt(H, q)) {
+    const D = B(d, a, g, M);
+    b = d + Math.cos(D) * (e / 2 + l), $ = a + Math.sin(D) * (o / 2 + l), S = g - Math.cos(D) * (i / 2 + p), E = M - Math.sin(D) * (u / 2 + p);
+    const [Mt, pt] = [
+      z(b, S, 0.5),
+      z($, E, 0.5)
+    ];
+    return [b, $, Mt, pt, S, E, D + R, D + R];
+  }
+  const T = e / 2, v = o / 2, I = i / 2, X = u / 2, Y = Math.tan(j), K = Math.abs(Y), ht = v / T, lt = X / I;
+  K > ht ? ($ = a + (M > a ? v + l : -(v + l)), b = d + (M > a ? v + l : -(v + l)) / Y) : (b = d + (g > d ? T + l : -(T + l)), $ = a + (g > d ? T + l : -(T + l)) * Y), K > lt ? (E = M + (a > M ? X + p : -(X + p)), S = g + (a > M ? X + p : -(X + p)) / Y) : (S = g + (d > g ? I + p : -(I + p)), E = M + (d > g ? I + p : -(I + p)) * Y);
+  const J = Pt(b, $, S, E), dt = Et(J, [y, P], [1, 0], !0) * x + f, N = B(b, $, S, E), W = z(b, S, 0.5), k = z($, E, 0.5), V = J * dt, Z = N + R / 2, m = C ? -1 : 1, _ = W + Math.cos(Z) * V * m, L = k + Math.sin(Z) * V * m;
+  if (O && Math.abs(_ - W) < 1 && Math.abs(L - k) < 1)
+    return [b, $, W, k, S, E, N + R, N];
+  const at = B(b, $, _, L) + R, gt = B(S, E, _, L);
+  return [b, $, _, L, S, E, at, gt];
+}
+function G(t, n, e, o) {
+  const s = 1 - o;
+  return s * s * t + 2 * s * o * n + o * o * e;
+}
+function Ct(t, n, e) {
+  const o = /* @__PURE__ */ new Set([0, 1]);
+  for (const c of ["x", "y"]) {
+    const f = t[c], x = n[c], y = e[c], P = f - 2 * x + y;
+    if (Math.abs(P) > 1e-9) {
+      const l = (f - x) / P;
+      l > 0 && l < 1 && o.add(l);
+    }
+  }
+  let s = 1 / 0, r = 1 / 0, i = -1 / 0, u = -1 / 0;
+  for (const c of o) {
+    const f = G(t.x, n.x, e.x, c), x = G(t.y, n.y, e.y, c);
+    f < s && (s = f), x < r && (r = x), f > i && (i = f), x > u && (u = x);
+  }
+  return { minX: s, minY: r, maxX: i, maxY: u };
+}
+function Ot(t, n, e) {
+  return {
+    x: G(t.x, n.x, e.x, 0.5),
+    y: G(t.y, n.y, e.y, 0.5)
+  };
+}
+function Dt(t, n, e = {}) {
+  const [o, s, r, i, u, c] = At(
+    t.node.x,
+    t.node.y,
+    t.node.width,
+    t.node.height,
+    n.node.x,
+    n.node.y,
+    n.node.width,
+    n.node.height,
+    {
+      bow: e.bow ?? 0,
+      stretch: e.stretch ?? 0.25,
+      stretchMin: e.stretchMin ?? 50,
+      stretchMax: e.stretchMax ?? 420,
+      padStart: e.padStart ?? 0,
+      padEnd: e.padEnd ?? 0,
+      flip: e.flip ?? !1,
+      straights: !0
+    }
+  ), f = { x: o, y: s }, x = { x: r, y: i }, y = { x: u, y: c };
+  return {
+    routing: "arc",
+    path: `M${o},${s} Q${r},${i} ${u},${c}`,
+    labelPoint: Ot(f, x, y),
+    bounds: Ct(f, x, y),
+    waypoints: [f, y],
+    segments: [
+      {
+        type: "cubic",
+        from: f,
+        control1: x,
+        control2: x,
+        to: y
+      }
+    ]
+  };
+}
+const Tt = 24, vt = 0.5, It = 24, Xt = 10, nt = {
+  top: { x: 0, y: -1 },
+  right: { x: 1, y: 0 },
+  bottom: { x: 0, y: 1 },
+  left: { x: -1, y: 0 }
+};
+function Q(t, n, e) {
+  return Math.min(e, Math.max(n, t));
+}
+function Yt(t) {
+  return t === "left" || t === "right" ? "horizontal" : "vertical";
+}
+function h(t, n) {
+  return { x: t, y: n };
+}
+function ot(t) {
+  return {
+    x: t.x + t.width / 2,
+    y: t.y + t.height / 2
+  };
+}
+function et(t, n) {
+  const e = Q(n.offset, 0, 1);
+  switch (n.side) {
+    case "top":
+      return { x: t.x + t.width * e, y: t.y };
+    case "bottom":
+      return { x: t.x + t.width * e, y: t.y + t.height };
+    case "left":
+      return { x: t.x, y: t.y + t.height * e };
+    default:
+      return { x: t.x + t.width, y: t.y + t.height * e };
+  }
+}
+function ft(t, n, e, o) {
+  const s = ot(t), r = ot(n), i = r.x - s.x, u = r.y - s.y, c = Math.abs(i), f = Math.abs(u);
+  if (c < 1e-3 && f < 1e-3)
+    return o || "right";
+  let x = c >= f ? "horizontal" : "vertical";
+  if (o) {
+    const y = Yt(o), P = Math.abs(c - f);
+    y !== x && P < Tt && (x = y);
+  }
+  return x === "horizontal" ? i >= 0 ? "right" : "left" : u >= 0 ? "bottom" : "top";
+}
+function it(t, n, e, o, s) {
+  const r = o === "source" ? t.fromAnchor : t.toAnchor;
+  if (r)
+    return {
+      nodeId: n.id,
+      node: n,
+      side: r.side,
+      offset: Q(r.offset, 0, 1),
+      point: et(n, r),
+      kind: "explicit"
+    };
+  const i = ft(n, e, o, s), u = vt;
+  return {
+    nodeId: n.id,
+    node: n,
+    side: i,
+    offset: u,
+    point: et(n, { side: i, offset: u }),
+    kind: "auto"
+  };
+}
+function Jt(t, n, e, o) {
+  const s = {
+    id: `floating-${e}`,
+    x: t.x,
+    y: t.y,
+    width: 0,
+    height: 0
+  }, r = {
+    x: n.x,
+    y: n.y,
+    width: 0,
+    height: 0
+  }, i = ft(s, r, e, o);
+  return {
+    nodeId: s.id,
+    node: s,
+    side: i,
+    offset: 0.5,
+    point: t,
+    kind: "auto"
+  };
+}
+function U(t) {
+  return t.reduce(
+    (n, e) => ({
+      minX: Math.min(n.minX, e.x),
+      minY: Math.min(n.minY, e.y),
+      maxX: Math.max(n.maxX, e.x),
+      maxY: Math.max(n.maxY, e.y)
+    }),
+    { minX: 1 / 0, minY: 1 / 0, maxX: -1 / 0, maxY: -1 / 0 }
+  );
+}
+function st(t, n, e, o, s) {
+  const r = 1 - s;
+  return r ** 3 * t + 3 * r ** 2 * s * n + 3 * r * s ** 2 * e + s ** 3 * o;
+}
+function rt(t, n, e, o) {
+  const s = -t + 3 * n - 3 * e + o, r = 2 * (t - 2 * n + e), i = n - t, u = [];
+  if (Math.abs(s) < 1e-9) {
+    if (Math.abs(r) < 1e-9)
+      return u;
+    const y = -i / r;
+    return y > 0 && y < 1 && u.push(y), u;
+  }
+  const c = r * r - 4 * s * i;
+  if (c < 0)
+    return u;
+  const f = Math.sqrt(c), x = [(-r + f) / (2 * s), (-r - f) / (2 * s)];
+  for (const y of x)
+    y > 0 && y < 1 && u.push(y);
+  return u;
+}
+function Rt(t, n, e, o) {
+  const s = /* @__PURE__ */ new Set([0, 1]);
+  for (const i of rt(
+    t.x,
+    n.x,
+    e.x,
+    o.x
+  ))
+    s.add(i);
+  for (const i of rt(
+    t.y,
+    n.y,
+    e.y,
+    o.y
+  ))
+    s.add(i);
+  const r = [...s].map(
+    (i) => h(
+      st(t.x, n.x, e.x, o.x, i),
+      st(t.y, n.y, e.y, o.y, i)
+    )
+  );
+  return U(r);
+}
+function Bt(t) {
+  return {
+    x: t.sourceX * 0.125 + t.sourceControlX * 0.375 + t.targetControlX * 0.375 + t.targetX * 0.125,
+    y: t.sourceY * 0.125 + t.sourceControlY * 0.375 + t.targetControlY * 0.375 + t.targetY * 0.125
+  };
+}
+const _t = 400, Lt = 0.35;
+function F(t, n) {
+  const e = Q(1 - Math.abs(t) / _t, 0, 1), o = e * e * Lt;
+  return t >= 0 ? (0.5 + o) * t : (n + o) * 25 * Math.sqrt(-t);
+}
+function ct(t) {
+  switch (t.pos) {
+    case "left":
+      return h(
+        t.x1 - F(t.x1 - t.x2, t.curvature),
+        t.y1
+      );
+    case "right":
+      return h(
+        t.x1 + F(t.x2 - t.x1, t.curvature),
+        t.y1
+      );
+    case "top":
+      return h(
+        t.x1,
+        t.y1 - F(t.y1 - t.y2, t.curvature)
+      );
+    default:
+      return h(
+        t.x1,
+        t.y1 + F(t.y2 - t.y1, t.curvature)
+      );
+  }
+}
+function zt(t, n) {
+  const e = ct({
+    pos: t.side,
+    x1: t.point.x,
+    y1: t.point.y,
+    x2: n.point.x,
+    y2: n.point.y,
+    curvature: 0.25
+  }), o = ct({
+    pos: n.side,
+    x1: n.point.x,
+    y1: n.point.y,
+    x2: t.point.x,
+    y2: t.point.y,
+    curvature: 0.25
+  });
+  return {
+    routing: "bezier",
+    path: `M${t.point.x},${t.point.y} C${e.x},${e.y} ${o.x},${o.y} ${n.point.x},${n.point.y}`,
+    labelPoint: Bt({
+      sourceX: t.point.x,
+      sourceY: t.point.y,
+      targetX: n.point.x,
+      targetY: n.point.y,
+      sourceControlX: e.x,
+      sourceControlY: e.y,
+      targetControlX: o.x,
+      targetControlY: o.y
+    }),
+    bounds: Rt(t.point, e, o, n.point),
+    waypoints: [t.point, n.point],
+    segments: [
+      {
+        type: "cubic",
+        from: t.point,
+        control1: e,
+        control2: o,
+        to: n.point
+      }
+    ]
+  };
+}
+function ut(t, n) {
+  return Math.hypot(n.x - t.x, n.y - t.y);
+}
+function Ft(t) {
+  return t.sourcePosition === "left" || t.sourcePosition === "right" ? t.source.x < t.target.x ? h(1, 0) : h(-1, 0) : t.source.y < t.target.y ? h(0, 1) : h(0, -1);
+}
+function yt(t, n) {
+  return {
+    x: (t.x + n.x) / 2,
+    y: (t.y + n.y) / 2
+  };
+}
+function Gt(t) {
+  const n = nt[t.sourcePosition], e = nt[t.targetPosition], o = h(
+    t.source.x + n.x * t.offset,
+    t.source.y + n.y * t.offset
+  ), s = h(
+    t.target.x + e.x * t.offset,
+    t.target.y + e.y * t.offset
+  ), r = Ft({
+    source: o,
+    sourcePosition: t.sourcePosition,
+    target: s
+  }), i = r.x !== 0 ? "x" : "y", u = r[i];
+  let c = [], f = yt(t.source, t.target);
+  const x = h(0, 0), y = h(0, 0);
+  if (n[i] * e[i] === -1) {
+    const C = i === "x" ? o.x + (s.x - o.x) * t.stepPosition : (o.x + s.x) / 2, O = i === "y" ? o.y + (s.y - o.y) * t.stepPosition : (o.y + s.y) / 2, w = [
+      h(C, o.y),
+      h(C, s.y)
+    ], A = [
+      h(o.x, O),
+      h(s.x, O)
+    ];
+    n[i] === u ? c = i === "x" ? w : A : c = i === "x" ? A : w;
+  } else {
+    const C = [h(o.x, s.y)], O = [h(s.x, o.y)];
+    if (i === "x" ? c = n.x === u ? O : C : c = n.y === u ? C : O, t.sourcePosition === t.targetPosition) {
+      const d = Math.abs(
+        t.source[i] - t.target[i]
+      );
+      if (d <= t.offset) {
+        const a = Math.min(t.offset - 1, t.offset - d);
+        n[i] === u ? x[i] = (o[i] > t.source[i] ? -1 : 1) * a : y[i] = (s[i] > t.target[i] ? -1 : 1) * a;
+      }
+    }
+    if (t.sourcePosition !== t.targetPosition) {
+      const d = i === "x" ? "y" : "x", a = n[i] === e[d], g = o[d] > s[d], M = o[d] < s[d];
+      (n[i] === 1 && (!a && g || a && M) || n[i] !== 1 && (!a && M || a && g)) && (c = i === "x" ? C : O);
+    }
+    const w = h(
+      o.x + x.x,
+      o.y + x.y
+    ), A = h(
+      s.x + y.x,
+      s.y + y.y
+    ), H = Math.max(
+      Math.abs(w.x - c[0].x),
+      Math.abs(A.x - c[0].x)
+    ), q = Math.max(
+      Math.abs(w.y - c[0].y),
+      Math.abs(A.y - c[0].y)
+    );
+    f = H >= q ? h((w.x + A.x) / 2, c[0].y) : h(c[0].x, (w.y + A.y) / 2);
+  }
+  const P = h(
+    o.x + x.x,
+    o.y + x.y
+  ), l = h(
+    s.x + y.x,
+    s.y + y.y
+  );
+  return [[
+    t.source,
+    ...P.x !== c[0].x || P.y !== c[0].y ? [P] : [],
+    ...c,
+    ...l.x !== c[c.length - 1].x || l.y !== c[c.length - 1].y ? [l] : [],
+    t.target
+  ], f];
+}
+function Ht(t, n, e, o) {
+  if (o <= 0)
+    return `L${n.x} ${n.y}`;
+  const s = Math.min(ut(t, n) / 2, ut(n, e) / 2, o), { x: r, y: i } = n;
+  if (t.x === r && r === e.x || t.y === i && i === e.y)
+    return `L${r} ${i}`;
+  if (t.y === i) {
+    const f = t.x < e.x ? -1 : 1, x = t.y < e.y ? 1 : -1;
+    return `L${r + s * f},${i}Q${r},${i} ${r},${i + s * x}`;
+  }
+  const u = t.x < e.x ? 1 : -1, c = t.y < e.y ? -1 : 1;
+  return `L${r},${i + s * c}Q${r},${i} ${r + s * u},${i}`;
+}
+function xt(t, n, e) {
+  const [o, s] = Gt({
+    source: t.point,
+    sourcePosition: t.side,
+    target: n.point,
+    targetPosition: n.side,
+    offset: It,
+    stepPosition: 0.5
+  });
+  let r = `M${o[0].x} ${o[0].y}`;
+  for (let i = 1; i < o.length - 1; i += 1)
+    r += Ht(
+      o[i - 1],
+      o[i],
+      o[i + 1],
+      e === "smooth-step" ? Xt : 0
+    );
+  return r += `L${o[o.length - 1].x} ${o[o.length - 1].y}`, {
+    routing: e,
+    path: r,
+    labelPoint: s,
+    bounds: U(o),
+    waypoints: o,
+    segments: o.slice(0, -1).map((i, u) => ({
+      type: "line",
+      from: i,
+      to: o[u + 1]
+    }))
+  };
+}
+function qt(t, n) {
+  return {
+    routing: "straight",
+    path: `M${t.point.x} ${t.point.y} L${n.point.x} ${n.point.y}`,
+    labelPoint: yt(t.point, n.point),
+    bounds: U([t.point, n.point]),
+    waypoints: [t.point, n.point],
+    segments: [{ type: "line", from: t.point, to: n.point }]
+  };
+}
+function Nt(t) {
+  switch (t.routing ?? "bezier") {
+    case "straight":
+      return qt(t.source, t.target);
+    case "step":
+      return xt(t.source, t.target, "step");
+    case "smooth-step":
+      return xt(t.source, t.target, "smooth-step");
+    case "arc":
+      return Dt(t.source, t.target);
+    default:
+      return zt(t.source, t.target);
+  }
+}
+function Wt(t, n, e, o = {}) {
+  const s = it(
+    t,
+    n,
+    e,
+    "source",
+    o.previousSourceSide
+  ), r = it(
+    t,
+    e,
+    n,
+    "target",
+    o.previousTargetSide
+  );
+  return {
+    source: s,
+    target: r,
+    route: Nt({
+      source: s,
+      target: r,
+      routing: o.routing
+    })
+  };
+}
+function Vt(t, n, e) {
+  const o = t.$nodes.get();
+  return t.plugins.connections.getEdges().filter((s) => {
+    const r = o.get(s.from), i = o.get(s.to);
+    if (!r || !i)
+      return !1;
+    const { route: u } = Wt(s, r, i, {
+      routing: e
+    });
+    return bt(n, u.bounds);
+  });
+}
+const kt = $t;
+function Qt(t) {
+  return St(t);
+}
+function Zt(t) {
+  if (!t)
+    return null;
+  const n = t.toLowerCase();
+  return kt.find((e) => e.hex.toLowerCase() === n)?.preset ?? null;
+}
+function mt(t) {
+  return t ? /^[1-6]$/.test(t) ? Qt(t) : t : "";
+}
+export {
+  kt as E,
+  Nt as a,
+  Dt as b,
+  Qt as c,
+  ft as d,
+  Kt as e,
+  it as f,
+  Vt as g,
+  Wt as h,
+  Jt as i,
+  mt as j,
+  Zt as p,
+  et as r
+};

package/dist/colors.d.ts

@@ -0,0 +1,10 @@
+import { type BoardColorOption, type BoardColorPreset } from '@lupinum/board-core';
+/** JSON Canvas color preset shared by nodes and edges. */
+export type EdgeColorPreset = BoardColorPreset;
+/** Edge-facing alias for the canonical board color option. */
+export type EdgeColorOption = BoardColorOption;
+/** Canonical JSON Canvas palette; edges and nodes intentionally share semantics. */
+export declare const EDGE_COLOR_PRESETS: readonly EdgeColorOption[];
+export declare function colorForPreset(preset: EdgeColorPreset): string;
+export declare function presetForColor(color: string | undefined): EdgeColorPreset | null;
+export declare function resolvePresetColor(color: string | undefined): string;

package/dist/connection-actions.d.ts

@@ -0,0 +1,41 @@
+import { type Ref } from 'vue';
+import { type BoardEngine, type BoardNode } from '@lupinum/board-core';
+import type { ConnectionNodeHandle } from './hit-testing.js';
+import type { ConnectionDragState, DragEnd } from './controller.js';
+import type { BoardEdge, ConnectionEndpointMode, ConnectionsApi, ConnectionsEventMap, CreateNodeForConnectionContext } from './types.js';
+type ConnectionEngine = BoardEngine<{
+    connections: ConnectionsApi;
+}, ConnectionsEventMap>;
+interface ConnectionActionsState {
+    hoveredEdgeId: Ref<string | null>;
+    hoveredNodeHandle: Ref<ConnectionNodeHandle | null>;
+    selectedEdgeId: Ref<string | null>;
+    editingEdgeId: Ref<string | null>;
+    labelDraft: Ref<string>;
+    colorMenuEdgeId: Ref<string | null>;
+    directionMenuEdgeId: Ref<string | null>;
+}
+interface ConnectionActionsDeps {
+    getEngine(): ConnectionEngine;
+    getEntry(edgeId: string): {
+        edge: BoardEdge;
+    } | undefined;
+    getRootElement(): HTMLElement | null;
+    getEndpointMode(): ConnectionEndpointMode;
+    createNodeForConnection(): ((context: CreateNodeForConnectionContext) => BoardNode | null) | null;
+    state: ConnectionActionsState;
+}
+/** Own edge editing and commit policy; the Vue layer only wires input/rendering. */
+export declare function createConnectionActions(deps: ConnectionActionsDeps): {
+    onEdgePointerDown: (edgeId: string, event: PointerEvent) => void;
+    beginLabelEdit: (edgeId: string) => void;
+    commitLabelEdit: () => void;
+    clearLabel: (edgeId: string) => void;
+    cancelLabelEdit: () => void;
+    setDirectionality: (edgeId: string, direction: "none" | "to" | "both") => void;
+    applyEdgeColor: (edgeId: string, color: string | undefined) => void;
+    resetEndpointAnchor: (edgeId: string, end: DragEnd | "both") => void;
+    deleteEdge: (edgeId: string) => void;
+    commitDrag: (active: ConnectionDragState) => void;
+};
+export {};