@dforge-core/diagram 0.0.1

package/dist/WorkspaceMap/workspace-types.d.ts

@@ -0,0 +1,32 @@
+export interface WorkspaceModule {
+    id: string;
+    moduleCd: string;
+    label: string;
+    color: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    entities: WorkspaceEntity[];
+}
+export interface WorkspaceEntity {
+    entityId: number;
+    entityCd: string;
+    label: string;
+    /** Nesting depth (0 = root, 1 = child, 2 = grandchild, ...) */
+    depth: number;
+    /** Position relative to parent module card */
+    rx: number;
+    ry: number;
+    width: number;
+    height: number;
+}
+export interface WorkspaceEdge {
+    id: string;
+    sourceModuleId: string;
+    sourceEntityId: number;
+    targetModuleId: string;
+    targetEntityId: number;
+    color: string;
+}
+//# sourceMappingURL=workspace-types.d.ts.map

package/dist/WorkspaceMap/workspace-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace-types.d.ts","sourceRoot":"","sources":["../../src/lib/WorkspaceMap/workspace-types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,eAAe;IAC/B,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,eAAe,EAAE,CAAC;CAC5B;AAED,MAAM,WAAW,eAAe;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,+DAA+D;IAC/D,KAAK,EAAE,MAAM,CAAC;IACd,8CAA8C;IAC9C,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,aAAa;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,cAAc,EAAE,MAAM,CAAC;IACvB,cAAc,EAAE,MAAM,CAAC;IACvB,cAAc,EAAE,MAAM,CAAC;IACvB,cAAc,EAAE,MAAM,CAAC;IACvB,KAAK,EAAE,MAAM,CAAC;CACd"}

package/dist/WorkspaceMap/workspace-types.js

@@ -0,0 +1 @@
+export {};

package/dist/diagram-types.d.ts

@@ -0,0 +1,47 @@
+import type { ModelColumn } from './model-types';
+export interface EntityNodeData {
+    entityCd: string;
+    resLabel?: string;
+    resIcon?: string;
+    moduleCd: string;
+    moduleColor: string;
+    columns: ModelColumn[];
+    /** Map of entityId → entityCd for resolving FK targets */
+    entityMap: Map<number, string>;
+}
+export interface DiagramNode {
+    id: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    data: EntityNodeData;
+}
+export interface DiagramEdge {
+    id: string;
+    source: string;
+    sourceHandle: string;
+    target: string;
+    color: string;
+    label?: string;
+    isNullable?: boolean;
+}
+/** Edge with fully resolved path — no recomputation needed at render time. */
+export interface ResolvedEdge extends DiagramEdge {
+    points: Point[];
+}
+export interface Point {
+    x: number;
+    y: number;
+}
+export interface ViewTransform {
+    x: number;
+    y: number;
+    k: number;
+}
+export interface DragSegment {
+    edgeId: string;
+    segIndex: number;
+    orientation: 'H' | 'V';
+}
+//# sourceMappingURL=diagram-types.d.ts.map

package/dist/diagram-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagram-types.d.ts","sourceRoot":"","sources":["../src/lib/diagram-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAEjD,MAAM,WAAW,cAAc;IAC9B,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,WAAW,EAAE,CAAC;IACvB,0DAA0D;IAC1D,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC/B;AAED,MAAM,WAAW,WAAW;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,cAAc,CAAC;CACrB;AAED,MAAM,WAAW,WAAW;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,8EAA8E;AAC9E,MAAM,WAAW,YAAa,SAAQ,WAAW;IAChD,MAAM,EAAE,KAAK,EAAE,CAAC;CAChB;AAED,MAAM,WAAW,KAAK;IACrB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACV;AAED,MAAM,WAAW,aAAa;IAC7B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACV;AAED,MAAM,WAAW,WAAW;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,GAAG,GAAG,GAAG,CAAA;CACtB"}

package/dist/diagram-types.js

@@ -0,0 +1,2 @@
+;
+export {};

package/dist/edge-routing.d.ts

@@ -0,0 +1,82 @@
+import type { DiagramNode, DiagramEdge, Point } from './diagram-types';
+export declare const PORT_DOT_RADIUS = 3;
+export interface EdgePath {
+    d: string;
+    labelX: number;
+    labelY: number;
+    srcPort: Point;
+    tgtPort: Point;
+    points: Point[];
+}
+export interface SegmentHandle {
+    x: number;
+    y: number;
+    segIndex: number;
+    orientation: 'H' | 'V';
+    draggable: boolean;
+}
+/**
+ * Compute source port position: right side of node, at the FK row's vertical center.
+ */
+export declare function sourcePort(node: DiagramNode, colCd: string): Point;
+/**
+ * Compute target port position: left side of node, at vertical center.
+ */
+export declare const targetPort: (node: DiagramNode) => Point;
+/**
+ * Snap first/last bend points to port Y positions.
+ * Keeps paths orthogonal when nodes are moved.
+ *
+ * Only snap when the bend forms a horizontal segment with the port
+ * (different X). If the bend shares the same X as the port, it's a
+ * vertical connection (e.g., after a segment split) and shouldn't be
+ * snapped — that would destroy jog shapes.
+ */
+export declare const snapBends: (src: Point, tgt: Point, bends: Point[]) => Point[];
+/**
+ * Compute auto-routed bend points for an edge.
+ * Returns the corners where the path changes direction.
+ */
+export declare function extractBendPoints(edge: DiagramEdge, nodes: Record<string, DiagramNode>): Point[];
+/**
+ * Remove redundant bend points: snap near-collinear points to exact
+ * alignment, remove zero-length duplicates, and collapse collinear midpoints.
+ */
+export declare function consolidateBends(edge: DiagramEdge, nodes: Record<string, DiagramNode>, bends: Point[]): Point[];
+/**
+ * Compute the SVG path for an edge.
+ * Uses stored bend points if provided, otherwise auto-routes.
+ */
+export declare function computeEdgePath(edge: DiagramEdge, nodes: Record<string, DiagramNode>, storedBends?: Point[]): EdgePath | null;
+/**
+ * Compute drag/split handles for an edge's segments.
+ */
+export declare function getEdgeHandles(edge: DiagramEdge, nodes: Record<string, DiagramNode>, storedBends?: Point[]): {
+    bendPoints: Point[];
+    handles: SegmentHandle[];
+} | null;
+/**
+ * Prepare bends for dragging by inserting clamp points where needed.
+ * When a segment's neighbors are collinear (same orientation), dragging
+ * would create diagonal lines. This inserts transition bends so that
+ * adjacent segments become perpendicular and stay orthogonal during drag.
+ * Call once at drag start, not on every move.
+ */
+export declare function prepareDrag(edge: DiagramEdge, nodes: Record<string, DiagramNode>, bends: Point[], segIndex: number, orientation: 'H' | 'V'): {
+    bends: Point[];
+    segIndex: number;
+};
+/**
+ * Move a segment by updating the two bend points that define it.
+ */
+export declare function dragSegment(bends: Point[], segIndex: number, orientation: 'H' | 'V', pos: Point): Point[];
+/**
+ * Split a segment by inserting a rectangular jog.
+ * Returns the new bend points and the draggable segment info.
+ */
+export declare function splitSegment(edge: DiagramEdge, nodes: Record<string, DiagramNode>, storedBends: Point[], handle: SegmentHandle): {
+    bends: Point[];
+    segIndex: number;
+    orientation: 'H' | 'V';
+};
+//# sourceMappingURL=edge-routing.d.ts.map

package/dist/edge-routing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edge-routing.d.ts","sourceRoot":"","sources":["../src/lib/edge-routing.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAQvE,eAAO,MAAM,eAAe,IAAI,CAAC;AAEjC,MAAM,WAAW,QAAQ;IACxB,CAAC,EAAE,MAAM,CAAC;IACV,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,KAAK,CAAC;IACf,OAAO,EAAE,KAAK,CAAC;IACf,MAAM,EAAE,KAAK,EAAE,CAAC;CAChB;AAED,MAAM,WAAW,aAAa;IAC7B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,GAAG,GAAG,GAAG,CAAC;IACvB,SAAS,EAAE,OAAO,CAAC;CACnB;AAMD;;GAEG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,WAAW,EAAE,KAAK,EAAE,MAAM,GAAG,KAAK,CASlE;AAED;;GAEG;AACH,eAAO,MAAM,UAAU,GAAI,MAAM,WAAW,KAAG,KAG9C,CAAC;AAIF;;;;;;;;GAQG;AACH,eAAO,MAAM,SAAS,GAAI,KAAK,KAAK,EAAE,KAAK,KAAK,EAAE,OAAO,KAAK,EAAE,KAAG,KAAK,EASrE,CAAC;AAiHJ;;;GAGG;AACH,wBAAgB,iBAAiB,CAChC,IAAI,EAAE,WAAW,EACjB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,GAChC,KAAK,EAAE,CA8CT;AAID;;;GAGG;AACH,wBAAgB,gBAAgB,CAC/B,IAAI,EAAE,WAAW,EACjB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,EAClC,KAAK,EAAE,KAAK,EAAE,GACZ,KAAK,EAAE,CA2CT;AAID;;;GAGG;AACH,wBAAgB,eAAe,CAC9B,IAAI,EAAE,WAAW,EACjB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,EAClC,WAAW,CAAC,EAAE,KAAK,EAAE,GACnB,QAAQ,GAAG,IAAI,CAajB;AAED;;GAEG;AACH,wBAAgB,cAAc,CAC7B,IAAI,EAAE,WAAW,EACjB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,EAClC,WAAW,CAAC,EAAE,KAAK,EAAE,GACnB;IAAE,UAAU,EAAE,KAAK,EAAE,CAAC;IAAC,OAAO,EAAE,aAAa,EAAE,CAAA;CAAE,GAAG,IAAI,CAU1D;AA+CD;;;;;;GAMG;AACH,wBAAgB,WAAW,CAC1B,IAAI,EAAE,WAAW,EACjB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,EAClC,KAAK,EAAE,KAAK,EAAE,EACd,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,GAAG,GAAG,GAAG,GACpB;IAAE,KAAK,EAAE,KAAK,EAAE,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAyCtC;AAED;;GAEG;AACH,wBAAgB,WAAW,CAC1B,KAAK,EAAE,KAAK,EAAE,EACd,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,GAAG,GAAG,GAAG,EACtB,GAAG,EAAE,KAAK,GACR,KAAK,EAAE,CAUT;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAC3B,IAAI,EAAE,WAAW,EACjB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,EAClC,WAAW,EAAE,KAAK,EAAE,EACpB,MAAM,EAAE,aAAa,GACnB;IAAE,KAAK,EAAE,KAAK,EAAE,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,GAAG,GAAG,GAAG,CAAA;CAAE,CA+B9D"}

package/dist/edge-routing.js

@@ -0,0 +1,388 @@
+const HEADER_HEIGHT = 30;
+const ROW_HEIGHT = 22;
+const BEND_RADIUS = 8;
+const STUB_LENGTH = 24;
+const TARGET_STUB = STUB_LENGTH;
+const SNAP = 3; // px — threshold for snapping near-collinear points
+export const PORT_DOT_RADIUS = 3;
+const point = (x, y) => ({ x, y });
+// --- Port positions ---
+/**
+ * Compute source port position: right side of node, at the FK row's vertical center.
+ */
+export function sourcePort(node, colCd) {
+    const colIndex = node.data.columns.findIndex((c) => c.columnCd === colCd);
+    const idx = colIndex >= 0 ? colIndex : 0;
+    return point(node.x + node.width, node.y + HEADER_HEIGHT + idx * ROW_HEIGHT + ROW_HEIGHT / 2);
+}
+/**
+ * Compute target port position: left side of node, at vertical center.
+ */
+export const targetPort = (node) => point(node.x, node.y + node.height / 2);
+// --- Bend point snapping ---
+/**
+ * Snap first/last bend points to port Y positions.
+ * Keeps paths orthogonal when nodes are moved.
+ *
+ * Only snap when the bend forms a horizontal segment with the port
+ * (different X). If the bend shares the same X as the port, it's a
+ * vertical connection (e.g., after a segment split) and shouldn't be
+ * snapped — that would destroy jog shapes.
+ */
+export const snapBends = (src, tgt, bends) => bends.length === 0
+    ? bends
+    : bends.map((b, i) => i === 0 && Math.abs(b.x - src.x) > SNAP
+        ? { ...b, y: src.y }
+        : i === bends.length - 1 && Math.abs(b.x - tgt.x) > SNAP
+            ? { ...b, y: tgt.y }
+            : b);
+// --- SVG path helpers ---
+/**
+ * Build a quadratic Bezier corner between two segments.
+ * prev→corner→next defines the corner; r is the desired radius.
+ */
+function roundedCorner(from, corner, to, r) {
+    const d1 = Math.max(Math.abs(corner.x - from.x), Math.abs(corner.y - from.y));
+    const d2 = Math.max(Math.abs(to.x - corner.x), Math.abs(to.y - corner.y));
+    const cr = Math.min(r, d1 / 2, d2 / 2);
+    if (cr < 1)
+        return `L ${corner.x} ${corner.y}`;
+    // Use dominant-axis direction: for near-orthogonal segments the minor
+    // axis may be a few pixels off, and raw Math.sign would produce ±1
+    // instead of 0, sending the Bezier exit in the wrong direction.
+    const d1x = corner.x - from.x, d1y = corner.y - from.y;
+    const d2x = to.x - corner.x, d2y = to.y - corner.y;
+    const h1 = Math.abs(d1x) >= Math.abs(d1y);
+    const dx1 = h1 ? Math.sign(d1x) : 0;
+    const dy1 = h1 ? 0 : Math.sign(d1y);
+    const h2 = Math.abs(d2x) >= Math.abs(d2y);
+    const dx2 = h2 ? Math.sign(d2x) : 0;
+    const dy2 = h2 ? 0 : Math.sign(d2y);
+    const ax = corner.x - dx1 * cr;
+    const ay = corner.y - dy1 * cr;
+    const bx = corner.x + dx2 * cr;
+    const by = corner.y + dy2 * cr;
+    return `L ${ax} ${ay} Q ${corner.x} ${corner.y} ${bx} ${by}`;
+}
+/**
+ * Fix diagonal segments by inserting corner points (horizontal-first).
+ */
+function orthogonalize(raw) {
+    const points = [raw[0]];
+    for (let i = 1; i < raw.length; i++) {
+        const prev = points[points.length - 1];
+        const curr = raw[i];
+        if (Math.abs(prev.x - curr.x) > SNAP && Math.abs(prev.y - curr.y) > SNAP) {
+            points.push(point(curr.x, prev.y)); // horizontal-first corner
+        }
+        points.push(curr);
+    }
+    return points;
+}
+/**
+ * Ensure the path arrives at the target with a horizontal segment.
+ * If the last non-trivial segment is vertical (same X as target),
+ * pull it back by TARGET_STUB and insert a horizontal approach.
+ */
+function ensureHorizontalApproach(points) {
+    if (points.length < 2)
+        return;
+    // Skip trailing zero-length duplicates to find the real approach segment
+    const tgtIdx = points.length - 1;
+    let prevIdx = tgtIdx - 1;
+    while (prevIdx >= 0
+        && Math.abs(points[prevIdx].x - points[tgtIdx].x) < 1
+        && Math.abs(points[prevIdx].y - points[tgtIdx].y) < 1) {
+        prevIdx--;
+    }
+    if (prevIdx < 0)
+        return;
+    const prev = points[prevIdx];
+    const tgt = points[tgtIdx];
+    // Vertical approach: same X, different Y → replace with horizontal stub.
+    // Splice out prev and any trailing duplicates, insert offset detour.
+    if (Math.abs(prev.x - tgt.x) < 1 && Math.abs(prev.y - tgt.y) > 1) {
+        const stubX = tgt.x - TARGET_STUB;
+        points.splice(prevIdx, tgtIdx - prevIdx, point(stubX, prev.y), point(stubX, tgt.y));
+    }
+}
+/**
+ * Build an orthogonal SVG path through a sequence of points (src + bends + tgt).
+ * Auto-fixes any diagonal segments by inserting corner points (horizontal-first).
+ */
+function buildPath(src, tgt, bends) {
+    const raw = orthogonalize([src, ...bends, tgt]);
+    ensureHorizontalApproach(raw);
+    // Strip consecutive duplicate points — zero-length segments cause
+    // roundedCorner to produce sharp angles (cr drops to 0).
+    const points = [raw[0]];
+    for (let i = 1; i < raw.length; i++) {
+        const prev = points[points.length - 1];
+        if (Math.abs(prev.x - raw[i].x) > 0.5 || Math.abs(prev.y - raw[i].y) > 0.5) {
+            points.push(raw[i]);
+        }
+    }
+    let d = `M ${points[0].x} ${points[0].y}`;
+    for (let i = 1; i < points.length - 1; i++) {
+        d += ` ${roundedCorner(points[i - 1], points[i], points[i + 1], BEND_RADIUS)}`;
+    }
+    d += ` L ${points[points.length - 1].x} ${points[points.length - 1].y}`;
+    const mid = points[Math.floor(points.length / 2)];
+    return { d, labelX: mid.x, labelY: mid.y - 6, srcPort: src, tgtPort: tgt, points };
+}
+// --- Auto-routing ---
+/**
+ * Compute auto-routed bend points for an edge.
+ * Returns the corners where the path changes direction.
+ */
+export function extractBendPoints(edge, nodes) {
+    const srcNode = nodes[edge.source];
+    const tgtNode = nodes[edge.target];
+    if (!srcNode || !tgtNode)
+        return [];
+    const src = sourcePort(srcNode, edge.sourceHandle);
+    const tgt = targetPort(tgtNode);
+    // Self-referencing edge
+    if (edge.source === edge.target) {
+        const loopOffset = 40;
+        const rightX = src.x + loopOffset;
+        const topY = Math.min(src.y, tgt.y) - loopOffset;
+        const leftX = tgt.x - loopOffset;
+        return [
+            point(rightX, src.y),
+            point(rightX, topY),
+            point(leftX, topY),
+            point(leftX, tgt.y),
+        ];
+    }
+    // Normal case: target is to the right of source
+    if (tgt.x > src.x + STUB_LENGTH * 2) {
+        const midX = (src.x + tgt.x) / 2;
+        return [
+            point(midX, src.y),
+            point(midX, tgt.y),
+        ];
+    }
+    // Backwards case: target is to the left or overlapping
+    const rightX = src.x + STUB_LENGTH;
+    const leftX = tgt.x - STUB_LENGTH;
+    const midY = (src.y + tgt.y) / 2;
+    const routeY = Math.abs(src.y - tgt.y) < ROW_HEIGHT * 2
+        ? Math.min(srcNode.y, tgtNode.y) - 30
+        : midY;
+    return [
+        point(rightX, src.y),
+        point(rightX, routeY),
+        point(leftX, routeY),
+        point(leftX, tgt.y),
+    ];
+}
+// --- Bend consolidation ---
+/**
+ * Remove redundant bend points: snap near-collinear points to exact
+ * alignment, remove zero-length duplicates, and collapse collinear midpoints.
+ */
+export function consolidateBends(edge, nodes, bends) {
+    if (bends.length === 0)
+        return bends;
+    const srcNode = nodes[edge.source];
+    const tgtNode = nodes[edge.target];
+    if (!srcNode || !tgtNode)
+        return bends;
+    const src = sourcePort(srcNode, edge.sourceHandle);
+    const tgt = targetPort(tgtNode);
+    const snapped = snapBends(src, tgt, bends);
+    const points = [src, ...snapped, tgt];
+    // Snap near-collinear consecutive points to exact alignment.
+    // e.g. (380,279)→(379,74) differs by 1px in X → snap to (380,74).
+    for (let i = 1; i < points.length; i++) {
+        const prev = points[i - 1];
+        const curr = points[i];
+        if (Math.abs(prev.x - curr.x) <= SNAP && Math.abs(prev.y - curr.y) > SNAP) {
+            points[i] = point(prev.x, curr.y); // near-vertical → align X
+        }
+        else if (Math.abs(prev.y - curr.y) <= SNAP && Math.abs(prev.x - curr.x) > SNAP) {
+            points[i] = point(curr.x, prev.y); // near-horizontal → align Y
+        }
+    }
+    // Remove duplicates and collinear midpoints
+    const kept = [points[0]];
+    for (let i = 1; i < points.length; i++) {
+        const prev = kept[kept.length - 1];
+        const curr = points[i];
+        // Skip zero-length duplicates
+        if (Math.abs(prev.x - curr.x) <= SNAP && Math.abs(prev.y - curr.y) <= SNAP)
+            continue;
+        // Skip collinear midpoints only if monotonic (between prev and next).
+        // Direction-reversal vertices (jog peaks) must be preserved.
+        if (i < points.length - 1) {
+            const next = points[i + 1];
+            const sameX = Math.abs(prev.x - curr.x) <= SNAP && Math.abs(curr.x - next.x) <= SNAP;
+            const sameY = Math.abs(prev.y - curr.y) <= SNAP && Math.abs(curr.y - next.y) <= SNAP;
+            if (sameX && curr.y >= Math.min(prev.y, next.y) && curr.y <= Math.max(prev.y, next.y))
+                continue;
+            if (sameY && curr.x >= Math.min(prev.x, next.x) && curr.x <= Math.max(prev.x, next.x))
+                continue;
+        }
+        kept.push(curr);
+    }
+    // Strip src (first) and tgt (last) — return only bends
+    return kept.slice(1, -1);
+}
+// --- Main API ---
+/**
+ * Compute the SVG path for an edge.
+ * Uses stored bend points if provided, otherwise auto-routes.
+ */
+export function computeEdgePath(edge, nodes, storedBends) {
+    const srcNode = nodes[edge.source];
+    const tgtNode = nodes[edge.target];
+    if (!srcNode || !tgtNode)
+        return null;
+    const src = sourcePort(srcNode, edge.sourceHandle);
+    const tgt = targetPort(tgtNode);
+    const bends = storedBends && storedBends.length > 0
+        ? snapBends(src, tgt, storedBends)
+        : extractBendPoints(edge, nodes);
+    return buildPath(src, tgt, bends);
+}
+/**
+ * Compute drag/split handles for an edge's segments.
+ */
+export function getEdgeHandles(edge, nodes, storedBends) {
+    const srcNode = nodes[edge.source];
+    const tgtNode = nodes[edge.target];
+    if (!srcNode || !tgtNode)
+        return null;
+    const src = sourcePort(srcNode, edge.sourceHandle);
+    const tgt = targetPort(tgtNode);
+    const rawBends = storedBends ?? extractBendPoints(edge, nodes);
+    const bends = snapBends(src, tgt, rawBends);
+    return { bendPoints: bends, handles: getSegmentHandles(src, tgt, bends) };
+}
+/**
+ * Get drag handles for all segments of the path.
+ * Only internal segments are draggable; first/last are split-only.
+ * Uses orthogonalized points so handles appear on the rendered path,
+ * not floating off diagonal shortcuts.
+ */
+function getSegmentHandles(src, tgt, bends) {
+    const raw = [src, ...bends, tgt];
+    const handles = [];
+    const lastSeg = raw.length - 2; // segment count in original (un-orthogonalized) path
+    for (let i = 0; i <= lastSeg; i++) {
+        const a = raw[i];
+        const b = raw[i + 1];
+        const isDiag = Math.abs(a.x - b.x) > 1 && Math.abs(a.y - b.y) > 1;
+        if (isDiag) {
+            // orthogonalize inserts (b.x, a.y) between a and b,
+            // creating H-leg (a → corner) then V-leg (corner → b).
+            // Place handle at midpoint of the H-leg.
+            const corner = point(b.x, a.y);
+            handles.push({
+                x: (a.x + corner.x) / 2,
+                y: a.y,
+                segIndex: i,
+                orientation: 'H',
+                draggable: i > 0 && i < lastSeg,
+            });
+        }
+        else {
+            const orientation = Math.abs(a.y - b.y) < 1 ? 'H' : 'V';
+            handles.push({
+                x: (a.x + b.x) / 2,
+                y: (a.y + b.y) / 2,
+                segIndex: i,
+                orientation,
+                draggable: i > 0 && i < lastSeg,
+            });
+        }
+    }
+    return handles;
+}
+// --- Bend point mutation (pure functions) ---
+/**
+ * Prepare bends for dragging by inserting clamp points where needed.
+ * When a segment's neighbors are collinear (same orientation), dragging
+ * would create diagonal lines. This inserts transition bends so that
+ * adjacent segments become perpendicular and stay orthogonal during drag.
+ * Call once at drag start, not on every move.
+ */
+export function prepareDrag(edge, nodes, bends, segIndex, orientation) {
+    const srcNode = nodes[edge.source];
+    const tgtNode = nodes[edge.target];
+    const src = sourcePort(srcNode, edge.sourceHandle);
+    const tgt = targetPort(tgtNode);
+    const result = [...bends];
+    let bi = segIndex - 1; // bends-array index of left endpoint
+    let bj = segIndex; // bends-array index of right endpoint
+    if (orientation === 'H') {
+        const y = result[bi].y;
+        // Check left neighbor: if at same Y (horizontal run), insert clamp
+        const leftPt = bi > 0 ? result[bi - 1] : src;
+        if (Math.abs(leftPt.y - y) < 1 && Math.abs(leftPt.x - result[bi].x) > 1) {
+            result.splice(bi, 0, { ...result[bi] });
+            bi++;
+            bj++;
+        }
+        // Check right neighbor: if at same Y (horizontal run), insert clamp
+        const rightPt = bj + 1 < result.length ? result[bj + 1] : tgt;
+        if (Math.abs(rightPt.y - y) < 1 && Math.abs(rightPt.x - result[bj].x) > 1) {
+            result.splice(bj + 1, 0, { ...result[bj] });
+        }
+    }
+    else {
+        const x = result[bi].x;
+        const leftPt = bi > 0 ? result[bi - 1] : src;
+        if (Math.abs(leftPt.x - x) < 1 && Math.abs(leftPt.y - result[bi].y) > 1) {
+            result.splice(bi, 0, { ...result[bi] });
+            bi++;
+            bj++;
+        }
+        const rightPt = bj + 1 < result.length ? result[bj + 1] : tgt;
+        if (Math.abs(rightPt.x - x) < 1 && Math.abs(rightPt.y - result[bj].y) > 1) {
+            result.splice(bj + 1, 0, { ...result[bj] });
+        }
+    }
+    return { bends: result, segIndex: bi + 1 };
+}
+/**
+ * Move a segment by updating the two bend points that define it.
+ */
+export function dragSegment(bends, segIndex, orientation, pos) {
+    const result = [...bends];
+    if (orientation === 'H') {
+        result[segIndex - 1] = { ...result[segIndex - 1], y: pos.y };
+        result[segIndex] = { ...result[segIndex], y: pos.y };
+    }
+    else {
+        result[segIndex - 1] = { ...result[segIndex - 1], x: pos.x };
+        result[segIndex] = { ...result[segIndex], x: pos.x };
+    }
+    return result;
+}
+/**
+ * Split a segment by inserting a rectangular jog.
+ * Returns the new bend points and the draggable segment info.
+ */
+export function splitSegment(edge, nodes, storedBends, handle) {
+    const srcNode = nodes[edge.source];
+    const tgtNode = nodes[edge.target];
+    const src = sourcePort(srcNode, edge.sourceHandle);
+    const tgt = targetPort(tgtNode);
+    const bends = snapBends(src, tgt, [...storedBends]);
+    const points = [src, ...bends, tgt];
+    const seg = handle.segIndex;
+    const a = points[seg];
+    const b = points[seg + 1];
+    const insertAt = seg;
+    if (handle.orientation === 'H') {
+        const mx = (a.x + b.x) / 2;
+        bends.splice(insertAt, 0, point(mx, a.y), point(mx, a.y), point(b.x, a.y));
+    }
+    else {
+        const my = (a.y + b.y) / 2;
+        bends.splice(insertAt, 0, point(a.x, my), point(a.x, my), point(a.x, b.y));
+    }
+    return { bends, segIndex: seg + 2, orientation: handle.orientation };
+}

package/dist/i18n.d.ts

@@ -0,0 +1,13 @@
+export interface DiagramTranslations {
+    zoom_in: string;
+    zoom_out: string;
+    fit_view: string;
+    reset_layout: string;
+    col_type_formula: string;
+    col_type_ref: string;
+    col_type_set: string;
+}
+export declare const DIAGRAM_TRANSLATIONS_EN: DiagramTranslations;
+export declare function setDiagramTranslations(translations: DiagramTranslations): void;
+export declare function getDiagramTranslations(): DiagramTranslations;
+//# sourceMappingURL=i18n.d.ts.map

package/dist/i18n.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"i18n.d.ts","sourceRoot":"","sources":["../src/lib/i18n.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,mBAAmB;IACnC,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,gBAAgB,EAAE,MAAM,CAAC;IACzB,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;CACrB;AAED,eAAO,MAAM,uBAAuB,EAAE,mBAQrC,CAAC;AAIF,wBAAgB,sBAAsB,CAAC,YAAY,EAAE,mBAAmB,GAAG,IAAI,CAE9E;AAED,wBAAgB,sBAAsB,IAAI,mBAAmB,CAK5D"}

package/dist/i18n.js

@@ -0,0 +1,20 @@
+import { getContext, hasContext, setContext } from 'svelte';
+export const DIAGRAM_TRANSLATIONS_EN = {
+    zoom_in: 'Zoom in',
+    zoom_out: 'Zoom out',
+    fit_view: 'Fit view',
+    reset_layout: 'Reset layout',
+    col_type_formula: 'formula',
+    col_type_ref: 'ref',
+    col_type_set: 'set',
+};
+const DIAGRAM_I18N_KEY = Symbol('dforge-diagram-i18n');
+export function setDiagramTranslations(translations) {
+    setContext(DIAGRAM_I18N_KEY, translations);
+}
+export function getDiagramTranslations() {
+    if (hasContext(DIAGRAM_I18N_KEY)) {
+        return getContext(DIAGRAM_I18N_KEY);
+    }
+    return DIAGRAM_TRANSLATIONS_EN;
+}

package/dist/index.d.ts

@@ -0,0 +1,23 @@
+export { setDiagramTranslations, getDiagramTranslations, DIAGRAM_TRANSLATIONS_EN } from './i18n';
+export type { DiagramTranslations } from './i18n';
+export type { DiagramNode, DiagramEdge, ResolvedEdge, Point, ViewTransform, EntityNodeData, DragSegment } from './diagram-types';
+export type { ModelGetResponse, ModelModule, ModelEntity, ModelConstraint, ModelColumn } from './model-types';
+export { default as SimpleDiagram } from './SimpleDiagram/SimpleDiagram.svelte';
+export { default as ModelDiagram } from './SimpleDiagram/ModelDiagram.svelte';
+export { default as EntityNode } from './EntityNode.svelte';
+export { default as DiagramDebug } from './SimpleDiagram/DiagramDebug.svelte';
+export { simpleLayout, moduleLayout, routeEdge, routeAllEdges } from './SimpleDiagram/simple-layout';
+export type { NodeLookup } from './SimpleDiagram/simple-layout';
+export { buildGraph, buildEntityMap, getModuleColor, MODULE_COLORS } from './model-graph';
+export { buildSvgPath, edgeLabelPos, prepareDragPoints, consolidatePoints, insertJog, getSegmentHandles, applySegmentDrag } from './SimpleDiagram/diagram-geometry';
+export type { SegHandle } from './SimpleDiagram/diagram-geometry';
+export { createPanZoom } from './pan-zoom.svelte';
+export type { PanZoomConfig, ContentBounds } from './pan-zoom.svelte';
+export { createLocalStorageSync } from './local-storage-sync';
+export type { WorkspaceModule, WorkspaceEntity, WorkspaceEdge } from './WorkspaceMap/workspace-types';
+export { buildWorkspaceGraph } from './WorkspaceMap/workspace-graph';
+export { default as WorkspaceMap } from './WorkspaceMap/WorkspaceMap.svelte';
+export { default as ModuleCard } from './WorkspaceMap/ModuleCard.svelte';
+export { computeEdgePath, extractBendPoints, getEdgeHandles, prepareDrag, dragSegment, splitSegment, consolidateBends, PORT_DOT_RADIUS } from './edge-routing';
+export type { EdgePath, SegmentHandle } from './edge-routing';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/lib/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,sBAAsB,EAAE,sBAAsB,EAAE,uBAAuB,EAAE,MAAM,QAAQ,CAAC;AACjG,YAAY,EAAE,mBAAmB,EAAE,MAAM,QAAQ,CAAC;AAGlD,YAAY,EAAE,WAAW,EAAE,WAAW,EAAE,YAAY,EAAE,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAGjI,YAAY,EAAE,gBAAgB,EAAE,WAAW,EAAE,WAAW,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAG9G,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,sCAAsC,CAAC;AAChF,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,qCAAqC,CAAC;AAC9E,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,qCAAqC,CAAC;AAG9E,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AACrG,YAAY,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAGhE,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAG1F,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,SAAS,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACpK,YAAY,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAGlE,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAClD,YAAY,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AACtE,OAAO,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AAG9D,YAAY,EAAE,eAAe,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AACtG,OAAO,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAC;AACrE,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,oCAAoC,CAAC;AAC7E,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,kCAAkC,CAAC;AAGzE,OAAO,EAAE,eAAe,EAAE,iBAAiB,EAAE,cAAc,EAAE,WAAW,EAAE,WAAW,EAAE,YAAY,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAC/J,YAAY,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/index.js

@@ -0,0 +1,21 @@
+// i18n
+export { setDiagramTranslations, getDiagramTranslations, DIAGRAM_TRANSLATIONS_EN } from './i18n';
+// Components
+export { default as SimpleDiagram } from './SimpleDiagram/SimpleDiagram.svelte';
+export { default as ModelDiagram } from './SimpleDiagram/ModelDiagram.svelte';
+export { default as EntityNode } from './EntityNode.svelte';
+export { default as DiagramDebug } from './SimpleDiagram/DiagramDebug.svelte';
+// Layout
+export { simpleLayout, moduleLayout, routeEdge, routeAllEdges } from './SimpleDiagram/simple-layout';
+// Graph building
+export { buildGraph, buildEntityMap, getModuleColor, MODULE_COLORS } from './model-graph';
+// Geometry
+export { buildSvgPath, edgeLabelPos, prepareDragPoints, consolidatePoints, insertJog, getSegmentHandles, applySegmentDrag } from './SimpleDiagram/diagram-geometry';
+// Pan/Zoom & persistence utilities
+export { createPanZoom } from './pan-zoom.svelte';
+export { createLocalStorageSync } from './local-storage-sync';
+export { buildWorkspaceGraph } from './WorkspaceMap/workspace-graph';
+export { default as WorkspaceMap } from './WorkspaceMap/WorkspaceMap.svelte';
+export { default as ModuleCard } from './WorkspaceMap/ModuleCard.svelte';
+// Edge routing (used by ModelDiagram)
+export { computeEdgePath, extractBendPoints, getEdgeHandles, prepareDrag, dragSegment, splitSegment, consolidateBends, PORT_DOT_RADIUS } from './edge-routing';