@unicom-cloud/ui 0.8.168 → 0.8.169

package/draw/element/transformHandles.js

@@ -0,0 +1,67 @@
+/* 潘启宝 2026-06-25 08:58:50 星期四 山东省济南市 */
+import { pointFrom as e, pointRotateRads as t } from "../libs/math/point.js";
+import "../libs/math/index.js";
+import "../common/index.js";
+import { isElbowArrow as n, isFrameLikeElement as r, isImageElement as i, isLinearElement as a } from "./typeChecks.js";
+import { getElementAbsoluteCoords as o } from "./bounds.js";
+//#region components/pc/draw/element/transformHandles.ts
+var s = {
+	mouse: 8,
+	pen: 16,
+	touch: 28
+}, c = 16, l = {
+	e: !0,
+	s: !0,
+	n: !0,
+	w: !0
+}, u = {
+	e: !0,
+	s: !0,
+	n: !0,
+	w: !0,
+	nw: !0,
+	se: !0
+}, d = {
+	e: !0,
+	s: !0,
+	n: !0,
+	w: !0
+}, f = (n, r, i, a, o, s, c) => {
+	let [l, u] = t(e(n + i / 2, r + a / 2), e(o, s), c);
+	return [
+		l - i / 2,
+		u - a / 2,
+		i,
+		a
+	];
+}, p = (e) => !(e.formFactor === "phone" && e.userAgent.isMobileDevice), m = (e) => p(e) ? l : {}, h = ([e, t, n, r, i, a], o, l, u, d = {}, p = 4, m = 2) => {
+	let h = s[u], g = h / l.value, _ = h / l.value, v = h / l.value, y = h / l.value, b = n - e, x = r - t, S = p / l.value, C = (h - m * 2) / (2 * l.value), w = {
+		nw: d.nw ? void 0 : f(e - S - v + C, t - S - y + C, g, _, i, a, o),
+		ne: d.ne ? void 0 : f(n + S - C, t - S - y + C, g, _, i, a, o),
+		sw: d.sw ? void 0 : f(e - S - v + C, r + S - C, g, _, i, a, o),
+		se: d.se ? void 0 : f(n + S - C, r + S - C, g, _, i, a, o),
+		rotation: d.rotation ? void 0 : f(e + b / 2 - g / 2, t - S - y + C - c / l.value, g, _, i, a, o)
+	}, T = 5 * s.mouse / l.value;
+	return Math.abs(b) > T && (d.n || (w.n = f(e + b / 2 - g / 2, t - S - y + C, g, _, i, a, o)), d.s || (w.s = f(e + b / 2 - g / 2, r + S - C, g, _, i, a, o))), Math.abs(x) > T && (d.w || (w.w = f(e - S - v + C, t + x / 2 - _ / 2, g, _, i, a, o)), d.e || (w.e = f(n + S - C, t + x / 2 - _ / 2, g, _, i, a, o))), w;
+}, g = (e, t, s, c = "mouse", f = l) => {
+	if (e.locked || n(e)) return {};
+	if (e.type === "freedraw" || a(e)) {
+		if (e.points.length === 2) {
+			let [, t] = e.points;
+			t[0] === 0 || t[1] === 0 ? f = d : t[0] > 0 && t[1] < 0 ? f = u : t[0] > 0 && t[1] > 0 ? f = d : t[0] < 0 && t[1] > 0 ? f = u : t[0] < 0 && t[1] < 0 && (f = d);
+		}
+	} else r(e) && (f = {
+		...f,
+		rotation: !0
+	});
+	let p = a(e) ? 10 : i(e) ? 0 : 2;
+	return h(o(e, s, !0), e.angle, t, c, f, p, i(e) ? 0 : void 0);
+}, _ = (e, t, r) => {
+	if (t.selectedLinearElement?.isEditing || t.selectedLinearElement?.isDragging) return !1;
+	if (e.length > 1) return !0;
+	let i = e[0];
+	return n(i) ? !1 : a(i) ? i.points.length > 2 && !r.userAgent.isMobileDevice : !0;
+};
+//#endregion
+export { l as DEFAULT_OMIT_SIDES, p as canResizeFromSides, m as getOmitSidesForEditorInterface, g as getTransformHandles, h as getTransformHandlesFromCoords, _ as hasBoundingBox };
+/* 独立思考，明辨是非 */

package/draw/element/typeChecks.d.ts

@@ -0,0 +1,54 @@
+import type { MarkNonNullable } from '../common/utility-types';
+import type { ElementOrToolType } from '../interface';
+import type { DrawArrowElement, DrawBindableElement, DrawElbowArrowElement, DrawElement, DrawElementType, DrawEmbeddableElement, DrawFlowchartNodeElement, DrawFrameElement, DrawFrameLikeElement, DrawFreeDrawElement, DrawIframeElement, DrawIframeLikeElement, DrawImageElement, DrawLineElement, DrawLinearElement, DrawLinearElementSubType, DrawMagicFrameElement, DrawTextContainer, DrawTextElement, DrawTextElementWithContainer, InitializedDrawImageElement, RoundnessType } from './types';
+export declare const isInitializedImageElement: (element: DrawElement | null) => element is InitializedDrawImageElement;
+export declare const isImageElement: (element: DrawElement | null) => element is DrawImageElement;
+export declare const isEmbeddableElement: (element: DrawElement | null | undefined) => element is DrawEmbeddableElement;
+export declare const isIframeElement: (element: DrawElement | null) => element is DrawIframeElement;
+export declare const isIframeLikeElement: (element: DrawElement | null) => element is DrawIframeLikeElement;
+export declare const isTextElement: (element: DrawElement | null) => element is DrawTextElement;
+export declare const isFrameElement: (element: DrawElement | null) => element is DrawFrameElement;
+export declare const isMagicFrameElement: (element: DrawElement | null) => element is DrawMagicFrameElement;
+export declare const isFrameLikeElement: (element: DrawElement | null) => element is DrawFrameLikeElement;
+export declare const isFreeDrawElement: (element?: DrawElement | null) => element is DrawFreeDrawElement;
+export declare const isFreeDrawElementType: (elementType: DrawElementType) => boolean;
+export declare const isLinearElement: (element?: DrawElement | null) => element is DrawLinearElement;
+export declare const isLineElement: (element?: DrawElement | null) => element is DrawLineElement;
+export declare const isArrowElement: (element?: DrawElement | null) => element is DrawArrowElement;
+export declare const isElbowArrow: (element?: DrawElement) => element is DrawElbowArrowElement;
+/**
+ * sharp or curved arrow, but not elbow
+ */
+export declare const isSimpleArrow: (element?: DrawElement) => element is DrawArrowElement;
+export declare const isSharpArrow: (element?: DrawElement) => element is DrawArrowElement;
+export declare const isCurvedArrow: (element?: DrawElement) => element is DrawArrowElement;
+export declare const isLinearElementType: (elementType: ElementOrToolType) => boolean;
+export declare const isBindingElement: (element?: DrawElement | null, includeLocked?: boolean) => element is DrawArrowElement;
+export declare const isBindingElementType: (elementType: ElementOrToolType) => boolean;
+export declare const isBindableElement: (element: DrawElement | null | undefined, includeLocked?: boolean) => element is DrawBindableElement;
+export declare const isRectanguloidElement: (element?: DrawElement | null) => element is DrawBindableElement;
+export declare const isRectangularElement: (element?: DrawElement | null) => element is DrawBindableElement;
+export declare const isTextBindableContainer: (element: DrawElement | null, includeLocked?: boolean) => element is DrawTextContainer;
+export declare const isDrawElement: (element: any) => element is DrawElement;
+export declare const isFlowchartNodeElement: (element: DrawElement) => element is DrawFlowchartNodeElement;
+export declare const hasBoundTextElement: (element: DrawElement | null) => element is MarkNonNullable<DrawBindableElement, "boundElements">;
+export declare const isBoundToContainer: (element: DrawElement | null) => element is DrawTextElementWithContainer;
+export declare const isArrowBoundToElement: (element: DrawArrowElement) => boolean;
+export declare const isUsingAdaptiveRadius: (type: string) => type is "image" | "iframe" | "rectangle" | "embeddable";
+export declare const isUsingProportionalRadius: (type: string) => type is "line" | "arrow" | "diamond";
+export declare const canApplyRoundnessTypeToElement: (roundnessType: RoundnessType, element: DrawElement) => boolean;
+export declare const getDefaultRoundnessTypeForElement: (element: DrawElement) => {
+    type: 2;
+} | {
+    type: 3;
+} | null;
+export declare const getLinearElementSubType: (element: DrawLinearElement) => DrawLinearElementSubType;
+/**
+ * Checks if current element points meet all the conditions for polygon=true
+ * (this isn't a element type check, for that use isLineElement).
+ *
+ * If you want to check if points *can* be turned into a polygon, use
+ *  canBecomePolygon(points).
+ */
+export declare const isValidPolygon: (points: DrawLineElement["points"]) => boolean;
+export declare const canBecomePolygon: (points: DrawLineElement["points"]) => boolean;

package/draw/element/typeChecks.js

@@ -0,0 +1,30 @@
+/* 潘启宝 2026-06-25 08:58:50 星期四 山东省济南市 */
+import { ROUNDNESS as e } from "../common/constants.js";
+import { pointsEqual as t } from "../libs/math/point.js";
+import "../libs/math/index.js";
+import { assertNever as n } from "../common/utils.js";
+import "../common/index.js";
+//#region components/pc/draw/element/typeChecks.ts
+var r = (e) => !!e && e.type === "image" && !!e.fileId, i = (e) => !!e && e.type === "image", a = (e) => !!e && e.type === "embeddable", o = (e) => !!e && e.type === "iframe", s = (e) => !!e && (e.type === "iframe" || e.type === "embeddable"), c = (e) => e != null && e.type === "text", l = (e) => e != null && e.type === "frame", u = (e) => e != null && e.type === "magicframe", d = (e) => e != null && (e.type === "frame" || e.type === "magicframe"), f = (e) => e != null && p(e.type), p = (e) => e === "freedraw", m = (e) => e != null && x(e.type), h = (e) => e != null && e.type === "line", g = (e) => e != null && e.type === "arrow", _ = (e) => g(e) && e.elbowed, v = (e) => g(e) && !e.elbowed, y = (e) => g(e) && !e.elbowed && !e.roundness, b = (e) => g(e) && !e.elbowed && e.roundness !== null, x = (e) => e === "arrow" || e === "line", S = (e, t = !0) => e != null && (!e.locked || t === !0) && C(e.type), C = (e) => e === "arrow", w = (e, t = !0) => e != null && (!e.locked || t === !0) && (e.type === "rectangle" || e.type === "diamond" || e.type === "ellipse" || e.type === "image" || e.type === "iframe" || e.type === "embeddable" || e.type === "frame" || e.type === "magicframe" || e.type === "text" && !e.containerId), T = (e) => e != null && (e.type === "rectangle" || e.type === "diamond" || e.type === "image" || e.type === "iframe" || e.type === "embeddable" || e.type === "frame" || e.type === "magicframe" || e.type === "text" && !e.containerId), E = (e) => e != null && (e.type === "rectangle" || e.type === "image" || e.type === "text" || e.type === "iframe" || e.type === "embeddable" || e.type === "frame" || e.type === "magicframe" || e.type === "freedraw"), D = (e, t = !0) => e != null && (!e.locked || t === !0) && (e.type === "rectangle" || e.type === "diamond" || e.type === "ellipse" || g(e)), O = (e) => {
+	let t = e?.type;
+	if (!t) return !1;
+	switch (t) {
+		case "text":
+		case "diamond":
+		case "rectangle":
+		case "iframe":
+		case "embeddable":
+		case "ellipse":
+		case "arrow":
+		case "freedraw":
+		case "line":
+		case "frame":
+		case "magicframe":
+		case "image":
+		case "selection": return !0;
+		default: return n(t, null), !1;
+	}
+}, k = (e) => e.type === "rectangle" || e.type === "ellipse" || e.type === "diamond", A = (e) => D(e) && !!e.boundElements?.some?.(({ type: e }) => e === "text"), j = (e) => e !== null && "containerId" in e && e.containerId !== null && c(e), M = (e) => !!e.startBinding || !!e.endBinding, N = (e) => e === "rectangle" || e === "embeddable" || e === "iframe" || e === "image", P = (e) => e === "line" || e === "arrow" || e === "diamond", F = (t, n) => !!((t === e.ADAPTIVE_RADIUS || t === e.LEGACY) && N(n.type) || t === e.PROPORTIONAL_RADIUS && P(n.type)), I = (t) => P(t.type) ? { type: e.PROPORTIONAL_RADIUS } : N(t.type) ? { type: e.ADAPTIVE_RADIUS } : null, L = (e) => y(e) ? "sharpArrow" : b(e) ? "curvedArrow" : _(e) ? "elbowArrow" : "line", R = (e) => e.length > 3 && t(e[0], e[e.length - 1]), z = (e) => e.length > 3 || e.length === 3 && !t(e[0], e[e.length - 1]);
+//#endregion
+export { F as canApplyRoundnessTypeToElement, z as canBecomePolygon, I as getDefaultRoundnessTypeForElement, L as getLinearElementSubType, A as hasBoundTextElement, M as isArrowBoundToElement, g as isArrowElement, w as isBindableElement, S as isBindingElement, C as isBindingElementType, j as isBoundToContainer, b as isCurvedArrow, O as isDrawElement, _ as isElbowArrow, a as isEmbeddableElement, k as isFlowchartNodeElement, l as isFrameElement, d as isFrameLikeElement, f as isFreeDrawElement, p as isFreeDrawElementType, o as isIframeElement, s as isIframeLikeElement, i as isImageElement, r as isInitializedImageElement, h as isLineElement, m as isLinearElement, x as isLinearElementType, u as isMagicFrameElement, E as isRectangularElement, T as isRectanguloidElement, y as isSharpArrow, v as isSimpleArrow, D as isTextBindableContainer, c as isTextElement, N as isUsingAdaptiveRadius, P as isUsingProportionalRadius, R as isValidPolygon };
+/* 独立思考，明辨是非 */

package/draw/element/types.d.ts

@@ -0,0 +1,291 @@
+import type { FONT_FAMILY, ROUNDNESS, TEXT_ALIGN, THEME, VERTICAL_ALIGN } from '../common';
+import type { MakeBrand, MarkNonNullable, Merge, ValueOf } from '../common/utility-types';
+import type { LocalPoint, Radians } from '../libs/math';
+export type ChartType = 'bar' | 'line';
+export type FillStyle = 'hachure' | 'cross-hatch' | 'solid' | 'zigzag';
+export type FontFamilyKeys = keyof typeof FONT_FAMILY;
+export type FontFamilyValues = (typeof FONT_FAMILY)[FontFamilyKeys];
+export type Theme = (typeof THEME)[keyof typeof THEME];
+export type FontString = string & {
+    _brand: 'fontString';
+};
+export type GroupId = string;
+export type PointerType = 'mouse' | 'pen' | 'touch';
+export type StrokeRoundness = 'round' | 'sharp';
+export type RoundnessType = ValueOf<typeof ROUNDNESS>;
+export type StrokeStyle = 'solid' | 'dashed' | 'dotted';
+export type TextAlign = (typeof TEXT_ALIGN)[keyof typeof TEXT_ALIGN];
+type VerticalAlignKeys = keyof typeof VERTICAL_ALIGN;
+export type VerticalAlign = (typeof VERTICAL_ALIGN)[VerticalAlignKeys];
+export type FractionalIndex = string & {
+    _brand: 'franctionalIndex';
+};
+export type BoundElement = Readonly<{
+    id: DrawLinearElement['id'];
+    type: 'arrow' | 'text';
+}>;
+type _DrawElementBase = Readonly<{
+    id: string;
+    x: number;
+    y: number;
+    strokeColor: string;
+    backgroundColor: string;
+    fillStyle: FillStyle;
+    strokeWidth: number;
+    strokeStyle: StrokeStyle;
+    roundness: null | {
+        type: RoundnessType;
+        value?: number;
+    };
+    roughness: number;
+    opacity: number;
+    width: number;
+    height: number;
+    angle: Radians;
+    /** Random integer used to seed shape generation so that the roughjs shape
+        doesn't differ across renders. */
+    seed: number;
+    /** Integer that is sequentially incremented on each change. Used to reconcile
+        elements during collaboration or when saving to server. */
+    version: number;
+    /** Random integer that is regenerated on each change.
+        Used for deterministic reconciliation of updates during collaboration,
+        in case the versions (see above) are identical. */
+    versionNonce: number;
+    /** String in a fractional form defined by https://github.com/rocicorp/fractional-indexing.
+        Used for ordering in multiplayer scenarios, such as during reconciliation or undo / redo.
+        Always kept in sync with the array order by `syncMovedIndices` and `syncInvalidIndices`.
+        Could be null, i.e. for new elements which were not yet assigned to the scene. */
+    index: FractionalIndex | null;
+    isDeleted: boolean;
+    /** List of groups the element belongs to.
+        Ordered from deepest to shallowest. */
+    groupIds: readonly GroupId[];
+    frameId: string | null;
+    /** other elements that are bound to this element */
+    boundElements: readonly BoundElement[] | null;
+    /** epoch (ms) timestamp of last element update */
+    updated: number;
+    link: string | null;
+    locked: boolean;
+    customData?: Record<string, any>;
+}>;
+export type DrawSelectionElement = _DrawElementBase & {
+    type: 'selection';
+};
+export type DrawRectangleElement = _DrawElementBase & {
+    type: 'rectangle';
+};
+export type DrawDiamondElement = _DrawElementBase & {
+    type: 'diamond';
+};
+export type DrawEllipseElement = _DrawElementBase & {
+    type: 'ellipse';
+};
+export type DrawEmbeddableElement = _DrawElementBase & Readonly<{
+    type: 'embeddable';
+}>;
+export type MagicGenerationData = {
+    status: 'pending';
+} | {
+    status: 'done';
+    html: string;
+} | {
+    status: 'error';
+    message?: string;
+    code: 'ERR_GENERATION_INTERRUPTED' | string;
+};
+export type DrawIframeElement = _DrawElementBase & Readonly<{
+    type: 'iframe';
+    customData?: {
+        generationData?: MagicGenerationData;
+    };
+}>;
+export type DrawIframeLikeElement = DrawIframeElement | DrawEmbeddableElement;
+export type IframeData = {
+    intrinsicSize: {
+        w: number;
+        h: number;
+    };
+    error?: Error;
+    sandbox?: {
+        allowSameOrigin?: boolean;
+    };
+} & ({
+    type: 'video' | 'generic';
+    link: string;
+} | {
+    type: 'document';
+    srcdoc: (theme: Theme) => string;
+});
+export type ImageCrop = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    naturalWidth: number;
+    naturalHeight: number;
+};
+export type DrawImageElement = _DrawElementBase & Readonly<{
+    type: 'image';
+    fileId: FileId | null;
+    /** whether respective file is persisted */
+    status: 'pending' | 'saved' | 'error';
+    /** X and Y scale factors <-1, 1>, used for image axis flipping */
+    scale: [number, number];
+    /** whether an element is cropped */
+    crop: ImageCrop | null;
+}>;
+export type InitializedDrawImageElement = MarkNonNullable<DrawImageElement, 'fileId'>;
+export type DrawFrameElement = _DrawElementBase & {
+    type: 'frame';
+    name: string | null;
+};
+export type DrawMagicFrameElement = _DrawElementBase & {
+    type: 'magicframe';
+    name: string | null;
+};
+export type DrawFrameLikeElement = DrawFrameElement | DrawMagicFrameElement;
+/**
+ * These are elements that don't have any additional properties.
+ */
+export type DrawGenericElement = DrawSelectionElement | DrawRectangleElement | DrawDiamondElement | DrawEllipseElement;
+export type DrawFlowchartNodeElement = DrawRectangleElement | DrawDiamondElement | DrawEllipseElement;
+export type DrawRectanguloidElement = DrawRectangleElement | DrawImageElement | DrawTextElement | DrawFreeDrawElement | DrawIframeLikeElement | DrawFrameLikeElement | DrawEmbeddableElement | DrawSelectionElement;
+/**
+ * DrawElement should be JSON serializable and (eventually) contain
+ * no computed data. The list of all DrawElements should be shareable
+ * between peers and contain no state local to the peer.
+ */
+export type DrawElement = DrawGenericElement | DrawTextElement | DrawLinearElement | DrawArrowElement | DrawFreeDrawElement | DrawImageElement | DrawFrameElement | DrawMagicFrameElement | DrawIframeElement | DrawEmbeddableElement;
+export type DrawNonSelectionElement = Exclude<DrawElement, DrawSelectionElement>;
+export type Ordered<TElement extends DrawElement> = TElement & {
+    index: FractionalIndex;
+};
+export type OrderedDrawElement = Ordered<DrawElement>;
+export type NonDeleted<TElement extends DrawElement> = TElement & {
+    isDeleted: boolean;
+};
+export type NonDeletedDrawElement = NonDeleted<DrawElement>;
+export type DrawTextElement = _DrawElementBase & Readonly<{
+    type: 'text';
+    fontSize: number;
+    fontFamily: FontFamilyValues;
+    text: string;
+    textAlign: TextAlign;
+    verticalAlign: VerticalAlign;
+    containerId: DrawGenericElement['id'] | null;
+    originalText: string;
+    /**
+     * If `true` the width will fit the text. If `false`, the text will
+     * wrap to fit the width.
+     *
+     * @default true
+     */
+    autoResize: boolean;
+    /**
+     * Unitless line height (aligned to W3C). To get line height in px, multiply
+     *  with font size (using `getLineHeightInPx` helper).
+     */
+    lineHeight: number & {
+        _brand: 'unitlessLineHeight';
+    };
+}>;
+export type DrawBindableElement = DrawRectangleElement | DrawDiamondElement | DrawEllipseElement | DrawTextElement | DrawImageElement | DrawIframeElement | DrawEmbeddableElement | DrawFrameElement | DrawMagicFrameElement;
+export type DrawTextContainer = DrawRectangleElement | DrawDiamondElement | DrawEllipseElement | DrawArrowElement;
+export type DrawTextElementWithContainer = {
+    containerId: DrawTextContainer['id'];
+} & DrawTextElement;
+export type FixedPoint = [number, number];
+export type BindMode = 'inside' | 'orbit' | 'skip';
+export type FixedPointBinding = {
+    elementId: DrawBindableElement['id'];
+    fixedPoint: FixedPoint;
+    mode: BindMode;
+};
+type Index = number;
+export type PointsPositionUpdates = Map<Index, {
+    point: LocalPoint;
+    isDragging?: boolean;
+}>;
+export type Arrowhead = 'arrow' | 'bar' | 'dot' | 'circle' | 'circle_outline' | 'triangle' | 'triangle_outline' | 'diamond' | 'diamond_outline' | 'crowfoot_one' | 'crowfoot_many' | 'crowfoot_one_or_many';
+export type DrawLinearElement = _DrawElementBase & Readonly<{
+    type: 'line' | 'arrow';
+    points: readonly LocalPoint[];
+    startBinding: FixedPointBinding | null;
+    endBinding: FixedPointBinding | null;
+    startArrowhead: Arrowhead | null;
+    endArrowhead: Arrowhead | null;
+}>;
+export type DrawLineElement = DrawLinearElement & Readonly<{
+    type: 'line';
+    polygon: boolean;
+}>;
+export type FixedSegment = {
+    start: LocalPoint;
+    end: LocalPoint;
+    index: Index;
+};
+export type DrawArrowElement = DrawLinearElement & Readonly<{
+    type: 'arrow';
+    elbowed: boolean;
+}>;
+export type DrawElbowArrowElement = Merge<DrawArrowElement, {
+    elbowed: true;
+    fixedSegments: readonly FixedSegment[] | null;
+    startBinding: FixedPointBinding | null;
+    endBinding: FixedPointBinding | null;
+    /**
+     * Marks that the 3rd point should be used as the 2nd point of the arrow in
+     * order to temporarily hide the first segment of the arrow without losing
+     * the data from the points array. It allows creating the expected arrow
+     * path when the arrow with fixed segments is bound on a horizontal side and
+     * moved to a vertical and vica versa.
+     */
+    startIsSpecial: boolean | null;
+    /**
+     * Marks that the 3rd point backwards from the end should be used as the 2nd
+     * point of the arrow in order to temporarily hide the last segment of the
+     * arrow without losing the data from the points array. It allows creating
+     * the expected arrow path when the arrow with fixed segments is bound on a
+     * horizontal side and moved to a vertical and vica versa.
+     */
+    endIsSpecial: boolean | null;
+}>;
+export type DrawFreeDrawElement = _DrawElementBase & Readonly<{
+    type: 'freedraw';
+    points: readonly LocalPoint[];
+    pressures: readonly number[];
+    simulatePressure: boolean;
+}>;
+export type FileId = string & {
+    _brand: 'FileId';
+};
+export type DrawElementType = DrawElement['type'];
+/**
+ * Map of draw elements.
+ * Unspecified whether deleted or non-deleted.
+ * Can be a subset of Scene elements.
+ */
+export type ElementsMap = Map<DrawElement['id'], DrawElement>;
+/**
+ * Map of non-deleted elements.
+ * Can be a subset of Scene elements.
+ */
+export type NonDeletedElementsMap = Map<DrawElement['id'], NonDeletedDrawElement> & MakeBrand<'NonDeletedElementsMap'>;
+/**
+ * Map of all draw Scene elements, including deleted.
+ * Not a subset. Use this type when you need access to current Scene elements.
+ */
+export type SceneElementsMap = Map<DrawElement['id'], Ordered<DrawElement>> & MakeBrand<'SceneElementsMap'>;
+/**
+ * Map of all non-deleted Scene elements.
+ * Not a subset. Use this type when you need access to current Scene elements.
+ */
+export type NonDeletedSceneElementsMap = Map<DrawElement['id'], Ordered<NonDeletedDrawElement>> & MakeBrand<'NonDeletedSceneElementsMap'>;
+export type ElementsMapOrArray = readonly DrawElement[] | Readonly<ElementsMap>;
+export type DrawLinearElementSubType = 'line' | 'sharpArrow' | 'curvedArrow' | 'elbowArrow';
+export type ConvertibleGenericTypes = 'rectangle' | 'diamond' | 'ellipse';
+export type ConvertibleLinearTypes = DrawLinearElementSubType;
+export type ConvertibleTypes = ConvertibleGenericTypes | ConvertibleLinearTypes;
+export {};

package/draw/element/utils.d.ts

@@ -0,0 +1,33 @@
+import type { Zoom } from '../interface';
+import type { Curve, GlobalPoint, LineSegment } from '../libs/math';
+import type { DrawArrowElement, DrawDiamondElement, DrawElement, DrawFreeDrawElement, DrawLinearElement, DrawRectanguloidElement, ElementsMap } from './types';
+/**
+ * Returns the **rotated** components of freedraw, line or arrow elements.
+ *
+ * @param element The linear element to deconstruct
+ * @returns The rotated in components.
+ */
+export declare function deconstructLinearOrFreeDrawElement(element: DrawLinearElement | DrawFreeDrawElement): [LineSegment<GlobalPoint>[], Curve<GlobalPoint>[]];
+/**
+ * Get the building components of a rectanguloid element in the form of
+ * line segments and curves **unrotated**.
+ *
+ * @param element Target rectanguloid element
+ * @param offset Optional offset to expand the rectanguloid shape
+ * @returns Tuple of **unrotated** line segments (0) and curves (1)
+ */
+export declare function deconstructRectanguloidElement(element: DrawRectanguloidElement, offset?: number): [LineSegment<GlobalPoint>[], Curve<GlobalPoint>[]];
+/**
+ * Get the **unrotated** building components of a diamond element
+ * in the form of line segments and curves as a tuple, in this order.
+ *
+ * @param element The element to deconstruct
+ * @param offset An optional offset
+ * @returns Tuple of line **unrotated** segments (0) and curves (1)
+ */
+export declare function deconstructDiamondElement(element: DrawDiamondElement, offset?: number): [LineSegment<GlobalPoint>[], Curve<GlobalPoint>[]];
+export declare const isPathALoop: (points: DrawLinearElement["points"], 
+/** supply if you want the loop detection to account for current zoom */
+zoomValue?: Zoom["value"]) => boolean;
+export declare const getCornerRadius: (x: number, element: DrawElement) => number;
+export declare const projectFixedPointOntoDiagonal: (arrow: DrawArrowElement, point: GlobalPoint, element: DrawElement, startOrEnd: "start" | "end", elementsMap: ElementsMap) => GlobalPoint | null;

package/draw/element/utils.js

@@ -0,0 +1,137 @@
+/* 潘启宝 2026-06-25 08:58:50 星期四 山东省济南市 */
+import { DEFAULT_PROPORTIONAL_RADIUS as e, ROUNDNESS as t } from "../common/constants.js";
+import { vectorFromPoint as n, vectorNormalize as r, vectorScale as i } from "../libs/math/vector.js";
+import { pointDistance as a, pointFrom as o, pointFromArray as s, pointFromVector as c, pointRotateRads as l, pointTranslate as u } from "../libs/math/point.js";
+import { curve as d, curveCatmullRomCubicApproxPoints as f, curveOffsetPoints as p } from "../libs/math/curve.js";
+import { lineSegment as m, lineSegmentIntersectionPoints as h } from "../libs/math/segment.js";
+import { rectangle as g } from "../libs/math/rectangle.js";
+import "../libs/math/index.js";
+import { invariant as _ } from "../common/utils.js";
+import "../common/index.js";
+import { isRectangularElement as v } from "./typeChecks.js";
+import { generateLinearCollisionShape as y } from "./shape.js";
+import { isPointInElement as b } from "./collision.js";
+import { LinearElementEditor as x } from "./linearElementEditor.js";
+import { elementCenterPoint as S, getDiamondPoints as C } from "./bounds.js";
+//#region components/pc/draw/element/utils.ts
+var w = /* @__PURE__ */ new WeakMap(), T = (e, t) => {
+	let n = w.get(e);
+	if (!n) return;
+	let { version: r, shapes: i } = n;
+	if (r !== e.version) {
+		w.delete(e);
+		return;
+	}
+	return i.get(t);
+}, E = (e, t, n) => {
+	let r = w.get(e);
+	if (!r) {
+		w.set(e, {
+			version: e.version,
+			shapes: /* @__PURE__ */ new Map([[n, t]])
+		});
+		return;
+	}
+	let { version: i, shapes: a } = r;
+	if (i !== e.version) {
+		w.set(e, {
+			version: e.version,
+			shapes: /* @__PURE__ */ new Map([[n, t]])
+		});
+		return;
+	}
+	a.set(n, t);
+};
+function D(e) {
+	let t = T(e, 0);
+	if (t) return t;
+	let n = y(e), r = [], i = [];
+	for (let t = 0; t < n.length; t += 1) {
+		let a = n[t], c = n[t - 1] && s(n[t - 1].data.slice(-2));
+		switch (a.op) {
+			case "move": continue;
+			case "lineTo":
+				if (!c) throw Error("prevPoint is undefined");
+				r.push(m(o(e.x + c[0], e.y + c[1]), o(e.x + a.data[0], e.y + a.data[1])));
+				continue;
+			case "bcurveTo":
+				if (!c) throw Error("prevPoint is undefined");
+				i.push(d(o(e.x + c[0], e.y + c[1]), o(e.x + a.data[0], e.y + a.data[1]), o(e.x + a.data[2], e.y + a.data[3]), o(e.x + a.data[4], e.y + a.data[5])));
+				continue;
+			default: console.error("Unknown op type", a.op);
+		}
+	}
+	let a = [r, i];
+	return E(e, a, 0), a;
+}
+function O(e, t = 0) {
+	let n = T(e, t);
+	if (n) return n;
+	let r = j(Math.min(e.width, e.height), e);
+	r === 0 && (r = .01);
+	let i = g(o(e.x, e.y), o(e.x + e.width, e.y + e.height)), a = m(o(i[0][0] + r, i[0][1]), o(i[1][0] - r, i[0][1])), s = m(o(i[1][0], i[0][1] + r), o(i[1][0], i[1][1] - r)), c = m(o(i[0][0] + r, i[1][1]), o(i[1][0] - r, i[1][1])), l = m(o(i[0][0], i[1][1] - r), o(i[0][0], i[0][1] + r)), u = [
+		d(l[1], o(l[1][0] + 2 / 3 * (i[0][0] - l[1][0]), l[1][1] + 2 / 3 * (i[0][1] - l[1][1])), o(a[0][0] + 2 / 3 * (i[0][0] - a[0][0]), a[0][1] + 2 / 3 * (i[0][1] - a[0][1])), a[0]),
+		d(a[1], o(a[1][0] + 2 / 3 * (i[1][0] - a[1][0]), a[1][1] + 2 / 3 * (i[0][1] - a[1][1])), o(s[0][0] + 2 / 3 * (i[1][0] - s[0][0]), s[0][1] + 2 / 3 * (i[0][1] - s[0][1])), s[0]),
+		d(s[1], o(s[1][0] + 2 / 3 * (i[1][0] - s[1][0]), s[1][1] + 2 / 3 * (i[1][1] - s[1][1])), o(c[1][0] + 2 / 3 * (i[1][0] - c[1][0]), c[1][1] + 2 / 3 * (i[1][1] - c[1][1])), c[1]),
+		d(c[0], o(c[0][0] + 2 / 3 * (i[0][0] - c[0][0]), c[0][1] + 2 / 3 * (i[1][1] - c[0][1])), o(l[0][0] + 2 / 3 * (i[0][0] - l[0][0]), l[0][1] + 2 / 3 * (i[1][1] - l[0][1])), l[0])
+	], h = t > 0 ? u.map((e) => f(p(e, t))) : [
+		[u[0]],
+		[u[1]],
+		[u[2]],
+		[u[3]]
+	], _ = [[
+		m(h[0][h[0].length - 1][3], h[1][0][0]),
+		m(h[1][h[1].length - 1][3], h[2][0][0]),
+		m(h[2][h[2].length - 1][3], h[3][0][0]),
+		m(h[3][h[3].length - 1][3], h[0][0][0])
+	], h.flat()];
+	return E(e, _, t), _;
+}
+function k(e, t = 0) {
+	let n = T(e, t);
+	if (n) return n;
+	let [r, i, a, s, c, l, u, h] = C(e), g = e.roundness ? j(Math.abs(r - u), e) : (r - u) * .01, _ = e.roundness ? j(Math.abs(s - i), e) : (s - i) * .01, [v, y, b, x] = [
+		o(e.x + r, e.y + i),
+		o(e.x + a, e.y + s),
+		o(e.x + c, e.y + l),
+		o(e.x + u, e.y + h)
+	], S = [
+		d(o(y[0] - g, y[1] - _), y, y, o(y[0] - g, y[1] + _)),
+		d(o(b[0] + g, b[1] - _), b, b, o(b[0] - g, b[1] - _)),
+		d(o(x[0] + g, x[1] + _), x, x, o(x[0] + g, x[1] - _)),
+		d(o(v[0] - g, v[1] + _), v, v, o(v[0] + g, v[1] + _))
+	].map((e) => f(p(e, t))), w = [[
+		m(S[0][S[0].length - 1][3], S[1][0][0]),
+		m(S[1][S[1].length - 1][3], S[2][0][0]),
+		m(S[2][S[2].length - 1][3], S[3][0][0]),
+		m(S[3][S[3].length - 1][3], S[0][0][0])
+	], S.flat()];
+	return E(e, w, t), w;
+}
+var A = (e, t = 1) => {
+	if (e.length >= 3) {
+		let [n, r] = [e[0], e[e.length - 1]];
+		return a(n, r) <= 8 / t;
+	}
+	return !1;
+}, j = (n, r) => {
+	if (r.roundness?.type === t.PROPORTIONAL_RADIUS || r.roundness?.type === t.LEGACY) return n * e;
+	if (r.roundness?.type === t.ADAPTIVE_RADIUS) {
+		let t = r.roundness?.value ?? 32;
+		return n <= t / .25 ? n * e : t;
+	}
+	return 0;
+}, M = (e, t) => {
+	let a = e.type === "rectangle" ? 15 : 0, s = (e) => {
+		let t = i(r(n(e[1], e[0])), a);
+		return m(u(e[0], t), u(e[1], i(t, -1)));
+	}, c = S(e, t);
+	return [s(v(e) ? m(l(o(e.x, e.y), c, e.angle), l(o(e.x + e.width, e.y + e.height), c, e.angle)) : m(l(o(e.x + e.width / 2, e.y), c, e.angle), l(o(e.x + e.width / 2, e.y + e.height), c, e.angle))), s(v(e) ? m(l(o(e.x + e.width, e.y), c, e.angle), l(o(e.x, e.y + e.height), c, e.angle)) : m(l(o(e.x, e.y + e.height / 2), c, e.angle), l(o(e.x + e.width, e.y + e.height / 2), c, e.angle)))];
+}, N = (e, t, r, o, s) => {
+	if (_(e.points.length >= 2, "Arrow must have at least two points"), e.width < 3 && e.height < 3) return null;
+	let [l, u] = M(r, s), d = x.getPointAtIndexGlobalCoordinates(e, o === "start" ? 1 : e.points.length - 2, s), f = m(t, c(i(n(t, d), 2 * a(d, t) + Math.max(a(l[0], l[1]), a(u[0], u[1]))), d)), p = h(l, f), g = h(u, f), v = p && a(d, p), y = g && a(d, g), S = null;
+	return S = v != null && y != null ? v < y ? p : g : p || g || null, S && b(S, r, s) ? S : null;
+};
+//#endregion
+export { k as deconstructDiamondElement, D as deconstructLinearOrFreeDrawElement, O as deconstructRectanguloidElement, j as getCornerRadius, A as isPathALoop, N as projectFixedPointOntoDiagonal };
+/* 独立思考，明辨是非 */