@leafer-in/linker 2.3.0 → 2.3.2

package/dist/linker.esm.js

@@ -0,0 +1,567 @@
+import { LineData, AroundHelper, PointHelper, Direction9, BoundsHelper, decorateLeafAttr, attr, doBoundsType, doStrokeType, PathCommandDataHelper, dataProcessor, pathType, registerUI, Line, BoundsEvent, LeafHelper, isString, isObject, Plugin, registerPointsCurve } from "@leafer-ui/draw";
+
+import { PointHelper as PointHelper$1, PathCommandMap } from "@leafer-ui/core";
+
+function __decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+class LinkerData extends LineData {
+    get __usePathBox() {
+        return this.path || this.__pathInputed;
+    }
+}
+
+const {directionData: directionData} = AroundHelper;
+
+const directionNames = [ "top-left", "top", "top-right", "right", "bottom-right", "bottom", "bottom-left", "left", "center" ];
+
+const LinkerHelper = {
+    getCtrlPoint(linker, node, point, direction, ctrl, offsetAngle) {
+        if (node) {
+            point = node.getBoxPoint(point, linker);
+        }
+        let ctrlPoint;
+        switch (direction) {
+          case "left":
+          case "top-left":
+          case "bottom-left":
+            ctrlPoint = {
+                x: point.x - ctrl.x,
+                y: point.y
+            };
+            break;
+
+          case "top":
+            ctrlPoint = {
+                x: point.x,
+                y: point.y - ctrl.y
+            };
+            break;
+
+          case "right":
+          case "top-right":
+          case "bottom-right":
+            ctrlPoint = {
+                x: point.x + ctrl.x,
+                y: point.y
+            };
+            break;
+
+          case "bottom":
+            ctrlPoint = {
+                x: point.x,
+                y: point.y + ctrl.y
+            };
+            break;
+
+          default:
+            ctrlPoint = {
+                x: point.x,
+                y: point.y
+            };
+        }
+        if (offsetAngle) {
+            offsetAngle = offsetAngle / 180 * Math.PI;
+            ctrlPoint = {
+                x: (ctrlPoint.x - point.x) * Math.cos(offsetAngle) - (ctrlPoint.y - point.y) * Math.sin(offsetAngle) + point.x,
+                y: (ctrlPoint.x - point.x) * Math.sin(offsetAngle) + (ctrlPoint.y - point.y) * Math.cos(offsetAngle) + point.y
+            };
+        }
+        if (node) node.getWorldPointByBox(ctrlPoint, linker, undefined, true);
+        return ctrlPoint;
+    },
+    isOppositeDirection(from, to) {
+        switch (from) {
+          case "left":
+            return to == "right";
+
+          case "top":
+            return to == "bottom";
+
+          case "right":
+            return to == "left";
+
+          case "bottom":
+            return to == "top";
+
+          case "center":
+            return to == "center";
+
+          default:
+            return false;
+        }
+    },
+    getDirectionForFromPoint(from, to) {
+        const a = from.x - to.x;
+        const b = from.y - to.y;
+        let direction;
+        let angle = 180 * Math.atan2(b, a) / Math.PI;
+        if (angle < 0) angle = 360 + angle;
+        if (angle > 315 || angle < 45) {
+            direction = "left";
+        } else if (angle > 45 && angle < 135) {
+            direction = "top";
+        } else if (angle > 135 && angle < 225) {
+            direction = "right";
+        } else {
+            direction = "bottom";
+        }
+        return direction;
+    },
+    getRotateDirection(direction, rotation, totalDirection = 8) {
+        let directionIndex = Direction9[direction];
+        directionIndex = (directionIndex + Math.round(rotation / (360 / totalDirection))) % totalDirection;
+        if (directionIndex < 0) directionIndex += totalDirection;
+        return directionNames[directionIndex];
+    },
+    getDirection: getDirection,
+    getPointDirection: getPointDirection,
+    autoRotatePoint(point, origin, ui) {
+        const {rotation: rotation, scaleX: scaleX, scaleY: scaleY} = ui;
+        const oneFlip = scaleX * scaleY < 0;
+        if (rotation || oneFlip) PointHelper.rotate(point, oneFlip ? -rotation : rotation, origin);
+    }
+};
+
+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];
+        const px = unit.x * width;
+        const py = unit.y * height;
+        const dx = boxPoint.x - px;
+        const dy = boxPoint.y - py;
+        if (Math.abs(dx) <= hitRadiusX && Math.abs(dy) <= hitRadiusY) {
+            if (eight) {
+                if (directionNames[i] !== "center") return directionNames[i];
+            } else return directionNames[i];
+        }
+    }
+    return undefined;
+}
+
+function getDirection(boxPoint, bounds, four) {
+    const {width: width, height: height} = bounds;
+    const center = BoundsHelper.getPoint(bounds, "center", true);
+    const dx = boxPoint.x - center.x;
+    const dy = boxPoint.y - center.y;
+    if (!four) {
+        if (Math.abs(dx) < width / 4 && Math.abs(dy) < height / 4) return "center";
+    }
+    const ax = Math.abs(dx) * height;
+    const ay = Math.abs(dy) * width;
+    if (ax > ay) {
+        return dx > 0 ? "right" : "left";
+    }
+    return dy > 0 ? "bottom" : "top";
+}
+
+function linkerPointType(defaultValue) {
+    return decorateLeafAttr(defaultValue, key => attr({
+        set(value) {
+            if (this.__setAttr(key, value)) {
+                const layout = this.__layout;
+                if (!layout.linkerChanged) {
+                    doBoundsType(this);
+                    doStrokeType(this);
+                    layout.linkerChanged = true;
+                }
+            }
+        }
+    }));
+}
+
+const {moveTo: moveTo, bezierCurveTo: bezierCurveTo, drawPoints: drawPoints$1} = PathCommandDataHelper;
+
+const {isEmpty: isEmpty, getPoint: getPoint} = BoundsHelper;
+
+const {getDistance: getDistance} = PointHelper;
+
+const {getCtrlPoint: getCtrlPoint, getDirectionForFromPoint: getDirectionForFromPoint, isOppositeDirection: isOppositeDirection} = LinkerHelper;
+
+const {max: max, min: min, abs: abs} = Math;
+
+let Linker = class Linker extends Line {
+    get __tag() {
+        return "Linker";
+    }
+    constructor(data) {
+        super(data);
+        this.onStartNodeChange = this.onStartNodeChange.bind(this);
+        this.onEndNodeChange = this.onEndNodeChange.bind(this);
+    }
+    __updatePath() {
+        const layout = this.__layout;
+        const {startNode: startNode, endNode: endNode} = this;
+        if (layout.linkerChanged) {
+            this.updateLinkerNode("start");
+            this.updateLinkerNode("end");
+            this.updateLinkerPoint("start");
+            this.updateLinkerPoint("end");
+            if (startNode !== this.startNode) this.listenLinkerNode(this.startNode, startNode, "start");
+            if (endNode !== this.endNode) this.listenLinkerNode(this.endNode, endNode, "end");
+            layout.linkerChanged = false;
+        }
+        this.updateLinkerPath();
+    }
+    listenLinkerNode(newNode, oldNode, type) {
+        if (oldNode) {
+            oldNode.off(BoundsEvent.WORLD, type === "end" ? this.onEndNodeChange : this.onStartNodeChange);
+            const list = type === "end" ? oldNode.endLinker : oldNode.startLinker;
+            if (list) {
+                const index = list.indexOf(this);
+                if (index > -1) list.splice(index, 1);
+            }
+        }
+        if (newNode) {
+            newNode.on(BoundsEvent.WORLD, type === "end" ? this.onEndNodeChange : this.onStartNodeChange);
+            const list = type === "end" ? newNode.endLinker || (newNode.endLinker = []) : newNode.startLinker || (newNode.startLinker = []);
+            list.push(this);
+        }
+    }
+    onStartNodeChange() {
+        this.onLinkerNodeChange("start");
+    }
+    onEndNodeChange() {
+        this.onLinkerNodeChange("end");
+    }
+    onLinkerNodeChange(type) {
+        if (this.leaferIsCreated) {
+            const {layouter: layouter, zoomLayer: zoomLayer} = this.leafer;
+            if (layouter.__updatedList.has(zoomLayer)) return;
+            layouter.addExtra(this, true);
+        }
+        const {startData: startData, endData: endData} = this;
+        if (type == "start") {
+            this.updateLinkerPoint("start");
+            if (endData && endData.auto) this.updateLinkerPoint("end");
+        } else {
+            if (startData && startData.auto) this.updateLinkerPoint("start");
+            this.updateLinkerPoint("end");
+        }
+        this.__layout.boxChange();
+        LeafHelper.updateBounds(this);
+    }
+    updateLinkerNode(type) {
+        const {startPoint: startPoint, endPoint: endPoint} = this;
+        const nowPoint = type === "end" ? endPoint : startPoint;
+        if (nowPoint) {
+            const {id: id} = nowPoint;
+            const ui = id && (isString(id) ? this.app.findId(id) : id);
+            type === "end" ? this.endNode = ui : this.startNode = ui;
+        }
+    }
+    getLinkerNodeCenter(type) {
+        const {startPoint: startPoint, endPoint: endPoint, startNode: startNode, endNode: endNode, startData: startData, endData: endData} = this;
+        const node = type === "end" ? endNode : startNode;
+        const data = type === "end" ? endData || endPoint : startData || startPoint;
+        if (node) {
+            const {worldRenderBounds: worldRenderBounds} = node;
+            if (isEmpty(worldRenderBounds)) LeafHelper.updateBounds(node);
+            return getPoint(node.worldRenderBounds, "center");
+        } else {
+            return data && isObject(data.point) && this.getWorldPointByLocal(data.point);
+        }
+    }
+    updateLinkerPoint(type) {
+        const {startPoint: startPoint, endPoint: endPoint} = this;
+        const nowPoint = type === "end" ? endPoint : startPoint;
+        if (nowPoint) {
+            const data = {};
+            const {id: id, offset: offset} = nowPoint;
+            let {direction: direction, point: point} = nowPoint;
+            if (direction === "center" || !direction && id && !point) {
+                const start = this.getLinkerNodeCenter("start");
+                const end = this.getLinkerNodeCenter("end");
+                const from = type === "end" ? end : start;
+                const to = type === "end" ? start : end;
+                if (from && to) direction = getDirectionForFromPoint(from, to);
+                data.auto = true;
+            }
+            if (!direction && isString(point)) direction = point;
+            data.direction = direction;
+            const ui = type === "end" ? this.endNode : this.startNode;
+            let p;
+            if (ui) {
+                if (!point) point = direction;
+                if (point) {
+                    const {boxBounds: boxBounds} = ui;
+                    if (isEmpty(boxBounds)) LeafHelper.updateBounds(ui);
+                    p = getPoint(boxBounds, point, true);
+                    ui.getWorldPointByBox(p, this, false, true);
+                }
+            } else {
+                if (isObject(point)) p = point;
+            }
+            if (p && offset) {
+                const o = Object.assign({}, offset);
+                if (!offset.x) o.x = 0;
+                if (!offset.y) o.y = 0;
+                if (ui) ui.getWorldPoint(o, this, true, true);
+                PointHelper.move(p, o);
+            }
+            data.point = p;
+            type === "end" ? this.endData = p && data : this.startData = p && data;
+        }
+    }
+    updateLinkerPath() {
+        const data = this.__;
+        const path = data.path = [];
+        const hasPoints = data.points && data.points.length;
+        const {startData: startData, endData: endData, startNode: startNode, endNode: endNode} = this;
+        if (!startData || !endData) {
+            return;
+        }
+        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)) {
+                minCtrl = arrowWidth * 2;
+            }
+        }
+        half.x = max(minCtrl, half.x);
+        half.y = max(minCtrl, half.y);
+        if (hasPoints) {
+            minCtrl *= .6;
+            const points = 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 {
+            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) {
+        const data = this.createLinkerPoint(worldPoint, node, options);
+        this.startPoint = data;
+        return data;
+    }
+    createEndPoint(worldPoint, node, options) {
+        const data = this.createLinkerPoint(worldPoint, node, options);
+        this.endPoint = data;
+        return data;
+    }
+    createLinkerPoint(worldPoint, node, options) {
+        const data = {};
+        if (node && node.id) {
+            const point = node.getBoxPoint(worldPoint);
+            const {boxBounds: boxBounds} = node;
+            const mode = options && options.mode;
+            const edge = mode === "edge" || !mode;
+            const four = mode === "four";
+            const auto = mode === "auto";
+            const free = mode === "free";
+            if (!auto) {
+                if (four) {
+                    data.point = LinkerHelper.getDirection(point, boxBounds, four);
+                } else {
+                    data.direction = LinkerHelper.getDirection(point, boxBounds, edge);
+                    data.point = LinkerHelper.getPointDirection(point, boxBounds, edge) || data.direction;
+                    if (data.point === data.direction) delete data.direction;
+                    if (free || edge) {
+                        const snapPoint = BoundsHelper.getPoint(boxBounds, data.point);
+                        const offsetX = point.x - snapPoint.x;
+                        const offsetY = point.y - snapPoint.y;
+                        const snapRadius = options && options.snapRadius || 10;
+                        if (Math.abs(offsetX) > snapRadius || Math.abs(offsetY) > snapRadius) {
+                            const offset = data.offset = {
+                                x: Math.abs(offsetX) > snapRadius ? offsetX : 0,
+                                y: Math.abs(offsetY) > snapRadius ? offsetY : 0
+                            };
+                            if (edge && (offset.x || offset.y)) {
+                                switch (data.direction || data.point) {
+                                  case "top":
+                                  case "bottom":
+                                    offset.y = 0;
+                                    break;
+
+                                  case "right":
+                                  case "left":
+                                    offset.x = 0;
+                                    break;
+
+                                  default:
+                                    if (offset.x > offset.y) offset.y = 0; else offset.x = 0;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            data.id = node.id;
+        } else {
+            data.point = this.getLocalPoint(worldPoint);
+        }
+        return data;
+    }
+};
+
+__decorate([ dataProcessor(LinkerData) ], Linker.prototype, "__", void 0);
+
+__decorate([ linkerPointType() ], Linker.prototype, "startPoint", void 0);
+
+__decorate([ linkerPointType() ], Linker.prototype, "endPoint", void 0);
+
+__decorate([ pathType({
+    type: "C",
+    value: .5
+}) ], Linker.prototype, "curve", void 0);
+
+Linker = __decorate([ registerUI() ], Linker);
+
+const {toNumberPoints: toNumberPoints} = PointHelper$1;
+
+const {M: M, L: L, C: C, Z: Z} = PathCommandMap;
+
+function drawPoints(data, originPoints, curve, close) {
+    const points = toNumberPoints(originPoints);
+    const count = points.length >> 1;
+    if (count < 2) return;
+    data.push(M, points[0], points[1]);
+    if (!curve || count < 3) {
+        for (let i = 1; i < count; i++) {
+            data.push(L, points[i * 2], points[i * 2 + 1]);
+        }
+        if (close) data.push(Z);
+        return;
+    }
+    let tension = curve === true ? .5 : curve;
+    if (tension < 0) tension = 0; else if (tension > 1) tension = 1;
+    const end = close ? count : count - 1;
+    let lastOutX = points[0];
+    let lastOutY = points[1];
+    {
+        const dx = points[2] - points[0];
+        const dy = points[3] - points[1];
+        const len = Math.sqrt(dx * dx + dy * dy);
+        if (len) {
+            lastOutX = points[0] + dx / len * len * tension;
+            lastOutY = points[1] + dy / len * len * tension;
+        }
+    }
+    for (let i = 0; i < end; i++) {
+        const index = i + 1 === count ? 0 : i + 1;
+        const bx = points[index * 2];
+        const by = points[index * 2 + 1];
+        const prev = index === 0 ? count - 1 : index - 1;
+        const next = index + 1 === count ? 0 : index + 1;
+        const ax = points[prev * 2];
+        const ay = points[prev * 2 + 1];
+        const cx = points[next * 2];
+        const cy = points[next * 2 + 1];
+        let bax = ax - bx;
+        let bay = ay - by;
+        let bcx = cx - bx;
+        let bcy = cy - by;
+        const ab = Math.sqrt(bax * bax + bay * bay);
+        const bc = Math.sqrt(bcx * bcx + bcy * bcy);
+        let inX = bx;
+        let inY = by;
+        let outX = bx;
+        let outY = by;
+        if (ab || bc) {
+            let ux = 0;
+            let uy = 0;
+            if (ab) {
+                ux += bax / ab;
+                uy += bay / ab;
+            }
+            if (bc) {
+                ux += bcx / bc;
+                uy += bcy / bc;
+            }
+            let uLen = Math.sqrt(ux * ux + uy * uy);
+            if (!uLen) {
+                if (bc) {
+                    ux = bcx / bc;
+                    uy = bcy / bc;
+                } else {
+                    ux = bax / ab;
+                    uy = bay / ab;
+                }
+                uLen = 1;
+            }
+            ux /= uLen;
+            uy /= uLen;
+            let tx = -uy;
+            let ty = ux;
+            if (bc) {
+                if (tx * bcx + ty * bcy < 0) {
+                    tx = -tx;
+                    ty = -ty;
+                }
+            }
+            let cos = 0;
+            if (ab && bc) {
+                cos = (bax * bcx + bay * bcy) / (ab * bc);
+                if (cos > 1) cos = 1; else if (cos < -1) cos = -1;
+            }
+            let angleFactor = Math.sqrt(Math.sqrt(Math.max(0, 1 - cos * cos)));
+            if (angleFactor < .15) angleFactor = .15;
+            let inLength = ab * tension * angleFactor;
+            let outLength = bc * tension * angleFactor;
+            const maxLength = Math.min(ab || bc, bc || ab) * .5;
+            if (inLength > maxLength) inLength = maxLength;
+            if (outLength > maxLength) outLength = maxLength;
+            inX = bx - tx * inLength;
+            inY = by - ty * inLength;
+            outX = bx + tx * outLength;
+            outY = by + ty * outLength;
+        }
+        data.push(C, lastOutX, lastOutY, inX, inY, bx, by);
+        lastOutX = outX;
+        lastOutY = outY;
+    }
+    if (close) data.push(Z);
+}
+
+Plugin.add("linker");
+
+registerPointsCurve("C", drawPoints);
+
+export { Linker, LinkerData };

package/dist/linker.esm.min.js

@@ -0,0 +1,2 @@
+import{LineData as t,AroundHelper as e,PointHelper as n,Direction9 as o,BoundsHelper as i,decorateLeafAttr as r,attr as s,doBoundsType as a,doStrokeType as d,PathCommandDataHelper as h,dataProcessor as c,pathType as u,registerUI as l,Line as p,BoundsEvent as f,LeafHelper as y,isString as g,isObject as x,Plugin as P,registerPointsCurve as k}from"@leafer-ui/draw";import{PointHelper as b,PathCommandMap as L}from"@leafer-ui/core";function N(t,e,n,o){var i,r=arguments.length,s=r<3?e:null===o?o=Object.getOwnPropertyDescriptor(e,n):o;if("object"==typeof Reflect&&"function"==typeof Reflect.decorate)s=Reflect.decorate(t,e,n,o);else for(var a=t.length-1;a>=0;a--)(i=t[a])&&(s=(r<3?i(s):r>3?i(e,n,s):i(e,n))||s);return r>3&&s&&Object.defineProperty(e,n,s),s}"function"==typeof SuppressedError&&SuppressedError;class m extends t{get __usePathBox(){return this.path||this.__pathInputed}}const{directionData:C}=e,M=["top-left","top","top-right","right","bottom-right","bottom","bottom-left","left","center"],_={getCtrlPoint(t,e,n,o,i,r){let s;switch(e&&(n=e.getBoxPoint(n,t)),o){case"left":case"top-left":case"bottom-left":s={x:n.x-i.x,y:n.y};break;case"top":s={x:n.x,y:n.y-i.y};break;case"right":case"top-right":case"bottom-right":s={x:n.x+i.x,y:n.y};break;case"bottom":s={x:n.x,y:n.y+i.y};break;default:s={x:n.x,y:n.y}}return r&&(r=r/180*Math.PI,s={x:(s.x-n.x)*Math.cos(r)-(s.y-n.y)*Math.sin(r)+n.x,y:(s.x-n.x)*Math.sin(r)+(s.y-n.y)*Math.cos(r)+n.y}),e&&e.getWorldPointByBox(s,t,void 0,!0),s},isOppositeDirection(t,e){switch(t){case"left":return"right"==e;case"top":return"bottom"==e;case"right":return"left"==e;case"bottom":return"top"==e;case"center":return"center"==e;default:return!1}},getDirectionForFromPoint(t,e){const n=t.x-e.x,o=t.y-e.y;let i,r=180*Math.atan2(o,n)/Math.PI;return r<0&&(r=360+r),i=r>315||r<45?"left":r>45&&r<135?"top":r>135&&r<225?"right":"bottom",i},getRotateDirection(t,e,n=8){let i=o[t];return i=(i+Math.round(e/(360/n)))%n,i<0&&(i+=n),M[i]},getDirection:function(t,e,n){const{width:o,height:r}=e,s=i.getPoint(e,"center",!0),a=t.x-s.x,d=t.y-s.y;if(!n&&Math.abs(a)<o/4&&Math.abs(d)<r/4)return"center";const h=Math.abs(a)*r,c=Math.abs(d)*o;if(h>c)return a>0?"right":"left";return d>0?"bottom":"top"},getPointDirection:function(t,e,n){const{width:o,height:i}=e,r=o/4,s=i/4;for(let e=0;e<C.length;e++){const a=C[e],d=a.x*o,h=a.y*i,c=t.x-d,u=t.y-h;if(Math.abs(c)<=r&&Math.abs(u)<=s){if(!n)return M[e];if("center"!==M[e])return M[e]}}return},autoRotatePoint(t,e,o){const{rotation:i,scaleX:r,scaleY:s}=o,a=r*s<0;(i||a)&&n.rotate(t,a?-i:i,e)}};function D(t){return r(t,t=>s({set(e){if(this.__setAttr(t,e)){const t=this.__layout;t.linkerChanged||(a(this),d(this),t.linkerChanged=!0)}}}))}const{moveTo:B,bezierCurveTo:v,drawPoints:w}=h,{isEmpty:E,getPoint:R}=i,{getDistance:O}=n,{getCtrlPoint:S,getDirectionForFromPoint:W,isOppositeDirection:q}=_,{max:I,min:j,abs:F}=Math;let z=class extends p{get __tag(){return"Linker"}constructor(t){super(t),this.onStartNodeChange=this.onStartNodeChange.bind(this),this.onEndNodeChange=this.onEndNodeChange.bind(this)}__updatePath(){const t=this.__layout,{startNode:e,endNode:n}=this;t.linkerChanged&&(this.updateLinkerNode("start"),this.updateLinkerNode("end"),this.updateLinkerPoint("start"),this.updateLinkerPoint("end"),e!==this.startNode&&this.listenLinkerNode(this.startNode,e,"start"),n!==this.endNode&&this.listenLinkerNode(this.endNode,n,"end"),t.linkerChanged=!1),this.updateLinkerPath()}listenLinkerNode(t,e,n){if(e){e.off(f.WORLD,"end"===n?this.onEndNodeChange:this.onStartNodeChange);const t="end"===n?e.endLinker:e.startLinker;if(t){const e=t.indexOf(this);e>-1&&t.splice(e,1)}}if(t){t.on(f.WORLD,"end"===n?this.onEndNodeChange:this.onStartNodeChange);("end"===n?t.endLinker||(t.endLinker=[]):t.startLinker||(t.startLinker=[])).push(this)}}onStartNodeChange(){this.onLinkerNodeChange("start")}onEndNodeChange(){this.onLinkerNodeChange("end")}onLinkerNodeChange(t){if(this.leaferIsCreated){const{layouter:t,zoomLayer:e}=this.leafer;if(t.__updatedList.has(e))return;t.addExtra(this,!0)}const{startData:e,endData:n}=this;"start"==t?(this.updateLinkerPoint("start"),n&&n.auto&&this.updateLinkerPoint("end")):(e&&e.auto&&this.updateLinkerPoint("start"),this.updateLinkerPoint("end")),this.__layout.boxChange(),y.updateBounds(this)}updateLinkerNode(t){const{startPoint:e,endPoint:n}=this,o="end"===t?n:e;if(o){const{id:e}=o,n=e&&(g(e)?this.app.findId(e):e);"end"===t?this.endNode=n:this.startNode=n}}getLinkerNodeCenter(t){const{startPoint:e,endPoint:n,startNode:o,endNode:i,startData:r,endData:s}=this,a="end"===t?i:o,d="end"===t?s||n:r||e;if(a){const{worldRenderBounds:t}=a;return E(t)&&y.updateBounds(a),R(a.worldRenderBounds,"center")}return d&&x(d.point)&&this.getWorldPointByLocal(d.point)}updateLinkerPoint(t){const{startPoint:e,endPoint:o}=this,i="end"===t?o:e;if(i){const e={},{id:o,offset:r}=i;let{direction:s,point:a}=i;if("center"===s||!s&&o&&!a){const n=this.getLinkerNodeCenter("start"),o=this.getLinkerNodeCenter("end"),i="end"===t?o:n,r="end"===t?n:o;i&&r&&(s=W(i,r)),e.auto=!0}!s&&g(a)&&(s=a),e.direction=s;const d="end"===t?this.endNode:this.startNode;let h;if(d){if(a||(a=s),a){const{boxBounds:t}=d;E(t)&&y.updateBounds(d),h=R(t,a,!0),d.getWorldPointByBox(h,this,!1,!0)}}else x(a)&&(h=a);if(h&&r){const t=Object.assign({},r);r.x||(t.x=0),r.y||(t.y=0),d&&d.getWorldPoint(t,this,!0,!0),n.move(h,t)}e.point=h,"end"===t?this.endData=h&&e:this.startData=h&&e}}updateLinkerPath(){const t=this.__,e=t.path=[],o=t.points&&t.points.length,{startData:i,endData:r,startNode:s,endNode:a}=this;if(!i||!r)return;const d=i.point,h=r.point,c=i.direction,u=r.direction,l={x:F((d.x-h.x)/2),y:F((d.y-h.y)/2)},p=8*this.__.strokeWidth;let f;if(this.__.__useArrow){const t=j(O(d,h)/(25*p),1);f=I(p*t*12,3*p)}else f=2*p;if(u&&q(c,u)&&c===W(d,h)&&(f=2*p),l.x=I(f,l.x),l.y=I(f,l.y),o){f*=.6;const o=n.toNumberPoints(t.points);if(w(e,[d.x,d.y,...o,h.x,h.y],t.curve,!1,t),c){const t=e[4],n=e[5];l.x=I(f,F(t-d.x)),l.y=I(f,F(n-d.y));const o=S(this,s,d,c,l);e[4]=o.x,e[5]=o.y}const i=e.length;if(u){const t=e[i-4],n=e[i-3];l.x=I(f,F(t-h.x)),l.y=I(f,F(n-h.y));const o=S(this,a,h,u,l);e[i-4]=o.x,e[i-3]=o.y}else e[i-4]=h.x,e[i-3]=h.y}else{const t=c?S(this,s,d,c,l):d,n=u?S(this,a,h,u,l):h;B(e,d.x,d.y),v(e,t.x,t.y,n.x,n.y,h.x,h.y)}}createStartPoint(t,e,n){const o=this.createLinkerPoint(t,e,n);return this.startPoint=o,o}createEndPoint(t,e,n){const o=this.createLinkerPoint(t,e,n);return this.endPoint=o,o}createLinkerPoint(t,e,n){const o={};if(e&&e.id){const r=e.getBoxPoint(t),{boxBounds:s}=e,a=n&&n.mode,d="edge"===a||!a,h="four"===a,c="free"===a;if(!("auto"===a))if(h)o.point=_.getDirection(r,s,h);else if(o.direction=_.getDirection(r,s,d),o.point=_.getPointDirection(r,s,d)||o.direction,o.point===o.direction&&delete o.direction,c||d){const t=i.getPoint(s,o.point),e=r.x-t.x,a=r.y-t.y,h=n&&n.snapRadius||10;if(Math.abs(e)>h||Math.abs(a)>h){const t=o.offset={x:Math.abs(e)>h?e:0,y:Math.abs(a)>h?a:0};if(d&&(t.x||t.y))switch(o.direction||o.point){case"top":case"bottom":t.y=0;break;case"right":case"left":t.x=0;break;default:t.x>t.y?t.y=0:t.x=0}}}o.id=e.id}else o.point=this.getLocalPoint(t);return o}};N([c(m)],z.prototype,"__",void 0),N([D()],z.prototype,"startPoint",void 0),N([D()],z.prototype,"endPoint",void 0),N([u({type:"C",value:.5})],z.prototype,"curve",void 0),z=N([l()],z);const{toNumberPoints:A}=b,{M:T,L:H,C:X,Z:Y}=L;P.add("linker"),k("C",function(t,e,n,o){const i=A(e),r=i.length>>1;if(r<2)return;if(t.push(T,i[0],i[1]),!n||r<3){for(let e=1;e<r;e++)t.push(H,i[2*e],i[2*e+1]);return void(o&&t.push(Y))}let s=!0===n?.5:n;s<0?s=0:s>1&&(s=1);const a=o?r:r-1;let d=i[0],h=i[1];{const t=i[2]-i[0],e=i[3]-i[1],n=Math.sqrt(t*t+e*e);n&&(d=i[0]+t/n*n*s,h=i[1]+e/n*n*s)}for(let e=0;e<a;e++){const n=e+1===r?0:e+1,o=i[2*n],a=i[2*n+1],c=0===n?r-1:n-1,u=n+1===r?0:n+1;let l=i[2*c]-o,p=i[2*c+1]-a,f=i[2*u]-o,y=i[2*u+1]-a;const g=Math.sqrt(l*l+p*p),x=Math.sqrt(f*f+y*y);let P=o,k=a,b=o,L=a;if(g||x){let t=0,e=0;g&&(t+=l/g,e+=p/g),x&&(t+=f/x,e+=y/x);let n=Math.sqrt(t*t+e*e);n||(x?(t=f/x,e=y/x):(t=l/g,e=p/g),n=1),t/=n,e/=n;let i=-e,r=t;x&&i*f+r*y<0&&(i=-i,r=-r);let d=0;g&&x&&(d=(l*f+p*y)/(g*x),d>1?d=1:d<-1&&(d=-1));let h=Math.sqrt(Math.sqrt(Math.max(0,1-d*d)));h<.15&&(h=.15);let c=g*s*h,u=x*s*h;const N=.5*Math.min(g||x,x||g);c>N&&(c=N),u>N&&(u=N),P=o-i*c,k=a-r*c,b=o+i*u,L=a+r*u}t.push(X,d,h,P,k,o,a),d=b,h=L}o&&t.push(Y)});export{z as Linker,m as LinkerData};
+//# sourceMappingURL=linker.esm.min.js.map