@fulate/tools 1.0.11 → 1.0.12

package/dist/index.d.ts

@@ -9,6 +9,6 @@ export { Rule } from "./rule/index";
 export type { RuleOption } from "./rule/index";
 export { EditorLayer } from "./editor-layer";
 export { alignElements } from "./select/align";
-export type { AlignType } from "./select/align";
+export { AlignType } from "./select/align";
 export { ArrangeType } from "./select/arrange";
 export type { ClipboardPlugin } from "./select/clipboard";

package/dist/index.js

@@ -1,6 +1,6 @@
 import { Element, ElementProperties, ElementTransform, Layer, isFormControlTarget, projectConnectionPortPoint, resolveOrigin, resolveReferenceTransform } from "@fulate/core";
 import { BaseLine, ContentEditingCapabilityToken, DEFAULT_LINE_TREE_BRANCH_STYLE, Group, Line, LineTree, PointEditingCapabilityToken, SelectionBehaviorCapabilityToken, SelectionBehaviorMode, SelectionDiveMode, SelectionSnapMode, SnapSourceCapabilityToken, TransformInteractionCapabilityToken, addLineTreeBranchAtTail, applyLineTreeTopologyDelta, connectionPortAccepts, createLineTreeTopology, createLineTreeTopologyDelta, getEditorCapability, getEditorFrameFlush, getEndpointRelationIndex, hasConnectionPortCapacity, isEndpointRelationSource, moveLineTreePoint, remapLineTreeRelations, resolveConnectEndpointChange, resolveConnectionPortChanges, resolveDisconnectEndpointChanges, resolveSelectionFrameBounds, workspaceFocusInsetsKey } from "@fulate/ui";
-import { Bound, Intersection, isIdentityMatrix, qrDecompose, transformPoint } from "@fulate/share";
+import { Bound, Intersection, isIdentityMatrix, makeBoundingBoxFromRects, qrDecompose, transformPoint } from "@fulate/share";
 import { cloneDeep, has, isNull, isString, isUndefined, last } from "lodash-es";
 import { deserializeElement } from "@fulate/import";
 import RBush from "rbush";
@@ -114,11 +114,15 @@ function rectCorners$1(rect) {
 * capability is authoritative (for example Text/KeyValue authored bounds);
 * owners without one use the shared local visual/layout fallback.
 */
-function worldSelectionFramePoints(owner) {
-	const localFrame = resolveSelectionFrameBounds(owner.element, owner.transform);
-	const matrix = owner.element.transform.getWorldMatrixView();
+function worldSelectionFramePoints(element, transform) {
+	const localFrame = resolveSelectionFrameBounds(element, transform);
+	const matrix = element.transform.getWorldMatrixView();
 	return rectCorners$1(localFrame).map((point) => transformPoint(matrix, point));
 }
+/** @internal Resolve the world AABB used by the selection frame. */
+function getWorldSelectionBounds(element, transform) {
+	return Bound.fromPoints(worldSelectionFramePoints(element, transform));
+}
 var ROTATED_RESIZE_CURSORS = [
 	"ns-resize",
 	"nesw-resize",
@@ -178,9 +182,7 @@ function createWorldSelectionFrame(owners, fallback) {
 			if (fallback) return fallback;
 			return frameFromSingleOwner(owners[0], ownerFrame);
 		}
-		const bounds = resolveSelectionFrameBounds(owners[0].element, owners[0].transform);
-		const matrix = owners[0].element.transform.getWorldMatrixView();
-		const worldBounds = Bound.fromPoints(rectCorners$1(bounds).map((point) => transformPoint(matrix, point)));
+		const worldBounds = getWorldSelectionBounds(owners[0].element, owners[0].transform);
 		if ((worldBounds.width === 0 || worldBounds.height === 0) && fallback) return fallback;
 		return createSelectionFrameProjection({
 			left: worldBounds.minX,
@@ -190,19 +192,9 @@ function createWorldSelectionFrame(owners, fallback) {
 			angle: 0
 		});
 	}
-	let left = Infinity;
-	let top = Infinity;
-	let right = -Infinity;
-	let bottom = -Infinity;
-	for (const owner of owners) for (const point of worldSelectionFramePoints(owner)) {
-		if (point.x < left) left = point.x;
-		if (point.y < top) top = point.y;
-		if (point.x > right) right = point.x;
-		if (point.y > bottom) bottom = point.y;
-	}
-	if (!Number.isFinite(left) || !Number.isFinite(top) || !Number.isFinite(right) || !Number.isFinite(bottom)) return fallback ?? null;
-	const width = right - left;
-	const height = bottom - top;
+	const bounds = makeBoundingBoxFromRects(owners.map(({ element, transform }) => getWorldSelectionBounds(element, transform)));
+	if (!Number.isFinite(bounds.left) || !Number.isFinite(bounds.top) || !Number.isFinite(bounds.width) || !Number.isFinite(bounds.height)) return fallback ?? null;
+	const { left, top, width, height } = bounds;
 	if ((width === 0 || height === 0) && fallback) return fallback;
 	return createSelectionFrameProjection({
 		left,
@@ -2887,86 +2879,139 @@ var HistoryManager = class {
 };
 //#endregion
 //#region packages/tools/src/select/align.ts
-function resolveOffsets(rects, type) {
-	if (type === "justify-start") {
-		const target = Math.min(...rects.map(({ left }) => left));
+/** Select 支持的对齐与分布方向。 */
+var AlignType = /* @__PURE__ */ function(AlignType) {
+	AlignType["JustifyStart"] = "justify-start";
+	AlignType["JustifyCenter"] = "justify-center";
+	AlignType["JustifyEnd"] = "justify-end";
+	AlignType["JustifyBetween"] = "justify-between";
+	AlignType["AlignStart"] = "align-start";
+	AlignType["AlignCenter"] = "align-center";
+	AlignType["AlignEnd"] = "align-end";
+	AlignType["AlignBetween"] = "align-between";
+	return AlignType;
+}({});
+function compareElementKeys(left, right) {
+	if (left.element.key < right.element.key) return -1;
+	if (left.element.key > right.element.key) return 1;
+	return 0;
+}
+function compareDistributionRects(left, right, axis) {
+	const primary = left[axis.position] - right[axis.position];
+	if (primary !== 0) return primary;
+	const secondary = left[axis.crossPosition] - right[axis.crossPosition];
+	if (secondary !== 0) return secondary;
+	return compareElementKeys(left, right);
+}
+function resolveDistributionOffsets(rects, reference, axis) {
+	const { position, size, offset } = axis;
+	const start = reference[position];
+	const referenceEnd = start + reference[size];
+	let totalSize = 0;
+	for (const rect of rects) totalSize += rect[size];
+	const roundoff = Math.max(1, Math.abs(start), Math.abs(referenceEnd), Math.abs(totalSize)) * Number.EPSILON * rects.length * 4;
+	const orderStep = roundoff * 8;
+	const freeSpace = reference[size] - totalSize;
+	const fittedFreeSpace = Math.abs(freeSpace) <= roundoff ? 0 : freeSpace;
+	const gap = fittedFreeSpace / (rects.length - 1);
+	const distributionEnd = start + totalSize + fittedFreeSpace;
+	rects.sort((left, right) => compareDistributionRects(left, right, axis));
+	const lastIndex = rects.length - 1;
+	const latestStarts = new Array(rects.length);
+	latestStarts[lastIndex] = distributionEnd - rects[lastIndex][size];
+	for (let index = lastIndex - 1; index >= 0; index--) latestStarts[index] = Math.min(distributionEnd - rects[index][size], latestStarts[index + 1] - orderStep);
+	if (latestStarts[0] < start) return;
+	let idealTarget = start;
+	let previousTarget = start;
+	for (let index = 0; index <= lastIndex; index++) {
+		let target;
+		if (index === 0) target = start;
+		else if (index === lastIndex) target = latestStarts[lastIndex];
+		else {
+			idealTarget += rects[index - 1][size] + gap;
+			target = Math.min(latestStarts[index], Math.max(previousTarget + orderStep, idealTarget));
+		}
+		const delta = target - rects[index][position];
+		rects[index][offset] = Math.abs(delta) <= roundoff ? 0 : delta;
+		previousTarget = target;
+	}
+}
+function resolveOffsets(rects, type, reference) {
+	if (type === AlignType.JustifyStart) {
+		const target = reference.left;
 		rects.forEach((rect) => {
 			rect.dx = target - rect.left;
 		});
 		return;
 	}
-	if (type === "justify-center") {
-		const target = (Math.min(...rects.map((rect) => rect.left)) + Math.max(...rects.map((rect) => rect.left + rect.width))) / 2;
+	if (type === AlignType.JustifyCenter) {
+		const target = reference.left + reference.width / 2;
 		rects.forEach((rect) => {
 			rect.dx = target - (rect.left + rect.width / 2);
 		});
 		return;
 	}
-	if (type === "justify-end") {
-		const target = Math.max(...rects.map((rect) => rect.left + rect.width));
+	if (type === AlignType.JustifyEnd) {
+		const target = reference.left + reference.width;
 		rects.forEach((rect) => {
 			rect.dx = target - (rect.left + rect.width);
 		});
 		return;
 	}
-	if (type === "justify-between") {
-		rects.sort((left, right) => left.left - right.left);
-		const start = rects[0].left;
-		const end = last(rects);
-		const total = rects.reduce((sum, rect) => sum + rect.width, 0);
-		const gap = (end.left + end.width - start - total) / (rects.length - 1);
-		let x = start;
-		for (const rect of rects) {
-			rect.dx = x - rect.left;
-			x += rect.width + gap;
-		}
+	if (type === AlignType.JustifyBetween) {
+		resolveDistributionOffsets(rects, reference, {
+			position: "left",
+			crossPosition: "top",
+			size: "width",
+			offset: "dx"
+		});
 		return;
 	}
-	if (type === "align-start") {
-		const target = Math.min(...rects.map(({ top }) => top));
+	if (type === AlignType.AlignStart) {
+		const target = reference.top;
 		rects.forEach((rect) => {
 			rect.dy = target - rect.top;
 		});
 		return;
 	}
-	if (type === "align-center") {
-		const target = (Math.min(...rects.map((rect) => rect.top)) + Math.max(...rects.map((rect) => rect.top + rect.height))) / 2;
+	if (type === AlignType.AlignCenter) {
+		const target = reference.top + reference.height / 2;
 		rects.forEach((rect) => {
 			rect.dy = target - (rect.top + rect.height / 2);
 		});
 		return;
 	}
-	if (type === "align-end") {
-		const target = Math.max(...rects.map((rect) => rect.top + rect.height));
+	if (type === AlignType.AlignEnd) {
+		const target = reference.top + reference.height;
 		rects.forEach((rect) => {
 			rect.dy = target - (rect.top + rect.height);
 		});
 		return;
 	}
-	rects.sort((left, right) => left.top - right.top);
-	const start = rects[0].top;
-	const end = last(rects);
-	const total = rects.reduce((sum, rect) => sum + rect.height, 0);
-	const gap = (end.top + end.height - start - total) / (rects.length - 1);
-	let y = start;
-	for (const rect of rects) {
-		rect.dy = y - rect.top;
-		y += rect.height + gap;
-	}
+	resolveDistributionOffsets(rects, reference, {
+		position: "top",
+		crossPosition: "left",
+		size: "height",
+		offset: "dy"
+	});
 }
-function alignElements(select, type) {
+function alignElements(select, type, referenceRect) {
 	const controller = select.interactionController;
 	let elements = controller.selection;
-	if (elements.length < 2 || type.endsWith("between") && elements.length < 3) return;
+	const between = type === AlignType.JustifyBetween || type === AlignType.AlignBetween;
+	const minimum = referenceRect ? between ? 2 : 1 : between ? 3 : 2;
+	if (elements.length < minimum) return;
 	controller.finishCurrentInteraction();
 	controller.root.frameRuntime.drain();
 	if (select.interactionController !== controller) return;
 	elements = controller.selection;
-	if (elements.length < 2 || type.endsWith("between") && elements.length < 3) return;
+	if (elements.length < minimum) return;
 	const rects = elements.map((element) => {
-		const bounds = element.transform.getWorldVisualBoundsView();
+		const transform = getEditorCapability(element, TransformInteractionCapabilityToken);
+		const bounds = getWorldSelectionBounds(element, transform);
 		return {
 			element,
+			transform,
 			left: bounds.left,
 			top: bounds.top,
 			width: bounds.width,
@@ -2975,14 +3020,21 @@ function alignElements(select, type) {
 			dy: 0
 		};
 	});
-	resolveOffsets(rects, type);
+	resolveOffsets(rects, type, referenceRect ?? makeBoundingBoxFromRects(rects));
 	const changes = [];
 	for (const rect of rects) {
 		if (rect.dx === 0 && rect.dy === 0) continue;
-		const capability = getEditorCapability(rect.element, TransformInteractionCapabilityToken);
-		if (!capability) continue;
-		const baseline = capability.captureTransformBaseline();
-		changes.push(...capability.resolveTransformChange(baseline, { worldDelta: new DOMMatrix().translate(rect.dx, rect.dy) }));
+		const { transform } = rect;
+		if (!transform) continue;
+		const baseline = transform.captureTransformBaseline();
+		changes.push(...transform.resolveTransformChange(baseline, { worldDelta: new DOMMatrix([
+			1,
+			0,
+			0,
+			1,
+			rect.dx,
+			rect.dy
+		]) }));
 	}
 	if (changes.length === 0) return;
 	const scope = select.history.openScope(elements);
@@ -3863,8 +3915,19 @@ var Select = class extends Element {
 	unGroup() {
 		return unGroup(this);
 	}
-	align(type) {
-		return alignElements(this, type);
+	/**
+	* Aligns the live selection in world space. Without `referenceRect`, the
+	* current selection-frame AABB is the reference. A supplied world Rect is
+	* used directly. Distribution keeps strict edge gaps when they are numerically
+	* possible and uses bounded overlap when the selected sizes exceed the reference,
+	* while keeping every selection-frame AABB inside it and preserving order. The
+	* current axis is a noop only when an element cannot fit or no ordered layout is
+	* representable. A successful non-noop creates one Transform batch and one Select
+	* History entry; a noop creates neither a transform, History entry, nor configured
+	* change.
+	*/
+	align(type, referenceRect) {
+		return alignElements(this, type, referenceRect);
 	}
 	/** 按当前 Layer 与 sibling 顺序排列 live selection。 */
 	arrange(type) {
@@ -5066,4 +5129,4 @@ var EditorLayer = class extends Layer {
 	}
 };
 //#endregion
-export { ArrangeType, EditorLayer, HistoryManager, LineTool, Rule, Select, Snap, alignElements };
+export { AlignType, ArrangeType, EditorLayer, HistoryManager, LineTool, Rule, Select, Snap, alignElements };

package/dist/select/align.d.ts

@@ -1,3 +1,14 @@
+import { type Rect } from "@fulate/share";
 import type { Select } from "./index";
-export type AlignType = "justify-start" | "justify-center" | "justify-end" | "justify-between" | "align-start" | "align-center" | "align-end" | "align-between";
-export declare function alignElements(select: Select, type: AlignType): void;
+/** Select 支持的对齐与分布方向。 */
+export declare enum AlignType {
+    JustifyStart = "justify-start",
+    JustifyCenter = "justify-center",
+    JustifyEnd = "justify-end",
+    JustifyBetween = "justify-between",
+    AlignStart = "align-start",
+    AlignCenter = "align-center",
+    AlignEnd = "align-end",
+    AlignBetween = "align-between"
+}
+export declare function alignElements(select: Select, type: AlignType, referenceRect?: Readonly<Rect>): void;

package/dist/select/index.d.ts

@@ -1,4 +1,5 @@
 import { Element, ElementProperties, type BaseElementOption, type ConnectionPortRef, type Layer, type Root } from "@fulate/core";
+import type { Rect } from "@fulate/share";
 import { EditorInteractionController } from "../editor/interaction-controller";
 import { HistoryManager } from "../history";
 import { type AlignType } from "./align";
@@ -75,7 +76,18 @@ export declare class Select extends Element {
      * An obvious non-Group noop does not drain the frame runtime.
      */
     unGroup(): Element<ElementProperties, BaseElementOption<any>, Partial<Omit<BaseElementOption<any>, "key" | "children">>>[];
-    align(type: AlignType): void;
+    /**
+     * Aligns the live selection in world space. Without `referenceRect`, the
+     * current selection-frame AABB is the reference. A supplied world Rect is
+     * used directly. Distribution keeps strict edge gaps when they are numerically
+     * possible and uses bounded overlap when the selected sizes exceed the reference,
+     * while keeping every selection-frame AABB inside it and preserving order. The
+     * current axis is a noop only when an element cannot fit or no ordered layout is
+     * representable. A successful non-noop creates one Transform batch and one Select
+     * History entry; a noop creates neither a transform, History entry, nor configured
+     * change.
+     */
+    align(type: AlignType, referenceRect?: Readonly<Rect>): void;
     /** 按当前 Layer 与 sibling 顺序排列 live selection。 */
     arrange(type: ArrangeType): void;
     /**

package/dist/select/projection.d.ts

@@ -1,6 +1,6 @@
 import { Element } from "@fulate/core";
 import { type PointEditTarget, type PointEditingScope, type SnapSourceCapability, type TransformInteractionCapability, type TransformInteractionPolicy } from "@fulate/ui";
-import { type PointView, type Rect } from "@fulate/share";
+import { Bound, type PointView, type Rect } from "@fulate/share";
 export type ResizeHandle = "tl" | "tr" | "br" | "bl" | "mt" | "mr" | "mb" | "ml";
 export type SelectionRotationPivot = {
     readonly kind: "selection-center";
@@ -109,14 +109,16 @@ export interface SelectionProjectionTopology {
     readonly pointScopeOutline: readonly PointView[] | null;
     readonly pointScopeValid: boolean;
 }
-export declare function createSelectionFrameProjection({ left, top, width, height, angle }: Pick<SelectionFrameProjection, "left" | "top" | "width" | "height" | "angle">): SelectionFrameProjection;
+/** @internal Resolve the world AABB used by the selection frame. */
+export declare function getWorldSelectionBounds(element: Element, transform: TransformInteractionCapability | undefined): Bound;
+export declare function createSelectionFrameProjection({ left, top, width, height, angle, }: Pick<SelectionFrameProjection, "left" | "top" | "width" | "height" | "angle">): SelectionFrameProjection;
 /** @internal Build a command frame from the current owner bounds. */
 export declare function createWorldSelectionFrame(owners: readonly ProjectionOwner[], fallback?: SelectionFrameProjection | null): SelectionFrameProjection;
 export declare function createSelectionRotationPivotSnapMarkers(frame: SelectionFrameProjection): readonly SelectionRotationPivotSnapMarker[];
 export declare function createSelectionProjectionMembership(owners: readonly ProjectionOwner[], policy: ProjectionPolicy): SelectionProjectionMembership;
 export declare function createSelectionProjectionTopology(owners: readonly ProjectionOwner[], isCurrent?: (owner: ProjectionOwner) => boolean): SelectionProjectionTopology;
 export declare function createProjectionOwner(element: Element, frameVisible?: boolean, pointScope?: PointEditingScope | null, pointEnabled?: boolean): ProjectionOwner;
-export declare function buildSelectionOverlayProjection({ owners, membership, topology, frame: frameOverride, policy, pivot, showPivot, pivotSnapMarkers, activePointTarget, marquee }: {
+export declare function buildSelectionOverlayProjection({ owners, membership, topology, frame: frameOverride, policy, pivot, showPivot, pivotSnapMarkers, activePointTarget, marquee, }: {
     readonly owners: readonly ProjectionOwner[];
     readonly membership: SelectionProjectionMembership;
     readonly topology: SelectionProjectionTopology;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fulate/tools",
-  "version": "1.0.11",
+  "version": "1.0.12",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",