@unicom-cloud/ui 0.8.167 → 0.8.169

package/draw/element/linearElementEditor.js

@@ -0,0 +1,602 @@
+/* 潘启宝 2026-06-25 08:58:50 星期四 山东省济南市 */
+import { KEYS as e, shouldRotateWithDiscreteAngle as t } from "../common/keys.js";
+import { vectorFromPoint as n } from "../libs/math/vector.js";
+import { pointCenter as r, pointDistance as i, pointFrom as a, pointRotateRads as o, pointsEqual as s } from "../libs/math/point.js";
+import { curveLength as c, curvePointAtLength as l } from "../libs/math/curve.js";
+import { lineSegment as u } from "../libs/math/segment.js";
+import "../libs/math/index.js";
+import { getGridPoint as d } from "../common/points.js";
+import { getFeatureFlag as f, invariant as p, isShallowEqual as m } from "../common/utils.js";
+import "../common/index.js";
+import { getCurvePathOps as h } from "../utils/shape.js";
+import { headingIsHorizontal as g, vectorToHeading as _ } from "./heading.js";
+import { isArrowElement as v, isBindingElement as y, isElbowArrow as b, isLineElement as x } from "./typeChecks.js";
+import { getBoundTextElement as S, handleBindTextResize as C } from "./textElement.js";
+import { mutateElement as w } from "./mutateElement.js";
+import { ShapeCache as T, toggleLinePolygonState as E } from "./shape.js";
+import { deconstructLinearOrFreeDrawElement as D, isPathALoop as O, projectFixedPointOntoDiagonal as k } from "./utils.js";
+import { calculateFixedPointForNonElbowArrowBinding as A, getBindingStrategyForDraggingBindingElementEndpoints as j, isBindingEnabled as M, updateBoundPoint as N } from "./binding.js";
+import { moveArrowAboveBindable as P } from "./zindex.js";
+import { getElementAbsoluteCoords as F, getElementPointsCoords as I, getMinMaxXYFromCurvePathOps as L } from "./bounds.js";
+import { getLockedLinearCursorAlignSize as R } from "./sizeHelpers.js";
+//#region components/pc/draw/element/linearElementEditor.ts
+var z = ({ points: e }) => {
+	let t = e[0][0], n = e[0][1];
+	return {
+		points: e.map((e) => a(e[0] - t, e[1] - n)),
+		offsetX: t,
+		offsetY: n
+	};
+}, B = class u {
+	constructor(e, t, n = !1) {
+		this.elementId = e.id, s(e.points[0], a(0, 0)) || (console.error("Linear element is not normalized", Error().stack), w(e, t, u.getNormalizeElementPointsAndCoords(e))), this.selectedPointsIndices = null, this.lastUncommittedPoint = null, this.lastCommittedPoint = null, this.isDragging = !1, this.pointerOffset = {
+			x: 0,
+			y: 0
+		}, this.initialState = {
+			prevSelectedPointsIndices: null,
+			lastClickedPoint: -1,
+			origin: null,
+			segmentMidpoint: {
+				value: null,
+				index: null,
+				added: !1
+			},
+			arrowStartIsInside: !1,
+			altFocusPoint: null
+		}, this.hoverPointIndex = -1, this.segmentMidPointHoveredCoords = null, this.hoveredFocusPointBinding = null, this.draggedFocusPointBinding = null, this.elbowed = b(e) && e.elbowed, this.customLineAngle = null, this.isEditing = n;
+	}
+	static {
+		this.POINT_HANDLE_SIZE = 10;
+	}
+	static getElement(e, t) {
+		return t.get(e) || null;
+	}
+	static handleBoxSelection(e, t, n, r) {
+		if (!t.selectedLinearElement?.isEditing || !t.selectionElement) return !1;
+		let { selectedLinearElement: i } = t, { selectedPointsIndices: a, elementId: o } = i, s = u.getElement(o, r);
+		if (!s) return !1;
+		let [c, l, d, f] = F(t.selectionElement, r), p = u.getPointsGlobalCoordinates(s, r).reduce((t, n, r) => ((n[0] >= c && n[0] <= d && n[1] >= l && n[1] <= f || e.shiftKey && a?.includes?.(r)) && t.push(r), t), []).filter((e) => !(b(s) && e !== 0 && e !== s.points.length - 1));
+		n({ selectedLinearElement: {
+			...i,
+			selectedPointsIndices: p.length ? p : null
+		} });
+	}
+	static handlePointerMove(n, r, i, o, s) {
+		let c = r.scene.getNonDeletedElementsMap(), l = r.scene.getNonDeletedElements(), { elementId: d } = s, f = u.getElement(d, c);
+		p(f, "Element being dragged must exist in the scene"), p(f.points.length > 1, "Element must have at least 2 points");
+		let h = f.points.length - 1, g = f.points[h], _ = f.points[h - 1], v = s.customLineAngle ?? U(_, f.points[h]), b = 0, x = 0;
+		if (t(n)) {
+			let [t, s] = u.#t(f, c, _, a(i, o), n[e.CTRL_OR_CMD] ? null : r.getEffectiveGridSize(), v), l = a(t + _[0], s + _[1]);
+			b = l[0] - g[0], x = l[1] - g[1];
+		} else {
+			let t = u.createPointAt(f, c, i - s.pointerOffset.x, o - s.pointerOffset.y, n[e.CTRL_OR_CMD] ? null : r.getEffectiveGridSize());
+			b = t[0] - g[0], x = t[1] - g[1];
+		}
+		let S = null, { positions: C, updates: w } = H([h], b, x, i, o, c, f, l, r, t(n), n.altKey);
+		if (u.movePoints(f, r.scene, C, {
+			startBinding: w?.startBinding,
+			endBinding: w?.endBinding,
+			moveMidPointsWithElement: w?.moveMidPointsWithElement
+		}), y(f, !1) && M(r.state) && (S = w?.suggestedBinding ?? null), y(f) && P(u.getPointGlobalCoordinates(f, f.points[f.points.length - 1], c), f, l, c, r.scene), r.state.selectedLinearElement?.customLineAngle === v && s.initialState.altFocusPoint && (!S || m(r.state.suggestedBinding ?? [], S))) return null;
+		let T = y(f) && f.startBinding && c.get(f.startBinding.elementId);
+		return {
+			selectedLinearElement: {
+				...s,
+				customLineAngle: v,
+				initialState: {
+					...s.initialState,
+					altFocusPoint: !s.initialState.altFocusPoint && T && w?.suggestedBinding?.id !== T.id ? k(f, a(f.x, f.y), T, "start", c) : s.initialState.altFocusPoint
+				}
+			},
+			suggestedBinding: S
+		};
+	}
+	static handlePointDragging(n, r, i, o, s) {
+		let c = r.scene.getNonDeletedElementsMap(), l = r.scene.getNonDeletedElements(), { elbowed: d, elementId: f, initialState: m } = s, h = Array.from(s.selectedPointsIndices ?? []), { lastClickedPoint: g } = m, _ = u.getElement(f, c);
+		p(_, "Element being dragged must exist in the scene"), p(_.points.length > 1, "Element must have at least 2 points"), p(h, "There must be selected points in order to drag them"), d && h.some((e, t) => e > 0 && e !== _.points.length - 1 ? (h[t] = _.points.length - 1, g = _.points.length - 1, !0) : !1), p(g > -1 && h.includes(g) && _.points[g], `There must be a valid lastClickedPoint in order to drag it. selectedPointsIndices(${JSON.stringify(h)}) points(0..${_.points.length - 1}) lastClickedPoint(${g})`);
+		let v = _.points[g], b = _.points[g === 0 ? 1 : g - 1], x = h.length === 1, w = s.customLineAngle ?? U(b, _.points[g]), T = h.includes(0), E = h.includes(_.points.length - 1), D = 0, O = 0;
+		if (t(n) && x) {
+			let [t, s] = u.#t(_, c, b, a(i, o), n[e.CTRL_OR_CMD] ? null : r.getEffectiveGridSize(), w), l = a(t + b[0], s + b[1]);
+			D = l[0] - v[0], O = l[1] - v[1];
+		} else {
+			let t = u.createPointAt(_, c, i - s.pointerOffset.x, o - s.pointerOffset.y, n[e.CTRL_OR_CMD] ? null : r.getEffectiveGridSize());
+			D = t[0] - v[0], O = t[1] - v[1];
+		}
+		let A = null, { positions: j, updates: N } = H(h, D, O, i, o, c, _, l, r, t(n) && x, n.altKey);
+		u.movePoints(_, r.scene, j, {
+			startBinding: N?.startBinding,
+			endBinding: N?.endBinding,
+			moveMidPointsWithElement: N?.moveMidPointsWithElement
+		}), y(_, !1) && M(r.state) && (T || E) && (A = N?.suggestedBinding ?? null), y(_) && T !== E && P(u.getPointGlobalCoordinates(_, T ? _.points[0] : _.points[_.points.length - 1], c), _, l, c, r.scene), S(_, c) && C(_, r.scene, !1);
+		let F = d ? E ? [_.points.length - 1] : [0] : h, I = d ? F[0] : g, L = !T && !E ? u.getPointGlobalCoordinates(_, v, c) : null, R = I, z = y(_) && _.startBinding && c.get(_.startBinding.elementId), B = y(_) && _.endBinding && c.get(_.endBinding.elementId), V = E && z && N?.suggestedBinding?.id !== z.id ? z : T && B && N?.suggestedBinding?.id !== B.id ? B : null;
+		return {
+			selectedLinearElement: {
+				...s,
+				selectedPointsIndices: F,
+				initialState: {
+					...s.initialState,
+					lastClickedPoint: I,
+					altFocusPoint: !s.initialState.altFocusPoint && y(_) && V ? k(_, a(_.x, _.y), V, "start", c) : s.initialState.altFocusPoint
+				},
+				segmentMidPointHoveredCoords: L,
+				hoverPointIndex: R,
+				isDragging: !0,
+				customLineAngle: w
+			},
+			suggestedBinding: A
+		};
+	}
+	static handlePointerUp(e, t, n, r) {
+		let i = r.getNonDeletedElementsMap(), { elementId: a, selectedPointsIndices: o, isDragging: s, initialState: c } = t, l = u.getElement(a, i);
+		if (!l) return t;
+		if (s && o) for (let e of o) (e === 0 || e === l.points.length - 1) && O(l.points, n.zoom.value) && (x(l) && r.mutateElement(l, { ...E(l, !0) }, {
+			informMutation: !1,
+			isDragging: !1
+		}), u.movePoints(l, r, /* @__PURE__ */ new Map([[e, { point: e === 0 ? l.points[l.points.length - 1] : l.points[0] }]])));
+		return {
+			...t,
+			segmentMidPointHoveredCoords: null,
+			hoverPointIndex: -1,
+			selectedPointsIndices: s || e.shiftKey ? !s && e.shiftKey && c.prevSelectedPointsIndices?.includes?.(c.lastClickedPoint) ? o && o.filter((e) => e !== c.lastClickedPoint) : o : o?.includes?.(c.lastClickedPoint) ? [c.lastClickedPoint] : o,
+			isDragging: !1,
+			customLineAngle: null,
+			initialState: {
+				...t.initialState,
+				origin: null,
+				arrowStartIsInside: !1
+			}
+		};
+	}
+	static {
+		this.getEditorMidPoints = (e, t, n) => {
+			let r = S(e, t);
+			if (!b(e) && !n.selectedLinearElement?.isEditing && e.points.length > 2 && !r) return [];
+			let i = u.getPointsGlobalCoordinates(e, t), a = 0, o = [];
+			for (; a < i.length - 1;) {
+				if (u.isSegmentTooShort(e, e.points[a], e.points[a + 1], a, n.zoom)) {
+					o.push(null), a++;
+					continue;
+				}
+				let t = u.getSegmentMidPoint(e, a + 1);
+				o.push(t), a++;
+			}
+			return o;
+		};
+	}
+	static {
+		this.getSegmentMidpointHitCoords = (e, t, n, r) => {
+			let { elementId: o } = e, s = u.getElement(o, r);
+			if (!s) return null;
+			let c = u.getPointIndexUnderCursor(s, r, n.zoom, t.x, t.y);
+			if (!b(s) && c >= 0 || u.getPointsGlobalCoordinates(s, r).length >= 3 && !n.selectedLinearElement?.isEditing && !b(s)) return null;
+			let l = (u.POINT_HANDLE_SIZE + 1) / n.zoom.value, d = e.segmentMidPointHoveredCoords;
+			if (d && i(a(d[0], d[1]), a(t.x, t.y)) <= l) return d;
+			let f = 0, p = u.getEditorMidPoints(s, r, n);
+			for (; f < p.length;) {
+				if (p[f] !== null && i(p[f], a(t.x, t.y)) <= l) return p[f];
+				f++;
+			}
+			return null;
+		};
+	}
+	static isSegmentTooShort(e, t, n, r, a) {
+		if (b(e)) return r >= 0 && r < e.points.length ? i(t, n) * a.value < u.POINT_HANDLE_SIZE / 2 : !1;
+		let o = i(t, n);
+		if (e.points.length > 2 && e.roundness) {
+			let [t, n] = D(e);
+			p(t.length === 0 && n.length > 0, "Only linears built out of curves are supported"), p(t.length + n.length >= r, "Invalid segment index while calculating mid point"), o = c(n[r]);
+		}
+		return o * a.value < u.POINT_HANDLE_SIZE * 4;
+	}
+	static getSegmentMidPoint(e, t) {
+		if (b(e)) {
+			p(e.points.length >= t, "Invalid segment index while calculating elbow arrow mid point");
+			let n = r(e.points[t - 1], e.points[t]);
+			return a(e.x + n[0], e.y + n[1]);
+		}
+		let [n, i] = D(e);
+		if (p(n.length === 0 && i.length > 0 || n.length > 0 && i.length === 0, "Only linears built out of either segments or curves are supported"), p(n.length + i.length >= t, "Invalid segment index while calculating mid point"), n.length) {
+			let e = n[t - 1];
+			return r(e[0], e[1]);
+		}
+		if (i.length) {
+			let e = i[t - 1];
+			return l(e, .5);
+		}
+		p(!1, "Invalid segment type while calculating mid point");
+	}
+	static getSegmentMidPointIndex(e, t, n, r) {
+		let i = u.getElement(e.elementId, r);
+		if (!i) return -1;
+		let a = u.getEditorMidPoints(i, r, t), o = 0;
+		for (; o < a.length;) {
+			if (u.arePointsEqual(n, a[o])) return o + 1;
+			o++;
+		}
+		return -1;
+	}
+	static handlePointerDown(t, n, r, i, s, c) {
+		let l = n.state, d = c.getNonDeletedElementsMap(), f = {
+			didAddPoint: !1,
+			hitElement: null,
+			linearElementEditor: null
+		};
+		if (!s) return f;
+		let { elementId: p } = s, m = u.getElement(p, d);
+		if (!m) return f;
+		let h = u.getSegmentMidpointHitCoords(s, i, l, d), g = a(i.x, i.y), _ = null;
+		if (h) _ = u.getSegmentMidPointIndex(s, l, h, d);
+		else if (t.altKey && l.selectedLinearElement?.isEditing) return s.lastUncommittedPoint ?? (c.mutateElement(m, { points: [...m.points, u.createPointAt(m, d, i.x, i.y, t[e.CTRL_OR_CMD] ? null : n.getEffectiveGridSize())] }), f.didAddPoint = !0), r.scheduleCapture(), f.linearElementEditor = {
+			...s,
+			initialState: {
+				prevSelectedPointsIndices: s.selectedPointsIndices,
+				lastClickedPoint: -1,
+				origin: g,
+				segmentMidpoint: {
+					value: h,
+					index: _,
+					added: !1
+				},
+				arrowStartIsInside: !!n.state.newElement && (n.state.bindMode === "inside" || n.state.bindMode === "skip"),
+				altFocusPoint: null
+			},
+			selectedPointsIndices: [m.points.length - 1],
+			lastUncommittedPoint: null
+		}, f.didAddPoint = !0, f;
+		let v = u.getPointIndexUnderCursor(m, d, l.zoom, i.x, i.y);
+		(v >= 0 || h) && (f.hitElement = m);
+		let [y, b, x, S] = F(m, d), C = (y + x) / 2, w = (b + S) / 2, T = v > -1 && o(a(m.x + m.points[v][0], m.y + m.points[v][1]), a(C, w), m.angle), E = v > -1 || t.shiftKey ? t.shiftKey || s.selectedPointsIndices?.includes?.(v) ? V([...s.selectedPointsIndices || [], v]) : [v] : null;
+		return f.linearElementEditor = {
+			...s,
+			initialState: {
+				prevSelectedPointsIndices: s.selectedPointsIndices,
+				lastClickedPoint: v,
+				origin: g,
+				segmentMidpoint: {
+					value: h,
+					index: _,
+					added: !1
+				},
+				arrowStartIsInside: !!n.state.newElement && (n.state.bindMode === "inside" || n.state.bindMode === "skip"),
+				altFocusPoint: null
+			},
+			selectedPointsIndices: E,
+			pointerOffset: T ? {
+				x: i.x - T[0],
+				y: i.y - T[1]
+			} : {
+				x: 0,
+				y: 0
+			}
+		}, f;
+	}
+	static arePointsEqual(e, t) {
+		return !e && !t ? !0 : !e || !t ? !1 : s(e, t);
+	}
+	static handlePointerMoveInEditMode(n, r, i, o) {
+		let s = o.state;
+		if (!s.selectedLinearElement?.isEditing) return null;
+		let { elementId: c, lastUncommittedPoint: l } = s.selectedLinearElement, d = o.scene.getNonDeletedElementsMap(), f = u.getElement(c, d);
+		if (!f) return s.selectedLinearElement;
+		let { points: p } = f, m = p[p.length - 1];
+		if (!n.altKey) return m === l && u.deletePoints(f, o, [p.length - 1]), s.selectedLinearElement?.lastUncommittedPoint ? {
+			...s.selectedLinearElement,
+			lastUncommittedPoint: null
+		} : s.selectedLinearElement;
+		let h;
+		if (t(n) && p.length >= 2) {
+			let t = p[p.length - 2], [s, c] = u.#t(f, d, t, a(r, i), n[e.CTRL_OR_CMD] ? null : o.getEffectiveGridSize());
+			h = a(s + t[0], c + t[1]);
+		} else h = u.createPointAt(f, d, r - s.selectedLinearElement.pointerOffset.x, i - s.selectedLinearElement.pointerOffset.y, n[e.CTRL_OR_CMD] || b(f) ? null : o.getEffectiveGridSize());
+		return m === l ? u.movePoints(f, o.scene, /* @__PURE__ */ new Map([[f.points.length - 1, { point: h }]])) : u.addPoints(f, o.scene, [h]), {
+			...s.selectedLinearElement,
+			lastUncommittedPoint: f.points[f.points.length - 1]
+		};
+	}
+	static getPointGlobalCoordinates(e, t, n) {
+		let [r, i, s, c] = F(e, n), l = (r + s) / 2, u = (i + c) / 2, { x: d, y: f } = e;
+		return o(a(d + t[0], f + t[1]), a(l, u), e.angle);
+	}
+	static getPointsGlobalCoordinates(e, t) {
+		let [n, r, i, s] = F(e, t), c = (n + i) / 2, l = (r + s) / 2;
+		return e.points.map((t) => {
+			let { x: n, y: r } = e;
+			return o(a(n + t[0], r + t[1]), a(c, l), e.angle);
+		});
+	}
+	static getPointAtIndexGlobalCoordinates(e, t, n) {
+		let r = t < 0 ? e.points.length + t : t, [, , , , i, s] = F(e, n), c = a(i, s), l = e.points[r], { x: u, y: d } = e;
+		return o(l ? a(u + l[0], d + l[1]) : a(u, d), c, e.angle);
+	}
+	static pointFromAbsoluteCoords(e, t, n) {
+		if (b(e)) return a(t[0] - e.x, t[1] - e.y);
+		let [r, i, s, c] = F(e, n), l = (r + s) / 2, u = (i + c) / 2, [d, f] = o(a(t[0], t[1]), a(l, u), -e.angle);
+		return a(d - e.x, f - e.y);
+	}
+	static getPointIndexUnderCursor(e, t, n, r, o) {
+		let s = u.getPointsGlobalCoordinates(e, t), c = s.length;
+		for (; --c > -1;) {
+			let e = s[c];
+			if (i(a(r, o), a(e[0], e[1])) * n.value < u.POINT_HANDLE_SIZE + 1) return c;
+		}
+		return -1;
+	}
+	static createPointAt(e, t, n, r, i) {
+		let s = d(n, r, i), [c, l, u, f] = F(e, t), p = (c + u) / 2, m = (l + f) / 2, [h, g] = o(a(s[0], s[1]), a(p, m), -e.angle);
+		return a(h - e.x, g - e.y);
+	}
+	static getNormalizeElementPointsAndCoords(e) {
+		let { points: t, offsetX: n, offsetY: r } = z(e);
+		return {
+			points: t,
+			x: e.x + n,
+			y: e.y + r
+		};
+	}
+	static duplicateSelectedPoints(e, t) {
+		p(e.selectedLinearElement?.isEditing, "Not currently editing a linear element");
+		let n = t.getNonDeletedElementsMap(), { selectedPointsIndices: r, elementId: i } = e.selectedLinearElement, o = u.getElement(i, n);
+		p(o, "The linear element does not exist in the provided Scene"), p(r != null, "There are no selected points to duplicate");
+		let { points: s } = o, c = [], l = !1, d = -1, f = s.reduce((e, t, n) => {
+			if (++d, e.push(t), r.includes(n)) {
+				let r = s[n + 1];
+				r || (l = !0), e.push(r ? a((t[0] + r[0]) / 2, (t[1] + r[1]) / 2) : a(t[0], t[1])), c.push(d + 1), ++d;
+			}
+			return e;
+		}, []);
+		if (t.mutateElement(o, { points: f }), l) {
+			let e = o.points[o.points.length - 1];
+			u.movePoints(o, t, /* @__PURE__ */ new Map([[o.points.length - 1, { point: a(e[0] + 30, e[1] + 30) }]]));
+		}
+		return {
+			...e,
+			selectedLinearElement: {
+				...e.selectedLinearElement,
+				selectedPointsIndices: c
+			}
+		};
+	}
+	static deletePoints(e, t, n) {
+		let r = t.state.selectedLinearElement?.isEditing && t.state.selectedLinearElement?.lastUncommittedPoint === e.points[e.points.length - 1], i = e.points.filter((e, t) => !n.includes(t));
+		x(e) && e.polygon && (r || n.includes(0) || n.includes(e.points.length - 1)) && (i[0] = a(i[i.length - 1][0], i[i.length - 1][1]));
+		let { points: o, offsetX: s, offsetY: c } = z({ points: i });
+		u.#e(e, t.scene, o, s, c);
+	}
+	static addPoints(e, t, n) {
+		let r = [...e.points, ...n];
+		x(e) && e.polygon && (r[0] = a(r[r.length - 1][0], r[r.length - 1][1]));
+		let { points: i, offsetX: o, offsetY: s } = z({ points: r });
+		u.#e(e, t, i, o, s);
+	}
+	static movePoints(e, t, n, r) {
+		let { points: i } = e;
+		if (x(e) && e.polygon) {
+			let e = n.get(0), t = n.get(i.length - 1);
+			e ? n.set(i.length - 1, {
+				point: a(e.point[0], e.point[1]),
+				isDragging: e.isDragging
+			}) : t && n.set(0, {
+				point: a(t.point[0], t.point[1]),
+				isDragging: t.isDragging
+			});
+		}
+		let [o, s] = n.get(0)?.point ?? a(0, 0), c = b(e) ? [n.get(0)?.point ?? i[0], n.get(i.length - 1)?.point ?? i[i.length - 1]] : i.map((e, t) => {
+			let c = n.get(t)?.point ?? e;
+			return r?.moveMidPointsWithElement && t !== 0 && t !== i.length - 1 && !n.has(t) ? c : a(c[0] - o, c[1] - s);
+		});
+		u.#e(e, t, c, o, s, r, { isDragging: Array.from(n.values()).some((e) => e.isDragging) });
+	}
+	static shouldAddMidpoint(e, t, n, r) {
+		let o = u.getElement(e.elementId, r);
+		if (o && b(o) || !o) return !1;
+		let { segmentMidpoint: s } = e.initialState;
+		if (s.added || s.value === null || s.index === null || e.initialState.origin === null) return !1;
+		let c = e.initialState.origin, l = i(c, a(t.x, t.y));
+		return !(!n.selectedLinearElement?.isEditing && l < 10 / n.zoom.value);
+	}
+	static addMidpoint(e, t, n, r, i) {
+		let a = i.getNonDeletedElementsMap(), o = u.getElement(e.elementId, a);
+		if (!o) return;
+		let { segmentMidpoint: s } = e.initialState, c = {
+			pointerDownState: e.initialState,
+			selectedPointsIndices: e.selectedPointsIndices
+		}, l = u.createPointAt(o, a, t.x, t.y, r && !b(o) ? n.getEffectiveGridSize() : null), d = [
+			...o.points.slice(0, s.index),
+			l,
+			...o.points.slice(s.index)
+		];
+		return i.mutateElement(o, { points: d }), c.pointerDownState = {
+			...e.initialState,
+			segmentMidpoint: {
+				...e.initialState.segmentMidpoint,
+				added: !0
+			},
+			lastClickedPoint: s.index
+		}, c.selectedPointsIndices = [s.index], c;
+	}
+	static #e(e, t, n, r, i, s, c) {
+		if (b(e)) {
+			let r = {};
+			s?.startBinding !== void 0 && (r.startBinding = s.startBinding), s?.endBinding !== void 0 && (r.endBinding = s.endBinding), r.points = Array.from(n), t.mutateElement(e, r, {
+				informMutation: !0,
+				isDragging: c?.isDragging ?? !1
+			});
+		} else {
+			let c = I(e, n), l = I(e, e.points), u = (c[0] + c[2]) / 2, d = (c[1] + c[3]) / 2, f = (l[0] + l[2]) / 2, p = (l[1] + l[3]) / 2, m = f - u, h = p - d, g = o(a(r, i), a(m, h), e.angle);
+			t.mutateElement(e, {
+				...s,
+				points: n,
+				x: e.x + g[0],
+				y: e.y + g[1]
+			});
+		}
+	}
+	static #t(e, t, n, r, i, s) {
+		let c = u.getPointGlobalCoordinates(e, n, t);
+		if (b(e)) return [r[0] - c[0], r[1] - c[1]];
+		let [l, f] = d(r[0], r[1], i), { width: p, height: m } = R(c[0], c[1], l, f, s);
+		return o(a(p, m), a(0, 0), -e.angle);
+	}
+	static {
+		this.getBoundTextElementPosition = (e, t, n) => {
+			u.getPointsGlobalCoordinates(e, n).length < 2 && w(t, n, { isDeleted: !0 });
+			let r = 0, i = 0;
+			if (e.points.length % 2 == 1) {
+				let a = Math.floor(e.points.length / 2), o = u.getPointGlobalCoordinates(e, e.points[a], n);
+				r = o[0] - t.width / 2, i = o[1] - t.height / 2;
+			} else {
+				let n = e.points.length / 2 - 1, a = u.getSegmentMidPoint(e, n + 1);
+				r = a[0] - t.width / 2, i = a[1] - t.height / 2;
+			}
+			return {
+				x: r,
+				y: i
+			};
+		};
+	}
+	static {
+		this.getMinMaxXYWithBoundText = (e, t, n, r) => {
+			let [i, s, c, l] = n, d = (i + c) / 2, f = (s + l) / 2, { x: p, y: m } = u.getBoundTextElementPosition(e, r, t), h = p + r.width, g = m + r.height, _ = a(d, f), v = o(a(i, s), _, e.angle), y = o(a(c, s), _, e.angle), b = o(a(p, m), _, -e.angle), x = o(a(h, m), _, -e.angle), S = o(a(p, g), _, -e.angle), C = o(a(h, g), _, -e.angle);
+			return v[0] < y[0] && v[1] >= y[1] ? (i = Math.min(i, S[0]), c = Math.max(c, Math.max(x[0], C[0])), s = Math.min(s, b[1]), l = Math.max(l, C[1])) : v[0] >= y[0] && v[1] > y[1] ? (i = Math.min(i, C[0]), c = Math.max(c, Math.max(b[0], x[0])), s = Math.min(s, S[1]), l = Math.max(l, x[1])) : v[0] >= y[0] ? (i = Math.min(i, x[0]), c = Math.max(c, S[0]), s = Math.min(s, C[1]), l = Math.max(l, b[1])) : v[1] <= y[1] && (i = Math.min(i, Math.min(x[0], b[0])), c = Math.max(c, C[0]), s = Math.min(s, x[1]), l = Math.max(l, S[1])), [
+				i,
+				s,
+				c,
+				l,
+				d,
+				f
+			];
+		};
+	}
+	static {
+		this.getElementAbsoluteCoords = (e, t, n = !1) => {
+			let [r, i, a, o] = L(h(T.generateElementShape(e, null)[0])), s = r + e.x, c = i + e.y, l = a + e.x, d = o + e.y, f = (s + l) / 2, p = (c + d) / 2, m = n && S(e, t);
+			return m ? u.getMinMaxXYWithBoundText(e, t, [
+				s,
+				c,
+				l,
+				d
+			], m) : [
+				s,
+				c,
+				l,
+				d,
+				f,
+				p
+			];
+		};
+	}
+	static moveFixedSegment(e, t, r, i, o) {
+		let s = o.getNonDeletedElementsMap(), c = u.getElement(e.elementId, s);
+		if (!c || !b(c)) return e;
+		if (t && t > 0 && t < c.points.length) {
+			let s = g(_(n(c.points[t], c.points[t - 1]))), l = (c.fixedSegments ?? []).reduce((e, t) => (e[t.index] = t, e), {});
+			l[t] = {
+				index: t,
+				start: a(s ? c.points[t - 1][0] : r - c.x, s ? i - c.y : c.points[t - 1][1]),
+				end: a(s ? c.points[t][0] : r - c.x, s ? i - c.y : c.points[t][1])
+			};
+			let u = Object.values(l).sort((e, t) => e.index - t.index), d = u.map((e) => e.index).reduce((e, n) => n < t ? e + 1 : e, 0);
+			o.mutateElement(c, { fixedSegments: u });
+			let f = a(c.x + (c.fixedSegments[d].start[0] + c.fixedSegments[d].end[0]) / 2, c.y + (c.fixedSegments[d].start[1] + c.fixedSegments[d].end[1]) / 2);
+			return {
+				...e,
+				segmentMidPointHoveredCoords: f,
+				initialState: {
+					...e.initialState,
+					segmentMidpoint: {
+						added: !1,
+						index: c.fixedSegments[d].index,
+						value: f
+					}
+				}
+			};
+		}
+		return e;
+	}
+	static deleteFixedSegment(e, t, n) {
+		t.mutateElement(e, { fixedSegments: e.fixedSegments?.filter?.((e) => e.index !== n) });
+	}
+}, V = (e) => {
+	let t = [...new Set(e.filter((e) => e !== null && e !== -1))];
+	return t = t.sort((e, t) => e - t), t.length ? t : null;
+}, H = (e, t, n, r, o, s, c, l, d, p, m) => {
+	let h = new Map(e.map((e) => [e, {
+		point: a(c.points[e][0] + t, c.points[e][1] + n),
+		isDragging: !0
+	}]));
+	if (!v(c)) return { positions: h };
+	let g = e.includes(0), _ = e.includes(c.points.length - 1), { start: y, end: x } = j(c, h, r, o, s, l, d.state, {
+		newArrow: !!d.state.newElement,
+		angleLocked: p,
+		altKey: m
+	});
+	if (b(c)) return {
+		positions: h,
+		updates: { suggestedBinding: g ? y.element : _ ? x.element : null }
+	};
+	if (!g && !_) {
+		let e = {
+			...c,
+			points: c.points.map((e, t) => h.get(t)?.point ?? e)
+		}, t = new Map(h);
+		if (c.startBinding) {
+			let n = s.get(c.startBinding.elementId);
+			if (n) {
+				let r = N(e, "startBinding", c.startBinding, n, s) ?? null;
+				r && t.set(0, {
+					point: r,
+					isDragging: !0
+				});
+			}
+		}
+		if (c.endBinding) {
+			let n = s.get(c.endBinding.elementId);
+			if (n) {
+				let r = N(e, "endBinding", c.endBinding, n, s) ?? null;
+				r && t.set(c.points.length - 1, {
+					point: r,
+					isDragging: !0
+				});
+			}
+		}
+		return { positions: t };
+	}
+	if (g === _) return { positions: h };
+	let S = { suggestedBinding: null };
+	y.mode === null ? S.startBinding = null : y.mode ? (S.startBinding = {
+		elementId: y.element.id,
+		mode: y.mode,
+		...A(c, y.element, "start", s, y.focusPoint)
+	}, g && (S.startBinding.mode === "orbit" || !f("COMPLEX_BINDINGS")) && (S.suggestedBinding = y.element)) : g && (S.suggestedBinding = d.state.suggestedBinding), x.mode === null ? S.endBinding = null : x.mode ? (S.endBinding = {
+		elementId: x.element.id,
+		mode: x.mode,
+		...A(c, x.element, "end", s, x.focusPoint)
+	}, _ && (S.endBinding.mode === "orbit" || !f("COMPLEX_BINDINGS")) && (S.suggestedBinding = x.element)) : _ && (S.suggestedBinding = d.state.suggestedBinding);
+	let C = g ? a(c.points[0][0] + t, c.points[0][1] + n) : c.points[0], w = _ ? a(c.points[c.points.length - 1][0] + t, c.points[c.points.length - 1][1] + n) : c.points[c.points.length - 1], T = {
+		...c,
+		points: [
+			C,
+			...c.points.slice(1, -1),
+			w
+		],
+		startBinding: S.startBinding === void 0 ? c.startBinding : S.startBinding === null ? null : S.startBinding,
+		endBinding: S.endBinding === void 0 ? c.endBinding : S.endBinding === null ? null : S.endBinding
+	}, E = y.focusPoint && x.focusPoint ? u(y.focusPoint, x.focusPoint) : void 0, D = y.focusPoint && x.focusPoint ? u(x.focusPoint, y.focusPoint) : void 0, O = c.endBinding && T.startBinding && g && T.startBinding.elementId === c.endBinding.elementId, k = c.startBinding && T.endBinding && _ && c.startBinding.elementId === T.endBinding.elementId, M = T.endBinding ? x.element ?? s.get(T.endBinding.elementId) : null, P = O ? T.points[T.points.length - 1] : k && d.state.bindMode !== "inside" && f("COMPLEX_BINDINGS") ? T.points[0] : M && N(c, "endBinding", T.endBinding, M, s, { customIntersector: D }) || T.points[T.points.length - 1];
+	T.points[T.points.length - 1] = P;
+	let F = T.startBinding ? y.element ?? s.get(T.startBinding.elementId) : null, I = k && f("COMPLEX_BINDINGS") ? T.points[0] : O && d.state.bindMode !== "inside" && f("COMPLEX_BINDINGS") ? P : F && N(c, "startBinding", T.startBinding, F, s, { customIntersector: E }) || T.points[0], L = !O && !(k && d.state.bindMode !== "inside" && f("COMPLEX_BINDINGS")) && !!M, R = i(I, T.points[0]) !== 0, z = new Set(e);
+	F && R && z.add(0), M && L && z.add(c.points.length - 1);
+	let B = Array.from(z);
+	return {
+		updates: S,
+		positions: new Map(B.map((e) => [e, e === 0 ? {
+			point: I,
+			isDragging: !0
+		} : e === c.points.length - 1 ? {
+			point: P,
+			isDragging: !0
+		} : h.get(e)]))
+	};
+}, U = (e, t) => Math.atan2(t[1] - e[1], t[0] - e[0]);
+//#endregion
+export { B as LinearElementEditor };
+/* 独立思考，明辨是非 */

package/draw/element/mutateElement.d.ts

@@ -0,0 +1,23 @@
+import type { Mutable } from '../common/utility-types';
+import type { DrawElement, ElementsMap } from './types';
+export type ElementUpdate<TElement extends DrawElement> = Omit<Partial<TElement>, 'id' | 'updated'>;
+/**
+ * This function tracks updates of text elements for the purposes for collaboration.
+ * The version is used to compare updates when more than one user is working in
+ * the same drawing.
+ *
+ * WARNING: this won't trigger the component to update, so if you need to trigger component update,
+ * use `scene.mutateElement` or `DrawImperativeAPI.mutateElement` instead.
+ */
+export declare const mutateElement: <TElement extends Mutable<DrawElement>>(element: TElement, elementsMap: ElementsMap, updates: ElementUpdate<TElement>, options?: {
+    isDragging?: boolean;
+}) => TElement;
+export declare const newElementWith: <TElement extends DrawElement>(element: TElement, updates: ElementUpdate<TElement>, 
+/** pass `true` to always regenerate */
+force?: boolean) => TElement;
+/**
+ * Mutates element, bumping `version`, `versionNonce`, and `updated`.
+ *
+ * NOTE: does not trigger re-render.
+ */
+export declare const bumpVersion: <T extends Mutable<DrawElement>>(element: T, version?: DrawElement["version"]) => T;