@billtaofbj/mindmap 1.0.0

package/dist/Drag-BNJqZaaB.mjs

@@ -0,0 +1,458 @@
+import { Dt as e, I as t, dt as n, i as r, k as i, ut as a } from "./utils-DjW7eJ1w.mjs";
+import { t as o } from "./Base-B8xfItDp.mjs";
+import { t as s } from "./AutoMove-B6piuV1l.mjs";
+//#region ../../node_modules/.pnpm/simple-mind-map@0.14.0-fix.2/node_modules/simple-mind-map/src/plugins/Drag.js
+var c = class extends o {
+	constructor({ mindMap: e }) {
+		super(e.renderer), this.mindMap = e, this.autoMove = new s(e), this.reset(), this.bindEvent();
+	}
+	reset() {
+		this.isDragging = !1, this.mousedownNode = null, this.beingDragNodeList = [], this.nodeList = [], this.overlapNode = null, this.prevNode = null, this.nextNode = null, this.drawTransform = null, this.clone = null, this.placeholder = null, this.placeholderWidth = 50, this.placeholderHeight = 10, this.placeHolderLine = null, this.placeHolderExtraLines = [], this.offsetX = 0, this.offsetY = 0, this.isMousedown = !1, this.mouseDownX = 0, this.mouseDownY = 0, this.mouseMoveX = 0, this.mouseMoveY = 0, this.checkDragOffset = 10, this.minOffset = 10;
+	}
+	bindEvent() {
+		this.onNodeMousedown = this.onNodeMousedown.bind(this), this.onMousemove = this.onMousemove.bind(this), this.onMouseup = this.onMouseup.bind(this), this.checkOverlapNode = n(this.checkOverlapNode, 300, this), this.mindMap.on("node_mousedown", this.onNodeMousedown), this.mindMap.on("mousemove", this.onMousemove), this.mindMap.on("node_mouseup", this.onMouseup), this.mindMap.on("mouseup", this.onMouseup);
+	}
+	unBindEvent() {
+		this.mindMap.off("node_mousedown", this.onNodeMousedown), this.mindMap.off("mousemove", this.onMousemove), this.mindMap.off("node_mouseup", this.onMouseup), this.mindMap.off("mouseup", this.onMouseup);
+	}
+	onNodeMousedown(e, t) {
+		if (this.mindMap.opt.readonly || t.which !== 1 || e.isGeneralization || e.isRoot) return;
+		this.isMousedown = !0, this.mousedownNode = e;
+		let { x: n, y: r } = this.mindMap.toPos(t.clientX, t.clientY);
+		this.mouseDownX = n, this.mouseDownY = r;
+	}
+	onMousemove(e) {
+		if (this.mindMap.opt.readonly || !this.isMousedown) return;
+		e.preventDefault();
+		let { x: t, y: n } = this.mindMap.toPos(e.clientX, e.clientY);
+		this.mouseMoveX = t, this.mouseMoveY = n, !(!this.isDragging && Math.abs(t - this.mouseDownX) <= this.checkDragOffset && Math.abs(n - this.mouseDownY) <= this.checkDragOffset) && (this.mindMap.emit("node_dragging", this.mousedownNode), this.handleStartMove(), this.onMove(t, n, e));
+	}
+	async onMouseup(e) {
+		if (!this.isMousedown) return;
+		let { autoMoveWhenMouseInEdgeOnDrag: t, enableFreeDrag: n, beforeDragEnd: r } = this.mindMap.opt;
+		t && this.mindMap.select && this.autoMove.clearAutoMoveTimer(), this.isMousedown = !1, this.beingDragNodeList.forEach((e) => {
+			e.setOpacity(1), e.showChildren(), e.endDrag();
+		}), this.removeCloneNode();
+		let i = this.overlapNode ? this.overlapNode.getData("uid") : "", a = this.prevNode ? this.prevNode.getData("uid") : "", o = this.nextNode ? this.nextNode.getData("uid") : "";
+		if (this.isDragging && typeof r == "function" && await r({
+			overlapNodeUid: i,
+			prevNodeUid: a,
+			nextNodeUid: o,
+			beingDragNodeList: [...this.beingDragNodeList]
+		})) {
+			this.reset();
+			return;
+		}
+		if (this.overlapNode) this.removeNodeActive(this.overlapNode), this.mindMap.execCommand("MOVE_NODE_TO", this.beingDragNodeList, this.overlapNode);
+		else if (this.prevNode) this.removeNodeActive(this.prevNode), this.mindMap.execCommand("INSERT_AFTER", this.beingDragNodeList, this.prevNode);
+		else if (this.nextNode) this.removeNodeActive(this.nextNode), this.mindMap.execCommand("INSERT_BEFORE", this.beingDragNodeList, this.nextNode);
+		else if (this.clone && n && this.beingDragNodeList.length === 1) {
+			let { x: t, y: n } = this.mindMap.toPos(e.clientX - this.offsetX, e.clientY - this.offsetY), { scaleX: r, scaleY: i, translateX: a, translateY: o } = this.drawTransform;
+			t = (t - a) / r, n = (n - o) / i, this.mousedownNode.left = t, this.mousedownNode.top = n, this.mousedownNode.customLeft = t, this.mousedownNode.customTop = n, this.mindMap.execCommand("SET_NODE_CUSTOM_POSITION", this.mousedownNode, t, n), this.mindMap.render();
+		}
+		this.isDragging && this.mindMap.emit("node_dragend", {
+			overlapNodeUid: i,
+			prevNodeUid: a,
+			nextNodeUid: o
+		}), this.reset();
+	}
+	removeNodeActive(e) {
+		e.getData("isActive") && this.mindMap.execCommand("SET_NODE_ACTIVE", e, !1);
+	}
+	onMove(e, t, n) {
+		if (!this.isMousedown || !this.isDragging) return;
+		let { scaleX: r, scaleY: i, translateX: a, translateY: o } = this.drawTransform, s = e - this.offsetX, c = t - this.offsetY;
+		e = (s - a) / r, t = (c - o) / i;
+		let l = this.clone.transform();
+		this.clone.translate(e - l.translateX, t - l.translateY), this.checkOverlapNode(), this.drawTransform = this.mindMap.draw.transform(), this.autoMove.clearAutoMoveTimer(), this.autoMove.onMove(n.clientX, n.clientY);
+	}
+	async handleStartMove() {
+		if (!this.isDragging) {
+			let e = this.mousedownNode;
+			this.drawTransform = this.mindMap.draw.transform();
+			let { scaleX: n, scaleY: r, translateX: i, translateY: o } = this.drawTransform;
+			this.offsetX = this.mouseDownX - (e.left * n + i), this.offsetY = this.mouseDownY - (e.top * r + o), e.getData("isActive") ? this.beingDragNodeList = a(t(this.mindMap.renderer.activeNodeList.filter((e) => !e.isRoot && !e.isGeneralization))) : this.beingDragNodeList = [e];
+			let { beforeDragStart: s } = this.mindMap.opt;
+			if (typeof s == "function" && await s([...this.beingDragNodeList])) return;
+			this.nodeTreeToList(), this.createCloneNode(), this.mindMap.execCommand("CLEAR_ACTIVE_NODE"), this.isDragging = !0;
+		}
+	}
+	nodeTreeToList() {
+		let e = [];
+		r(this.mindMap.renderer.root, (t) => {
+			this.checkIsInBeingDragNodeList(t) || (e[t.layerIndex] || (e[t.layerIndex] = []), e[t.layerIndex].push(t));
+		}), this.nodeList = e.reduceRight((e, t) => [...e, ...t], []);
+	}
+	createCloneNode() {
+		if (!this.clone) {
+			let { dragMultiNodeRectConfig: e, dragPlaceholderRectFill: t, dragPlaceholderLineConfig: n, dragOpacityConfig: r, handleDragCloneNode: i } = this.mindMap.opt, { width: a, height: o, fill: s } = e, c = this.beingDragNodeList[0], l = c.style.merge("lineColor", !0);
+			if (this.beingDragNodeList.length > 1) this.clone = this.mindMap.otherDraw.rect().size(a, o).radius(o / 2).fill({ color: s || l }), this.offsetX = a / 2, this.offsetY = o / 2;
+			else {
+				this.clone = c.group.clone();
+				let e = this.clone.findOne(".smm-expand-btn");
+				e && e.remove(), this.mindMap.otherDraw.add(this.clone), typeof i == "function" && i(this.clone);
+			}
+			this.clone.opacity(r.cloneNodeOpacity), this.clone.css("z-index", 99999), this.placeholder = this.mindMap.otherDraw.rect().fill({ color: t || l }).radius(5), this.placeHolderLine = this.mindMap.otherDraw.path().stroke({
+				color: n.color || l,
+				width: n.width
+			}).fill({ color: "none" }), this.beingDragNodeList.forEach((e) => {
+				e.setOpacity(r.beingDragNodeOpacity), e.hideChildren(), e.startDrag();
+			});
+		}
+	}
+	removeCloneNode() {
+		this.clone && (this.clone.remove(), this.placeholder.remove(), this.placeHolderLine.remove(), this.removeExtraLines());
+	}
+	removeExtraLines() {
+		this.placeHolderExtraLines.forEach((e) => {
+			e.remove();
+		}), this.placeHolderExtraLines = [];
+	}
+	checkOverlapNode() {
+		if (!this.drawTransform || !this.placeholder) return;
+		let { LOGICAL_STRUCTURE: t, LOGICAL_STRUCTURE_LEFT: n, MIND_MAP: r, ORGANIZATION_STRUCTURE: i, CATALOG_ORGANIZATION: a, TIMELINE: o, TIMELINE2: s, VERTICAL_TIMELINE: c, VERTICAL_TIMELINE2: l, VERTICAL_TIMELINE3: u, FISHBONE: d, FISHBONE2: f, RIGHT_FISHBONE: p, RIGHT_FISHBONE2: m } = e.LAYOUT;
+		this.overlapNode = null, this.prevNode = null, this.nextNode = null, this.placeholder.size(0, 0), this.placeHolderLine.hide(), this.removeExtraLines(), this.nodeList.forEach((e) => {
+			if (e.getData("isActive") && this.mindMap.execCommand("SET_NODE_ACTIVE", e, !1), !(this.overlapNode || this.prevNode && this.nextNode)) switch (this.mindMap.opt.layout) {
+				case t:
+				case n:
+					this.handleLogicalStructure(e);
+					break;
+				case r:
+					this.handleMindMap(e);
+					break;
+				case i:
+					this.handleOrganizationStructure(e);
+					break;
+				case a:
+					this.handleCatalogOrganization(e);
+					break;
+				case o:
+					this.handleTimeLine(e);
+					break;
+				case s:
+					this.handleTimeLine2(e);
+					break;
+				case c:
+				case l:
+				case u:
+					this.handleLogicalStructure(e);
+					break;
+				case d:
+				case f:
+				case p:
+				case m:
+					this.handleFishbone(e);
+					break;
+				default: this.handleLogicalStructure(e);
+			}
+		}), this.overlapNode && this.handleOverlapNode();
+	}
+	handleOverlapNode() {
+		let { LOGICAL_STRUCTURE: t, LOGICAL_STRUCTURE_LEFT: n, MIND_MAP: r, ORGANIZATION_STRUCTURE: i, CATALOG_ORGANIZATION: a, TIMELINE: o, TIMELINE2: s, VERTICAL_TIMELINE: c, VERTICAL_TIMELINE2: l, VERTICAL_TIMELINE3: u, FISHBONE: d, FISHBONE2: f, RIGHT_FISHBONE: p, RIGHT_FISHBONE2: m } = e.LAYOUT, { LEFT: h, TOP: g, RIGHT: _, BOTTOM: v } = e.LAYOUT_GROW_DIR, y = this.overlapNode.layerIndex, b = this.overlapNode.children, x = this.mindMap.renderer.layout.getMarginX(y + 1), S = this.mindMap.renderer.layout.getMarginY(y + 1), C = this.placeholderWidth / 2, w = this.placeholderHeight / 2, T = "", E = "", D = "", O = !1, k = !1;
+		if (b.length > 0) {
+			let e = b[b.length - 1], v = this.getNodeRect(e);
+			switch (T = this.getNewChildNodeDir(e), this.mindMap.opt.layout) {
+				case t:
+				case r:
+					E = T === h ? v.originRight - this.placeholderWidth : v.originLeft, D = v.originBottom + this.minOffset - w;
+					break;
+				case n:
+					E = v.originRight - this.placeholderWidth, D = v.originBottom + this.minOffset - w;
+					break;
+				case i:
+					O = !0, E = v.originRight + this.minOffset - w, D = v.originTop;
+					break;
+				case a:
+					y === 0 ? (O = !0, E = v.originRight + this.minOffset - w, D = v.originTop) : (E = v.originLeft, D = v.originBottom + this.minOffset - w);
+					break;
+				case o:
+					y === 0 ? (O = !0, E = v.originRight + this.minOffset - w, D = v.originTop + v.originHeight / 2 - C) : (E = v.originLeft, D = v.originBottom + this.minOffset - w);
+					break;
+				case s:
+					y === 0 ? (O = !0, E = v.originRight + this.minOffset - w, D = v.originTop + v.originHeight / 2 - C) : (E = v.originLeft, D = y === 1 && T === g ? v.originTop - this.placeholderHeight - this.minOffset + w : v.originBottom + this.minOffset - w);
+					break;
+				case c:
+				case l:
+				case u:
+					y === 0 ? (E = v.originLeft + v.originWidth / 2 - C, D = v.originBottom + this.minOffset - w) : (E = T === _ ? v.originLeft : v.originRight - this.placeholderWidth, D = v.originBottom + this.minOffset - w);
+					break;
+				case d:
+				case f:
+				case p:
+				case m:
+					y <= 1 ? (k = !0, this.mindMap.execCommand("SET_NODE_ACTIVE", this.overlapNode, !0)) : (E = v.originLeft, D = T === g ? v.originBottom + this.minOffset - w : v.originTop - this.placeholderHeight - this.minOffset + w);
+					break;
+				default:
+			}
+		} else {
+			let e = this.getNodeRect(this.overlapNode);
+			switch (T = this.getNewChildNodeDir(this.overlapNode), this.mindMap.opt.layout) {
+				case t:
+				case r:
+					E = T === _ ? e.originRight + x : e.originLeft - this.placeholderWidth - x, D = e.originTop + (e.originHeight - this.placeholderHeight) / 2;
+					break;
+				case n:
+					E = e.originLeft - this.placeholderWidth - x, D = e.originTop + (e.originHeight - this.placeholderHeight) / 2;
+					break;
+				case i:
+					O = !0, E = e.originLeft + (e.originWidth - this.placeholderHeight) / 2, D = e.originBottom + x;
+					break;
+				case a:
+					y === 0 && (O = !0), E = e.originLeft + e.originWidth * .5, D = e.originBottom + x;
+					break;
+				case o:
+					y === 0 && (O = !0), E = e.originLeft + e.originWidth * .5, D = e.originBottom + S;
+					break;
+				case s:
+					y === 0 && (O = !0), E = e.originLeft + e.originWidth * .5, D = y === 1 && T === g ? e.originTop - this.placeholderHeight - x : e.originBottom + x;
+					break;
+				case c:
+				case l:
+				case u:
+					y === 0 && (O = !0), E = T === _ ? e.originRight + x : e.originLeft - this.placeholderWidth - x, D = e.originTop + e.originHeight / 2 - w;
+					break;
+				case d:
+				case f:
+				case p:
+				case m:
+					y <= 1 ? (k = !0, this.mindMap.execCommand("SET_NODE_ACTIVE", this.overlapNode, !0)) : (E = e.originLeft + e.originWidth * .5, D = T === v ? e.originTop - this.placeholderHeight - this.minOffset + w : e.originBottom + this.minOffset - w);
+					break;
+				default:
+			}
+		}
+		k || this.setPlaceholderRect({
+			x: E,
+			y: D,
+			dir: T,
+			rotate: O
+		});
+	}
+	getNewChildNodeDir(t) {
+		let { LOGICAL_STRUCTURE: n, LOGICAL_STRUCTURE_LEFT: r, MIND_MAP: i, TIMELINE2: a, VERTICAL_TIMELINE: o, VERTICAL_TIMELINE2: s, VERTICAL_TIMELINE3: c, FISHBONE: l, FISHBONE2: u, RIGHT_FISHBONE: d, RIGHT_FISHBONE2: f } = e.LAYOUT;
+		switch (this.mindMap.opt.layout) {
+			case n: return e.LAYOUT_GROW_DIR.RIGHT;
+			case r: return e.LAYOUT_GROW_DIR.LEFT;
+			case i:
+			case a:
+			case o:
+			case s:
+			case c:
+			case l:
+			case u:
+			case d:
+			case f: return t.dir;
+			default: return "";
+		}
+	}
+	handleVerticalCheck(t, n, r = !1) {
+		let { layout: i } = this.mindMap.opt, { LAYOUT: a, LAYOUT_GROW_DIR: o } = e, { VERTICAL_TIMELINE: s, VERTICAL_TIMELINE2: c, VERTICAL_TIMELINE3: l, FISHBONE: u, FISHBONE2: d, RIGHT_FISHBONE: f, RIGHT_FISHBONE2: p } = a, { LEFT: m } = o, h = this.mouseMoveX, g = this.mouseMoveY, _ = this.getNodeRect(t), v = this.getNewChildNodeDir(t), y = t.layerIndex;
+		r && (n = n.reverse());
+		let b = _.originHeight / 4, { prevBrotherOffset: x, nextBrotherOffset: S } = this.getNodeDistanceToSiblingNode(n, t, _, "v");
+		if (_.left <= h && _.right >= h) {
+			if (!this.overlapNode && !this.prevNode && !this.nextNode && !t.isRoot) {
+				let e = S > 0 ? g > _.bottom && g <= _.bottom + S : g >= _.bottom - b && g <= _.bottom, n = x > 0 ? g < _.top && g >= _.top - x : g >= _.top && g <= _.top + b, { scaleY: a } = this.drawTransform, o = v === m ? _.originRight - this.placeholderWidth : _.originLeft, h = !1;
+				switch (i) {
+					case s:
+					case c:
+					case l:
+						y === 1 && (o = _.originLeft + _.originWidth / 2 - this.placeholderWidth / 2);
+						break;
+					case f:
+					case p:
+						o = _.originLeft + _.originWidth - this.placeholderWidth;
+						break;
+					default:
+				}
+				if (e) {
+					r ? this.nextNode = t : this.prevNode = t;
+					let e = _.originBottom + S / a - this.placeholderHeight / 2;
+					switch (i) {
+						case u:
+						case d:
+						case f:
+						case p:
+							y === 2 && (h = !0, e = _.originBottom + this.minOffset - this.placeholderHeight / 2);
+							break;
+						default:
+					}
+					this.setPlaceholderRect({
+						x: o,
+						y: e,
+						dir: v,
+						notRenderLine: h
+					});
+				} else if (n) {
+					r ? this.prevNode = t : this.nextNode = t;
+					let e = _.originTop - this.placeholderHeight - x / a + this.placeholderHeight / 2;
+					switch (i) {
+						case u:
+						case d:
+						case f:
+						case p:
+							y === 2 && (h = !0, e = _.originTop - this.placeholderHeight - this.minOffset + this.placeholderHeight / 2);
+							break;
+						default:
+					}
+					this.setPlaceholderRect({
+						x: o,
+						y: e,
+						dir: v,
+						notRenderLine: h
+					});
+				}
+			}
+			this.checkIsOverlap({
+				node: t,
+				dir: "v",
+				prevBrotherOffset: x,
+				nextBrotherOffset: S,
+				size: b,
+				pos: g,
+				nodeRect: _
+			});
+		}
+	}
+	handleHorizontalCheck(t, n) {
+		let { layout: r } = this.mindMap.opt, { LAYOUT: i } = e, { FISHBONE: a, FISHBONE2: o, RIGHT_FISHBONE: s, RIGHT_FISHBONE2: c, TIMELINE: l, TIMELINE2: u } = i, d = this.mouseMoveX, f = this.mouseMoveY, p = this.getNodeRect(t), m = p.originWidth / 4, { prevBrotherOffset: h, nextBrotherOffset: g } = this.getNodeDistanceToSiblingNode(n, t, p, "h");
+		if (p.top <= f && p.bottom >= f) {
+			if (!this.overlapNode && !this.prevNode && !this.nextNode && !t.isRoot) {
+				let e = g > 0 ? d < p.right + g && d >= p.right : d <= p.right && d >= p.right - m, n = h > 0 ? d > p.left - h && d <= p.left : d <= p.left + m && d >= p.left, { scaleX: i } = this.drawTransform, f = t.layerIndex, _ = p.originTop, v = !1;
+				switch (r) {
+					case l:
+					case u:
+						_ = p.originTop + p.originHeight / 2 - this.placeholderWidth / 2;
+						break;
+					case a:
+					case o:
+					case s:
+					case c:
+						f === 1 && (v = !0, _ = p.originTop + p.originHeight / 2 - this.placeholderWidth / 2);
+						break;
+					default:
+				}
+				e ? ([s, c].includes(r) ? this.nextNode = t : this.prevNode = t, this.setPlaceholderRect({
+					x: p.originRight + g / i - this.placeholderHeight / 2,
+					y: _,
+					rotate: !0,
+					notRenderLine: v
+				})) : n && ([s, c].includes(r) ? this.prevNode = t : this.nextNode = t, this.setPlaceholderRect({
+					x: p.originLeft - this.placeholderHeight - h / i + this.placeholderHeight / 2,
+					y: _,
+					rotate: !0,
+					notRenderLine: v
+				}));
+			}
+			this.checkIsOverlap({
+				node: t,
+				dir: "h",
+				prevBrotherOffset: h,
+				nextBrotherOffset: g,
+				size: m,
+				pos: d,
+				nodeRect: p
+			});
+		}
+	}
+	getNodeDistanceToSiblingNode(t, n, r, a) {
+		let { TOP: o, LEFT: s, BOTTOM: c, RIGHT: l } = e.LAYOUT_GROW_DIR, { scaleX: u, scaleY: d } = this.drawTransform, f = a === "v" ? o : s, p = a === "v" ? c : l, m = a === "v" ? d : u, h = this.minOffset * m, g = i(n, t), _ = null, v = null;
+		g !== -1 && (g - 1 >= 0 && (_ = t[g - 1]), g + 1 <= t.length - 1 && (v = t[g + 1]));
+		let y = 0;
+		if (_) {
+			let e = this.getNodeRect(_);
+			y = r[f] - e[p], y = y >= h ? y / 2 : 0;
+		} else y = h;
+		let b = 0;
+		return v ? (b = this.getNodeRect(v)[f] - r[p], b = b >= h ? b / 2 : 0) : b = h, {
+			prevBrother: _,
+			prevBrotherOffset: y,
+			nextBrother: v,
+			nextBrotherOffset: b
+		};
+	}
+	setPlaceholderRect({ x: e, y: t, dir: n, rotate: r, notRenderLine: i }) {
+		let a = this.placeholderWidth, o = this.placeholderHeight;
+		if (r) {
+			let e = a;
+			a = o, o = e;
+		}
+		if (this.placeholder.size(a, o).move(e, t), i) return;
+		let { dragPlaceholderLineConfig: s } = this.mindMap.opt, c = null, l = null;
+		this.overlapNode ? (c = this.overlapNode, l = this.overlapNode) : (c = this.prevNode || this.nextNode, l = c.parent), l = l.fakeClone(), c = c.fakeClone();
+		let u = this.beingDragNodeList[0].fakeClone();
+		u.dir = n, u.left = e, u.top = t, u.width = a, u.height = o, l.children = [u], l._lines = [], this.placeHolderLine.show(), this.mindMap.renderer.layout.renderLine(l, [this.placeHolderLine], (...e) => {}, c.style.getStyle("lineStyle", !0)), this.placeHolderExtraLines = [...l._lines], this.placeHolderExtraLines.forEach((e) => {
+			this.mindMap.otherDraw.add(e), e.stroke({
+				color: s.color,
+				width: s.width
+			}).fill({ color: "none" });
+		});
+	}
+	checkIsOverlap({ node: t, dir: n, prevBrotherOffset: r, nextBrotherOffset: i, size: a, pos: o, nodeRect: s }) {
+		let { TOP: c, LEFT: l, BOTTOM: u, RIGHT: d } = e.LAYOUT_GROW_DIR, f = n === "v" ? c : l, p = n === "v" ? u : d;
+		!this.overlapNode && !this.prevNode && !this.nextNode && s[f] + (r > 0 ? 0 : a) <= o && s[p] - (i > 0 ? 0 : a) >= o && (this.overlapNode = t);
+	}
+	handleLogicalStructure(e) {
+		let t = this.commonGetNodeCheckList(e);
+		this.handleVerticalCheck(e, t);
+	}
+	handleMindMap(e) {
+		let t = e.parent ? e.parent.children.filter((t) => {
+			let n = !0;
+			return e.layerIndex === 1 && (n = t.dir === e.dir), n && !this.checkIsInBeingDragNodeList(t);
+		}) : [];
+		this.handleVerticalCheck(e, t);
+	}
+	handleOrganizationStructure(e) {
+		let t = this.commonGetNodeCheckList(e);
+		this.handleHorizontalCheck(e, t);
+	}
+	handleCatalogOrganization(e) {
+		let t = this.commonGetNodeCheckList(e);
+		e.layerIndex === 1 ? this.handleHorizontalCheck(e, t) : this.handleVerticalCheck(e, t);
+	}
+	handleTimeLine(e) {
+		let t = this.commonGetNodeCheckList(e);
+		e.layerIndex === 1 ? this.handleHorizontalCheck(e, t) : this.handleVerticalCheck(e, t);
+	}
+	handleTimeLine2(t) {
+		let n = this.commonGetNodeCheckList(t);
+		t.layerIndex === 1 ? this.handleHorizontalCheck(t, n) : t.dir === e.LAYOUT_GROW_DIR.TOP && t.layerIndex === 2 ? this.handleVerticalCheck(t, n, !0) : this.handleVerticalCheck(t, n);
+	}
+	handleFishbone(t) {
+		let n = t.parent ? t.parent.children.filter((e) => e.layerIndex > 1 && !this.checkIsInBeingDragNodeList(e)) : [];
+		if (t.layerIndex === 1) this.handleHorizontalCheck(t, n);
+		else {
+			let r = t.dir === e.LAYOUT_GROW_DIR.TOP && t.layerIndex === 2, i = t.dir === e.LAYOUT_GROW_DIR.BOTTOM && t.layerIndex >= 3;
+			r || i ? this.handleVerticalCheck(t, n, !0) : this.handleVerticalCheck(t, n);
+		}
+	}
+	commonGetNodeCheckList(e) {
+		return e.parent ? [...e.parent.children].filter((e) => !this.checkIsInBeingDragNodeList(e)) : [];
+	}
+	getNodeRect(e) {
+		let { scaleX: t, scaleY: n, translateX: r, translateY: i } = this.drawTransform, { left: a, top: o, width: s, height: c } = e, l = s, u = c, d = a, f = o, p = o + c, m = a + s, h = (a + s) * t + r, g = (o + c) * n + i;
+		return a = a * t + r, o = o * n + i, {
+			left: a,
+			top: o,
+			right: h,
+			bottom: g,
+			originWidth: l,
+			originHeight: u,
+			originLeft: d,
+			originTop: f,
+			originBottom: p,
+			originRight: m
+		};
+	}
+	checkIsInBeingDragNodeList(e) {
+		return !!this.beingDragNodeList.find((t) => t.uid === e.uid || t.isAncestor(e));
+	}
+	beforePluginRemove() {
+		this.unBindEvent();
+	}
+	beforePluginDestroy() {
+		this.unBindEvent();
+	}
+};
+c.instanceName = "drag";
+//#endregion
+export { c as default };