@meta2d/core 1.0.55 → 1.0.57

package/src/diagrams/line/polyline.js

@@ -1,657 +1,627 @@
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
-import { Direction } from '../../data';
-import { deleteTempAnchor, facePen, getFromAnchor, getToAnchor, } from '../../pen';
-import { s8 } from '../../utils';
-var faceSpace = 10;
-export function polyline(store, pen, mousedwon) {
-    var _a;
-    if (!pen.calculative.worldAnchors) {
-        pen.calculative.worldAnchors = [];
-    }
-    faceSpace = store.options.polylineSpace || 10;
-    if (pen.calculative.worldAnchors.length < 2) {
-        return;
-    }
-    var from = getFromAnchor(pen);
-    var to = getToAnchor(pen);
-    if (!from || !to) {
-        return;
-    }
-    // 拖拽起点
-    var dragFrom;
-    if (((_a = pen.anchors) === null || _a === void 0 ? void 0 : _a.length) && from === pen.calculative.activeAnchor) {
-        dragFrom = true;
-        from = to;
-        to = getFromAnchor(pen);
-    }
-    else if ((!pen.anchors || !pen.anchors.length) &&
-        from !== pen.calculative.activeAnchor) {
-        from = pen.calculative.activeAnchor;
-    }
-    if (!from || !to) {
-        return;
-    }
-    from.next = undefined;
-    to.prev = undefined;
-    var connected = to.connectTo;
-    deleteTempAnchor(pen);
-    var pts = [];
-    var fromPen = store.pens[from.connectTo];
-    var toPen = store.pens[to.connectTo];
-    var fromFace = facePen(from, fromPen);
-    var toFace = facePen(to, toPen);
-    var a = getFacePoint(from, fromFace, faceSpace);
-    if (a) {
-        from = a;
-        pts.push(a);
-    }
-    a = getFacePoint(to, toFace, faceSpace);
-    var end = to;
-    var corner = undefined;
-    if (a) {
-        to = a;
-        if (end.connectTo) {
-            if ((a.y > end.y && from.y < end.y) || (a.y < end.y && from.y > end.y)) {
-                //拐角 防止连线覆盖
-                corner = a;
-                var _faceSpace = faceSpace;
-                if (from.x < a.x) {
-                    _faceSpace = -_faceSpace;
-                }
-                if (Math.abs(from.x - a.x) < _faceSpace) {
-                    _faceSpace = -_faceSpace;
-                }
-                var point = { x: a.x + _faceSpace, y: a.y, id: s8() };
-                to = point;
-            }
-        }
-    }
-    switch (fromFace) {
-        case Direction.Up:
-            pts.push.apply(pts, __spreadArray([], __read(getNextPointsOfUp(from, to, toFace)), false));
-            break;
-        case Direction.Right:
-            pts.push.apply(pts, __spreadArray([], __read(getNextPointsOfRight(from, to, toFace)), false));
-            break;
-        case Direction.Bottom:
-            pts.push.apply(pts, __spreadArray([], __read(getNextPointsOfBottom(from, to, toFace)), false));
-            break;
-        case Direction.Left:
-            pts.push.apply(pts, __spreadArray([], __read(getNextPointsOfLeft(from, to, toFace)), false));
-            break;
-        default:
-            pts.push.apply(pts, __spreadArray([], __read(getNextPoints(pen, from, to)), false));
-            break;
-    }
-    pts.forEach(function (anchor) {
-        anchor.id = s8();
-        anchor.penId = pen.id;
-        pen.calculative.worldAnchors.push(anchor);
-    });
-    pen.calculative.worldAnchors.push(to);
-    if (corner) {
-        pen.calculative.worldAnchors.push(corner);
-    }
-    if (a) {
-        pen.calculative.worldAnchors.push(end);
-    }
-    if (dragFrom) {
-        pen.calculative.worldAnchors.reverse();
-    }
-    if (connected) {
-        var i = pen.calculative.worldAnchors.length - 2;
-        pen.calculative.worldAnchors[i].isTemp = false;
-        pen.calculative.worldAnchors[1].isTemp = false;
-    }
-}
-function getFacePoint(pt, d, dis) {
-    var point = { x: pt.x, y: pt.y, id: s8() };
-    switch (d) {
-        case Direction.Up:
-            point.y -= dis;
-            break;
-        case Direction.Right:
-            point.x += dis;
-            break;
-        case Direction.Bottom:
-            point.y += dis;
-            break;
-        case Direction.Left:
-            point.x -= dis;
-            break;
-        default: {
-            return;
-        }
-    }
-    return point;
-}
-function getNextPointsOfUp(from, to, toFace) {
-    if (from.x === to.x || from.y === to.y) {
-        return [];
-    }
-    var pts = [];
-    var x;
-    var y;
-    switch (toFace) {
-        case Direction.Up:
-            if (from.y < to.y) {
-                x = to.x;
-                y = from.y;
-            }
-            else {
-                x = from.x;
-                y = to.y;
-            }
-            pts.push({ x: x, y: y });
-            break;
-        case Direction.Bottom:
-            x = to.x;
-            y = from.y;
-            if (to.y > from.y) {
-                x = from.x + (to.x - from.x) / 2;
-                pts.push({ x: x, y: from.y }, { x: x, y: to.y });
-            }
-            else {
-                var centerY = (from.y + to.y) / 2;
-                pts.push({ x: from.x, y: centerY }, { x: to.x, y: centerY });
-            }
-            break;
-        case Direction.Right:
-            x = to.x;
-            y = from.y;
-            if (to.x < from.x && to.y < from.y) {
-                x = from.x;
-                y = to.y;
-            }
-            pts.push({ x: x, y: y });
-            break;
-        case Direction.Left:
-            x = to.x;
-            y = from.y;
-            if (to.x > from.x && to.y < from.y) {
-                x = from.x;
-                y = to.y;
-            }
-            pts.push({ x: x, y: y });
-            break;
-        default:
-            if (to.y > from.y - faceSpace) {
-                x = from.x + (to.x - from.x) / 2;
-                pts.push({ x: x, y: from.y }, { x: x, y: to.y });
-            }
-            else {
-                var centerY = (from.y + to.y + faceSpace) / 2;
-                pts.push({ x: from.x, y: centerY }, { x: to.x, y: centerY });
-            }
-            break;
-    }
-    return pts;
-}
-function getNextPointsOfRight(from, to, toFace) {
-    if (from.x === to.x || from.y === to.y) {
-        return [];
-    }
-    var pts = [];
-    var x;
-    var y;
-    switch (toFace) {
-        case Direction.Up:
-            x = from.x;
-            y = to.y;
-            if (to.x > from.x && to.y > from.y) {
-                x = to.x;
-                y = from.y;
-            }
-            pts.push({ x: x, y: y });
-            break;
-        case Direction.Bottom:
-            x = from.x;
-            y = to.y;
-            if (to.x > from.x && to.y < from.y) {
-                x = to.x;
-                y = from.y;
-            }
-            pts.push({ x: x, y: y });
-            break;
-        case Direction.Left:
-            x = to.x;
-            y = from.y;
-            if (to.x < from.x) {
-                y = from.y + (to.y - from.y) / 2;
-                pts.push({ x: from.x, y: y }, { x: to.x, y: y });
-            }
-            else {
-                var centerX = (from.x + to.x) / 2;
-                pts.push({ x: centerX, y: y }, { x: centerX, y: to.y });
-            }
-            break;
-        case Direction.Right:
-            if (to.x < from.x) {
-                pts.push({ x: from.x, y: to.y });
-            }
-            else {
-                pts.push({ x: to.x, y: from.y });
-            }
-            break;
-        default:
-            x = to.x;
-            y = to.y;
-            if (to.x < from.x + faceSpace) {
-                pts.push({ x: from.x, y: y });
-            }
-            else {
-                var centerX = (from.x + to.x - faceSpace) / 2;
-                pts.push({ x: centerX, y: from.y }, { x: centerX, y: y });
-            }
-            break;
-    }
-    return pts;
-}
-function getNextPointsOfBottom(from, to, toFace) {
-    if (from.x === to.x || from.y === to.y) {
-        return [];
-    }
-    var pts = [];
-    var x;
-    var y;
-    switch (toFace) {
-        case Direction.Up:
-            x = from.x;
-            y = to.y;
-            if (to.y < from.y) {
-                x = from.x + (to.x - from.x) / 2;
-                pts.push({ x: x, y: from.y }, { x: x, y: to.y });
-            }
-            else {
-                var centerY = (from.y + to.y) / 2;
-                pts.push({ x: x, y: centerY }, { x: to.x, y: centerY });
-            }
-            break;
-        case Direction.Right:
-            x = to.x;
-            y = from.y;
-            if (to.x < from.x && to.y > from.y) {
-                x = from.x;
-                y = to.y;
-            }
-            pts.push({ x: x, y: y });
-            break;
-        case Direction.Bottom:
-            if (from.y > to.y) {
-                x = to.x;
-                y = from.y;
-            }
-            else {
-                x = from.x;
-                y = to.y;
-            }
-            pts.push({ x: x, y: y });
-            break;
-        case Direction.Left:
-            x = to.x;
-            y = from.y;
-            if (to.x > from.x && to.y > from.y) {
-                x = from.x;
-                y = to.y;
-            }
-            pts.push({ x: x, y: y });
-            break;
-        default:
-            x = from.x;
-            if (to.y < from.y + faceSpace) {
-                x = from.x + (to.x - from.x) / 2;
-                pts.push({ x: x, y: from.y }, { x: x, y: to.y });
-            }
-            else {
-                var centerY = (from.y + to.y - faceSpace) / 2;
-                pts.push({ x: x, y: centerY }, { x: to.x, y: centerY });
-            }
-            break;
-    }
-    return pts;
-}
-function getNextPointsOfLeft(from, to, toFace) {
-    if (from.x === to.x || from.y === to.y) {
-        return [];
-    }
-    var pts = [];
-    var x;
-    var y;
-    switch (toFace) {
-        case Direction.Up:
-            x = from.x;
-            y = to.y;
-            if (to.x < from.x && to.y > from.y) {
-                x = to.x;
-                y = from.y;
-            }
-            pts.push({ x: x, y: y });
-            break;
-        case Direction.Bottom:
-            x = from.x;
-            y = to.y;
-            if (to.x < from.x && to.y < from.y) {
-                x = to.x;
-                y = from.y;
-            }
-            pts.push({ x: x, y: y });
-            break;
-        case Direction.Right:
-            x = from.x;
-            y = to.y;
-            if (to.x > from.x) {
-                x = to.x;
-                y = from.y + (to.y - from.y) / 2;
-                pts.push({ x: from.x, y: y }, { x: to.x, y: y });
-            }
-            else {
-                var centerX = (from.x + to.x) / 2;
-                pts.push({ x: centerX, y: from.y }, { x: centerX, y: to.y });
-            }
-            break;
-        case Direction.Left:
-            if (to.x > from.x) {
-                pts.push({ x: from.x, y: to.y });
-            }
-            else {
-                pts.push({ x: to.x, y: from.y });
-            }
-            break;
-        default:
-            x = from.x;
-            y = to.y;
-            if (to.x < from.x - faceSpace) {
-                var centerX = (from.x + to.x + faceSpace) / 2;
-                pts.push({ x: centerX, y: from.y }, { x: centerX, y: y });
-            }
-            else {
-                pts.push({ x: from.x, y: y });
-            }
-            break;
-    }
-    return pts;
-}
-function getNextPoints(pen, from, to) {
-    var pts = [];
-    if (pen.calculative.drawlineH == undefined) {
-        pen.calculative.drawlineH =
-            Math.abs(to.x - from.x) > Math.abs(to.y - from.y);
-    }
-    var index = pen.calculative.worldAnchors.findIndex(function (anchor) { return anchor.id == from.id; });
-    if (index > 1) {
-        var prev = pen.calculative.worldAnchors[index - 1];
-        if (prev.x === from.x && prev.y !== from.y) {
-            //水平
-            pts.push({ x: to.x, y: from.y });
-            return pts;
-        }
-        else if (prev.y === from.y && prev.x !== from.x) {
-            //垂直
-            pts.push({ x: from.x, y: to.y });
-            return pts;
-        }
-    }
-    if (pen.calculative.worldAnchors.length) {
-        to.isTemp = undefined;
-        if (pen.calculative.drawlineH) {
-            pts.push({ x: to.x, y: from.y });
-            if (Math.abs(to.y - from.y) < faceSpace) {
-                to.isTemp = true;
-            }
-        }
-        else {
-            pts.push({ x: from.x, y: to.y });
-            if (Math.abs(to.x - from.x) < faceSpace) {
-                to.isTemp = true;
-            }
-        }
-    }
-    return pts;
-}
-export function anchorInHorizontal(pen, anchor, from) {
-    var _a, _b;
-    if (from === void 0) { from = true; }
-    var anchors = pen.calculative.worldAnchors;
-    if (!from) {
-        anchors = [];
-        pen.calculative.worldAnchors.forEach(function (item) {
-            anchors.unshift(item);
-        });
-    }
-    for (var i = 0; i < anchors.length; i++) {
-        if (anchors[i].id === anchor.id) {
-            break;
-        }
-        if (anchors[i].y !== anchor.y) {
-            return false;
-        }
-        if (anchors[i].x === ((_a = anchors[i + 1]) === null || _a === void 0 ? void 0 : _a.x) &&
-            anchors[i].y !== ((_b = anchors[i + 1]) === null || _b === void 0 ? void 0 : _b.y)) {
-            return false;
-        }
-    }
-    return true;
-}
-export function anchorInVertical(pen, anchor, from) {
-    var _a, _b;
-    if (from === void 0) { from = true; }
-    var anchors = pen.calculative.worldAnchors;
-    if (!from) {
-        anchors = [];
-        pen.calculative.worldAnchors.forEach(function (item) {
-            anchors.unshift(item);
-        });
-    }
-    for (var i = 0; i < anchors.length; i++) {
-        if (anchors[i].id === anchor.id) {
-            break;
-        }
-        if (anchors[i].x !== anchor.x) {
-            return false;
-        }
-        if (anchors[i].y === ((_a = anchors[i + 1]) === null || _a === void 0 ? void 0 : _a.y) &&
-            anchors[i].x !== ((_b = anchors[i + 1]) === null || _b === void 0 ? void 0 : _b.x)) {
-            return false;
-        }
-    }
-    return true;
-}
-export function translatePolylineAnchor(pen, anchor, pt) {
-    if (!pen.calculative.worldAnchors) {
-        return;
-    }
-    var i = pen.calculative.worldAnchors.findIndex(function (item) { return item.id === anchor.id; });
-    var from = getFromAnchor(pen);
-    var to = getToAnchor(pen);
-    var prev = pen.calculative.worldAnchors[i - 1];
-    var next = pen.calculative.worldAnchors[i + 1];
-    if (pen.calculative.h == undefined) {
-        if (from.connectTo) {
-            if (anchorInHorizontal(pen, anchor, true)) {
-                pen.calculative.h = true;
-            }
-            else if (anchorInVertical(pen, anchor, true)) {
-                pen.calculative.h = false;
-            }
-        }
-        if (pen.calculative.h == undefined && to.connectTo) {
-            if (anchorInHorizontal(pen, anchor, false)) {
-                pen.calculative.h = true;
-            }
-            else if (anchorInVertical(pen, anchor, false)) {
-                pen.calculative.h = false;
-            }
-        }
-        if (pen.calculative.h == undefined) {
-            if (prev) {
-                pen.calculative.h = prev.y === anchor.y;
-            }
-            else if (next) {
-                pen.calculative.h = next.y === anchor.y;
-            }
-        }
-    }
-    // 水平
-    if (pen.calculative.h) {
-        anchor.x = pt.x;
-        if (from.connectTo && anchorInHorizontal(pen, anchor, true)) {
-            if (next && next.y !== anchor.y) {
-                next.x = anchor.x;
-            }
-            return;
-        }
-        if (to.connectTo && anchorInHorizontal(pen, anchor, false)) {
-            if (prev && prev.y !== anchor.y) {
-                prev.x = anchor.x;
-            }
-            return;
-        }
-        var a = pen.anchors[i];
-        var d = void 0;
-        for (var pos = i - 1; pos > -1; pos--) {
-            prev = pen.anchors[pos];
-            if (d == undefined) {
-                d = prev.y === a.y;
-            }
-            if (d === true) {
-                if (prev.y === a.y) {
-                    pen.calculative.worldAnchors[pos].y = pt.y;
-                }
-                else {
-                    break;
-                }
-            }
-            else {
-                if (prev.x === a.x) {
-                    pen.calculative.worldAnchors[pos].x = pt.x;
-                }
-                else {
-                    break;
-                }
-            }
-        }
-        d = undefined;
-        for (var pos = i + 1; pos < pen.calculative.worldAnchors.length; pos++) {
-            next = pen.anchors[pos];
-            if (next) {
-                if (d == undefined) {
-                    d = next.y === a.y;
-                }
-                if (d === true) {
-                    if (next.y === a.y) {
-                        pen.calculative.worldAnchors[pos].y = pt.y;
-                    }
-                    else {
-                        break;
-                    }
-                }
-                else {
-                    if (next.x === a.x) {
-                        pen.calculative.worldAnchors[pos].x = pt.x;
-                    }
-                    else {
-                        break;
-                    }
-                }
-            }
-            else {
-                break;
-            }
-        }
-        anchor.y = pt.y;
-    }
-    // 垂直
-    else {
-        anchor.y = pt.y;
-        if (from.connectTo && anchorInVertical(pen, anchor, true)) {
-            if (next && next.x !== anchor.x) {
-                next.y = anchor.y;
-            }
-            return;
-        }
-        if (to.connectTo && anchorInVertical(pen, anchor, false)) {
-            if (prev && prev.x !== anchor.x) {
-                prev.y = anchor.y;
-            }
-            return;
-        }
-        var a = pen.anchors[i];
-        var d = void 0;
-        for (var pos = i - 1; pos > -1; pos--) {
-            prev = pen.anchors[pos];
-            if (d == undefined) {
-                d = prev.x === a.x;
-            }
-            if (d === true) {
-                if (prev.x === a.x) {
-                    pen.calculative.worldAnchors[pos].x = pt.x;
-                }
-                else {
-                    break;
-                }
-            }
-            else {
-                if (prev.y === a.y) {
-                    pen.calculative.worldAnchors[pos].y = pt.y;
-                }
-                else {
-                    break;
-                }
-            }
-        }
-        d = undefined;
-        for (var pos = i + 1; pos < pen.calculative.worldAnchors.length; pos++) {
-            next = pen.anchors[pos];
-            if (next) {
-                if (d == undefined) {
-                    d = next.x === a.x;
-                }
-                if (d === true) {
-                    if (next.x === a.x) {
-                        pen.calculative.worldAnchors[pos].x = pt.x;
-                    }
-                    else {
-                        break;
-                    }
-                }
-                else {
-                    if (next.y === a.y) {
-                        pen.calculative.worldAnchors[pos].y = pt.y;
-                    }
-                    else {
-                        break;
-                    }
-                }
-            }
-            else {
-                break;
-            }
-        }
-        anchor.x = pt.x;
-    }
-}
+import { Direction } from '../../data';
+import { deleteTempAnchor, facePen, getFromAnchor, getToAnchor, } from '../../pen';
+import { s8 } from '../../utils';
+let faceSpace = 10;
+export function polyline(store, pen, mousedwon) {
+    if (!pen.calculative.worldAnchors) {
+        pen.calculative.worldAnchors = [];
+    }
+    faceSpace = store.options.polylineSpace || 10;
+    if (pen.calculative.worldAnchors.length < 2) {
+        return;
+    }
+    let from = getFromAnchor(pen);
+    let to = getToAnchor(pen);
+    if (!from || !to) {
+        return;
+    }
+    // 拖拽起点
+    let dragFrom;
+    if (pen.anchors?.length && from === pen.calculative.activeAnchor) {
+        dragFrom = true;
+        from = to;
+        to = getFromAnchor(pen);
+    }
+    else if ((!pen.anchors || !pen.anchors.length) &&
+        from !== pen.calculative.activeAnchor) {
+        from = pen.calculative.activeAnchor;
+    }
+    if (!from || !to) {
+        return;
+    }
+    from.next = undefined;
+    to.prev = undefined;
+    const connected = to.connectTo;
+    deleteTempAnchor(pen);
+    const pts = [];
+    const fromPen = store.pens[from.connectTo];
+    const toPen = store.pens[to.connectTo];
+    const fromFace = facePen(from, fromPen);
+    const toFace = facePen(to, toPen);
+    let a = getFacePoint(from, fromFace, faceSpace);
+    if (a) {
+        from = a;
+        pts.push(a);
+    }
+    a = getFacePoint(to, toFace, faceSpace);
+    const end = to;
+    let corner = undefined;
+    if (a) {
+        to = a;
+        if (end.connectTo) {
+            if ((a.y > end.y && from.y < end.y) || (a.y < end.y && from.y > end.y)) {
+                //拐角 防止连线覆盖
+                corner = a;
+                let _faceSpace = faceSpace;
+                if (from.x < a.x) {
+                    _faceSpace = -_faceSpace;
+                }
+                if (Math.abs(from.x - a.x) < _faceSpace) {
+                    _faceSpace = -_faceSpace;
+                }
+                const point = { x: a.x + _faceSpace, y: a.y, id: s8() };
+                to = point;
+            }
+        }
+    }
+    switch (fromFace) {
+        case Direction.Up:
+            pts.push(...getNextPointsOfUp(from, to, toFace));
+            break;
+        case Direction.Right:
+            pts.push(...getNextPointsOfRight(from, to, toFace));
+            break;
+        case Direction.Bottom:
+            pts.push(...getNextPointsOfBottom(from, to, toFace));
+            break;
+        case Direction.Left:
+            pts.push(...getNextPointsOfLeft(from, to, toFace));
+            break;
+        default:
+            pts.push(...getNextPoints(pen, from, to));
+            break;
+    }
+    pts.forEach((anchor) => {
+        anchor.id = s8();
+        anchor.penId = pen.id;
+        pen.calculative.worldAnchors.push(anchor);
+    });
+    pen.calculative.worldAnchors.push(to);
+    if (corner) {
+        pen.calculative.worldAnchors.push(corner);
+    }
+    if (a) {
+        pen.calculative.worldAnchors.push(end);
+    }
+    if (dragFrom) {
+        pen.calculative.worldAnchors.reverse();
+    }
+    if (connected) {
+        const i = pen.calculative.worldAnchors.length - 2;
+        pen.calculative.worldAnchors[i].isTemp = false;
+        pen.calculative.worldAnchors[1].isTemp = false;
+    }
+}
+function getFacePoint(pt, d, dis) {
+    const point = { x: pt.x, y: pt.y, id: s8() };
+    switch (d) {
+        case Direction.Up:
+            point.y -= dis;
+            break;
+        case Direction.Right:
+            point.x += dis;
+            break;
+        case Direction.Bottom:
+            point.y += dis;
+            break;
+        case Direction.Left:
+            point.x -= dis;
+            break;
+        default: {
+            return;
+        }
+    }
+    return point;
+}
+function getNextPointsOfUp(from, to, toFace) {
+    if (from.x === to.x || from.y === to.y) {
+        return [];
+    }
+    const pts = [];
+    let x;
+    let y;
+    switch (toFace) {
+        case Direction.Up:
+            if (from.y < to.y) {
+                x = to.x;
+                y = from.y;
+            }
+            else {
+                x = from.x;
+                y = to.y;
+            }
+            pts.push({ x, y });
+            break;
+        case Direction.Bottom:
+            x = to.x;
+            y = from.y;
+            if (to.y > from.y) {
+                x = from.x + (to.x - from.x) / 2;
+                pts.push({ x, y: from.y }, { x, y: to.y });
+            }
+            else {
+                const centerY = (from.y + to.y) / 2;
+                pts.push({ x: from.x, y: centerY }, { x: to.x, y: centerY });
+            }
+            break;
+        case Direction.Right:
+            x = to.x;
+            y = from.y;
+            if (to.x < from.x && to.y < from.y) {
+                x = from.x;
+                y = to.y;
+            }
+            pts.push({ x, y });
+            break;
+        case Direction.Left:
+            x = to.x;
+            y = from.y;
+            if (to.x > from.x && to.y < from.y) {
+                x = from.x;
+                y = to.y;
+            }
+            pts.push({ x, y });
+            break;
+        default:
+            if (to.y > from.y - faceSpace) {
+                x = from.x + (to.x - from.x) / 2;
+                pts.push({ x, y: from.y }, { x, y: to.y });
+            }
+            else {
+                const centerY = (from.y + to.y + faceSpace) / 2;
+                pts.push({ x: from.x, y: centerY }, { x: to.x, y: centerY });
+            }
+            break;
+    }
+    return pts;
+}
+function getNextPointsOfRight(from, to, toFace) {
+    if (from.x === to.x || from.y === to.y) {
+        return [];
+    }
+    const pts = [];
+    let x;
+    let y;
+    switch (toFace) {
+        case Direction.Up:
+            x = from.x;
+            y = to.y;
+            if (to.x > from.x && to.y > from.y) {
+                x = to.x;
+                y = from.y;
+            }
+            pts.push({ x, y });
+            break;
+        case Direction.Bottom:
+            x = from.x;
+            y = to.y;
+            if (to.x > from.x && to.y < from.y) {
+                x = to.x;
+                y = from.y;
+            }
+            pts.push({ x, y });
+            break;
+        case Direction.Left:
+            x = to.x;
+            y = from.y;
+            if (to.x < from.x) {
+                y = from.y + (to.y - from.y) / 2;
+                pts.push({ x: from.x, y }, { x: to.x, y });
+            }
+            else {
+                const centerX = (from.x + to.x) / 2;
+                pts.push({ x: centerX, y }, { x: centerX, y: to.y });
+            }
+            break;
+        case Direction.Right:
+            if (to.x < from.x) {
+                pts.push({ x: from.x, y: to.y });
+            }
+            else {
+                pts.push({ x: to.x, y: from.y });
+            }
+            break;
+        default:
+            x = to.x;
+            y = to.y;
+            if (to.x < from.x + faceSpace) {
+                pts.push({ x: from.x, y });
+            }
+            else {
+                const centerX = (from.x + to.x - faceSpace) / 2;
+                pts.push({ x: centerX, y: from.y }, { x: centerX, y });
+            }
+            break;
+    }
+    return pts;
+}
+function getNextPointsOfBottom(from, to, toFace) {
+    if (from.x === to.x || from.y === to.y) {
+        return [];
+    }
+    const pts = [];
+    let x;
+    let y;
+    switch (toFace) {
+        case Direction.Up:
+            x = from.x;
+            y = to.y;
+            if (to.y < from.y) {
+                x = from.x + (to.x - from.x) / 2;
+                pts.push({ x, y: from.y }, { x, y: to.y });
+            }
+            else {
+                const centerY = (from.y + to.y) / 2;
+                pts.push({ x, y: centerY }, { x: to.x, y: centerY });
+            }
+            break;
+        case Direction.Right:
+            x = to.x;
+            y = from.y;
+            if (to.x < from.x && to.y > from.y) {
+                x = from.x;
+                y = to.y;
+            }
+            pts.push({ x, y });
+            break;
+        case Direction.Bottom:
+            if (from.y > to.y) {
+                x = to.x;
+                y = from.y;
+            }
+            else {
+                x = from.x;
+                y = to.y;
+            }
+            pts.push({ x, y });
+            break;
+        case Direction.Left:
+            x = to.x;
+            y = from.y;
+            if (to.x > from.x && to.y > from.y) {
+                x = from.x;
+                y = to.y;
+            }
+            pts.push({ x, y });
+            break;
+        default:
+            x = from.x;
+            if (to.y < from.y + faceSpace) {
+                x = from.x + (to.x - from.x) / 2;
+                pts.push({ x, y: from.y }, { x, y: to.y });
+            }
+            else {
+                const centerY = (from.y + to.y - faceSpace) / 2;
+                pts.push({ x, y: centerY }, { x: to.x, y: centerY });
+            }
+            break;
+    }
+    return pts;
+}
+function getNextPointsOfLeft(from, to, toFace) {
+    if (from.x === to.x || from.y === to.y) {
+        return [];
+    }
+    const pts = [];
+    let x;
+    let y;
+    switch (toFace) {
+        case Direction.Up:
+            x = from.x;
+            y = to.y;
+            if (to.x < from.x && to.y > from.y) {
+                x = to.x;
+                y = from.y;
+            }
+            pts.push({ x, y });
+            break;
+        case Direction.Bottom:
+            x = from.x;
+            y = to.y;
+            if (to.x < from.x && to.y < from.y) {
+                x = to.x;
+                y = from.y;
+            }
+            pts.push({ x, y });
+            break;
+        case Direction.Right:
+            x = from.x;
+            y = to.y;
+            if (to.x > from.x) {
+                x = to.x;
+                y = from.y + (to.y - from.y) / 2;
+                pts.push({ x: from.x, y }, { x: to.x, y });
+            }
+            else {
+                const centerX = (from.x + to.x) / 2;
+                pts.push({ x: centerX, y: from.y }, { x: centerX, y: to.y });
+            }
+            break;
+        case Direction.Left:
+            if (to.x > from.x) {
+                pts.push({ x: from.x, y: to.y });
+            }
+            else {
+                pts.push({ x: to.x, y: from.y });
+            }
+            break;
+        default:
+            x = from.x;
+            y = to.y;
+            if (to.x < from.x - faceSpace) {
+                const centerX = (from.x + to.x + faceSpace) / 2;
+                pts.push({ x: centerX, y: from.y }, { x: centerX, y });
+            }
+            else {
+                pts.push({ x: from.x, y });
+            }
+            break;
+    }
+    return pts;
+}
+function getNextPoints(pen, from, to) {
+    const pts = [];
+    if (pen.calculative.drawlineH == undefined) {
+        pen.calculative.drawlineH =
+            Math.abs(to.x - from.x) > Math.abs(to.y - from.y);
+    }
+    let index = pen.calculative.worldAnchors.findIndex((anchor) => anchor.id == from.id);
+    if (index > 1) {
+        let prev = pen.calculative.worldAnchors[index - 1];
+        if (prev.x === from.x && prev.y !== from.y) {
+            //水平
+            pts.push({ x: to.x, y: from.y });
+            return pts;
+        }
+        else if (prev.y === from.y && prev.x !== from.x) {
+            //垂直
+            pts.push({ x: from.x, y: to.y });
+            return pts;
+        }
+    }
+    if (pen.calculative.worldAnchors.length) {
+        to.isTemp = undefined;
+        if (pen.calculative.drawlineH) {
+            pts.push({ x: to.x, y: from.y });
+            if (Math.abs(to.y - from.y) < faceSpace) {
+                to.isTemp = true;
+            }
+        }
+        else {
+            pts.push({ x: from.x, y: to.y });
+            if (Math.abs(to.x - from.x) < faceSpace) {
+                to.isTemp = true;
+            }
+        }
+    }
+    return pts;
+}
+export function anchorInHorizontal(pen, anchor, from = true) {
+    let anchors = pen.calculative.worldAnchors;
+    if (!from) {
+        anchors = [];
+        pen.calculative.worldAnchors.forEach((item) => {
+            anchors.unshift(item);
+        });
+    }
+    for (let i = 0; i < anchors.length; i++) {
+        if (anchors[i].id === anchor.id) {
+            break;
+        }
+        if (anchors[i].y !== anchor.y) {
+            return false;
+        }
+        if (anchors[i].x === anchors[i + 1]?.x &&
+            anchors[i].y !== anchors[i + 1]?.y) {
+            return false;
+        }
+    }
+    return true;
+}
+export function anchorInVertical(pen, anchor, from = true) {
+    let anchors = pen.calculative.worldAnchors;
+    if (!from) {
+        anchors = [];
+        pen.calculative.worldAnchors.forEach((item) => {
+            anchors.unshift(item);
+        });
+    }
+    for (let i = 0; i < anchors.length; i++) {
+        if (anchors[i].id === anchor.id) {
+            break;
+        }
+        if (anchors[i].x !== anchor.x) {
+            return false;
+        }
+        if (anchors[i].y === anchors[i + 1]?.y &&
+            anchors[i].x !== anchors[i + 1]?.x) {
+            return false;
+        }
+    }
+    return true;
+}
+export function translatePolylineAnchor(pen, anchor, pt) {
+    if (!pen.calculative.worldAnchors) {
+        return;
+    }
+    const i = pen.calculative.worldAnchors.findIndex((item) => item.id === anchor.id);
+    const from = getFromAnchor(pen);
+    const to = getToAnchor(pen);
+    let prev = pen.calculative.worldAnchors[i - 1];
+    let next = pen.calculative.worldAnchors[i + 1];
+    if (pen.calculative.h == undefined) {
+        if (from.connectTo) {
+            if (anchorInHorizontal(pen, anchor, true)) {
+                pen.calculative.h = true;
+            }
+            else if (anchorInVertical(pen, anchor, true)) {
+                pen.calculative.h = false;
+            }
+        }
+        if (pen.calculative.h == undefined && to.connectTo) {
+            if (anchorInHorizontal(pen, anchor, false)) {
+                pen.calculative.h = true;
+            }
+            else if (anchorInVertical(pen, anchor, false)) {
+                pen.calculative.h = false;
+            }
+        }
+        if (pen.calculative.h == undefined) {
+            if (prev) {
+                pen.calculative.h = prev.y === anchor.y;
+            }
+            else if (next) {
+                pen.calculative.h = next.y === anchor.y;
+            }
+        }
+    }
+    // 水平
+    if (pen.calculative.h) {
+        anchor.x = pt.x;
+        if (from.connectTo && anchorInHorizontal(pen, anchor, true)) {
+            if (next && next.y !== anchor.y) {
+                next.x = anchor.x;
+            }
+            return;
+        }
+        if (to.connectTo && anchorInHorizontal(pen, anchor, false)) {
+            if (prev && prev.y !== anchor.y) {
+                prev.x = anchor.x;
+            }
+            return;
+        }
+        const a = pen.anchors[i];
+        let d;
+        for (let pos = i - 1; pos > -1; pos--) {
+            prev = pen.anchors[pos];
+            if (d == undefined) {
+                d = prev.y === a.y;
+            }
+            if (d === true) {
+                if (prev.y === a.y) {
+                    pen.calculative.worldAnchors[pos].y = pt.y;
+                }
+                else {
+                    break;
+                }
+            }
+            else {
+                if (prev.x === a.x) {
+                    pen.calculative.worldAnchors[pos].x = pt.x;
+                }
+                else {
+                    break;
+                }
+            }
+        }
+        d = undefined;
+        for (let pos = i + 1; pos < pen.calculative.worldAnchors.length; pos++) {
+            next = pen.anchors[pos];
+            if (next) {
+                if (d == undefined) {
+                    d = next.y === a.y;
+                }
+                if (d === true) {
+                    if (next.y === a.y) {
+                        pen.calculative.worldAnchors[pos].y = pt.y;
+                    }
+                    else {
+                        break;
+                    }
+                }
+                else {
+                    if (next.x === a.x) {
+                        pen.calculative.worldAnchors[pos].x = pt.x;
+                    }
+                    else {
+                        break;
+                    }
+                }
+            }
+            else {
+                break;
+            }
+        }
+        anchor.y = pt.y;
+    }
+    // 垂直
+    else {
+        anchor.y = pt.y;
+        if (from.connectTo && anchorInVertical(pen, anchor, true)) {
+            if (next && next.x !== anchor.x) {
+                next.y = anchor.y;
+            }
+            return;
+        }
+        if (to.connectTo && anchorInVertical(pen, anchor, false)) {
+            if (prev && prev.x !== anchor.x) {
+                prev.y = anchor.y;
+            }
+            return;
+        }
+        const a = pen.anchors[i];
+        let d;
+        for (let pos = i - 1; pos > -1; pos--) {
+            prev = pen.anchors[pos];
+            if (d == undefined) {
+                d = prev.x === a.x;
+            }
+            if (d === true) {
+                if (prev.x === a.x) {
+                    pen.calculative.worldAnchors[pos].x = pt.x;
+                }
+                else {
+                    break;
+                }
+            }
+            else {
+                if (prev.y === a.y) {
+                    pen.calculative.worldAnchors[pos].y = pt.y;
+                }
+                else {
+                    break;
+                }
+            }
+        }
+        d = undefined;
+        for (let pos = i + 1; pos < pen.calculative.worldAnchors.length; pos++) {
+            next = pen.anchors[pos];
+            if (next) {
+                if (d == undefined) {
+                    d = next.x === a.x;
+                }
+                if (d === true) {
+                    if (next.x === a.x) {
+                        pen.calculative.worldAnchors[pos].x = pt.x;
+                    }
+                    else {
+                        break;
+                    }
+                }
+                else {
+                    if (next.y === a.y) {
+                        pen.calculative.worldAnchors[pos].y = pt.y;
+                    }
+                    else {
+                        break;
+                    }
+                }
+            }
+            else {
+                break;
+            }
+        }
+        anchor.x = pt.x;
+    }
+}
 //# sourceMappingURL=polyline.js.map