@unicom-cloud/ui 0.8.167 → 0.8.169

package/draw/element/delta.js

@@ -0,0 +1,544 @@
+/* 潘启宝 2026-06-25 08:58:50 星期四 山东省济南市 */
+import { arrayToMap as e, arrayToObject as t, assertNever as n, isDevEnv as r, isShallowEqual as i, isTestEnv as a } from "../common/utils.js";
+import { randomInteger as o } from "../common/random.js";
+import "../common/index.js";
+import { hasBoundTextElement as s, isBindableElement as c, isBoundToContainer as l, isTextElement as u } from "./typeChecks.js";
+import { getBoundTextElementId as d, redrawTextBoundingBox as f } from "./textElement.js";
+import { getNonDeletedGroupIds as p } from "./groups.js";
+import { mutateElement as m, newElementWith as h } from "./mutateElement.js";
+import { BindableElement as g, BoundElement as _, bindingProperties as v, updateBoundElements as y } from "./binding.js";
+import { orderByFractionalIndex as b, syncMovedIndices as x } from "./fractionalIndex.js";
+import { LinearElementEditor as S } from "./linearElementEditor.js";
+import { Scene as C } from "./Scene.js";
+import { StoreSnapshot as w, getObservedAppState as T } from "./store.js";
+//#region components/pc/draw/element/delta.ts
+var E = class e {
+	constructor(e, t) {
+		this.deleted = e, this.inserted = t;
+	}
+	static create(t, n, r, i) {
+		return new e(r && i !== "inserted" ? r(t, "deleted") : t, r && i !== "deleted" ? r(n, "inserted") : n);
+	}
+	static calculate(t, n, r, i) {
+		if (t === n) return e.empty();
+		let a = {}, o = {};
+		for (let e of this.getDifferences(t, n)) a[e] = t[e], o[e] = n[e];
+		let [s, c] = i ? i(a, o) : [a, o];
+		return e.create(s, c, r);
+	}
+	static empty() {
+		return new e({}, {});
+	}
+	static isEmpty(e) {
+		return !Object.keys(e.deleted).length && !Object.keys(e.inserted).length;
+	}
+	static merge(t, n, r = e.empty()) {
+		return e.create({
+			...t.deleted,
+			...n.deleted,
+			...r.deleted
+		}, {
+			...t.inserted,
+			...n.inserted,
+			...r.inserted
+		});
+	}
+	static mergeObjects(e, t, n = {}) {
+		let r = { ...e };
+		for (let e of Object.keys(n)) delete r[e];
+		return {
+			...r,
+			...t
+		};
+	}
+	static mergeArrays(n, r, i, a) {
+		return Object.values(e.mergeObjects(t(n ?? [], a), t(r ?? [], a), t(i ?? [], a)));
+	}
+	static diffObjects(t, n, r, i) {
+		if (!t[r] && !n[r]) return;
+		let a = t[r] !== null && typeof t[r] == "object", o = n[r] !== null && typeof n[r] == "object";
+		if (a || o) {
+			let a = t[r] ?? {}, o = n[r] ?? {}, s = e.getLeftDifferences(a, o).reduce((e, t) => (e[t] = i(a[t]), e), {}), c = e.getRightDifferences(a, o).reduce((e, t) => (e[t] = i(o[t]), e), {});
+			Object.keys(s).length || Object.keys(c).length ? (Reflect.set(t, r, s), Reflect.set(n, r, c)) : (Reflect.deleteProperty(t, r), Reflect.deleteProperty(n, r));
+		} else t[r] === n[r] && (Reflect.deleteProperty(t, r), Reflect.deleteProperty(n, r));
+	}
+	static diffArrays(n, r, i, a) {
+		if (!(!n[i] && !r[i]) && (Array.isArray(n[i]) || Array.isArray(r[i]))) {
+			let o = Array.isArray(n[i]) ? n[i] : [], s = Array.isArray(r[i]) ? r[i] : [], c = t(e.getLeftDifferences(t(o, a), t(s, a)), (e) => e), l = t(e.getRightDifferences(t(o, a), t(s, a)), (e) => e);
+			if (Object.keys(c).length || Object.keys(l).length) {
+				let e = o.filter((e) => c[a ? a(e) : String(e)]), t = s.filter((e) => l[a ? a(e) : String(e)]);
+				Reflect.set(n, i, e), Reflect.set(r, i, t);
+			} else Reflect.deleteProperty(n, i), Reflect.deleteProperty(r, i);
+		}
+	}
+	static isLeftDifferent(e, t, n = !1) {
+		return !!this.#e("left", e, t, n).next().value;
+	}
+	static isRightDifferent(e, t, n = !1) {
+		return !!this.#e("right", e, t, n).next().value;
+	}
+	static isInnerDifferent(e, t, n = !1) {
+		return !!this.#e("inner", e, t, n).next().value;
+	}
+	static isDifferent(e, t, n = !1) {
+		return !!this.#e("full", e, t, n).next().value;
+	}
+	static getLeftDifferences(e, t, n = !1) {
+		return Array.from(this.#e("left", e, t, n)).sort();
+	}
+	static getRightDifferences(e, t, n = !1) {
+		return Array.from(this.#e("right", e, t, n)).sort();
+	}
+	static getInnerDifferences(e, t, n = !1) {
+		return Array.from(this.#e("inner", e, t, n)).sort();
+	}
+	static getDifferences(e, t, n = !1) {
+		return Array.from(this.#e("full", e, t, n)).sort();
+	}
+	static *#e(e, t, r, a = !1) {
+		if (t === r) return;
+		let o = [];
+		e === "left" ? o = Object.keys(t) : e === "right" ? o = Object.keys(r) : e === "inner" ? o = Object.keys(t).filter((e) => e in r) : e === "full" ? o = Array.from(/* @__PURE__ */ new Set([...Object.keys(t), ...Object.keys(r)])) : n(e, `Unknown distinctKeysIterator's join param "${e}"`, !0);
+		for (let e of o) {
+			let n = t[e], o = r[e];
+			if (n !== o) {
+				if (!a && typeof n == "object" && typeof o == "object" && n !== null && o !== null && i(n, o)) continue;
+				yield e;
+			}
+		}
+	}
+}, D = class e {
+	constructor(e) {
+		this.delta = e;
+	}
+	static create(t) {
+		return new e(t);
+	}
+	static calculate(t, n) {
+		return new e(E.calculate(t, n, e.#o, e.#a));
+	}
+	static restore(t) {
+		let { delta: n } = t;
+		return new e(n);
+	}
+	static empty() {
+		return new e(E.create({}, {}));
+	}
+	inverse() {
+		return new e(E.create(this.delta.inserted, this.delta.deleted));
+	}
+	squash(e) {
+		if (e.isEmpty()) return this;
+		let t = E.mergeObjects(this.delta.deleted.selectedElementIds ?? {}, e.delta.deleted.selectedElementIds ?? {}), n = E.mergeObjects(this.delta.inserted.selectedElementIds ?? {}, e.delta.inserted.selectedElementIds ?? {}), r = E.mergeObjects(this.delta.deleted.selectedGroupIds ?? {}, e.delta.deleted.selectedGroupIds ?? {}), i = E.mergeObjects(this.delta.inserted.selectedGroupIds ?? {}, e.delta.inserted.selectedGroupIds ?? {}), a = E.mergeObjects(this.delta.deleted.lockedMultiSelections ?? {}, e.delta.deleted.lockedMultiSelections ?? {}), o = E.mergeObjects(this.delta.inserted.lockedMultiSelections ?? {}, e.delta.inserted.lockedMultiSelections ?? {}), s = {}, c = {};
+		return (Object.keys(t).length || Object.keys(n).length) && (c.selectedElementIds = t, s.selectedElementIds = n), (Object.keys(r).length || Object.keys(i).length) && (c.selectedGroupIds = r, s.selectedGroupIds = i), (Object.keys(a).length || Object.keys(o).length) && (c.lockedMultiSelections = a, s.lockedMultiSelections = o), this.delta = E.merge(this.delta, e.delta, E.create(c, s)), this;
+	}
+	applyTo(e, t) {
+		try {
+			let { selectedElementIds: n = {}, selectedGroupIds: r = {}, lockedMultiSelections: i = {} } = this.delta.deleted, { selectedElementIds: a = {}, selectedGroupIds: o = {}, lockedMultiSelections: s = {}, selectedLinearElement: c, ...l } = this.delta.inserted, u = E.mergeObjects(e.selectedElementIds, a, n), d = E.mergeObjects(e.selectedGroupIds, o, r), f = E.mergeObjects(e.lockedMultiSelections, s, i), p = c && t.has(c.elementId) ? new S(t.get(c.elementId), t, c.isEditing) : null, m = {
+				...e,
+				...l,
+				selectedElementIds: u,
+				selectedGroupIds: d,
+				lockedMultiSelections: f,
+				selectedLinearElement: c === void 0 ? e.selectedLinearElement : p
+			};
+			return [m, this.#e(e, m, t)];
+		} catch (t) {
+			if (console.error("Couldn't apply appstate change", t), a() || r()) throw t;
+			return [e, !1];
+		}
+	}
+	isEmpty() {
+		return E.isEmpty(this.delta);
+	}
+	#e(t, r, a) {
+		let o = T(t), s = T(r), c = E.isRightDifferent(e.#r(o), e.#r(s)), l = E.isRightDifferent(e.#i(o), e.#i(s));
+		if (!c && !l) return !1;
+		let u = { value: c };
+		if (l) {
+			let c = E.getRightDifferences(e.#i(o), e.#i(s)), l = /* @__PURE__ */ new Set();
+			(c.includes("editingGroupId") || c.includes("selectedGroupIds")) && (l = p(a));
+			for (let o of c) switch (o) {
+				case "selectedElementIds":
+					r[o] = e.#t(r[o], a, u);
+					break;
+				case "selectedGroupIds":
+					r[o] = e.#n(r[o], l, u);
+					break;
+				case "croppingElementId": {
+					let e = r[o];
+					if (!e) u.value = !0;
+					else {
+						let t = a.get(e);
+						t && !t.isDeleted ? u.value = !0 : r[o] = null;
+					}
+					break;
+				}
+				case "editingGroupId":
+					let s = r[o];
+					s ? l.has(s) ? u.value = !0 : r[o] = null : u.value = !0;
+					break;
+				case "selectedLinearElement":
+					let c = r[o];
+					if (!c) u.value = !0;
+					else {
+						let e = a.get(c.elementId);
+						e && !e.isDeleted ? u.value = !0 : r[o] = null;
+					}
+					break;
+				case "lockedMultiSelections":
+					i(t[o] || {}, r[o] || {}) || (u.value = !0);
+					break;
+				case "activeLockedId":
+					(t[o] || null) !== (r[o] || null) && (u.value = !0);
+					break;
+				default: n(o, `Unknown ObservedElementsAppState's key "${o}"`, !0);
+			}
+		}
+		return u.value;
+	}
+	static #t(e, t, n) {
+		let r = Object.keys(e);
+		if (!r.length) return n.value = !0, e;
+		let i = { ...e };
+		for (let e of r) {
+			let r = t.get(e);
+			r && !r.isDeleted ? n.value = !0 : delete i[e];
+		}
+		return i;
+	}
+	static #n(e, t, n) {
+		if (!Object.keys(e).length) return n.value = !0, e;
+		let r = { ...e };
+		for (let e of Object.keys(r)) t.has(e) ? n.value = !0 : delete r[e];
+		return r;
+	}
+	static #r(e) {
+		let { editingGroupId: t, selectedGroupIds: n, selectedElementIds: r, selectedLinearElement: i, croppingElementId: a, lockedMultiSelections: o, activeLockedId: s, ...c } = e;
+		return c;
+	}
+	static #i(e) {
+		let { name: t, viewBackgroundColor: n, ...r } = e;
+		return r;
+	}
+	static #a(e, t) {
+		try {
+			E.diffObjects(e, t, "selectedElementIds", (e) => !0), E.diffObjects(e, t, "selectedGroupIds", (e) => e ?? !1), E.diffObjects(e, t, "lockedMultiSelections", (e) => e ?? {});
+		} catch (e) {
+			if (console.error("Couldn't postprocess appstate change deltas."), a() || r()) throw e;
+		} finally {
+			return [e, t];
+		}
+	}
+	static #o(e) {
+		let t = {};
+		for (let n of Object.keys(e).sort()) t[n] = e[n];
+		return t;
+	}
+}, O = class t {
+	constructor(e, t, n) {
+		this.added = e, this.removed = t, this.updated = n;
+	}
+	static create(e, n, i, o = { shouldRedistribute: !1 }) {
+		let s;
+		if (o.shouldRedistribute) {
+			let r = {}, a = {}, o = {}, c = [
+				...Object.entries(e),
+				...Object.entries(n),
+				...Object.entries(i)
+			];
+			for (let [e, t] of c) this.#e(t) ? r[e] = t : this.#t(t) ? a[e] = t : o[e] = t;
+			s = new t(r, a, o);
+		} else s = new t(e, n, i);
+		return (a() || r()) && (t.#a(s, "added", this.#e), t.#a(s, "removed", this.#t), t.#a(s, "updated", this.#n)), s;
+	}
+	static restore(e) {
+		let { added: n, removed: r, updated: i } = e;
+		return t.create(n, r, i);
+	}
+	static #e = ({ deleted: e, inserted: t }) => e.isDeleted === !0 && !t.isDeleted;
+	static #t = ({ deleted: e, inserted: t }) => !e.isDeleted && t.isDeleted === !0;
+	static #n = ({ deleted: e, inserted: t }) => !!e.isDeleted == !!t.isDeleted;
+	static #r = ({ deleted: e, inserted: t }) => !!(Number.isInteger(e.version) && Number.isInteger(t.version) && e.version >= 0 && t.version >= 0 && e.version !== t.version);
+	static #i = (e, t) => {
+		let { added: n, removed: r, updated: i } = e;
+		return [
+			n[t],
+			r[t],
+			i[t]
+		].filter(Boolean).length === 1;
+	};
+	static #a(e, t, n) {
+		for (let [r, i] of Object.entries(e[t])) if (!this.#r(i) || !this.#i(e, r) || !n(i)) throw console.error(`Broken invariant for "${t}" delta, element "${r}", delta:`, i), Error(`ElementsDelta invariant broken for element "${r}".`);
+	}
+	static calculate(e, n) {
+		if (e === n) return t.empty();
+		let r = {}, i = {}, a = {};
+		for (let r of e.values()) if (!n.get(r.id)) {
+			let e = { ...r }, n = {
+				isDeleted: !0,
+				version: r.version + 1,
+				versionNonce: o()
+			}, s = E.create(e, n, t.#_);
+			r.isDeleted ? a[r.id] = s : i[r.id] = s;
+		}
+		for (let s of n.values()) {
+			let n = e.get(s.id);
+			if (!n) {
+				let e = {
+					isDeleted: !0,
+					version: s.version - 1,
+					versionNonce: o()
+				}, n = { ...s }, i = E.create(e, n, t.#_);
+				s.isDeleted ? a[s.id] = i : r[s.id] = i;
+				continue;
+			}
+			if (n.versionNonce !== s.versionNonce) {
+				let e = E.calculate(n, s, t.#_, t.#g);
+				if (typeof n.isDeleted == "boolean" && typeof s.isDeleted == "boolean" && n.isDeleted !== s.isDeleted) {
+					n.isDeleted && !s.isDeleted ? r[s.id] = e : i[s.id] = e;
+					continue;
+				}
+				a[s.id] = e;
+			}
+		}
+		return t.create(r, i, a);
+	}
+	static empty() {
+		return t.create({}, {}, {});
+	}
+	inverse() {
+		let e = (e) => {
+			let t = {};
+			for (let [n, { inserted: r, deleted: i }] of Object.entries(e)) t[n] = E.create({ ...r }, { ...i });
+			return t;
+		}, n = e(this.added), r = e(this.removed), i = e(this.updated);
+		return t.create(r, n, i);
+	}
+	isEmpty() {
+		return Object.keys(this.added).length === 0 && Object.keys(this.removed).length === 0 && Object.keys(this.updated).length === 0;
+	}
+	applyLatestChanges(e, n, r) {
+		let i = (e, t) => (n, r) => {
+			let i;
+			switch (r) {
+				case "deleted":
+					i = e;
+					break;
+				case "inserted":
+					i = t;
+					break;
+			}
+			if (!i) return console.error("Element not found when trying to apply latest changes"), n;
+			let a = {};
+			for (let e of Object.keys(n)) switch (e) {
+				case "boundElements":
+					a[e] = n[e];
+					break;
+				default: a[e] = i[e];
+			}
+			return a;
+		}, a = (t) => {
+			let a = {};
+			for (let [o, s] of Object.entries(t)) {
+				let t = e.get(o), c = n.get(o), l = null;
+				l = t || c ? E.create(s.deleted, s.inserted, i(t, c), r) : s, E.isInnerDifferent(l.deleted, l.inserted) && (a[o] = l);
+			}
+			return a;
+		}, o = a(this.added), s = a(this.removed), c = a(this.updated);
+		return t.create(o, s, c, { shouldRedistribute: !0 });
+	}
+	applyTo(e, n = w.empty().elements, i) {
+		let o = new Map(e), s, c = {
+			containsVisibleDifference: !1,
+			containsZindexDifference: !1,
+			applyDirection: void 0
+		};
+		try {
+			let r = t.#o(e, o, n, c, i), a = r(this.added), l = r(this.removed), u = r(this.updated), d = this.#u(e, o, c.applyDirection);
+			s = new Map([
+				...a,
+				...l,
+				...u,
+				...d
+			]);
+		} catch (t) {
+			if (console.error("Couldn't apply elements delta", t), a() || r()) throw t;
+			return [e, !0];
+		}
+		try {
+			o = t.#h(o, s, c), t.redrawElements(o, s);
+		} catch (e) {
+			if (console.error("Couldn't mutate elements after applying elements change", e), a() || r()) throw e;
+		} finally {
+			return [o, c.containsVisibleDifference];
+		}
+	}
+	squash(e) {
+		if (e.isEmpty()) return this;
+		let { added: n, removed: i, updated: o } = e, s = (e, t) => {
+			let n = E.mergeArrays(e.deleted.boundElements ?? [], t.deleted.boundElements ?? [], void 0, (e) => e.id) ?? [], r = E.mergeArrays(e.inserted.boundElements ?? [], t.inserted.boundElements ?? [], void 0, (e) => e.id) ?? [];
+			if (!(!n.length && !r.length)) return E.create({ boundElements: n }, { boundElements: r });
+		};
+		for (let [e, t] of Object.entries(n)) {
+			let n = this.added[e] ?? this.removed[e] ?? this.updated[e];
+			if (!n) this.added[e] = t;
+			else {
+				let r = s(n, t);
+				delete this.removed[e], delete this.updated[e], this.added[e] = E.merge(n, t, r);
+			}
+		}
+		for (let [e, t] of Object.entries(i)) {
+			let n = this.added[e] ?? this.removed[e] ?? this.updated[e];
+			if (!n) this.removed[e] = t;
+			else {
+				let r = s(n, t);
+				delete this.added[e], delete this.updated[e], this.removed[e] = E.merge(n, t, r);
+			}
+		}
+		for (let [e, t] of Object.entries(o)) {
+			let n = this.added[e] ?? this.removed[e] ?? this.updated[e];
+			if (!n) this.updated[e] = t;
+			else {
+				let r = s(n, t), i = E.merge(n, t, r);
+				n === this.added[e] ? this.added[e] = i : n === this.removed[e] ? this.removed[e] = i : this.updated[e] = i;
+			}
+		}
+		return (a() || r()) && (t.#a(this, "added", t.#e), t.#a(this, "removed", t.#t), t.#a(this, "updated", t.#n)), this;
+	}
+	static #o = (e, n, r, i, a) => (o) => {
+		let s = t.#s(n, r, i);
+		return Object.entries(o).reduce((r, [o, c]) => {
+			let l = s(o, c.inserted);
+			if (l) {
+				let s = t.#c(l, c, i, a);
+				if (n.set(s.id, s), r.set(s.id, s), !i.applyDirection) {
+					let t = e.get(o);
+					t && (i.applyDirection = t.version > s.version ? "backward" : "forward");
+				}
+			}
+			return r;
+		}, /* @__PURE__ */ new Map());
+	};
+	static #s = (e, t, n) => (r, i) => {
+		let a = e.get(r);
+		return a || (a = t.get(r), a ? (n.containsZindexDifference = !0, (!i.isDeleted || i.isDeleted && !a.isDeleted) && (n.containsVisibleDifference = !0)) : a = h({
+			id: r,
+			version: 1
+		}, { ...i })), a;
+	};
+	static #c(e, n, r, i) {
+		let a = {};
+		for (let e of Object.keys(n.inserted)) {
+			if (e === "boundElements" || i?.excludedProperties?.has?.(e)) continue;
+			let t = n.inserted[e];
+			Reflect.set(a, e, t);
+		}
+		if (n.deleted.boundElements?.length || n.inserted.boundElements?.length) {
+			let t = E.mergeArrays(e.boundElements, n.inserted.boundElements, n.deleted.boundElements, (e) => e.id);
+			Object.assign(a, { boundElements: t });
+		}
+		if (!r.containsVisibleDifference) {
+			let { index: n, ...i } = a;
+			r.containsVisibleDifference = t.#l(e, i);
+		}
+		return r.containsZindexDifference ||= n.deleted.index !== n.inserted.index, h(e, a, !0);
+	}
+	static #l(e, t) {
+		return e.isDeleted && t.isDeleted !== !1 ? !1 : e.isDeleted && t.isDeleted === !1 || e.isDeleted === !1 && t.isDeleted ? !0 : E.isRightDifferent(e, t);
+	}
+	#u(e, n, r = "forward") {
+		let i = /* @__PURE__ */ new Map(), a = (t, a) => {
+			let o = n.get(t.id);
+			if (!o) return;
+			let s = e.get(t.id), c = r === "forward" ? o.version + 1 : o.version - 1, l = a, u;
+			u = s === o ? h(o, {
+				...l,
+				version: c
+			}, !0) : m(o, n, {
+				...l,
+				version: s?.version === o.version ? c : o.version
+			}), i.set(u.id, u), n.set(u.id, u);
+		};
+		for (let r of Object.keys(this.removed)) t.#d(e, n, r, a);
+		for (let r of Object.keys(this.added)) t.#f(e, n, r, a);
+		for (let [r] of Array.from(Object.entries(this.updated)).filter(([e, t]) => Object.keys({
+			...t.deleted,
+			...t.inserted
+		}).find((e) => v.has(e)))) {
+			let i = n.get(r);
+			!i || i.isDeleted || t.#f(e, n, r, a);
+		}
+		let o = new Map(Array.from(e).filter(([e]) => i.has(e)));
+		return this.squash(t.calculate(o, i)), i;
+	}
+	static #d(e, t, n, r) {
+		let i = () => e.get(n), a = () => t.get(n);
+		_.unbindAffected(t, i(), r), _.unbindAffected(t, a(), r), g.unbindAffected(t, i(), r), g.unbindAffected(t, a(), r);
+	}
+	static #f(e, t, n, r) {
+		let i = () => e.get(n), a = () => t.get(n);
+		_.unbindAffected(t, i(), r), _.rebindAffected(t, a(), r), g.unbindAffected(t, i(), (e, t) => {
+			u(e) && r(e, t);
+		}), g.rebindAffected(t, a(), r);
+	}
+	static redrawElements(e, n) {
+		try {
+			let r = new C(e, { skipValidation: !0 });
+			t.#p(r, n), t.#m(r, n);
+		} catch (e) {
+			if (console.error("Couldn't redraw elements", e), a() || r()) throw e;
+		} finally {
+			return e;
+		}
+	}
+	static #p(e, t) {
+		let n = e.getNonDeletedElementsMap(), r = /* @__PURE__ */ new Map();
+		for (let e of t.values()) {
+			if (l(e)) {
+				let { containerId: t } = e, i = t ? n.get(t) : void 0;
+				i && r.set(i.id, {
+					container: i,
+					boundText: e
+				});
+			}
+			if (s(e)) {
+				let t = d(e), i = t ? n.get(t) : void 0;
+				i && r.set(e.id, {
+					container: e,
+					boundText: i
+				});
+			}
+		}
+		for (let { container: t, boundText: n } of r.values()) t.isDeleted || n.isDeleted || f(n, t, e);
+	}
+	static #m(e, t) {
+		for (let n of t.values()) !n.isDeleted && c(n) && y(n, e, { changedElements: t });
+	}
+	static #h(t, n, r) {
+		if (!r.containsZindexDifference) return t;
+		let i = Array.from(t.values()), a = b([...i]), o = E.getRightDifferences(i, a, !0).reduce((e, t) => {
+			let r = i[Number(t)];
+			return r && n.has(r.id) && e.set(r.id, r), e;
+		}, /* @__PURE__ */ new Map());
+		return !r.containsVisibleDifference && o.size && (r.containsVisibleDifference = !0), e(x(a, o));
+	}
+	static #g(e, t) {
+		try {
+			E.diffArrays(e, t, "boundElements", (e) => e.id);
+			let n = e.points ?? [], r = t.points ?? [];
+			E.isDifferent(n, r) || (Reflect.deleteProperty(e, "points"), Reflect.deleteProperty(t, "points"));
+		} catch (e) {
+			if (console.error("Couldn't postprocess elements delta."), a() || r()) throw e;
+		} finally {
+			return [e, t];
+		}
+	}
+	static #_(e) {
+		let { id: t, updated: n, ...r } = e;
+		return r;
+	}
+};
+//#endregion
+export { D as AppStateDelta, E as Delta, O as ElementsDelta };
+/* 独立思考，明辨是非 */

package/draw/element/distance.d.ts

@@ -0,0 +1,3 @@
+import type { GlobalPoint } from '../libs/math';
+import type { DrawElement, ElementsMap } from './types';
+export declare const distanceToElement: (element: DrawElement, elementsMap: ElementsMap, p: GlobalPoint) => number;

package/draw/element/distance.js

@@ -0,0 +1,41 @@
+/* 潘启宝 2026-06-25 08:58:50 星期四 山东省济南市 */
+import { pointRotateRads as e } from "../libs/math/point.js";
+import { curvePointDistance as t } from "../libs/math/curve.js";
+import { ellipse as n, ellipseDistanceFromPoint as r } from "../libs/math/ellipse.js";
+import { distanceToLineSegment as i } from "../libs/math/segment.js";
+import "../libs/math/index.js";
+import { deconstructDiamondElement as a, deconstructLinearOrFreeDrawElement as o, deconstructRectanguloidElement as s } from "./utils.js";
+import { elementCenterPoint as c } from "./bounds.js";
+//#region components/pc/draw/element/distance.ts
+var l = (e, t, n) => {
+	switch (e.type) {
+		case "selection":
+		case "rectangle":
+		case "image":
+		case "text":
+		case "iframe":
+		case "embeddable":
+		case "frame":
+		case "magicframe": return u(e, t, n);
+		case "diamond": return d(e, t, n);
+		case "ellipse": return f(e, t, n);
+		case "line":
+		case "arrow":
+		case "freedraw": return p(e, n);
+	}
+}, u = (n, r, a) => {
+	let o = e(a, c(n, r), -n.angle), [l, u] = s(n);
+	return Math.min(...l.map((e) => i(o, e)), ...u.map((e) => t(e, o)).filter((e) => e !== null));
+}, d = (n, r, o) => {
+	let s = e(o, c(n, r), -n.angle), [l, u] = a(n);
+	return Math.min(...l.map((e) => i(s, e)), ...u.map((e) => t(e, s)).filter((e) => e !== null));
+}, f = (t, i, a) => {
+	let o = c(t, i);
+	return r(e(a, o, -t.angle), n(o, t.width / 2, t.height / 2));
+}, p = (e, n) => {
+	let [r, a] = o(e);
+	return Math.min(...r.map((e) => i(n, e)), ...a.map((e) => t(e, n)));
+};
+//#endregion
+export { l as distanceToElement };
+/* 独立思考，明辨是非 */

package/draw/element/distribute.d.ts

@@ -0,0 +1,8 @@
+import type { AppState } from '../interface';
+import type { Scene } from './Scene';
+import type { DrawElement, ElementsMap } from './types';
+export interface Distribution {
+    space: 'between';
+    axis: 'x' | 'y';
+}
+export declare const distributeElements: (selectedElements: DrawElement[], elementsMap: ElementsMap, distribution: Distribution, appState: Readonly<AppState>, scene: Scene) => DrawElement[];

package/draw/element/distribute.js

@@ -0,0 +1,53 @@
+/* 潘启宝 2026-06-25 08:58:50 星期四 山东省济南市 */
+import { getSelectedElementsByGroup as e } from "./groups.js";
+import { updateBoundElements as t } from "./binding.js";
+import { getCommonBoundingBox as n } from "./bounds.js";
+//#region components/pc/draw/element/distribute.ts
+var r = (r, i, a, o, s) => {
+	let [c, l, u, d] = a.axis === "x" ? [
+		"minX",
+		"midX",
+		"maxX",
+		"width"
+	] : [
+		"minY",
+		"midY",
+		"maxY",
+		"height"
+	], f = n(r), p = e(r, i, o).map((e) => [e, n(e)]).sort((e, t) => e[1][l] - t[1][l]), m = 0;
+	for (let e of p) m += e[1][d];
+	let h = (f[d] - m) / (p.length - 1);
+	if (h < 0) {
+		let e = p.findIndex((e) => e[1][c] === f[c]), n = p.findIndex((e) => e[1][u] === f[u]), r = (p[n][1][l] - p[e][1][l]) / (p.length - 1), i = p[e][1][l];
+		return p.flatMap(([o, c], u) => {
+			let d = {
+				x: 0,
+				y: 0
+			};
+			return u !== e && u !== n && (i += r, d[a.axis] = i - c[l]), o.map((e) => {
+				let n = s.mutateElement(e, {
+					x: e.x + d.x,
+					y: e.y + d.y
+				});
+				return t(e, s, { simultaneouslyUpdated: o }), n;
+			});
+		});
+	}
+	let g = f[c];
+	return p.flatMap(([e, n]) => {
+		let r = {
+			x: 0,
+			y: 0
+		};
+		return r[a.axis] = g - n[c], g += h, g += n[d], e.map((n) => {
+			let i = s.mutateElement(n, {
+				x: n.x + r.x,
+				y: n.y + r.y
+			});
+			return t(n, s, { simultaneouslyUpdated: e }), i;
+		});
+	});
+};
+//#endregion
+export { r as distributeElements };
+/* 独立思考，明辨是非 */

package/draw/element/dragElements.d.ts

@@ -0,0 +1,33 @@
+import type { AppState, NormalizedZoomValue, NullableGridSize, PointerDownState } from '../interface';
+import type { Scene } from './Scene';
+import type { NonDeletedDrawElement } from './types';
+export declare const dragSelectedElements: (pointerDownState: PointerDownState, _selectedElements: NonDeletedDrawElement[], offset: {
+    x: number;
+    y: number;
+}, scene: Scene, snapOffset: {
+    x: number;
+    y: number;
+}, gridSize: NullableGridSize) => void;
+export declare const getDragOffsetXY: (selectedElements: NonDeletedDrawElement[], x: number, y: number) => [number, number];
+export declare const dragNewElement: ({ newElement, elementType, originX, originY, x, y, width, height, shouldMaintainAspectRatio, shouldResizeFromCenter, zoom, scene, widthAspectRatio, originOffset, informMutation, }: {
+    newElement: NonDeletedDrawElement;
+    elementType: AppState["activeTool"]["type"];
+    originX: number;
+    originY: number;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    shouldMaintainAspectRatio: boolean;
+    shouldResizeFromCenter: boolean;
+    zoom: NormalizedZoomValue;
+    scene: Scene;
+    /** whether to keep given aspect ratio when `isResizeWithSidesSameLength` is
+        true */
+    widthAspectRatio?: number | null;
+    originOffset?: {
+        x: number;
+        y: number;
+    } | null;
+    informMutation?: boolean;
+}) => void;