@unicom-cloud/ui 0.8.168 → 0.8.169

package/draw/core/snapping.js

@@ -0,0 +1,544 @@
+/* 潘启宝 2026-06-25 08:58:50 星期四 山东省济南市 */
+import { TOOL_TYPE as e } from "../common/constants.js";
+import { KEYS as t } from "../common/keys.js";
+import { pointFrom as n, pointRotateRads as r } from "../libs/math/point.js";
+import { rangeInclusive as i, rangeIntersection as a, rangesOverlap as o } from "../libs/math/range.js";
+import "../libs/math/index.js";
+import "../common/index.js";
+import { isBoundToContainer as s } from "../element/typeChecks.js";
+import { getSelectedElements as c, getVisibleAndNonSelectedElements as l } from "../element/selection.js";
+import { getMaximumGroups as u } from "../element/groups.js";
+import { getCommonBounds as d, getDraggedElementsBounds as f, getElementAbsoluteCoords as p } from "../element/bounds.js";
+import "../element/index.js";
+//#region components/pc/draw/core/snapping.ts
+var m = 8, h = 99999, g = (e) => m / e, _ = class e {
+	static #e = null;
+	static #t = null;
+	static {
+		this.setReferenceSnapPoints = (t) => {
+			e.#e = t;
+		};
+	}
+	static {
+		this.getReferenceSnapPoints = () => e.#e;
+	}
+	static {
+		this.setVisibleGaps = (t) => {
+			e.#t = t;
+		};
+	}
+	static {
+		this.getVisibleGaps = () => e.#t;
+	}
+	static {
+		this.destroy = () => {
+			e.#e = null, e.#t = null;
+		};
+	}
+}, v = (e) => e.props.gridModeEnabled ?? e.state.gridModeEnabled, y = ({ event: e, app: n, selectedElements: r }) => {
+	if (e) {
+		let r = n.state.activeTool.type === "lasso" && n.state.selectedElementsAreBeingDragged;
+		return (n.state.activeTool.type !== "lasso" || r) && (n.state.objectsSnapModeEnabled && !e[t.CTRL_OR_CMD] || !n.state.objectsSnapModeEnabled && e[t.CTRL_OR_CMD] && !v(n));
+	}
+	return r.length === 1 && r[0].type === "arrow" ? !1 : n.state.objectsSnapModeEnabled;
+}, b = (e, t, n = .01) => Math.abs(e - t) <= n, x = (e, t, { omitCenter: i, boundingBoxCorners: a, dragOffset: o } = {
+	omitCenter: !1,
+	boundingBoxCorners: !1
+}) => {
+	let s = [];
+	if (e.length === 1) {
+		let c = e[0], [l, u, d, f, m, h] = p(c, t);
+		o && (l += o.x, d += o.x, m += o.x, u += o.y, f += o.y, h += o.y);
+		let g = (d - l) / 2, _ = (f - u) / 2;
+		if ((c.type === "diamond" || c.type === "ellipse") && !a) {
+			let e = r(n(l, u + _), n(m, h), c.angle), t = r(n(l + g, u), n(m, h), c.angle), a = r(n(d, u + _), n(m, h), c.angle), o = r(n(l + g, f), n(m, h), c.angle), p = n(m, h);
+			s = i ? [
+				e,
+				t,
+				a,
+				o
+			] : [
+				e,
+				t,
+				a,
+				o,
+				p
+			];
+		} else {
+			let e = r(n(l, u), n(m, h), c.angle), t = r(n(d, u), n(m, h), c.angle), a = r(n(l, f), n(m, h), c.angle), o = r(n(d, f), n(m, h), c.angle), p = n(m, h);
+			s = i ? [
+				e,
+				t,
+				a,
+				o
+			] : [
+				e,
+				t,
+				a,
+				o,
+				p
+			];
+		}
+	} else if (e.length > 1) {
+		let [t, r, a, c] = f(e, o ?? {
+			x: 0,
+			y: 0
+		}), l = a - t, u = c - r, d = n(t, r), p = n(a, r), m = n(t, c), h = n(a, c), g = n(t + l / 2, r + u / 2);
+		s = i ? [
+			d,
+			p,
+			m,
+			h
+		] : [
+			d,
+			p,
+			m,
+			h,
+			g
+		];
+	}
+	return s.map((e) => n(O(e[0]), O(e[1])));
+}, S = (e, t, n, r) => l(e, t, n, r), C = (e, t, r, c) => {
+	let l = u(S(e, t, r, c), c).filter((e) => !(e.length === 1 && s(e[0]))).map((e) => d(e).map((e) => O(e))), f = l.sort((e, t) => e[0] - t[0]), p = [], m = 0;
+	horizontal: for (let e = 0; e < f.length; e++) {
+		let t = f[e];
+		for (let r = e + 1; r < f.length; r++) {
+			if (++m > h) break horizontal;
+			let e = f[r], [, s, c, l] = t, [u, d, , g] = e;
+			c < u && o(i(s, l), i(d, g)) && p.push({
+				startBounds: t,
+				endBounds: e,
+				startSide: [n(c, s), n(c, l)],
+				endSide: [n(u, d), n(u, g)],
+				length: u - c,
+				overlap: a(i(s, l), i(d, g))
+			});
+		}
+	}
+	let g = l.sort((e, t) => e[1] - t[1]), _ = [];
+	m = 0;
+	vertical: for (let e = 0; e < g.length; e++) {
+		let t = g[e];
+		for (let r = e + 1; r < g.length; r++) {
+			if (++m > h) break vertical;
+			let e = g[r], [s, , c, l] = t, [u, d, f] = e;
+			l < d && o(i(s, c), i(u, f)) && _.push({
+				startBounds: t,
+				endBounds: e,
+				startSide: [n(s, l), n(c, l)],
+				endSide: [n(u, d), n(f, d)],
+				length: d - l,
+				overlap: a(i(s, c), i(u, f))
+			});
+		}
+	}
+	return {
+		horizontalGaps: p,
+		verticalGaps: _
+	};
+}, w = (e, t, n, r, a, s, c) => {
+	if (!y({
+		app: n,
+		event: r,
+		selectedElements: e
+	}) || e.length === 0) return [];
+	let l = _.getVisibleGaps();
+	if (l) {
+		let { horizontalGaps: n, verticalGaps: r } = l, [u, d, p, m] = f(e, t).map((e) => O(e)), h = (u + p) / 2, g = (d + m) / 2;
+		for (let e of n) {
+			if (!o(i(d, m), e.overlap)) continue;
+			let t = O(e.startSide[0][0] + e.length / 2 - h);
+			if (e.length > p - u && Math.abs(t) <= c.x) {
+				Math.abs(t) < c.x && (a.length = 0), c.x = Math.abs(t);
+				let n = {
+					type: "gap",
+					direction: "center_horizontal",
+					gap: e,
+					offset: t
+				};
+				a.push(n);
+				continue;
+			}
+			let [, , n] = e.endBounds, r = u - n, s = O(e.length - r);
+			if (Math.abs(s) <= c.x) {
+				Math.abs(s) < c.x && (a.length = 0), c.x = Math.abs(s);
+				let t = {
+					type: "gap",
+					direction: "side_right",
+					gap: e,
+					offset: s
+				};
+				a.push(t);
+				continue;
+			}
+			let [l, , ,] = e.startBounds, f = O(l - p - e.length);
+			if (Math.abs(f) <= c.x) {
+				Math.abs(f) < c.x && (a.length = 0), c.x = Math.abs(f);
+				let t = {
+					type: "gap",
+					direction: "side_left",
+					gap: e,
+					offset: f
+				};
+				a.push(t);
+				continue;
+			}
+		}
+		for (let e of r) {
+			if (!o(i(u, p), e.overlap)) continue;
+			let t = O(e.startSide[0][1] + e.length / 2 - g);
+			if (e.length > m - d && Math.abs(t) <= c.y) {
+				Math.abs(t) < c.y && (s.length = 0), c.y = Math.abs(t);
+				let n = {
+					type: "gap",
+					direction: "center_vertical",
+					gap: e,
+					offset: t
+				};
+				s.push(n);
+				continue;
+			}
+			let [, n, ,] = e.startBounds, r = O(n - m - e.length);
+			if (Math.abs(r) <= c.y) {
+				Math.abs(r) < c.y && (s.length = 0), c.y = Math.abs(r);
+				let t = {
+					type: "gap",
+					direction: "side_top",
+					gap: e,
+					offset: r
+				};
+				s.push(t);
+				continue;
+			}
+			let [, , , a] = e.endBounds, l = O(d - a), f = e.length - l;
+			if (Math.abs(f) <= c.y) {
+				Math.abs(f) < c.y && (s.length = 0), c.y = Math.abs(f);
+				let t = {
+					type: "gap",
+					direction: "side_bottom",
+					gap: e,
+					offset: f
+				};
+				s.push(t);
+				continue;
+			}
+		}
+	}
+}, T = (e, t, n, r) => u(S(e, t, n, r), r).filter((e) => !(e.length === 1 && s(e[0]))).flatMap((e) => x(e, r)), E = (e, t, n, r, i, a, o) => {
+	if (!y({
+		app: n,
+		event: r,
+		selectedElements: e
+	}) || e.length === 0 && t.length === 0) return [];
+	let s = _.getReferenceSnapPoints();
+	if (s) for (let e of t) for (let t of s) {
+		let n = t[0] - e[0], r = t[1] - e[1];
+		Math.abs(n) <= o.x && (Math.abs(n) < o.x && (i.length = 0), i.push({
+			type: "point",
+			points: [e, t],
+			offset: n
+		}), o.x = Math.abs(n)), Math.abs(r) <= o.y && (Math.abs(r) < o.y && (a.length = 0), a.push({
+			type: "point",
+			points: [e, t],
+			offset: r
+		}), o.y = Math.abs(r));
+	}
+}, D = (e, t, n, r, i) => {
+	let a = n.state, o = c(e, a);
+	if (!y({
+		app: n,
+		event: r,
+		selectedElements: o
+	}) || o.length === 0) return {
+		snapOffset: {
+			x: 0,
+			y: 0
+		},
+		snapLines: []
+	};
+	t.x = O(t.x), t.y = O(t.y);
+	let s = [], l = [], u = g(a.zoom.value), d = {
+		x: u,
+		y: u
+	};
+	E(o, x(o, i, { dragOffset: t }), n, r, s, l, d), w(o, t, n, r, s, l, d);
+	let f = {
+		x: s[0]?.offset ?? 0,
+		y: l[0]?.offset ?? 0
+	};
+	d.x = 0, d.y = 0, s.length = 0, l.length = 0;
+	let p = {
+		x: O(t.x + f.x),
+		y: O(t.y + f.y)
+	};
+	E(o, x(o, i, { dragOffset: p }), n, r, s, l, d), w(o, p, n, r, s, l, d);
+	let m = A(s, l), h = M(o, p, [...s, ...l].filter((e) => e.type === "gap"));
+	return {
+		snapOffset: f,
+		snapLines: [...m, ...h]
+	};
+}, O = (e) => Math.round(e * 10 ** 6) / 10 ** 6, k = (e) => {
+	let t = /* @__PURE__ */ new Map();
+	for (let n of e) {
+		let e = n.join(",");
+		t.has(e) || t.set(e, n);
+	}
+	return Array.from(t.values());
+}, A = (e, t) => {
+	let r = {}, i = {};
+	if (e.length > 0) {
+		for (let t of e) if (t.type === "point") {
+			let e = O(t.points[0][0]);
+			r[e] || (r[e] = []), r[e].push(...t.points.map((e) => n(O(e[0]), O(e[1]))));
+		}
+	}
+	if (t.length > 0) {
+		for (let e of t) if (e.type === "point") {
+			let t = O(e.points[0][1]);
+			i[t] || (i[t] = []), i[t].push(...e.points.map((e) => n(O(e[0]), O(e[1]))));
+		}
+	}
+	return Object.entries(r).map(([e, t]) => ({
+		type: "points",
+		points: k(t.map((t) => n(Number(e), t[1])).sort((e, t) => e[1] - t[1]))
+	})).concat(Object.entries(i).map(([e, t]) => ({
+		type: "points",
+		points: k(t.map((t) => n(t[0], Number(e))).sort((e, t) => e[0] - t[0]))
+	})));
+}, j = (e) => {
+	let t = /* @__PURE__ */ new Map();
+	for (let n of e) {
+		let e = n.points.flat().map((e) => [O(e)]).join(",");
+		t.has(e) || t.set(e, n);
+	}
+	return Array.from(t.values());
+}, M = (e, t, r) => {
+	let [o, s, c, l] = f(e, t), u = [];
+	for (let e of r) {
+		let [t, r, d, f] = e.gap.startBounds, [p, m, h, g] = e.gap.endBounds, _ = a(i(s, l), e.gap.overlap), v = a(i(o, c), e.gap.overlap);
+		switch (e.direction) {
+			case "center_horizontal":
+				if (_) {
+					let t = (_[0] + _[1]) / 2;
+					u.push({
+						type: "gap",
+						direction: "horizontal",
+						points: [n(e.gap.startSide[0][0], t), n(o, t)]
+					}, {
+						type: "gap",
+						direction: "horizontal",
+						points: [n(c, t), n(e.gap.endSide[0][0], t)]
+					});
+				}
+				break;
+			case "center_vertical":
+				if (v) {
+					let t = (v[0] + v[1]) / 2;
+					u.push({
+						type: "gap",
+						direction: "vertical",
+						points: [n(t, e.gap.startSide[0][1]), n(t, s)]
+					}, {
+						type: "gap",
+						direction: "vertical",
+						points: [n(t, l), n(t, e.gap.endSide[0][1])]
+					});
+				}
+				break;
+			case "side_right":
+				if (_) {
+					let e = (_[0] + _[1]) / 2;
+					u.push({
+						type: "gap",
+						direction: "horizontal",
+						points: [n(d, e), n(p, e)]
+					}, {
+						type: "gap",
+						direction: "horizontal",
+						points: [n(h, e), n(o, e)]
+					});
+				}
+				break;
+			case "side_left":
+				if (_) {
+					let e = (_[0] + _[1]) / 2;
+					u.push({
+						type: "gap",
+						direction: "horizontal",
+						points: [n(c, e), n(t, e)]
+					}, {
+						type: "gap",
+						direction: "horizontal",
+						points: [n(d, e), n(p, e)]
+					});
+				}
+				break;
+			case "side_top":
+				if (v) {
+					let e = (v[0] + v[1]) / 2;
+					u.push({
+						type: "gap",
+						direction: "vertical",
+						points: [n(e, l), n(e, r)]
+					}, {
+						type: "gap",
+						direction: "vertical",
+						points: [n(e, f), n(e, m)]
+					});
+				}
+				break;
+			case "side_bottom":
+				if (v) {
+					let e = (v[0] + v[1]) / 2;
+					u.push({
+						type: "gap",
+						direction: "vertical",
+						points: [n(e, f), n(e, m)]
+					}, {
+						type: "gap",
+						direction: "vertical",
+						points: [n(e, g), n(e, s)]
+					});
+				}
+				break;
+		}
+	}
+	return j(u.map((e) => ({
+		...e,
+		points: e.points.map((e) => n(O(e[0]), O(e[1])))
+	})));
+}, N = (e, t, r, i, a, o) => {
+	if (!y({
+		event: i,
+		selectedElements: e,
+		app: r
+	}) || e.length === 0 || e.length === 1 && !b(e[0].angle, 0)) return {
+		snapOffset: {
+			x: 0,
+			y: 0
+		},
+		snapLines: []
+	};
+	let [s, c, l, u] = d(t);
+	o && (o.includes("e") ? l += a.x : o.includes("w") && (s += a.x), o.includes("n") ? c += a.y : o.includes("s") && (u += a.y));
+	let f = [];
+	if (o) switch (o) {
+		case "e":
+			f.push(n(l, c), n(l, u));
+			break;
+		case "w":
+			f.push(n(s, c), n(s, u));
+			break;
+		case "n":
+			f.push(n(s, c), n(l, c));
+			break;
+		case "s":
+			f.push(n(s, u), n(l, u));
+			break;
+		case "ne":
+			f.push(n(l, c));
+			break;
+		case "nw":
+			f.push(n(s, c));
+			break;
+		case "se":
+			f.push(n(l, u));
+			break;
+		case "sw":
+			f.push(n(s, u));
+			break;
+	}
+	let p = g(r.state.zoom.value), m = {
+		x: p,
+		y: p
+	}, h = [], _ = [];
+	E(t, f, r, i, h, _, m);
+	let v = {
+		x: h[0]?.offset ?? 0,
+		y: _[0]?.offset ?? 0
+	};
+	m.x = 0, m.y = 0, h.length = 0, _.length = 0;
+	let [x, S, C, w] = d(e).map((e) => O(e));
+	return E(e, [
+		n(x, S),
+		n(x, w),
+		n(C, S),
+		n(C, w)
+	], r, i, h, _, m), {
+		snapOffset: v,
+		snapLines: A(h, _)
+	};
+}, P = (e, t, r, i, a, o) => {
+	if (!y({
+		event: r,
+		selectedElements: [e],
+		app: t
+	})) return {
+		snapOffset: {
+			x: 0,
+			y: 0
+		},
+		snapLines: []
+	};
+	let s = [n(i.x + a.x, i.y + a.y)], c = g(t.state.zoom.value), l = {
+		x: c,
+		y: c
+	}, u = [], d = [];
+	E([e], s, t, r, u, d, l);
+	let f = {
+		x: u[0]?.offset ?? 0,
+		y: d[0]?.offset ?? 0
+	};
+	l.x = 0, l.y = 0, u.length = 0, d.length = 0;
+	let p = x([e], o, {
+		boundingBoxCorners: !0,
+		omitCenter: !0
+	});
+	return E([e], p, t, r, u, d, l), {
+		snapOffset: f,
+		snapLines: A(u, d)
+	};
+}, F = (e, t, r, i, a) => {
+	if (!y({
+		event: i,
+		selectedElements: [],
+		app: t
+	})) return {
+		originOffset: {
+			x: 0,
+			y: 0
+		},
+		snapLines: []
+	};
+	let o = l(e, [], t.state, a), s = g(t.state.zoom.value), c = {
+		x: s,
+		y: s
+	}, u = [], d = [];
+	for (let e of o) {
+		let t = x([e], a);
+		for (let e of t) {
+			let t = e[0] - r.x;
+			Math.abs(t) <= Math.abs(c.x) && (Math.abs(t) < Math.abs(c.x) && (d.length = 0), d.push({
+				type: "pointer",
+				points: [e, n(e[0], r.y)],
+				direction: "vertical"
+			}), c.x = t);
+			let i = e[1] - r.y;
+			Math.abs(i) <= Math.abs(c.y) && (Math.abs(i) < Math.abs(c.y) && (u.length = 0), u.push({
+				type: "pointer",
+				points: [e, n(r.x, e[1])],
+				direction: "horizontal"
+			}), c.y = i);
+		}
+	}
+	return {
+		originOffset: {
+			x: d.length > 0 ? d[0].points[0][0] - r.x : 0,
+			y: u.length > 0 ? u[0].points[0][1] - r.y : 0
+		},
+		snapLines: [...d, ...u]
+	};
+}, I = (t) => t === e.rectangle || t === e.ellipse || t === e.diamond || t === e.frame || t === e.magicframe || t === e.image || t === e.text;
+//#endregion
+export { _ as SnapCache, T as getReferenceSnapPoints, F as getSnapLinesAtPointer, C as getVisibleGaps, I as isActiveToolNonLinearSnappable, v as isGridModeEnabled, y as isSnappingEnabled, D as snapDraggedElements, P as snapNewElement, N as snapResizingElements };
+/* 独立思考，明辨是非 */

package/draw/core/workers.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Pool of idle short-lived workers.
+ *
+ * IMPORTANT: for simplicity it does not limit the number of newly created workers, leaving it up to the caller to manage the pool size.
+ */
+export declare class WorkerPool<T, R> {
+    #private;
+    private constructor();
+    /**
+     * Create a new worker pool.
+     *
+     * @param workerUrl - The URL of the worker file.
+     * @param options - The options for the worker pool.
+     * @throws If the worker is bundled into the main chunk.
+     * @returns A new worker pool instance.
+     */
+    static create<T, R>(workerUrl: URL | undefined, options?: {
+        ttl?: number;
+    }): WorkerPool<T, R>;
+    /**
+     * Take idle worker from the pool or create a new one and post a message to it.
+     */
+    postMessage(data: T, options: StructuredSerializeOptions): Promise<R>;
+    /**
+     * Terminate the idle workers in the pool.
+     */
+    clear(): Promise<void>;
+}

package/draw/core/wysiwyg/textWysiwyg.d.ts

@@ -0,0 +1,24 @@
+import type { DrawElement, DrawTextElement } from '../../element/types';
+import type App from '../components/App';
+type SubmitHandler = () => void;
+export declare const textWysiwyg: ({ id, onChange, onSubmit, getViewportCoords, element, canvas, drawContainer, app, autoSelect, }: {
+    id: DrawElement["id"];
+    /**
+     * textWysiwyg only deals with `originalText`
+     *
+     * Note: `text`, which can be wrapped and therefore different from `originalText`,
+     *       is derived from `originalText`
+     */
+    onChange?: (nextOriginalText: string) => void;
+    onSubmit: (data: {
+        viaKeyboard: boolean;
+        nextOriginalText: string;
+    }) => void;
+    getViewportCoords: (x: number, y: number) => [number, number];
+    element: DrawTextElement;
+    canvas: HTMLCanvasElement;
+    drawContainer: HTMLDivElement | null;
+    app: App;
+    autoSelect?: boolean;
+}) => SubmitHandler;
+export {};