@unicom-cloud/ui 0.8.168 → 0.8.169

package/draw/element/textMeasurements.d.ts

@@ -0,0 +1,39 @@
+import type { DrawTextElement, FontString } from './types';
+export declare const measureText: (text: string, font: FontString, lineHeight: DrawTextElement["lineHeight"]) => {
+    width: number;
+    height: number;
+};
+export declare const getApproxMinLineWidth: (font: FontString, lineHeight: DrawTextElement["lineHeight"]) => number;
+export declare const getMinTextElementWidth: (font: FontString, lineHeight: DrawTextElement["lineHeight"]) => number;
+export declare const isMeasureTextSupported: () => boolean;
+export declare const normalizeText: (text: string) => string;
+/**
+ * To get unitless line-height (if unknown) we can calculate it by dividing
+ * height-per-line by fontSize.
+ */
+export declare const detectLineHeight: (textElement: DrawTextElement) => DrawTextElement["lineHeight"];
+/**
+ * We calculate the line height from the font size and the unitless line height,
+ * aligning with the W3C spec.
+ */
+export declare const getLineHeightInPx: (fontSize: DrawTextElement["fontSize"], lineHeight: DrawTextElement["lineHeight"]) => number;
+export declare const getApproxMinLineHeight: (fontSize: DrawTextElement["fontSize"], lineHeight: DrawTextElement["lineHeight"]) => number;
+/**
+ * Set a custom text metrics provider.
+ *
+ * Useful for overriding the width calculation algorithm where canvas API is not available / desired.
+ */
+export declare const setCustomTextMetricsProvider: (provider: TextMetricsProvider) => void;
+export interface TextMetricsProvider {
+    getLineWidth(text: string, fontString: FontString): number;
+}
+export declare const getLineWidth: (text: string, font: FontString) => number;
+export declare const getTextWidth: (text: string, font: FontString) => number;
+export declare const getTextHeight: (text: string, fontSize: number, lineHeight: DrawTextElement["lineHeight"]) => number;
+export declare const charWidth: {
+    calculate: (char: string, font: FontString) => number;
+    getCache: (font: FontString) => number[];
+    clearCache: (font: FontString) => void;
+};
+export declare const getMinCharWidth: (font: FontString) => number;
+export declare const getMaxCharWidth: (font: FontString) => number;

package/draw/element/textMeasurements.js

@@ -0,0 +1,66 @@
+/* 潘启宝 2026-06-25 08:58:50 星期四 山东省济南市 */
+import { DEFAULT_FONT_FAMILY as e } from "../common/constants.js";
+import { getFontString as t, isTestEnv as n, normalizeEOL as r } from "../common/utils.js";
+import "../common/index.js";
+//#region components/pc/draw/element/textMeasurements.ts
+var i = (e, t, n) => {
+	let r = e.split("\n").map((e) => e || " ").join("\n"), i = y(r, parseFloat(t), n);
+	return {
+		width: v(r, t),
+		height: i
+	};
+}, a = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789".toLocaleUpperCase(), o = (e, t) => {
+	let n = x(e);
+	return n === 0 ? i(a.split("").join("\n"), e, t).width + 10 : n + 10;
+}, s = (e, t) => i("", e, t).width + 10, c = () => v(a, t({
+	fontSize: 20,
+	fontFamily: e
+})) > 0, l = (e) => r(e).replace(/\t/g, "        "), u = (e) => l(e).split("\n"), d = (e) => {
+	let t = u(e.text).length;
+	return e.height / t / e.fontSize;
+}, f = (e, t) => e * t, p = (e, t) => f(e, t) + 10, m, h = (e) => {
+	m = e;
+}, g = class {
+	#e;
+	constructor() {
+		this.#e = document.createElement("canvas");
+	}
+	getLineWidth(e, t) {
+		let r = this.#e.getContext("2d");
+		r.font = t;
+		let i = r.measureText(e).width;
+		return n() ? i * 10 : i;
+	}
+}, _ = (e, t) => (m ||= new g(), m.getLineWidth(e, t)), v = (e, t) => {
+	let n = u(e), r = 0;
+	return n.forEach((e) => {
+		r = Math.max(r, _(e, t));
+	}), r;
+}, y = (e, t, n) => {
+	let r = u(e).length;
+	return f(t, n) * r;
+}, b = (() => {
+	let e = {};
+	return {
+		calculate: (t, n) => {
+			let r = t.charCodeAt(0);
+			if (e[n] || (e[n] = []), !e[n][r]) {
+				let i = _(t, n);
+				e[n][r] = i;
+			}
+			return e[n][r];
+		},
+		getCache: (t) => e[t],
+		clearCache: (t) => {
+			e[t] = [];
+		}
+	};
+})(), x = (e) => {
+	let t = b.getCache(e);
+	if (!t) return 0;
+	let n = t.filter((e) => e !== void 0);
+	return Math.max(...n);
+};
+//#endregion
+export { b as charWidth, d as detectLineHeight, p as getApproxMinLineHeight, o as getApproxMinLineWidth, f as getLineHeightInPx, _ as getLineWidth, x as getMaxCharWidth, s as getMinTextElementWidth, y as getTextHeight, v as getTextWidth, c as isMeasureTextSupported, i as measureText, l as normalizeText, h as setCustomTextMetricsProvider };
+/* 独立思考，明辨是非 */

package/draw/element/textWrapping.d.ts

@@ -0,0 +1,13 @@
+import type { FontString } from './types';
+/**
+ * Test if a given text contains any CJK characters (including symbols, punctuation, etc,).
+ */
+export declare const containsCJK: (text: string) => boolean;
+/**
+ * Breaks the line into the tokens based on the found line break opporutnities.
+ */
+export declare const parseTokens: (line: string) => string[];
+/**
+ * Wraps the original text into the lines based on the given width.
+ */
+export declare const wrapText: (text: string, font: FontString, maxWidth: number) => string;

package/draw/element/textWrapping.js

@@ -0,0 +1,149 @@
+/* 潘启宝 2026-06-25 08:58:50 星期四 山东省济南市 */
+import { isDevEnv as e, isTestEnv as t } from "../common/utils.js";
+import "../common/index.js";
+import { charWidth as n, getLineWidth as r } from "./textMeasurements.js";
+//#region components/pc/draw/element/textWrapping.ts
+var i, a, o = () => {
+	if (!i) try {
+		i = f();
+	} catch {
+		i = d();
+	}
+	return i;
+}, s = () => (a ||= p(), a), c = {
+	WHITESPACE: /\s/u,
+	HYPHEN: /-/u,
+	OPENING: /<\(\[\{/u,
+	CLOSING: />\)\]\}.,:;!\?…\//u
+}, l = {
+	CHAR: /\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}｀＇＾〃〰〆＃＆＊＋－ー／＼＝｜￤〒￢￣/u,
+	OPENING: /（［｛〈《｟｢「『【〖〔〘〚＜〝/u,
+	CLOSING: /）］｝〉》｠｣」』】〗〕〙〛＞。．，、〟‥？！：；・〜〞/u,
+	CURRENCY: /￥￦￡￠＄/u
+}, u = {
+	FLAG: /\p{RI}\p{RI}/u,
+	JOINER: /(?:\p{Emoji_Modifier}|\uFE0F\u20E3?|[\u{E0020}-\u{E007E}]+\u{E007F})?/u,
+	ZWJ: /\u200D/u,
+	ANY: /[\p{Emoji}]/u,
+	MOST: /[\p{Extended_Pictographic}\p{Emoji_Presentation}]/u
+}, d = () => m.or(s(), h.On(c.HYPHEN, c.WHITESPACE, l.CHAR)), f = () => m.or(s(), h.Before(c.WHITESPACE).Build(), h.After(c.WHITESPACE, c.HYPHEN).Build(), h.Before(l.CHAR, l.CURRENCY).NotPrecededBy(c.OPENING, l.OPENING).Build(), h.After(l.CHAR).NotFollowedBy(c.HYPHEN, c.CLOSING, l.CLOSING).Build(), h.BeforeMany(l.OPENING).NotPrecededBy(c.OPENING).Build(), h.AfterMany(l.CLOSING).NotFollowedBy(c.CLOSING).Build(), h.AfterMany(c.CLOSING).FollowedBy(c.OPENING).Build()), p = () => m.group(m.or(u.FLAG, m.and(u.MOST, u.JOINER, m.build(`(?:${u.ZWJ.source}(?:${u.FLAG.source}|${u.ANY.source}${u.JOINER.source}))*`)))), m = {
+	build: (e) => new RegExp(e, "u"),
+	join: (...e) => e.map((e) => e.source).join(""),
+	and: (...e) => m.build(m.join(...e)),
+	or: (...e) => m.build(e.map((e) => e.source).join("|")),
+	group: (...e) => m.build(`(${m.join(...e)})`),
+	class: (...e) => m.build(`[${m.join(...e)}]`)
+}, h = {
+	On: (...e) => {
+		let t = m.join(...e);
+		return m.build(`([${t}])`);
+	},
+	Before: (...e) => {
+		let t = m.join(...e);
+		return h.Chain(() => m.build(`(?=[${t}])`));
+	},
+	After: (...e) => {
+		let t = m.join(...e);
+		return h.Chain(() => m.build(`(?<=[${t}])`));
+	},
+	BeforeMany: (...e) => {
+		let t = m.join(...e);
+		return h.Chain(() => m.build(`(?<![${t}])(?=[${t}])`));
+	},
+	AfterMany: (...e) => {
+		let t = m.join(...e);
+		return h.Chain(() => m.build(`(?<=[${t}])(?![${t}])`));
+	},
+	NotBefore: (...e) => {
+		let t = m.join(...e);
+		return h.Chain(() => m.build(`(?![${t}])`));
+	},
+	NotAfter: (...e) => {
+		let t = m.join(...e);
+		return h.Chain(() => m.build(`(?<![${t}])`));
+	},
+	Chain: (e) => ({
+		Build: e,
+		PreceededBy: (...t) => {
+			let n = e(), r = h.After(...t).Build();
+			return h.Chain(() => m.and(r, n));
+		},
+		FollowedBy: (...t) => {
+			let n = e(), r = h.Before(...t).Build();
+			return h.Chain(() => m.and(n, r));
+		},
+		NotPrecededBy: (...t) => {
+			let n = e(), r = h.NotAfter(...t).Build();
+			return h.Chain(() => m.and(r, n));
+		},
+		NotFollowedBy: (...t) => {
+			let n = e(), r = h.NotBefore(...t).Build();
+			return h.Chain(() => m.and(n, r));
+		}
+	})
+}, g = (e) => {
+	let t = o();
+	return e.normalize("NFC").split(t).filter(Boolean);
+}, _ = (e, t, n) => {
+	if (!Number.isFinite(n) || n < 0) return e;
+	let i = [], a = e.split("\n");
+	for (let e of a) {
+		if (r(e, t) <= n) {
+			i.push(e);
+			continue;
+		}
+		let a = v(e, t, n);
+		i.push(...a);
+	}
+	return i.join("\n");
+}, v = (e, t, i) => {
+	let a = [], o = g(e)[Symbol.iterator](), s = "", c = 0, l = o.next();
+	for (; !l.done;) {
+		let e = l.value, u = s + e, d = x(e) ? c + n.calculate(e, t) : r(u, t);
+		if (/\s/.test(e) || d <= i) {
+			s = u, c = d, l = o.next();
+			continue;
+		}
+		if (s) a.push(s.trimEnd()), s = "", c = 0;
+		else {
+			let n = y(e, t, i), u = n[n.length - 1] ?? "", d = n.slice(0, -1);
+			a.push(...d), s = u, c = r(u, t), l = o.next();
+		}
+	}
+	if (s) {
+		let e = b(s, t, i);
+		a.push(e);
+	}
+	return a;
+}, y = (e, t, r) => {
+	if (s().test(e)) return [e];
+	S(e);
+	let i = [], a = Array.from(e), o = "", c = 0;
+	for (let e of a) {
+		let a = n.calculate(e, t), s = c + a;
+		if (s <= r) {
+			o += e, c = s;
+			continue;
+		}
+		o && i.push(o), o = e, c = a;
+	}
+	return o && i.push(o), i;
+}, b = (e, t, i) => {
+	if (!(r(e, t) > i)) return e;
+	let [, a, o] = e.match(/^(.+?)(\s+)$/) ?? [
+		e,
+		e.trimEnd(),
+		""
+	], s = r(a, t);
+	for (let e of Array.from(o)) {
+		let r = n.calculate(e, t), o = s + r;
+		if (o > i) break;
+		a += e, s = o;
+	}
+	return a;
+}, x = (e) => e.codePointAt(0) !== void 0 && e.codePointAt(1) === void 0, S = (n) => {
+	if ((t() || e()) && /\s/.test(n)) throw Error("Word should not contain any whitespaces!");
+};
+//#endregion
+export { g as parseTokens, _ as wrapText };
+/* 独立思考，明辨是非 */

package/draw/element/transform.d.ts

@@ -0,0 +1,81 @@
+import type { MarkOptional } from '../common/utility-types';
+import type { ElementConstructorOpts } from './newElement';
+import type { DrawBindableElement, DrawElement, DrawFrameElement, DrawFreeDrawElement, DrawGenericElement, DrawIframeLikeElement, DrawImageElement, DrawLinearElement, DrawMagicFrameElement, DrawSelectionElement, DrawTextElement, FileId, FontFamilyValues, TextAlign, VerticalAlign } from './types';
+export type ValidLinearElement = {
+    type: 'arrow' | 'line';
+    x: number;
+    y: number;
+    label?: {
+        text: string;
+        fontSize?: number;
+        fontFamily?: FontFamilyValues;
+        textAlign?: TextAlign;
+        verticalAlign?: VerticalAlign;
+    } & MarkOptional<ElementConstructorOpts, 'x' | 'y'>;
+    end?: (({
+        type: Exclude<DrawBindableElement['type'], 'image' | 'text' | 'frame' | 'magicframe' | 'embeddable' | 'iframe'>;
+        id?: DrawGenericElement['id'];
+    } | {
+        id: DrawGenericElement['id'];
+        type?: Exclude<DrawBindableElement['type'], 'image' | 'text' | 'frame' | 'magicframe' | 'embeddable' | 'iframe'>;
+    }) | (({
+        type: 'text';
+        text: string;
+    } | {
+        type?: 'text';
+        id: DrawTextElement['id'];
+        text: string;
+    }) & Partial<DrawTextElement>)) & MarkOptional<ElementConstructorOpts, 'x' | 'y'>;
+    start?: (({
+        type: Exclude<DrawBindableElement['type'], 'image' | 'text' | 'frame' | 'magicframe' | 'embeddable' | 'iframe'>;
+        id?: DrawGenericElement['id'];
+    } | {
+        id: DrawGenericElement['id'];
+        type?: Exclude<DrawBindableElement['type'], 'image' | 'text' | 'frame' | 'magicframe' | 'embeddable' | 'iframe'>;
+    }) | (({
+        type: 'text';
+        text: string;
+    } | {
+        type?: 'text';
+        id: DrawTextElement['id'];
+        text: string;
+    }) & Partial<DrawTextElement>)) & MarkOptional<ElementConstructorOpts, 'x' | 'y'>;
+} & Partial<DrawLinearElement>;
+export type ValidContainer = {
+    type: Exclude<DrawGenericElement['type'], 'selection'>;
+    id?: DrawGenericElement['id'];
+    label?: {
+        text: string;
+        fontSize?: number;
+        fontFamily?: FontFamilyValues;
+        textAlign?: TextAlign;
+        verticalAlign?: VerticalAlign;
+    } & MarkOptional<ElementConstructorOpts, 'x' | 'y'>;
+} & ElementConstructorOpts;
+export type DrawElementSkeleton = Extract<Exclude<DrawElement, DrawSelectionElement>, DrawIframeLikeElement | DrawFreeDrawElement> | ({
+    type: Extract<DrawLinearElement['type'], 'line'>;
+    x: number;
+    y: number;
+} & Partial<DrawLinearElement>) | ValidContainer | ValidLinearElement | ({
+    type: 'text';
+    text: string;
+    x: number;
+    y: number;
+    id?: DrawTextElement['id'];
+} & Partial<DrawTextElement>) | ({
+    type: Extract<DrawImageElement['type'], 'image'>;
+    x: number;
+    y: number;
+    fileId: FileId;
+} & Partial<DrawImageElement>) | ({
+    type: 'frame';
+    children: readonly DrawElement['id'][];
+    name?: string;
+} & Partial<DrawFrameElement>) | ({
+    type: 'magicframe';
+    children: readonly DrawElement['id'][];
+    name?: string;
+} & Partial<DrawMagicFrameElement>);
+export declare const convertToDrawElements: (elementsSkeleton: DrawElementSkeleton[] | null, opts?: {
+    regenerateIds: boolean;
+}) => import("./types").OrderedDrawElement[];

package/draw/element/transform.js

@@ -0,0 +1,288 @@
+/* 潘启宝 2026-06-25 08:58:50 星期四 山东省济南市 */
+import { DEFAULT_FONT_FAMILY as e, TEXT_ALIGN as t, VERTICAL_ALIGN as n } from "../common/constants.js";
+import { getLineHeight as r } from "../common/font-metadata.js";
+import { pointFrom as i } from "../libs/math/point.js";
+import "../libs/math/index.js";
+import { getSizeFromPoints as a } from "../common/points.js";
+import { arrayToMap as o, assertNever as s, cloneJSON as c, getFontString as l, isDevEnv as u, toBrandedType as d } from "../common/utils.js";
+import { randomId as f } from "../common/random.js";
+import "../common/index.js";
+import { isArrowElement as p } from "./typeChecks.js";
+import { measureText as m, normalizeText as h } from "./textMeasurements.js";
+import { redrawTextBoundingBox as g } from "./textElement.js";
+import { bindBindingElement as _ } from "./binding.js";
+import { syncInvalidIndices as v } from "./fractionalIndex.js";
+import { LinearElementEditor as y } from "./linearElementEditor.js";
+import { getCommonBounds as b } from "./bounds.js";
+import { Scene as x } from "./Scene.js";
+import { newArrowElement as S, newElement as C, newFrameElement as w, newImageElement as T, newLinearElement as E, newMagicFrameElement as D, newTextElement as O } from "./newElement.js";
+//#region components/pc/draw/element/transform.ts
+var k = {
+	width: 100,
+	height: 0
+}, A = 100, j = (e, r, i) => {
+	let a = O({
+		x: 0,
+		y: 0,
+		textAlign: t.CENTER,
+		verticalAlign: n.MIDDLE,
+		...r,
+		containerId: e.id,
+		strokeColor: r.strokeColor || e.strokeColor
+	});
+	return Object.assign(e, { boundElements: (e.boundElements || []).concat({
+		type: "text",
+		id: a.id
+	}) }), g(a, e, i), [e, a];
+}, M = (e, t, n, r, i) => {
+	let a, o;
+	if (Object.assign(e, {
+		startBinding: e?.startBinding || null,
+		endBinding: e.endBinding || null
+	}), t) {
+		let n = t?.width ?? A, o = t?.height ?? A, c;
+		t.id && (c = r.getElement(t.id), c || console.error(`No element for start binding with id ${t.id} found`));
+		let l = t.x || e.x - n, u = t.y || e.y - o / 2, d = c ? c.type : t.type;
+		if (d) {
+			if (d === "text") {
+				let n = "";
+				c && c.type === "text" ? n = c.text : t.type === "text" && (n = t.text), n || console.error(`No text found for start binding text element for ${e.id}`), a = O({
+					x: l,
+					y: u,
+					type: "text",
+					...c,
+					...t,
+					text: n
+				}), Object.assign(a, {
+					x: t.x || e.x - a.width,
+					y: t.y || e.y - a.height / 2
+				});
+			} else switch (d) {
+				case "rectangle":
+				case "ellipse":
+				case "diamond":
+					a = C({
+						x: l,
+						y: u,
+						width: n,
+						height: o,
+						...c,
+						...t,
+						type: d
+					});
+					break;
+				default: s(e, `Unhandled element start type "${t.type}"`, !0);
+			}
+			_(e, a, "orbit", "start", i);
+		}
+	}
+	if (n) {
+		let t = n?.height ?? A, a = n?.width ?? A, c;
+		n.id && (c = r.getElement(n.id), c || console.error(`No element for end binding with id ${n.id} found`));
+		let l = n.x || e.x + e.width, u = n.y || e.y - t / 2, d = c ? c.type : n.type;
+		if (d) {
+			if (d === "text") {
+				let t = "";
+				c && c.type === "text" ? t = c.text : n.type === "text" && (t = n.text), t || console.error(`No text found for end binding text element for ${e.id}`), o = O({
+					x: l,
+					y: u,
+					type: "text",
+					...c,
+					...n,
+					text: t
+				}), Object.assign(o, { y: n.y || e.y - o.height / 2 });
+			} else switch (d) {
+				case "rectangle":
+				case "ellipse":
+				case "diamond":
+					o = C({
+						x: l,
+						y: u,
+						width: a,
+						height: t,
+						...c,
+						...n,
+						type: d
+					});
+					break;
+				default: s(e, `Unhandled element end type "${d}"`, !0);
+			}
+			_(e, o, "orbit", "end", i);
+		}
+	}
+	if (e.points.length < 2) return {
+		linearElement: e,
+		startBoundElement: a,
+		endBoundElement: o
+	};
+	let l = e.points.length - 1, u = .5, d = c(e.points);
+	return e.points[l][0] > e.points[l - 1][0] && (d[0][0] = u, d[l][0] -= u), e.points[l][0] < e.points[l - 1][0] && (d[0][0] = -.5, d[l][0] += u), e.points[l][1] > e.points[l - 1][1] && (d[0][1] = u, d[l][1] -= u), e.points[l][1] < e.points[l - 1][1] && (d[0][1] = -.5, d[l][1] += u), Object.assign(e, y.getNormalizeElementPointsAndCoords({
+		...e,
+		points: d
+	})), {
+		linearElement: e,
+		startBoundElement: a,
+		endBoundElement: o
+	};
+}, N = class {
+	constructor() {
+		this.drawElements = /* @__PURE__ */ new Map(), this.add = (e) => {
+			e && this.drawElements.set(e.id, e);
+		}, this.getElements = () => v(Array.from(this.drawElements.values())), this.getElementsMap = () => d(o(this.getElements())), this.getElement = (e) => this.drawElements.get(e);
+	}
+}, P = (t, n) => {
+	if (!t) return [];
+	let o = c(t), d = new N(), g = /* @__PURE__ */ new Map(), _ = /* @__PURE__ */ new Map();
+	for (let t of o) {
+		let o, c = t.id;
+		switch (n?.regenerateIds !== !1 && Object.assign(t, { id: f() }), t.type) {
+			case "rectangle":
+			case "ellipse":
+			case "diamond": {
+				let e = t?.label?.text && t.width === void 0 ? 0 : t?.width || A, n = t?.label?.text && t.height === void 0 ? 0 : t?.height || A;
+				o = C({
+					...t,
+					width: e,
+					height: n
+				});
+				break;
+			}
+			case "line": {
+				let e = t.width || k.width, n = t.height || k.height;
+				o = E({
+					width: e,
+					height: n,
+					points: [i(0, 0), i(e, n)],
+					...t
+				});
+				break;
+			}
+			case "arrow": {
+				let e = t.width || k.width, n = t.height || k.height;
+				o = S({
+					width: e,
+					height: n,
+					endArrowhead: "arrow",
+					points: [i(0, 0), i(e, n)],
+					...t,
+					type: "arrow"
+				}), Object.assign(o, a(o.points));
+				break;
+			}
+			case "text": {
+				let n = t?.fontFamily || e, i = t?.fontSize || 20, a = t?.lineHeight || r(n), s = m(h(t.text ?? ""), l({
+					fontFamily: n,
+					fontSize: i
+				}), a);
+				o = O({
+					width: s.width,
+					height: s.height,
+					fontFamily: n,
+					fontSize: i,
+					...t
+				});
+				break;
+			}
+			case "image":
+				o = T({
+					width: t?.width || A,
+					height: t?.height || A,
+					...t
+				});
+				break;
+			case "frame":
+				o = w({
+					x: 0,
+					y: 0,
+					...t
+				});
+				break;
+			case "magicframe":
+				o = D({
+					x: 0,
+					y: 0,
+					...t
+				});
+				break;
+			case "freedraw":
+			case "iframe":
+			case "embeddable":
+				o = t;
+				break;
+			default: o = t, s(t, `Unhandled element type "${t.type}"`, !0);
+		}
+		d.getElement(o.id) ? console.error(`Duplicate id found for ${o.id}`) : (d.add(o), g.set(o.id, t), c && _.set(c, o.id));
+	}
+	let v = new x(d.getElementsMap());
+	for (let [e, t] of g) {
+		let n = d.getElement(e);
+		switch (t.type) {
+			case "rectangle":
+			case "ellipse":
+			case "diamond":
+			case "arrow":
+				if (t.label?.text) {
+					let [e, r] = j(n, t?.label, v);
+					if (d.add(e), d.add(r), p(e)) {
+						let n = t.type === "arrow" ? t?.start : void 0, r = t.type === "arrow" ? t?.end : void 0;
+						if (n && n.id) {
+							let e = _.get(n.id);
+							e && Object.assign(n, { id: e });
+						}
+						if (r && r.id) {
+							let e = _.get(r.id);
+							e && Object.assign(r, { id: e });
+						}
+						let { linearElement: i, startBoundElement: a, endBoundElement: o } = M(e, n, r, d, v);
+						e = i, d.add(i), d.add(a), d.add(o);
+					}
+				} else switch (t.type) {
+					case "arrow": {
+						let { start: e, end: r } = t;
+						if (e && e.id) {
+							let t = _.get(e.id);
+							Object.assign(e, { id: t });
+						}
+						if (r && r.id) {
+							let e = _.get(r.id);
+							Object.assign(r, { id: e });
+						}
+						let { linearElement: i, startBoundElement: a, endBoundElement: o } = M(n, e, r, d, v);
+						d.add(i), d.add(a), d.add(o);
+						break;
+					}
+				}
+				break;
+		}
+	}
+	for (let [e, t] of g) {
+		if (t.type !== "frame" && t.type !== "magicframe") continue;
+		let n = d.getElement(e);
+		if (!n) throw Error(`Draw element with id ${e} doesn't exist`);
+		let r = [];
+		t.children.forEach((e) => {
+			let t = _.get(e);
+			if (!t) throw Error(`Element with ${e} wasn't mapped correctly`);
+			let i = d.getElement(t);
+			if (!i) throw Error(`Frame element with id ${t} doesn't exist`);
+			Object.assign(i, { frameId: n.id }), i?.boundElements?.forEach?.((e) => {
+				let t = d.getElement(e.id);
+				if (!t) throw Error(`Bound element with id ${e.id} doesn't exist`);
+				Object.assign(t, { frameId: n.id }), r.push(t);
+			}), r.push(i);
+		});
+		let [i, a, o, s] = b(r);
+		i -= 10, a -= 10, o += 10, s += 10;
+		let c = n?.x || i, l = n?.y || a, f = n?.width || o - i, p = n?.height || s - a;
+		Object.assign(n, {
+			x: c,
+			y: l,
+			width: f,
+			height: p
+		}), u() && t.children.length && (n?.x || n?.y || n?.width || n?.height) && console.info("User provided frame attributes are being considered, if you find this inaccurate, please remove any of the attributes - x, y, width and height so frame coordinates and dimensions are calculated automatically");
+	}
+	return d.getElements();
+};
+//#endregion
+export { P as convertToDrawElements };
+/* 独立思考，明辨是非 */

package/draw/element/transformHandles.d.ts

@@ -0,0 +1,35 @@
+import type { Bounds, EditorInterface } from '../common';
+import type { InteractiveCanvasAppState, Zoom } from '../interface';
+import type { Radians } from '../libs/math';
+import type { DrawElement, ElementsMap, NonDeletedDrawElement, PointerType } from './types';
+export type TransformHandleDirection = 'n' | 's' | 'w' | 'e' | 'nw' | 'ne' | 'sw' | 'se';
+export type TransformHandleType = TransformHandleDirection | 'rotation';
+export type TransformHandle = Bounds;
+export type TransformHandles = Partial<{
+    [T in TransformHandleType]: TransformHandle;
+}>;
+export type MaybeTransformHandleType = TransformHandleType | false;
+export declare const DEFAULT_OMIT_SIDES: {
+    e: boolean;
+    s: boolean;
+    n: boolean;
+    w: boolean;
+};
+export declare const OMIT_SIDES_FOR_MULTIPLE_ELEMENTS: {
+    e: boolean;
+    s: boolean;
+    n: boolean;
+    w: boolean;
+};
+export declare const OMIT_SIDES_FOR_FRAME: {
+    e: boolean;
+    s: boolean;
+    n: boolean;
+    w: boolean;
+    rotation: boolean;
+};
+export declare const canResizeFromSides: (editorInterface: EditorInterface) => boolean;
+export declare const getOmitSidesForEditorInterface: (editorInterface: EditorInterface) => {};
+export declare const getTransformHandlesFromCoords: ([x1, y1, x2, y2, cx, cy]: [number, number, number, number, number, number], angle: Radians, zoom: Zoom, pointerType: PointerType, omitSides?: { [T in TransformHandleType]?: boolean; }, margin?: number, spacing?: number) => TransformHandles;
+export declare const getTransformHandles: (element: DrawElement, zoom: Zoom, elementsMap: ElementsMap, pointerType?: PointerType, omitSides?: { [T in TransformHandleType]?: boolean; }) => TransformHandles;
+export declare const hasBoundingBox: (elements: readonly NonDeletedDrawElement[], appState: InteractiveCanvasAppState, editorInterface: EditorInterface) => boolean;