@lupinum/board-connections 0.1.0

package/dist/connection-label.d.ts

@@ -0,0 +1,99 @@
+import { type PropType } from 'vue';
+import type { Point } from '@lupinum/board-core';
+/** SVG foreign-object label editor used by the connection render shell. */
+export declare const ConnectionLabel: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    edgeId: {
+        type: StringConstructor;
+        required: true;
+    };
+    point: {
+        type: PropType<Point>;
+        required: true;
+    };
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+    color: {
+        type: StringConstructor;
+        default: string;
+    };
+    zoom: {
+        type: NumberConstructor;
+        required: true;
+    };
+    selected: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    hovered: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    editing: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    draft: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    edgePointerDown: (_edgeId: string, _event: PointerEvent) => true;
+    beginEdit: (_edgeId: string) => true;
+    updateDraft: (_value: string) => true;
+    commitEdit: () => true;
+    cancelEdit: () => true;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    edgeId: {
+        type: StringConstructor;
+        required: true;
+    };
+    point: {
+        type: PropType<Point>;
+        required: true;
+    };
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+    color: {
+        type: StringConstructor;
+        default: string;
+    };
+    zoom: {
+        type: NumberConstructor;
+        required: true;
+    };
+    selected: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    hovered: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    editing: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    draft: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{
+    onEdgePointerDown?: ((_edgeId: string, _event: PointerEvent) => any) | undefined;
+    onBeginEdit?: ((_edgeId: string) => any) | undefined;
+    onUpdateDraft?: ((_value: string) => any) | undefined;
+    onCommitEdit?: (() => any) | undefined;
+    onCancelEdit?: (() => any) | undefined;
+}>, {
+    label: string;
+    color: string;
+    selected: boolean;
+    hovered: boolean;
+    editing: boolean;
+    draft: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/dist/connection-toolbar.d.ts

@@ -0,0 +1,19 @@
+import { type VNode } from 'vue';
+import type { Point } from '@lupinum/board-core';
+import type { BoardEdge } from './types.js';
+export interface ConnectionToolbarOptions {
+    edge: BoardEdge;
+    screen: Point;
+    colorMenuOpen: boolean;
+    directionMenuOpen: boolean;
+    onDelete: () => void;
+    onToggleColorMenu: () => void;
+    onToggleDirectionMenu: () => void;
+    onSetColor: (color: string | undefined) => void;
+    onSetDirectionality: (direction: 'none' | 'to' | 'both') => void;
+    onResetAnchor: (end: 'from' | 'to' | 'both') => void;
+    onClearLabel: () => void;
+    onBeginLabelEdit: () => void;
+}
+/** Render the selected-edge toolbar without owning connection domain state. */
+export declare function renderConnectionToolbar(options: ConnectionToolbarOptions): VNode;

package/dist/controller.d.ts

@@ -0,0 +1,50 @@
+import type { NodeId, Point } from '@lupinum/board-core';
+import type { AnchorPosition, AnchorSide } from './types.js';
+export type DragEnd = 'from' | 'to';
+export type ReconnectDragState = {
+    mode: 'reconnect';
+    edgeId: string;
+    end: DragEnd;
+    pointerId: number;
+    pointerWorld: Point;
+    candidateNodeId: NodeId | null;
+    candidateAnchor: AnchorPosition | null;
+};
+export type CreateDragState = {
+    mode: 'create';
+    sourceNodeId: NodeId;
+    sourceSide: AnchorSide;
+    pointerId: number;
+    pointerWorld: Point;
+    candidateNodeId: NodeId | null;
+    candidateAnchor: AnchorPosition | null;
+};
+export type ConnectionDragState = ReconnectDragState | CreateDragState;
+export type PendingConnectionDrag = {
+    mode: 'reconnect';
+    edgeId: string;
+    end: DragEnd;
+    pointerId: number;
+    startWorld: Point;
+} | {
+    mode: 'create';
+    sourceNodeId: NodeId;
+    sourceSide: AnchorSide;
+    pointerId: number;
+    startWorld: Point;
+};
+interface AdvanceDragInput {
+    pending: PendingConnectionDrag | null;
+    active: ConnectionDragState | null;
+    pointerId: number;
+    pointerWorld: Point;
+    candidateNodeId: NodeId | null;
+    candidateAnchor: AnchorPosition | null;
+    zoom: number;
+    threshold: number;
+}
+export declare function advanceConnectionDrag(input: AdvanceDragInput): {
+    pending: PendingConnectionDrag | null;
+    active: ConnectionDragState | null;
+};
+export {};

package/dist/directionality.d.ts

@@ -0,0 +1,8 @@
+import type { EdgeEnd } from './types.js';
+/** Arrow placement policy shared by connection defaults and editing commands. */
+export type ConnectionDirectionality = 'none' | 'start' | 'end' | 'both';
+/** Resolve a directionality choice to the persisted edge endpoint markers. */
+export declare function edgeEndsForDirectionality(directionality: ConnectionDirectionality): {
+    fromEnd: EdgeEnd;
+    toEnd: EdgeEnd;
+};

package/dist/geometry.d.ts

@@ -0,0 +1,23 @@
+import { type BoardEngine, type BoardNode, type Bounds, type Point } from '@lupinum/board-core';
+import type { AnchorPosition, AnchorSide, BoardEdge, ConnectionRoute, ConnectionRouting, ConnectionsApi, ResolvedConnectionEndpoint } from './types.js';
+export declare function resolveAnchorPoint(node: Pick<BoardNode, 'x' | 'y' | 'width' | 'height'>, anchor: AnchorPosition): Point;
+export declare function resolveAutoAnchorSide(source: Pick<BoardNode, 'x' | 'y' | 'width' | 'height'>, target: Pick<BoardNode, 'x' | 'y' | 'width' | 'height'>, _role: 'source' | 'target', previousSide?: AnchorSide): AnchorSide;
+export declare function resolveConnectionEndpoint(edge: BoardEdge, node: Pick<BoardNode, 'id' | 'x' | 'y' | 'width' | 'height'>, otherNode: Pick<BoardNode, 'id' | 'x' | 'y' | 'width' | 'height'>, role: 'source' | 'target', previousSide?: AnchorSide): ResolvedConnectionEndpoint;
+export declare function resolveFloatingEndpoint(pointValue: Point, otherPoint: Point, role: 'source' | 'target', previousSide?: AnchorSide): ResolvedConnectionEndpoint;
+export declare function buildConnectionRoute(params: {
+    source: ResolvedConnectionEndpoint;
+    target: ResolvedConnectionEndpoint;
+    routing?: ConnectionRouting;
+}): ConnectionRoute;
+export declare function resolveEdgeRenderState(edge: BoardEdge, sourceNode: Pick<BoardNode, 'id' | 'x' | 'y' | 'width' | 'height'>, targetNode: Pick<BoardNode, 'id' | 'x' | 'y' | 'width' | 'height'>, options?: {
+    routing?: ConnectionRouting;
+    previousSourceSide?: AnchorSide;
+    previousTargetSide?: AnchorSide;
+}): {
+    source: ResolvedConnectionEndpoint;
+    target: ResolvedConnectionEndpoint;
+    route: ConnectionRoute;
+};
+export declare function getVisibleEdges(engine: BoardEngine<{
+    connections: ConnectionsApi;
+}>, bounds: Bounds, routing?: ConnectionRouting): BoardEdge[];

package/dist/hit-testing.d.ts

@@ -0,0 +1,11 @@
+import type { BoardNode, NodeId, Point } from '@lupinum/board-core';
+import type { AnchorSide } from './types.js';
+export interface ConnectionNodeHandle {
+    nodeId: NodeId;
+    side: AnchorSide;
+    offset: number;
+}
+export declare function edgeIdFromTarget(target: EventTarget | null): string | null;
+export declare function nodeHandleFromTarget(target: EventTarget | null): ConnectionNodeHandle | null;
+export declare function sameEdgeTarget(target: EventTarget | null, edgeId: string): boolean;
+export declare function resolveNodeHandleAtWorldPoint(nodes: Iterable<BoardNode>, point: Point, threshold: number, cornerClearance: number): ConnectionNodeHandle | null;

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+/** Install the connections plugin and its `engine.plugins.connections` API. */
+export { connectionsPlugin } from './plugin.js';
+/** Shared mapping from directionality choices to persisted endpoint markers. */
+export { edgeEndsForDirectionality } from './directionality.js';
+export type { ConnectionDirectionality } from './directionality.js';
+/** Geometry helpers for resolving anchors, routes, and render state. */
+export { buildConnectionRoute, getVisibleEdges, resolveAnchorPoint, resolveAutoAnchorSide, resolveConnectionEndpoint, resolveFloatingEndpoint, resolveEdgeRenderState, } from './geometry.js';
+/** Arc routing helper inspired by hand-drawn arrow curves. */
+export { buildArcRoute } from './routing/arc.js';
+/** Options for tuning arc routing curvature. */
+export type { ArcOptions } from './routing/arc.js';
+/** Color helpers and presets used by edge rendering and toolbars. */
+export { EDGE_COLOR_PRESETS, colorForPreset, presetForColor, resolvePresetColor, } from './colors.js';
+/** Types for custom edge colors and preset names. */
+export type { EdgeColorOption, EdgeColorPreset } from './colors.js';
+/** Core edge model types and the connections engine API contract. */
+export type { AnchorPosition, AnchorSide, BoardEdge, BoardEdgePatch, ConnectionConfig, ConnectionEndpointMode, ConnectionPluginOptions, ConnectionRoute, ConnectionRouteSegment, ConnectionRouting, ConnectionsApi, ConnectionsEventMap, CreateNodeForConnectionContext, EdgeEnd, ResolvedConnectionEndpoint, } from './types.js';

package/dist/index.js

@@ -0,0 +1,298 @@
+import { asNodeId as S, asEdgeId as C, BoardNotFoundError as h, BoardConflictError as z, BoardInputError as b } from "@lupinum/board-core";
+import { defineInternalBoardPlugin as T } from "@lupinum/board-core/internal";
+import { e as $ } from "./colors-CI4AZ9tI.js";
+import { E as Z, b as L, a as k, c as H, g as J, p as V, r as q, d as K, f as Q, h as W, i as X, j as Y } from "./colors-CI4AZ9tI.js";
+const F = "connections", P = /* @__PURE__ */ new Set(["top", "right", "bottom", "left"]);
+function w(r, f) {
+  if (r) {
+    if (!P.has(r.side))
+      throw new b(
+        `Cannot use ${f}: anchor side "${String(r.side)}" is unsupported.`
+      );
+    if (!Number.isFinite(r.offset) || r.offset < 0 || r.offset > 1)
+      throw new b(
+        `Cannot use ${f}: anchor offset must be a finite number from 0 to 1.`
+      );
+  }
+}
+function v(r) {
+  if (r !== void 0 && !/^[1-6]$/.test(r) && !/^#[0-9a-fA-F]{6}$/.test(r))
+    throw new b(
+      `Cannot use edge color "${r}": expected a preset from 1 to 6 or a six-digit hex color.`
+    );
+}
+const _ = {
+  edges: /* @__PURE__ */ new Map(),
+  nextZIndex: 1
+};
+function N(r, f, A) {
+  switch (f.type) {
+    case "EDGE_CREATED": {
+      const a = A ?? new Map(r.edges);
+      return a.set(f.edge.id, f.edge), {
+        edges: a,
+        nextZIndex: Math.max(r.nextZIndex, f.edge.zIndex + 1)
+      };
+    }
+    case "EDGE_UPDATED": {
+      const a = A ?? new Map(r.edges);
+      return a.set(f.id, f.after), { ...r, edges: a };
+    }
+    case "EDGE_DELETED": {
+      if (!r.edges.has(f.id)) return r;
+      const a = A ?? new Map(r.edges);
+      return a.delete(f.id), { ...r, edges: a };
+    }
+  }
+}
+function m(r) {
+  return {
+    ...r,
+    data: structuredClone(r.data)
+  };
+}
+function M(r) {
+  return {
+    id: r.id,
+    fromNode: r.from,
+    ...r.fromAnchor?.side ? { fromSide: r.fromAnchor.side } : {},
+    ...r.fromEnd ? { fromEnd: r.fromEnd } : {},
+    toNode: r.to,
+    ...r.toAnchor?.side ? { toSide: r.toAnchor.side } : {},
+    ...r.toEnd ? { toEnd: r.toEnd } : {},
+    ...r.color ? { color: r.color } : {},
+    ...r.label ? { label: r.label } : {}
+  };
+}
+function B(r = {}) {
+  const f = r.routing ?? "bezier", A = r.endpointMode ?? "auto", a = r.defaultArrow ?? "end", y = {
+    routing: f,
+    endpointMode: A,
+    defaultArrow: a
+  }, D = $(a);
+  return T({
+    name: F,
+    slice: {
+      initial: _
+    },
+    nodeDeleted(d, c) {
+      d.updatePluginState((s) => {
+        const l = new Map(s.edges);
+        for (const [E, n] of l)
+          (n.from === c || n.to === c) && l.delete(E);
+        return l.size === s.edges.size ? s : { ...s, edges: l };
+      });
+    },
+    persistence: {
+      exportDocument(d) {
+        const c = d.plugins.connections.getEdges();
+        return c.length === 0 ? {} : {
+          edges: c.map(M),
+          "x-vue-board": {
+            edges: Object.fromEntries(
+              c.map((s) => [
+                s.id,
+                {
+                  zIndex: s.zIndex,
+                  ...Object.keys(s.data).length > 0 ? { data: s.data } : {}
+                }
+              ])
+            )
+          }
+        };
+      },
+      loadDocument(d, c, s, l) {
+        const E = d.plugins.connections;
+        if (s === "replace")
+          for (const n of E.getEdges())
+            E.deleteEdge(n.id);
+        for (const n of c.edges ?? []) {
+          const u = S(n.fromNode), x = S(n.toNode), e = l.get(u) ?? u, o = l.get(x) ?? x;
+          if (!d.hasNode(e) || !d.hasNode(o))
+            continue;
+          const t = c["x-vue-board"]?.edges?.[n.id], i = s === "merge" && E.getEdge(C(n.id)) ? C(crypto.randomUUID()) : C(n.id);
+          E.createEdge({
+            id: i,
+            from: e,
+            to: o,
+            ...n.fromSide ? { fromAnchor: { side: n.fromSide, offset: 0.5 } } : {},
+            ...n.toSide ? { toAnchor: { side: n.toSide, offset: 0.5 } } : {},
+            ...n.fromEnd ? { fromEnd: n.fromEnd } : {},
+            ...n.toEnd ? { toEnd: n.toEnd } : {},
+            ...n.color ? { color: n.color } : {},
+            ...n.label ? { label: n.label } : {},
+            data: t?.data ?? {},
+            ...t?.zIndex !== void 0 ? { zIndex: t.zIndex } : {}
+          });
+        }
+      }
+    },
+    install(d) {
+      const c = () => d.getPluginState();
+      let s = null;
+      const l = (e) => d.updatePluginState((o) => d.isBatching() ? (o.edges !== s && (s = new Map(o.edges)), N(o, e, s)) : (s = null, N(o, e)));
+      function E(e, o) {
+        const t = c().edges.get(e);
+        if (!t)
+          throw new h(
+            `Cannot ${o} edge: edge "${e}" does not exist.`
+          );
+        return t;
+      }
+      const n = {
+        createEdge(e) {
+          return d.runCommand(
+            "edge:create",
+            [e],
+            () => {
+              if (!d.hasNode(e.from))
+                throw new h(
+                  `Cannot create edge: source node "${e.from}" does not exist.`
+                );
+              if (!d.hasNode(e.to))
+                throw new h(
+                  `Cannot create edge: target node "${e.to}" does not exist.`
+                );
+              const o = c(), t = e.id ?? C(crypto.randomUUID());
+              if (o.edges.has(t))
+                throw new z(
+                  `Cannot create edge: edge "${t}" already exists.`
+                );
+              if (w(e.fromAnchor, "fromAnchor"), w(e.toAnchor, "toAnchor"), v(e.color), e.zIndex !== void 0 && !Number.isFinite(e.zIndex))
+                throw new b(
+                  "Cannot create edge: zIndex must be a finite number."
+                );
+              const i = {
+                id: t,
+                from: e.from,
+                to: e.to,
+                fromAnchor: e.fromAnchor,
+                toAnchor: e.toAnchor,
+                fromEnd: e.fromEnd ?? D.fromEnd,
+                toEnd: e.toEnd ?? D.toEnd,
+                label: e.label,
+                color: e.color,
+                data: structuredClone(e.data ?? {}),
+                zIndex: e.zIndex ?? o.nextZIndex
+              };
+              return l({ type: "EDGE_CREATED", edge: i }), m(i);
+            },
+            { history: "record" }
+          );
+        },
+        updateEdge(e, o) {
+          const t = E(e, "update");
+          return d.runCommand(
+            "edge:update",
+            [e, o],
+            () => {
+              const i = "from" in o ? o.from : t.from, g = "to" in o ? o.to : t.to;
+              if (!i || !d.hasNode(i))
+                throw new h(
+                  `Cannot update edge: source node "${i}" does not exist.`
+                );
+              if (!g || !d.hasNode(g))
+                throw new h(
+                  `Cannot update edge: target node "${g}" does not exist.`
+                );
+              w(
+                "fromAnchor" in o ? o.fromAnchor : t.fromAnchor,
+                "fromAnchor"
+              ), w(
+                "toAnchor" in o ? o.toAnchor : t.toAnchor,
+                "toAnchor"
+              ), v("color" in o ? o.color : t.color);
+              const I = {
+                ...t,
+                from: i,
+                to: g,
+                fromAnchor: "fromAnchor" in o ? o.fromAnchor : t.fromAnchor,
+                toAnchor: "toAnchor" in o ? o.toAnchor : t.toAnchor,
+                fromEnd: "fromEnd" in o ? o.fromEnd : t.fromEnd,
+                toEnd: "toEnd" in o ? o.toEnd : t.toEnd,
+                label: "label" in o ? o.label : t.label,
+                color: "color" in o ? o.color : t.color,
+                data: "data" in o ? structuredClone(o.data ?? {}) : structuredClone(t.data)
+              };
+              return l({
+                type: "EDGE_UPDATED",
+                id: e,
+                after: I
+              }), m(I);
+            },
+            { history: "record" }
+          );
+        },
+        deleteEdge(e) {
+          c().edges.get(e) && d.runCommand(
+            "edge:delete",
+            [e],
+            () => {
+              l({ type: "EDGE_DELETED", id: e });
+            },
+            { history: "record" }
+          );
+        },
+        getEdge(e) {
+          const o = c().edges.get(e);
+          return o ? m(o) : void 0;
+        },
+        getEdges() {
+          return Array.from(
+            c().edges.values(),
+            (e) => m(e)
+          );
+        },
+        getEdgesFrom(e) {
+          return n.getEdges().filter((o) => o.from === e);
+        },
+        getEdgesTo(e) {
+          return n.getEdges().filter((o) => o.to === e);
+        },
+        getEdgesBetween(e, o) {
+          return n.getEdges().filter((t) => t.from === e && t.to === o);
+        },
+        getConfig() {
+          return d.assertActive(), { ...y };
+        }
+      };
+      d.extend("connections", n);
+      let u = c().edges;
+      const x = d.projectCommit(() => {
+        const e = c().edges;
+        if (e === u) return () => {
+        };
+        const o = u;
+        return () => {
+          s = null;
+          for (const [t, i] of e) {
+            const g = o.get(t);
+            g ? g !== i && d.emit("edge:updated", m(i), m(g)) : d.emit("edge:created", m(i));
+          }
+          for (const [t] of o)
+            e.has(t) || d.emit("edge:deleted", t);
+          u = e;
+        };
+      });
+      return () => {
+        x();
+      };
+    }
+  });
+}
+export {
+  Z as EDGE_COLOR_PRESETS,
+  L as buildArcRoute,
+  k as buildConnectionRoute,
+  H as colorForPreset,
+  B as connectionsPlugin,
+  $ as edgeEndsForDirectionality,
+  J as getVisibleEdges,
+  V as presetForColor,
+  q as resolveAnchorPoint,
+  K as resolveAutoAnchorSide,
+  Q as resolveConnectionEndpoint,
+  W as resolveEdgeRenderState,
+  X as resolveFloatingEndpoint,
+  Y as resolvePresetColor
+};

package/dist/layer-helpers.d.ts

@@ -0,0 +1,26 @@
+import type { BoardEngine, BoardNode, Point } from '@lupinum/board-core';
+import type { AnchorPosition, AnchorSide } from './types.js';
+export interface EdgeRenderLayerContext {
+    toLocalPoint(clientX: number, clientY: number): Point;
+}
+export declare const CONNECTION_DRAG_THRESHOLD = 6;
+export declare const EDGE_STROKE_LOD_FADE_START = 0.95;
+export declare const EDGE_STROKE_LOD_SOFTEN_AT = 0.45;
+export declare const EDGE_ARROW_MARKER_SIZE = 18;
+export declare const EDGE_ARROW_SCREEN_SIZE = 16;
+export declare const EDGE_ARROW_MIN_SCREEN_SIZE = 10;
+export declare const EDGE_ARROW_MAX_SCREEN_SIZE = 22;
+export declare const EDGE_LABEL_MIN_ZOOM = 0.1;
+export declare const EDGE_LABEL_MAX_SCREEN_WIDTH = 220;
+export declare const EDGE_LABEL_HORIZONTAL_PADDING = 20;
+export declare const EDGE_LABEL_IDLE_HEIGHT = 18;
+export declare const EDGE_LABEL_ACTIVE_HEIGHT = 24;
+export declare const EDGE_LABEL_SCREEN_FONT_SIZE = 14;
+export declare const EDGE_LABEL_ACTIVE_FONT_SIZE = 13;
+export declare function clamp01(value: number): number;
+export declare function resolveLodAmount(zoom: number, fadeStart: number, minDetailAt: number): number;
+export declare function resolveArrowScreenSize(zoom: number): number;
+export declare function worldPointFromClient(ctx: EdgeRenderLayerContext, engine: BoardEngine, clientX: number, clientY: number): Point;
+export declare function floatingNodeAt(point: Point, role: 'source' | 'target'): Pick<BoardNode, 'id' | 'x' | 'y' | 'width' | 'height'>;
+export declare function anchorForPointOnNode(node: Pick<BoardNode, 'x' | 'y' | 'width' | 'height'>, side: AnchorSide, point: Point): AnchorPosition;
+export declare function sameAnchor(left: AnchorPosition | undefined, right: AnchorPosition | null): boolean;

package/dist/layer.d.ts

@@ -0,0 +1,38 @@
+import { type PropType } from 'vue';
+import { type BoardNode } from '@lupinum/board-core';
+import type { ConnectionEndpointMode, CreateNodeForConnectionContext, ConnectionRouting } from './types.js';
+export declare const BoardConnectionLayer: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    routing: {
+        type: PropType<ConnectionRouting | undefined>;
+        default: undefined;
+    };
+    endpointMode: {
+        type: PropType<ConnectionEndpointMode | undefined>;
+        default: undefined;
+    };
+    createNodeForConnection: {
+        type: PropType<(context: CreateNodeForConnectionContext) => BoardNode | null>;
+        default: null;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[], {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    routing: {
+        type: PropType<ConnectionRouting | undefined>;
+        default: undefined;
+    };
+    endpointMode: {
+        type: PropType<ConnectionEndpointMode | undefined>;
+        default: undefined;
+    };
+    createNodeForConnection: {
+        type: PropType<(context: CreateNodeForConnectionContext) => BoardNode | null>;
+        default: null;
+    };
+}>> & Readonly<{}>, {
+    routing: ConnectionRouting | undefined;
+    endpointMode: ConnectionEndpointMode | undefined;
+    createNodeForConnection: (context: CreateNodeForConnectionContext) => BoardNode | null;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/dist/plugin.d.ts

@@ -0,0 +1,7 @@
+import { type BoardPlugin, type BoardPluginApis } from '@lupinum/board-core';
+import type { ConnectionPluginOptions, ConnectionsApi, ConnectionsEventMap } from './types.js';
+interface ConnectionsPluginApis extends BoardPluginApis {
+    connections: ConnectionsApi;
+}
+export declare function connectionsPlugin(options?: ConnectionPluginOptions): BoardPlugin<ConnectionsPluginApis, ConnectionsEventMap>;
+export {};

package/dist/renderer.d.ts

@@ -0,0 +1,32 @@
+import { type VNode } from 'vue';
+import type { BoardNode } from '@lupinum/board-core';
+import type { ConnectionDragState } from './controller.js';
+import type { BoardEdge, ResolvedConnectionEndpoint } from './types.js';
+import type { buildConnectionRoute } from './geometry.js';
+export interface ConnectionRenderEntry {
+    edge: BoardEdge;
+    route: ReturnType<typeof buildConnectionRoute>;
+}
+export declare function renderDefaultEdgePath(options: {
+    entry: ConnectionRenderEntry;
+    markerId: string;
+    stroke: string;
+    opacity: number;
+    strokeWidth: number;
+}): VNode;
+interface PreviewRenderState {
+    edge: BoardEdge | null;
+    source: ResolvedConnectionEndpoint;
+    target: ResolvedConnectionEndpoint;
+    route: ReturnType<typeof buildConnectionRoute>;
+    candidateNode: BoardNode | null | undefined;
+}
+export declare function renderConnectionPreview(options: {
+    preview: PreviewRenderState;
+    drag: ConnectionDragState;
+    markerId: string;
+    zoom: number;
+    handleRadius: number;
+    strokeWidth: number;
+}): Array<VNode | null>;
+export {};

package/dist/routing/arc.d.ts

@@ -0,0 +1,11 @@
+import type { ConnectionRoute, ResolvedConnectionEndpoint } from '../types.js';
+export interface ArcOptions {
+    bow?: number;
+    stretch?: number;
+    stretchMin?: number;
+    stretchMax?: number;
+    padStart?: number;
+    padEnd?: number;
+    flip?: boolean;
+}
+export declare function buildArcRoute(source: ResolvedConnectionEndpoint, target: ResolvedConnectionEndpoint, options?: ArcOptions): ConnectionRoute;