@leafer-in/linker 2.3.2 → 2.3.4

package/dist/linker.cjs

@@ -21,7 +21,7 @@ class LinkerData extends draw.LineData {
     }
 }
 
-const {directionData: directionData} = draw.AroundHelper;
+const {directionData: directionData$1} = draw.AroundHelper;
 
 const directionNames = [ "top-left", "top", "top-right", "right", "bottom-right", "bottom", "bottom-left", "left", "center" ];
 
@@ -137,8 +137,8 @@ function getPointDirection(boxPoint, bounds, eight) {
     const {width: width, height: height} = bounds;
     const hitRadiusX = width / 4;
     const hitRadiusY = height / 4;
-    for (let i = 0; i < directionData.length; i++) {
-        const unit = directionData[i];
+    for (let i = 0; i < directionData$1.length; i++) {
+        const unit = directionData$1[i];
         const px = unit.x * width;
         const py = unit.y * height;
         const dx = boxPoint.x - px;
@@ -183,7 +183,400 @@ function linkerPointType(defaultValue) {
     }));
 }
 
-const {moveTo: moveTo, bezierCurveTo: bezierCurveTo, drawPoints: drawPoints$1} = draw.PathCommandDataHelper;
+const {directionData: directionData} = draw.AroundHelper;
+
+const {moveTo: moveTo$1, lineTo: lineTo$1} = draw.PathCommandDataHelper;
+
+const POLYLINE_X = 0, POLYLINE_Y = 1;
+
+const POLYLINE_EPSILON = .001;
+
+const POLYLINE_MIN_SEGMENT = 4;
+
+const POLYLINE_TURN_WEIGHT = 1.5;
+
+function getPolylineDirectionIndex(direction) {
+    switch (direction) {
+      case "top-left":
+        return 0;
+
+      case "top":
+        return 1;
+
+      case "top-right":
+        return 2;
+
+      case "right":
+        return 3;
+
+      case "bottom-right":
+        return 4;
+
+      case "bottom":
+        return 5;
+
+      case "bottom-left":
+        return 6;
+
+      case "left":
+        return 7;
+
+      default:
+        return 8;
+    }
+}
+
+function getPolylinePorts(direction, point, target, bounds, targetBounds) {
+    const data = directionData[getPolylineDirectionIndex(direction)];
+    const dx = Math.sign(data.x - .5), dy = Math.sign(data.y - .5);
+    const cx = bounds ? bounds.x + bounds.width / 2 : point.x;
+    const cy = bounds ? bounds.y + bounds.height / 2 : point.y;
+    const tx = targetBounds ? targetBounds.x + targetBounds.width / 2 : target.x;
+    const ty = targetBounds ? targetBounds.y + targetBounds.height / 2 : target.y;
+    const deltaX = tx - cx, deltaY = ty - cy;
+    const xPort = (dx || (deltaX >= 0 ? 1 : -1)) > 0 ? 1 : 0;
+    const yPort = (dy || (deltaY >= 0 ? 1 : -1)) > 0 ? 3 : 2;
+    if (dx && !dy) return [ xPort ];
+    if (dy && !dx) return [ yPort ];
+    return Math.abs(deltaX) >= Math.abs(deltaY) ? [ xPort, yPort ] : [ yPort, xPort ];
+}
+
+function getPolylineExit(point, bounds, port, clearance) {
+    const axis = port >> 1, sign = port & 1 ? 1 : -1;
+    if (axis === POLYLINE_X) {
+        const x = bounds ? bounds.x + (sign > 0 ? bounds.width : 0) : point.x;
+        return {
+            x: x + sign * clearance,
+            y: point.y
+        };
+    }
+    const y = bounds ? bounds.y + (sign > 0 ? bounds.height : 0) : point.y;
+    return {
+        x: point.x,
+        y: y + sign * clearance
+    };
+}
+
+function isPolylinePointBlocked(x, y, bounds, clearance) {
+    if (!bounds) return false;
+    const left = bounds.x - clearance, right = bounds.x + bounds.width + clearance;
+    const top = bounds.y - clearance, bottom = bounds.y + bounds.height + clearance;
+    return x > left + POLYLINE_EPSILON && x < right - POLYLINE_EPSILON && y > top + POLYLINE_EPSILON && y < bottom - POLYLINE_EPSILON;
+}
+
+function isPolylineSegmentBlocked(x1, y1, x2, y2, bounds, clearance) {
+    if (!bounds) return false;
+    const left = bounds.x - clearance, right = bounds.x + bounds.width + clearance;
+    const top = bounds.y - clearance, bottom = bounds.y + bounds.height + clearance;
+    if (Math.abs(y1 - y2) <= POLYLINE_EPSILON) {
+        return y1 > top + POLYLINE_EPSILON && y1 < bottom - POLYLINE_EPSILON && Math.max(Math.min(x1, x2), left + POLYLINE_EPSILON) < Math.min(Math.max(x1, x2), right - POLYLINE_EPSILON);
+    }
+    if (Math.abs(x1 - x2) <= POLYLINE_EPSILON) {
+        return x1 > left + POLYLINE_EPSILON && x1 < right - POLYLINE_EPSILON && Math.max(Math.min(y1, y2), top + POLYLINE_EPSILON) < Math.min(Math.max(y1, y2), bottom - POLYLINE_EPSILON);
+    }
+    return true;
+}
+
+function addPolylineBoundsCoordinates(xs, ys, bounds, clearance, margin) {
+    if (!bounds) return;
+    const left = bounds.x - clearance, right = bounds.x + bounds.width + clearance;
+    const top = bounds.y - clearance, bottom = bounds.y + bounds.height + clearance;
+    xs.push(left, right, left - margin, right + margin);
+    ys.push(top, bottom, top - margin, bottom + margin);
+}
+
+function sortPolylineCoordinates(values) {
+    values.sort((a, b) => a - b);
+    let write = 0;
+    for (let i = 0; i < values.length; i++) {
+        if (!write || Math.abs(values[i] - values[write - 1]) > POLYLINE_EPSILON) values[write++] = values[i];
+    }
+    values.length = write;
+}
+
+function getPolylineCoordinateIndex(values, value) {
+    for (let i = 0; i < values.length; i++) {
+        if (Math.abs(values[i] - value) <= POLYLINE_EPSILON) return i;
+    }
+    return -1;
+}
+
+function getPolylineMidpointAxis(startPort, endPort, sx, sy, ex, ey) {
+    const startAxis = startPort >> 1, endAxis = endPort >> 1;
+    const startSign = startPort & 1 ? 1 : -1, endSign = endPort & 1 ? 1 : -1;
+    if (startAxis === endAxis && startSign === -endSign) return startAxis;
+    return Math.abs(ex - sx) >= Math.abs(ey - sy) ? POLYLINE_X : POLYLINE_Y;
+}
+
+function isPolylinePortAligned(port, stub, dx, dy) {
+    const offset = port >> 1 === POLYLINE_X ? dx : dy;
+    const sign = port & 1 ? 1 : -1;
+    return Math.abs(offset) <= POLYLINE_EPSILON ? stub > POLYLINE_EPSILON : offset * sign > 0;
+}
+
+function isPolylineMidpointAligned(port, stub, dx, dy, axis) {
+    if (port === undefined) return true;
+    if (axis === POLYLINE_X && Math.abs(dx / 2) > POLYLINE_EPSILON) return isPolylinePortAligned(port, stub, dx, 0);
+    if (axis === POLYLINE_Y && Math.abs(dy / 2) > POLYLINE_EPSILON) return isPolylinePortAligned(port, stub, 0, dy);
+    if (Math.abs(dx) <= POLYLINE_EPSILON && Math.abs(dy) <= POLYLINE_EPSILON) return true;
+    return isPolylinePortAligned(port, stub, dx, dy);
+}
+
+function isPolylineApproachAligned(points, port) {
+    if (port === undefined) return true;
+    const last = points.length - 2, x = points[last], y = points[last + 1];
+    for (let i = last - 2; i >= 0; i -= 2) {
+        const dx = points[i] - x, dy = points[i + 1] - y;
+        if (Math.abs(dx) > POLYLINE_EPSILON || Math.abs(dy) > POLYLINE_EPSILON) return isPolylinePortAligned(port, 1, dx, dy);
+    }
+    return true;
+}
+
+function getPolylineRoute(result, startPoint, endPoint, startPort, endPort, startBounds, endBounds, clearance, strictPorts, approachPort) {
+    const startExit = getPolylineExit(startPoint, startBounds, startPort, clearance);
+    const endExit = endPort === undefined ? endPoint : getPolylineExit(endPoint, endBounds, endPort, clearance);
+    const {x: sx, y: sy} = startExit, {x: ex, y: ey} = endExit;
+    const startStub = Math.abs(sx - startPoint.x) + Math.abs(sy - startPoint.y);
+    const endStub = Math.abs(ex - endPoint.x) + Math.abs(ey - endPoint.y);
+    if (isPolylineSegmentBlocked(startPoint.x, startPoint.y, sx, sy, endBounds, clearance) || isPolylineSegmentBlocked(endPoint.x, endPoint.y, ex, ey, startBounds, clearance)) return Infinity;
+    if (endPort === undefined && (isPolylinePointBlocked(ex, ey, startBounds, clearance) || isPolylinePointBlocked(ex, ey, endBounds, clearance))) return Infinity;
+    const axis = endPort === undefined ? startPort >> 1 : getPolylineMidpointAxis(startPort, endPort, sx, sy, ex, ey);
+    const dx = ex - sx, dy = ey - sy;
+    result.length = 0;
+    result.push(startPoint.x, startPoint.y, sx, sy);
+    if ((!strictPorts || isPolylineMidpointAligned(startPort, startStub, dx, dy, axis) && isPolylineMidpointAligned(endPort, endStub, -dx, -dy, axis)) && isPolylineMidpointAligned(approachPort, 1, -dx, -dy, axis)) {
+        const mx = (sx + ex) / 2, my = (sy + ey) / 2;
+        if (axis === POLYLINE_X) result.push(mx, sy, mx, ey); else result.push(sx, my, ex, my);
+        result.push(ex, ey, endPoint.x, endPoint.y);
+        for (let i = 4; i < result.length - 2; i += 2) {
+            if (isPolylineSegmentBlocked(result[i - 2], result[i - 1], result[i], result[i + 1], startBounds, clearance) || isPolylineSegmentBlocked(result[i - 2], result[i - 1], result[i], result[i + 1], endBounds, clearance)) {
+                result.length = 4;
+                break;
+            }
+        }
+        if (result.length > 4 && isPolylineApproachAligned(result, approachPort)) return getPolylineScore(result, clearance);
+        result.length = 4;
+    }
+    const score = findPolylineGridRoute(result, startExit, endExit, startPort, endPort, startBounds, endBounds, clearance, axis, startStub, endStub, strictPorts, approachPort);
+    if (score === Infinity) return score;
+    result.push(endPoint.x, endPoint.y);
+    return isPolylineApproachAligned(result, approachPort) ? score + startStub + endStub : Infinity;
+}
+
+function findPolylineGridRoute(result, startExit, endExit, startPort, endPort, startBounds, endBounds, clearance, midpointAxis, startStub, endStub, strictPorts, approachPort) {
+    const {x: sx, y: sy} = startExit, {x: ex, y: ey} = endExit;
+    const margin = Math.max(clearance, POLYLINE_MIN_SEGMENT) * 2;
+    const xs = [ sx, ex, (sx + ex) / 2 ], ys = [ sy, ey, (sy + ey) / 2 ];
+    addPolylineBoundsCoordinates(xs, ys, startBounds, clearance, margin);
+    addPolylineBoundsCoordinates(xs, ys, endBounds, clearance, margin);
+    xs.push(Math.min(...xs) - margin * 2, Math.max(...xs) + margin * 2);
+    ys.push(Math.min(...ys) - margin * 2, Math.max(...ys) + margin * 2);
+    sortPolylineCoordinates(xs);
+    sortPolylineCoordinates(ys);
+    const nx = xs.length, ny = ys.length;
+    const startXIndex = getPolylineCoordinateIndex(xs, sx), startYIndex = getPolylineCoordinateIndex(ys, sy);
+    const endXIndex = getPolylineCoordinateIndex(xs, ex), endYIndex = getPolylineCoordinateIndex(ys, ey);
+    if (startXIndex < 0 || startYIndex < 0 || endXIndex < 0 || endYIndex < 0) return Infinity;
+    const startNode = startYIndex * nx + startXIndex, endNode = endYIndex * nx + endXIndex;
+    const total = nx * ny * 3;
+    const distance = new Float64Array(total), previous = new Int32Array(total), visited = new Uint8Array(total);
+    distance.fill(Infinity);
+    previous.fill(-1);
+    const startState = startNode * 3;
+    distance[startState] = 0;
+    const pending = [ startState ];
+    const turnCost = Math.max(POLYLINE_MIN_SEGMENT, clearance * POLYLINE_TURN_WEIGHT);
+    const preferredCoordinate = midpointAxis === POLYLINE_X ? (sx + ex) / 2 : (sy + ey) / 2;
+    let currentState = -1, currentNode = -1, currentAxis = 0;
+    let currentX = 0, currentY = 0, currentDistance = 0;
+    const relax = (nextXIndex, nextYIndex, axis) => {
+        const nextX = xs[nextXIndex], nextY = ys[nextYIndex];
+        const nextNode = nextYIndex * nx + nextXIndex;
+        const dx = nextX - currentX, dy = nextY - currentY;
+        if (nextNode === startNode) return;
+        if (approachPort !== undefined && nextNode === endNode && !isPolylinePortAligned(approachPort, 1, -dx, -dy)) return;
+        if (strictPorts && (currentState === startState && !isPolylinePortAligned(startPort, startStub, dx, dy) || endPort !== undefined && nextNode === endNode && !isPolylinePortAligned(endPort, endStub, -dx, -dy))) return;
+        if (isPolylinePointBlocked(nextX, nextY, startBounds, clearance) || isPolylinePointBlocked(nextX, nextY, endBounds, clearance) || isPolylineSegmentBlocked(currentX, currentY, nextX, nextY, startBounds, clearance) || isPolylineSegmentBlocked(currentX, currentY, nextX, nextY, endBounds, clearance)) return;
+        const nextState = nextNode * 3 + axis;
+        if (visited[nextState]) return;
+        let cost = currentDistance + (Math.abs(dx) + Math.abs(dy));
+        if (currentAxis && currentAxis !== axis) {
+            cost += turnCost;
+            const turnCoordinate = currentAxis === POLYLINE_X + 1 ? currentX : currentY;
+            if (Math.abs(turnCoordinate - preferredCoordinate) > POLYLINE_EPSILON) cost += turnCost * 2;
+        }
+        if (cost < distance[nextState]) {
+            if (distance[nextState] === Infinity) pending.push(nextState);
+            distance[nextState] = cost;
+            previous[nextState] = currentState;
+        }
+    };
+    let bestState = -1;
+    while (pending.length) {
+        let index = 0, state = pending[0];
+        for (let i = 1; i < pending.length; i++) {
+            const next = pending[i];
+            if (distance[next] < distance[state] || distance[next] === distance[state] && next < state) {
+                index = i;
+                state = next;
+            }
+        }
+        pending[index] = pending[pending.length - 1];
+        pending.pop();
+        currentState = state;
+        currentNode = Math.floor(state / 3);
+        currentAxis = state % 3;
+        currentDistance = distance[state];
+        visited[state] = 1;
+        if (currentNode === endNode) {
+            bestState = state;
+            break;
+        }
+        const xIndex = currentNode % nx, yIndex = Math.floor(currentNode / nx);
+        currentX = xs[xIndex];
+        currentY = ys[yIndex];
+        if (xIndex > 0) relax(xIndex - 1, yIndex, POLYLINE_X + 1);
+        if (xIndex < nx - 1) relax(xIndex + 1, yIndex, POLYLINE_X + 1);
+        if (yIndex > 0) relax(xIndex, yIndex - 1, POLYLINE_Y + 1);
+        if (yIndex < ny - 1) relax(xIndex, yIndex + 1, POLYLINE_Y + 1);
+    }
+    if (bestState < 0) return Infinity;
+    const reverse = [];
+    let state = bestState;
+    while (state >= 0) {
+        const node = Math.floor(state / 3);
+        reverse.push(xs[node % nx], ys[Math.floor(node / nx)]);
+        if (state === startState) break;
+        state = previous[state];
+    }
+    if (state !== startState) return Infinity;
+    for (let i = reverse.length - 4; i >= 0; i -= 2) result.push(reverse[i], reverse[i + 1]);
+    return distance[bestState];
+}
+
+function getPolylineFallback(start, end, port, startBounds, endBounds) {
+    const {x: sx, y: sy} = start, {x: ex, y: ey} = end;
+    if (sx === ex || sy === ey) return [ sx, sy, ex, ey ];
+    const horizontal = port >> 1 === POLYLINE_X;
+    const crosses = (x, y) => {
+        let count = 0;
+        if (isPolylineSegmentBlocked(sx, sy, x, y, startBounds, 0)) count++;
+        if (isPolylineSegmentBlocked(x, y, ex, ey, startBounds, 0)) count++;
+        if (isPolylineSegmentBlocked(sx, sy, x, y, endBounds, 0)) count++;
+        if (isPolylineSegmentBlocked(x, y, ex, ey, endBounds, 0)) count++;
+        return count;
+    };
+    const xy = crosses(ex, sy), yx = crosses(sx, ey);
+    return xy < yx || xy === yx && horizontal ? [ sx, sy, ex, sy, ex, ey ] : [ sx, sy, sx, ey, ex, ey ];
+}
+
+function getBestPolyline(startPoint, endPoint, startDirection, endDirection, startBounds, endBounds, clearance, approachPort) {
+    const startPorts = getPolylinePorts(startDirection, startPoint, endPoint, startBounds, endDirection === undefined ? undefined : endBounds);
+    const endPorts = endDirection === undefined ? [ undefined ] : getPolylinePorts(endDirection, endPoint, startPoint, endBounds, startBounds);
+    let candidate = [], best = [], bestScore = Infinity;
+    for (let pass = clearance ? 0 : 1; pass < 3 && !best.length; pass++) {
+        const gap = pass ? 0 : clearance;
+        for (let i = 0; i < startPorts.length; i++) {
+            for (let j = 0; j < endPorts.length; j++) {
+                const score = getPolylineRoute(candidate, startPoint, endPoint, startPorts[i], endPorts[j], startBounds, endBounds, gap, pass < 2, approachPort);
+                if (score < bestScore) {
+                    bestScore = score;
+                    const previous = best;
+                    best = candidate;
+                    candidate = previous;
+                }
+            }
+        }
+    }
+    if (!best.length) return getPolylineFallback(startPoint, endPoint, startPorts[0], startBounds, endBounds);
+    simplifyPolyline(best);
+    const last = best.length - 2;
+    if (best[last] !== endPoint.x || best[last + 1] !== endPoint.y) best.push(endPoint.x, endPoint.y);
+    return best;
+}
+
+function getPolylineEditSide(point, waypoint, direction, bounds, otherBounds, clearance, points, index, step) {
+    if (point.x === waypoint.x && point.y === waypoint.y) return [];
+    let approachPort;
+    for (let i = index + step; i >= 0 && i < points.length; i += step) {
+        const dx = points[i] - waypoint.x, dy = points[i + 1] - waypoint.y;
+        if (Math.abs(dx) <= POLYLINE_EPSILON && Math.abs(dy) <= POLYLINE_EPSILON) continue;
+        if (Math.abs(dy) <= POLYLINE_EPSILON) approachPort = dx > 0 ? 0 : 1; else if (Math.abs(dx) <= POLYLINE_EPSILON) approachPort = dy > 0 ? 2 : 3;
+        break;
+    }
+    const side = getBestPolyline(point, waypoint, direction, undefined, bounds, otherBounds, clearance, approachPort);
+    side.length -= 2;
+    return side;
+}
+
+function drawPolylineEditPath(path, startPoint, endPoint, startDirection, endDirection, startBounds, endBounds, clearance, points) {
+    const length = points.length, last = length - 2;
+    if (length % 2) return false;
+    for (let i = 0; i < length; i++) if (!Number.isFinite(points[i])) return false;
+    const start = getPolylineEditSide(startPoint, {
+        x: points[0],
+        y: points[1]
+    }, startDirection, startBounds, endBounds, clearance, points, 0, 2);
+    const end = getPolylineEditSide(endPoint, {
+        x: points[last],
+        y: points[last + 1]
+    }, endDirection, endBounds, startBounds, clearance, points, last, -2);
+    const first = start.length ? start : points;
+    moveTo$1(path, first[0], first[1]);
+    for (let i = 2; i < start.length; i += 2) lineTo$1(path, start[i], start[i + 1]);
+    for (let i = start.length ? 0 : 2; i < length; i += 2) lineTo$1(path, points[i], points[i + 1]);
+    for (let i = end.length - 2; i >= 0; i -= 2) lineTo$1(path, end[i], end[i + 1]);
+    return true;
+}
+
+function getPolylineScore(points, clearance) {
+    let length = 0, turns = 0, previousAxis = -1;
+    for (let i = 2; i < points.length; i += 2) {
+        const dx = points[i] - points[i - 2], dy = points[i + 1] - points[i - 1];
+        if (Math.abs(dx) <= POLYLINE_EPSILON && Math.abs(dy) <= POLYLINE_EPSILON) continue;
+        const axis = Math.abs(dx) > POLYLINE_EPSILON ? POLYLINE_X : POLYLINE_Y;
+        length += Math.abs(dx) + Math.abs(dy);
+        if (previousAxis !== -1 && previousAxis !== axis) turns++;
+        previousAxis = axis;
+    }
+    return length + turns * Math.max(clearance, POLYLINE_MIN_SEGMENT) * POLYLINE_TURN_WEIGHT;
+}
+
+function simplifyPolyline(points) {
+    let write = 2;
+    for (let read = 2; read < points.length; read += 2) {
+        const x = points[read], y = points[read + 1];
+        const px = points[write - 2], py = points[write - 1];
+        if (Math.abs(x - px) <= POLYLINE_EPSILON && Math.abs(y - py) <= POLYLINE_EPSILON) continue;
+        if (write >= 4) {
+            const ax = points[write - 4], ay = points[write - 3];
+            const horizontal = Math.abs(ay - py) <= POLYLINE_EPSILON && Math.abs(py - y) <= POLYLINE_EPSILON && (px - ax) * (x - px) >= 0;
+            const vertical = Math.abs(ax - px) <= POLYLINE_EPSILON && Math.abs(px - x) <= POLYLINE_EPSILON && (py - ay) * (y - py) >= 0;
+            if (horizontal || vertical) {
+                points[write - 2] = x;
+                points[write - 1] = y;
+                continue;
+            }
+        }
+        points[write++] = x;
+        points[write++] = y;
+    }
+    points.length = write;
+}
+
+function drawPolyline(path, startPoint, endPoint, startDirection, endDirection, startBounds, endBounds, clearance = 8, points) {
+    if (!Number.isFinite(startPoint.x) || !Number.isFinite(startPoint.y) || !Number.isFinite(endPoint.x) || !Number.isFinite(endPoint.y)) return false;
+    if (startBounds && (!Number.isFinite(startBounds.x) || !Number.isFinite(startBounds.y) || !Number.isFinite(startBounds.width) || !Number.isFinite(startBounds.height) || startBounds.width < 0 || startBounds.height < 0)) return false;
+    if (endBounds && (!Number.isFinite(endBounds.x) || !Number.isFinite(endBounds.y) || !Number.isFinite(endBounds.width) || !Number.isFinite(endBounds.height) || endBounds.width < 0 || endBounds.height < 0)) return false;
+    clearance = Number.isFinite(clearance) ? Math.max(0, clearance) : 8;
+    if (points === null || points === void 0 ? void 0 : points.length) return drawPolylineEditPath(path, startPoint, endPoint, startDirection, endDirection, startBounds, endBounds, clearance, points);
+    const best = getBestPolyline(startPoint, endPoint, startDirection, endDirection, startBounds, endBounds, clearance);
+    moveTo$1(path, best[0], best[1]);
+    for (let i = 2; i < best.length; i += 2) lineTo$1(path, best[i], best[i + 1]);
+    return true;
+}
+
+const {moveTo: moveTo, lineTo: lineTo, bezierCurveTo: bezierCurveTo, drawPoints: drawPoints$1} = draw.PathCommandDataHelper;
 
 const {isEmpty: isEmpty, getPoint: getPoint} = draw.BoundsHelper;
 
@@ -276,7 +669,7 @@ exports.Linker = class Linker extends draw.Line {
         }
     }
     updateLinkerPoint(type) {
-        const {startPoint: startPoint, endPoint: endPoint} = this;
+        const {startPoint: startPoint, endPoint: endPoint, lineType: lineType} = this;
         const nowPoint = type === "end" ? endPoint : startPoint;
         if (nowPoint) {
             const data = {};
@@ -301,6 +694,7 @@ exports.Linker = class Linker extends draw.Line {
                     if (isEmpty(boxBounds)) draw.LeafHelper.updateBounds(ui);
                     p = getPoint(boxBounds, point, true);
                     ui.getWorldPointByBox(p, this, false, true);
+                    if (lineType === "polyline") data.bounds = ui.getBounds("box", this.parent);
                 }
             } else {
                 if (draw.isObject(point)) p = point;
@@ -326,56 +720,69 @@ exports.Linker = class Linker extends draw.Line {
         }
         const startPoint = startData.point, endPoint = endData.point;
         const startDirection = startData.direction, endDirection = endData.direction;
-        const half = {
-            x: abs((startPoint.x - endPoint.x) / 2),
-            y: abs((startPoint.y - endPoint.y) / 2)
-        };
         const arrowWidth = this.__.strokeWidth * 8;
-        let minCtrl;
-        if (this.__.__useArrow) {
-            const ratio = min(getDistance(startPoint, endPoint) / (arrowWidth * 25), 1);
-            minCtrl = max(arrowWidth * ratio * 12, arrowWidth * 3);
-        } else {
-            minCtrl = arrowWidth * 2;
-        }
-        if (endDirection) {
-            if (isOppositeDirection(startDirection, endDirection) && startDirection === getDirectionForFromPoint(startPoint, endPoint)) {
+        switch (data.lineType) {
+          case "straight":
+            moveTo(path, startPoint.x, startPoint.y);
+            lineTo(path, endPoint.x, endPoint.y);
+            break;
+
+          case "polyline":
+            drawPolyline(path, startPoint, endPoint, startDirection, endDirection, startData.bounds, endData.bounds, arrowWidth, hasPoints && draw.PointHelper.toNumberPoints(data.points));
+            break;
+
+          case "curve":
+          default:
+            const half = {
+                x: abs((startPoint.x - endPoint.x) / 2),
+                y: abs((startPoint.y - endPoint.y) / 2)
+            };
+            let minCtrl;
+            if (this.__.__useArrow) {
+                const ratio = min(getDistance(startPoint, endPoint) / (arrowWidth * 25), 1);
+                minCtrl = max(arrowWidth * ratio * 12, arrowWidth * 3);
+            } else {
                 minCtrl = arrowWidth * 2;
             }
-        }
-        half.x = max(minCtrl, half.x);
-        half.y = max(minCtrl, half.y);
-        if (hasPoints) {
-            minCtrl *= .6;
-            const points = draw.PointHelper.toNumberPoints(data.points);
-            drawPoints$1(path, [ startPoint.x, startPoint.y, ...points, endPoint.x, endPoint.y ], data.curve, false, data);
-            if (startDirection) {
-                const handleX = path[4];
-                const handleY = path[5];
-                half.x = max(minCtrl, abs(handleX - startPoint.x));
-                half.y = max(minCtrl, abs(handleY - startPoint.y));
-                const startCtrlPoint = getCtrlPoint(this, startNode, startPoint, startDirection, half);
-                path[4] = startCtrlPoint.x;
-                path[5] = startCtrlPoint.y;
-            }
-            const len = path.length;
             if (endDirection) {
-                const handleX = path[len - 4];
-                const handleY = path[len - 3];
-                half.x = max(minCtrl, abs(handleX - endPoint.x));
-                half.y = max(minCtrl, abs(handleY - endPoint.y));
-                const endCtrlPoint = getCtrlPoint(this, endNode, endPoint, endDirection, half);
-                path[len - 4] = endCtrlPoint.x;
-                path[len - 3] = endCtrlPoint.y;
+                if (isOppositeDirection(startDirection, endDirection) && startDirection === getDirectionForFromPoint(startPoint, endPoint)) {
+                    minCtrl = arrowWidth * 2;
+                }
+            }
+            half.x = max(minCtrl, half.x);
+            half.y = max(minCtrl, half.y);
+            if (hasPoints) {
+                minCtrl *= .6;
+                const points = draw.PointHelper.toNumberPoints(data.points);
+                drawPoints$1(path, [ startPoint.x, startPoint.y, ...points, endPoint.x, endPoint.y ], data.curve, false, data);
+                if (startDirection) {
+                    const handleX = path[4];
+                    const handleY = path[5];
+                    half.x = max(minCtrl, abs(handleX - startPoint.x));
+                    half.y = max(minCtrl, abs(handleY - startPoint.y));
+                    const startCtrlPoint = getCtrlPoint(this, startNode, startPoint, startDirection, half);
+                    path[4] = startCtrlPoint.x;
+                    path[5] = startCtrlPoint.y;
+                }
+                const len = path.length;
+                if (endDirection) {
+                    const handleX = path[len - 4];
+                    const handleY = path[len - 3];
+                    half.x = max(minCtrl, abs(handleX - endPoint.x));
+                    half.y = max(minCtrl, abs(handleY - endPoint.y));
+                    const endCtrlPoint = getCtrlPoint(this, endNode, endPoint, endDirection, half);
+                    path[len - 4] = endCtrlPoint.x;
+                    path[len - 3] = endCtrlPoint.y;
+                } else {
+                    path[len - 4] = endPoint.x;
+                    path[len - 3] = endPoint.y;
+                }
             } else {
-                path[len - 4] = endPoint.x;
-                path[len - 3] = endPoint.y;
+                const startCtrlPoint = startDirection ? getCtrlPoint(this, startNode, startPoint, startDirection, half) : startPoint;
+                const endCtrlPoint = endDirection ? getCtrlPoint(this, endNode, endPoint, endDirection, half) : endPoint;
+                moveTo(path, startPoint.x, startPoint.y);
+                bezierCurveTo(path, startCtrlPoint.x, startCtrlPoint.y, endCtrlPoint.x, endCtrlPoint.y, endPoint.x, endPoint.y);
             }
-        } else {
-            const startCtrlPoint = startDirection ? getCtrlPoint(this, startNode, startPoint, startDirection, half) : startPoint;
-            const endCtrlPoint = endDirection ? getCtrlPoint(this, endNode, endPoint, endDirection, half) : endPoint;
-            moveTo(path, startPoint.x, startPoint.y);
-            bezierCurveTo(path, startCtrlPoint.x, startCtrlPoint.y, endCtrlPoint.x, endCtrlPoint.y, endPoint.x, endPoint.y);
         }
     }
     createStartPoint(worldPoint, node, options) {
@@ -445,6 +852,8 @@ exports.Linker = class Linker extends draw.Line {
 
 __decorate([ draw.dataProcessor(LinkerData) ], exports.Linker.prototype, "__", void 0);
 
+__decorate([ draw.boundsType("curve") ], exports.Linker.prototype, "lineType", void 0);
+
 __decorate([ linkerPointType() ], exports.Linker.prototype, "startPoint", void 0);
 
 __decorate([ linkerPointType() ], exports.Linker.prototype, "endPoint", void 0);