@pixerate/editor 0.23.0 → 0.24.0

package/dist/canvas/index.d.ts

@@ -1100,6 +1100,214 @@ declare function snapNodeResize(nodes: CanvasNode[], id: string, rect: Rect, han
  */
 declare function getResizingNodeRect(node: CanvasNode, lookup: ReadonlyMap<string, CanvasNode>, options?: NodeRectOptions): Rect;
 
+/**
+ * Figma-style auto layout for xyflow sub-flows.
+ *
+ * A *frame* is any node with `data.layout` (an {@link AutoLayout}); its children are the nodes
+ * whose `parentId` is the frame, in node-array order. Children may carry `data.childLayout`
+ * (an {@link AutoLayoutChild}) for their own sizing, min / max, absolute positioning,
+ * constraints and grid cell. The functions here are pure: they return `CanvasNodeUpdate`s
+ * (positions relative to the parent, sizes) for `applyNodeUpdates`.
+ */
+/** Data key holding a frame's {@link AutoLayout}. */
+declare const AUTO_LAYOUT_DATA_KEY = "layout";
+/** Data key holding a child's {@link AutoLayoutChild}. */
+declare const CHILD_LAYOUT_DATA_KEY = "childLayout";
+type AutoLayoutMode = 'horizontal' | 'vertical' | 'grid';
+/** `fixed` keeps the size, `hug` fits the content (frames and text), `fill` shares the parent's free space. */
+type AutoLayoutSizing = 'fixed' | 'hug' | 'fill';
+type AutoLayoutAlignMain = 'start' | 'center' | 'end' | 'space-between' | 'space-around' | 'space-evenly';
+type AutoLayoutAlignCross = 'start' | 'center' | 'end' | 'stretch' | 'baseline';
+/** How wrapped lines share the free cross space: packed by `alignCross` (`auto`) or spread (`space-between`). */
+type AutoLayoutAlignContent = 'auto' | 'space-between';
+/** `number` (all sides), `[vertical, horizontal]`, `[top, right, bottom, left]` or per side. */
+type AutoLayoutPadding = number | [number, number] | [number, number, number, number] | {
+    top?: number;
+    right?: number;
+    bottom?: number;
+    left?: number;
+};
+interface AutoLayoutSize {
+    width?: number;
+    height?: number;
+}
+interface AutoLayoutSizingPair {
+    width?: AutoLayoutSizing;
+    height?: AutoLayoutSizing;
+}
+/** A grid track: pixels, `'hug'` (fits its content), `'2fr'` or `{ fr: 2 }` (shares the rest like CSS `fr`). */
+type AutoLayoutGridTrack = number | 'hug' | `${number}fr` | {
+    fr: number;
+};
+interface AutoLayoutGrid {
+    /** Column count (all `1fr`) or the column tracks (default 2 columns). */
+    columns?: number | AutoLayoutGridTrack[];
+    /** Minimum row count or the row tracks (default 1); rows are added to fit the children. Missing tracks are `1fr`. */
+    rows?: number | AutoLayoutGridTrack[];
+}
+/** A frame's auto layout (`node.data.layout`). */
+interface AutoLayout {
+    mode: AutoLayoutMode;
+    /** Main-axis gap (grid: column gap). Negative gaps overlap. Default 0. */
+    gap?: number;
+    /** Gap between wrapped lines (grid: row gap). Default: `gap`. */
+    rowGap?: number;
+    /** Default 0. */
+    padding?: AutoLayoutPadding;
+    /** Horizontal / vertical: wrap into lines when the main axis runs out (ignored while hugging it). */
+    wrap?: boolean;
+    /** Default `start`. Grid: the cell alignment along x (`start`, `center`, `end`). */
+    alignMain?: AutoLayoutAlignMain;
+    /** Default `start`. `baseline` applies to horizontal layouts. Grid: the cell alignment along y. */
+    alignCross?: AutoLayoutAlignCross;
+    alignContent?: AutoLayoutAlignContent;
+    /** The frame's own sizing (`childLayout.sizing` wins when both are set). Default `fixed`. */
+    sizing?: AutoLayoutSizingPair;
+    /** The frame's own limits (`childLayout.min` / `max` win when set). */
+    min?: AutoLayoutSize;
+    max?: AutoLayoutSize;
+    grid?: AutoLayoutGrid;
+}
+type AutoLayoutHorizontalConstraint = 'left' | 'right' | 'leftRight' | 'center' | 'scale';
+type AutoLayoutVerticalConstraint = 'top' | 'bottom' | 'topBottom' | 'center' | 'scale';
+interface AutoLayoutConstraints {
+    horizontal?: AutoLayoutHorizontalConstraint;
+    vertical?: AutoLayoutVerticalConstraint;
+}
+type AutoLayoutCellAlign = 'start' | 'center' | 'end';
+/** A grid child's cell. Column / row are 0-based anchors; unanchored children flow in reading order. */
+interface AutoLayoutGridArea {
+    column?: number;
+    row?: number;
+    columnSpan?: number;
+    rowSpan?: number;
+    /** The child's own alignment in its cell (wins over the frame's). */
+    alignX?: AutoLayoutCellAlign;
+    alignY?: AutoLayoutCellAlign;
+}
+/** A child's layout properties (`node.data.childLayout`). */
+interface AutoLayoutChild {
+    sizing?: AutoLayoutSizingPair;
+    min?: AutoLayoutSize;
+    max?: AutoLayoutSize;
+    /** Ignore auto layout: keep its place and follow `constraints` when the frame resizes. */
+    absolute?: boolean;
+    /** How the child follows its parent's resizes (default left / top). */
+    constraints?: AutoLayoutConstraints;
+    gridArea?: AutoLayoutGridArea;
+}
+/**
+ * Measuring hooks. `size` defaults to `getNodeSize` (xyflow `measured` size, then `width` /
+ * `height`, then style). Nodes for which `textSize` returns a size are *text-like*: they can
+ * hug, and wrap (`textHeight`) when their width is set by the layout.
+ */
+interface AutoLayoutMeasure {
+    size?: (node: CanvasNode) => {
+        width: number;
+        height: number;
+    } | undefined;
+    /** Natural (unwrapped) size of a text-like node. */
+    textSize?: (node: CanvasNode) => {
+        width: number;
+        height: number;
+    } | undefined;
+    /** Height of a text-like node wrapped at `width`. */
+    textHeight?: (node: CanvasNode, width: number) => number | undefined;
+    /** Distance from the node's top to its first text baseline (for `alignCross: 'baseline'`). */
+    textBaseline?: (node: CanvasNode) => number | undefined;
+}
+interface AutoLayoutOptions {
+    measure?: AutoLayoutMeasure;
+    /** Size resolution for unmeasured nodes when `measure.size` is not given. */
+    rectOptions?: NodeRectOptions;
+}
+type Axis = 'width' | 'height';
+/** Clamps a size to `[min, max]`; non-finite or negative sizes become 0 and min wins over a smaller max. */
+declare function clampLayoutSize(value: number, min?: number, max?: number): number;
+/** The node's auto layout, or `undefined` when it is not an auto layout frame. */
+declare function getAutoLayout(node: CanvasNode | undefined | null): AutoLayout | undefined;
+/** Whether the node is an auto layout frame. */
+declare function isAutoLayoutFrame(node: CanvasNode | undefined | null): boolean;
+/** The node's child layout properties (empty when unset). */
+declare function getChildLayout(node: CanvasNode | undefined | null): AutoLayoutChild;
+/** Effective sizing of a node on one axis: `childLayout.sizing`, then `layout.sizing`, then `fixed`. */
+declare function getLayoutSizing(node: CanvasNode, axis: Axis): AutoLayoutSizing;
+/** Padding as `[top, right, bottom, left]`, sanitised (non-finite and negative values become 0). */
+declare function resolvePadding(padding: AutoLayoutPadding | undefined): [number, number, number, number];
+/** A grid child's cell (0-based column / row and spans). */
+interface AutoLayoutGridCell {
+    id: string;
+    column: number;
+    row: number;
+    columnSpan: number;
+    rowSpan: number;
+}
+/** A grid frame's resolved geometry (frame-local): column x ranges, row y ranges, cells and the size it wants. */
+interface AutoLayoutGridGeometry {
+    columns: [number, number][];
+    rows: [number, number][];
+    cells: AutoLayoutGridCell[];
+    width: number;
+    height: number;
+}
+/**
+ * Lays out one auto layout frame's children and sizes the frame when it hugs (nested frames
+ * that are resized by the layout are laid out again). Returns the position / size updates.
+ */
+declare function layoutFrame(nodes: CanvasNode[], frameId: string, options?: AutoLayoutOptions): CanvasNodeUpdate[];
+/** Lays out every auto layout frame, children before parents, so nested hugging settles in one pass. */
+declare function layoutAll(nodes: CanvasNode[], options?: AutoLayoutOptions): CanvasNodeUpdate[];
+/**
+ * Lays out `changedId` (when it is a frame) and then each of its auto layout ancestors,
+ * innermost first. Use it after a node inside a frame was added, removed, resized or moved.
+ */
+declare function layoutUp(nodes: CanvasNode[], changedId: string, options?: AutoLayoutOptions): CanvasNodeUpdate[];
+/** {@link layoutUp} for several changed nodes at once (each chain once, innermost frames first). */
+declare function layoutUpMany(nodes: CanvasNode[], changedIds: Iterable<string>, options?: AutoLayoutOptions): CanvasNodeUpdate[];
+/**
+ * Children of `parentId` follow their constraints after the parent was resized from
+ * `previousSize` to its current size. In an auto layout frame only absolute children move
+ * (the layout places the others). Returns the updates.
+ */
+declare function applyConstraints(nodes: CanvasNode[], parentId: string, previousSize: {
+    width: number;
+    height: number;
+}, options?: AutoLayoutOptions): CanvasNodeUpdate[];
+/** The resolved grid of a grid frame (frame-local), from its children's current sizes. */
+declare function getAutoLayoutGrid(nodes: CanvasNode[], frameId: string, options?: AutoLayoutOptions): AutoLayoutGridGeometry | undefined;
+/** Ids of the children a frame places (visible, not absolute), in order. */
+declare function getFlowChildren(nodes: CanvasNode[], frameId: string): string[];
+/** The nearest auto layout frame that places `id` (its parent, when `id` is a flow child). */
+declare function getLayoutParent(nodes: CanvasNode[], id: string): CanvasNode | undefined;
+/**
+ * Makes a node's sizing coherent with where it sits, and that of its children: `fill` needs an
+ * auto layout parent that does not hug that axis (and a flow child), `hug` needs an auto layout
+ * frame or a text-like node (see `measure.textSize`); otherwise the axis becomes `fixed`.
+ * Writes `data.childLayout.sizing`. Returns a new array (unchanged nodes keep their identity).
+ */
+declare function makeSizingCoherent<TNode extends CanvasNode>(nodes: TNode[], id: string, options?: AutoLayoutOptions): TNode[];
+interface AutoLayoutInsertTarget {
+    frameId: string;
+    /** Index among the frame's flow children, not counting the dragged node. */
+    index: number;
+    /** Insertion marker (absolute flow coordinates) for `<CanvasGuidesLayer>`. */
+    guide: GuideLine;
+}
+/**
+ * Where a node dropped at `point` (absolute flow coordinates) goes among the flow children of
+ * auto layout frame `frameId`: the reading-order index of the slot under the point. `excludeId`
+ * (the dragged node) is left out of the siblings.
+ */
+declare function getAutoLayoutInsertTarget(nodes: CanvasNode[], frameId: string, point: XYPosition, options?: AutoLayoutOptions & {
+    excludeId?: string;
+}): AutoLayoutInsertTarget | undefined;
+/**
+ * Moves child `childId` of an auto layout frame to flow index `index` (among its flow siblings)
+ * by reordering the node array; parents still precede their children. Returns a new array
+ * (the same array when nothing moves).
+ */
+declare function moveLayoutChild<TNode extends CanvasNode>(nodes: TNode[], childId: string, index: number): TNode[];
+
 /** Minimal history surface (`HistoryManager` satisfies it). */
 interface ArrangeHistoryTarget {
     execute(command: Command): void;
@@ -1129,6 +1337,11 @@ interface CanvasArrangeControllerOptions<TNode extends CanvasNode = CanvasNode>
     rectOptions?: NodeRectOptions;
     /** Called whenever the guide segments change (set while dragging, cleared on drop). */
     onGuidesChange?: (guides: GuideLine[]) => void;
+    /**
+     * Re-run auto layout (`data.layout` frames) around the nodes an arrange action moves or
+     * resizes, in the same undoable step. `true` uses the default measuring.
+     */
+    autoLayout?: boolean | AutoLayoutOptions;
 }
 /**
  * A React Flow / SvelteFlow style node change; only `position` changes are inspected.
@@ -1370,4 +1583,108 @@ declare function fitPathData(ring: readonly Point[], options?: FitPathDataOption
  */
 declare function fitFreehandPath(points: readonly Point[], options?: Omit<FitPathDataOptions, 'closed'>): string;
 
-export { AlignEdge, AlignNodesOptions, type ArrangeHistoryTarget, CONNECTION_LINE_TYPES, CanvasArrangeAction, type CanvasArrangeController, type CanvasArrangeControllerOptions, CanvasClipboardPayload, type CanvasConnectionLineType, CanvasEdge, type CanvasHeightOptions, CanvasLayoutOptions, CanvasNode, CanvasNodeStyle, CanvasNodeUpdate, type CanvasScene, type CanvasScenesOptions, type CanvasScenesState, CanvasScenesStore, type CanvasViewport, type Clock, type CombineShapeNodesOptions, type CombineShapeNodesRefusal, type CombineShapeNodesResult, type ConnectorSnap, type ConnectorSnapOptions, type ConnectorSnapTarget, type CubicSegment, DEFAULT_NODE_HEIGHT, DEFAULT_NODE_WIDTH, DEFAULT_PLACEMENT_GAP, DirectionalDisplacementOptions, DistributeAxis, DistributeMode, DistributeNodesOptions, type EllipseShape, FanOutTrajectoryOptions, type FitCubicsOptions, type FitPathDataOptions, type FitViewportOptions, type FlattenOptions, type GuideIndex, type GuideLine, IncrementalLayoutOptions, ManualClock, MatchSizeOptions, type MeasureGuide, type MeasureSelectionOptions, type MeasureSelectionResult, type MultiNodeTransitionOptions, type MultiPolygon, NodeRectOptions, NodeTransition, type PathCommand, type PathShape, PlaceBesideOptions, Point, type PolygonBooleanOperation, type PolygonBooleanOptions, type PolygonFillRule, type PolygonInput, type PolygonOperand, type PolygonPiece, type PolygonRing, type PolygonToPathOptions, type PolygonWithHoles, Position, type PositionChangeLike, RESIZE_HANDLES, Rect, type RectShape, ReflowDisplacementOptions, type RegularPolygonShape, type ResizeHandle, SHAPE_DATA_KEY, SHAPE_KINDS, SHAPE_NODE_TYPE, SHAPE_OPERATIONS, type SerializedCanvasScenes, type ShapeDescription, type ShapeKind, type ShapeNodePolygonOptions, type ShapeOperation, type ShapePaint, type ShapeRenderData, type ShapeSize, Side, SizeDimension, type SnapGuidesOptions, type SnapNodeDragOptions, type SnapNodeDragResult, type SnapNodeResizeOptions, type SnapNodeResizeResult, type SnapResizeOptions, type SnapResizeResult, type SnapResult, type StarShape, StreamingLayoutManager, type StreamingLayoutManagerOptions, TrajectoryFunction, XYPosition, ZOrderOperation, applyShapeCombination, blendLayout, boundsOf, calculateDagreReflowDisplacement, calculateDirectionalDisplacement, canCombineShapeNodes, canvasHeight, centerNodes, centre, collectDescendantIds, combineShapeNodes, computeNodesBoundingBox, computeSnapGuides, connectedOnly, createBezierTrajectory, createCanvasArrangeController, createCanvasScenesStore, createFanOutTrajectory, createGuideIndex, createNodeGuideIndex, cubicPointAt, cubicsToPathData, defaultEasing, dividePolygons, ensureLayout, estimateCanvasHeight, estimateNodeSize, findConnectorSnap, fitCubicRun, fitCubics, fitFreehandPath, fitPathData, fitViewportToNodes, fitViewportToRect, flattenSvgPath, flowSide, formatNumber, getCenteredNodePosition, getLayoutedNodes, getNodeShape, getResizingNodeRect, getShapeRenderData, getShapeSvg, handlePoint, inferResizeHandle, intersectPolygons, isEventFromTextInput, isMeasureModifierHeld, isShapeDescription, isShapeNode, isStraightCubic, isValidCanvasEdge, isValidCanvasNode, isValidCanvasScene, isValidUrl, layoutBounds, linearPositionTrajectory, linearTrajectory, measureBetween, measureLabel, measureSelection, measureToLine, multiPolygonArea, multiPolygonBounds, nearestHandlePositions, oppositePosition, overlaps, pageHidden, parseCanvasClipboardData, parseCanvasScenes, parseSvgPath, placeBeside, pointInMultiPolygon, pointInRings, polygonArea, polygonBoolean, polygonToSvgPath, positionToSide, realClock, remapPastedNodes, repositionNodesTo, resizeHandleAxes, revertShapeCombination, ringSignedArea, runMultiNodeTransition, serializeCanvasNodes, shapeNodeToPolygon, shapeToPolygon, sideToPosition, simplifyRing, snapNodeDrag, snapNodeResize, snapResize, snapToGrid, subtractPolygons, unionPolygons, withStyleOpacity, xorPolygons };
+interface CanvasAutoLayoutControllerOptions<TNode extends CanvasNode = CanvasNode> extends AutoLayoutOptions {
+    getNodes: () => TNode[];
+    setNodes: (nodes: TNode[]) => void;
+    /** When set, controller actions (add / remove / resize / reorder / apply) are one undoable step each. */
+    history?: ArrangeHistoryTarget;
+    /** Turns automatic relayout off (explicit `applyAutoLayout` still works). Default `true`. */
+    enabled?: boolean;
+    /** Reorder flow children by dragging them inside their frame (default `true`). */
+    dragReorder?: boolean;
+    /** Called when the drop marker of a reorder drag changes (empty when none). */
+    onGuidesChange?: (guides: GuideLine[]) => void;
+}
+/**
+ * Merges the updates of several layout passes (later ones win per field).
+ */
+declare function mergeNodeUpdates(...lists: CanvasNodeUpdate[][]): CanvasNodeUpdate[];
+/**
+ * Updates that re-run auto layout around `ids` after a change: each id's own layout (if a
+ * frame) and its auto layout ancestors, plus the frames that lost removed children
+ * (`parentIds`). Pure helper used by the controllers.
+ */
+declare function relayoutUpdates(nodes: CanvasNode[], ids: Iterable<string>, options?: AutoLayoutOptions): CanvasNodeUpdate[];
+/**
+ * Framework-agnostic auto layout controller shared by the React hook and the Svelte rune.
+ * Applies auto layout to frames (`data.layout`) after nodes inside them are added, removed,
+ * resized or reordered, either through its own (undoable) actions or by watching the flow's
+ * node changes (`noteChanges` + `flush`), and reorders flow children dragged within a frame.
+ */
+declare function createCanvasAutoLayoutController<TNode extends CanvasNode = CanvasNode>(options: CanvasAutoLayoutControllerOptions<TNode>): {
+    /** Drop marker of the active reorder drag (flow coordinates); empty otherwise. */
+    readonly guides: GuideLine[];
+    /**
+     * Lays out frame `frameId` and its auto layout ancestors (default: every frame) as one
+     * (optionally undoable) step. Returns the updates.
+     */
+    applyAutoLayout(frameId?: string): CanvasNodeUpdate[];
+    /** Updates that relayout around `ids` on the current nodes, without applying them. */
+    layoutUpdates(ids: Iterable<string>): CanvasNodeUpdate[];
+    /**
+     * Applies the relayout around `ids` (frames, or nodes inside frames) directly, not
+     * recorded in history: auto layout is derived state, re-run after any change.
+     */
+    relayout(ids: Iterable<string>): CanvasNodeUpdate[];
+    /**
+     * Adds `node` (into the frame named by its `parentId`, at flow `index` when given) and
+     * lays out its frame, as one step.
+     */
+    addNode(node: TNode, addOptions?: {
+        index?: number;
+    }): CanvasNodeUpdate[];
+    /** Removes nodes (and their descendants) and lays out the frames they leave, as one step. */
+    removeNodes(ids: Iterable<string>): CanvasNodeUpdate[];
+    /**
+     * Resizes node `id` (its children follow their constraints) and lays out around it,
+     * as one step.
+     */
+    resizeNode(id: string, size: {
+        width?: number;
+        height?: number;
+    }): CanvasNodeUpdate[];
+    /** Moves flow child `childId` to flow index `index` in its frame and lays it out, as one step. */
+    moveChild(childId: string, index: number): CanvasNodeUpdate[];
+    /** Where flow child `id` would drop if released at `point` (default: its centre). */
+    getInsertTarget(id: string, point?: XYPosition): AutoLayoutInsertTarget | undefined;
+    /** Records the start position of a reorder drag. Optional: `dragReorder` records it lazily. */
+    beginReorderDrag(id: string): void;
+    /**
+     * While flow child `id` is dragged (as currently positioned in `getNodes()`): updates the
+     * drop marker. Returns the insert target.
+     */
+    dragReorder(id: string, point?: XYPosition): AutoLayoutInsertTarget | undefined;
+    /**
+     * Ends a reorder drag: moves `id` to the slot under `point` (default: its centre) and lays
+     * the frame out, as one undoable step whose undo puts the node back where the drag began.
+     */
+    endReorderDrag(id: string, point?: XYPosition): CanvasNodeUpdate[];
+    /**
+     * Notes a batch of React Flow / SvelteFlow style node changes (before or after they are
+     * applied) so `flush` can relayout: dimension changes (measured sizes, resize ends),
+     * added and removed nodes, and position changes of flow children (reorder drags).
+     * Returns the changes unchanged.
+     */
+    noteChanges<TChange extends PositionChangeLike>(changes: TChange[]): TChange[];
+    /**
+     * Notes nodes that were already removed (e.g. SvelteFlow's `ondelete`), so `flush`
+     * relayouts the frames they left. The nodes must still carry their `parentId`.
+     */
+    noteRemoved(removed: Iterable<{
+        id: string;
+        parentId?: string;
+    }>): void;
+    /** Whether `noteChanges` left work for `flush`. */
+    readonly hasPending: boolean;
+    /**
+     * Applies the work noted by `noteChanges` to the current nodes: drop markers while
+     * dragging, committed reorders on drop (undoable), and a relayout (not recorded) for
+     * size, add and remove changes. Call it once the changes are applied.
+     */
+    flush(): CanvasNodeUpdate[];
+    /** Whether `id` is an auto layout frame. */
+    isFrame: (id: string) => boolean;
+};
+type CanvasAutoLayoutController<TNode extends CanvasNode = CanvasNode> = ReturnType<typeof createCanvasAutoLayoutController<TNode>>;
+
+export { AUTO_LAYOUT_DATA_KEY, AlignEdge, AlignNodesOptions, type ArrangeHistoryTarget, type AutoLayout, type AutoLayoutAlignContent, type AutoLayoutAlignCross, type AutoLayoutAlignMain, type AutoLayoutCellAlign, type AutoLayoutChild, type AutoLayoutConstraints, type AutoLayoutGrid, type AutoLayoutGridArea, type AutoLayoutGridCell, type AutoLayoutGridGeometry, type AutoLayoutGridTrack, type AutoLayoutHorizontalConstraint, type AutoLayoutInsertTarget, type AutoLayoutMeasure, type AutoLayoutMode, type AutoLayoutOptions, type AutoLayoutPadding, type AutoLayoutSize, type AutoLayoutSizing, type AutoLayoutSizingPair, type AutoLayoutVerticalConstraint, CHILD_LAYOUT_DATA_KEY, CONNECTION_LINE_TYPES, CanvasArrangeAction, type CanvasArrangeController, type CanvasArrangeControllerOptions, type CanvasAutoLayoutController, type CanvasAutoLayoutControllerOptions, CanvasClipboardPayload, type CanvasConnectionLineType, CanvasEdge, type CanvasHeightOptions, CanvasLayoutOptions, CanvasNode, CanvasNodeStyle, CanvasNodeUpdate, type CanvasScene, type CanvasScenesOptions, type CanvasScenesState, CanvasScenesStore, type CanvasViewport, type Clock, type CombineShapeNodesOptions, type CombineShapeNodesRefusal, type CombineShapeNodesResult, type ConnectorSnap, type ConnectorSnapOptions, type ConnectorSnapTarget, type CubicSegment, DEFAULT_NODE_HEIGHT, DEFAULT_NODE_WIDTH, DEFAULT_PLACEMENT_GAP, DirectionalDisplacementOptions, DistributeAxis, DistributeMode, DistributeNodesOptions, type EllipseShape, FanOutTrajectoryOptions, type FitCubicsOptions, type FitPathDataOptions, type FitViewportOptions, type FlattenOptions, type GuideIndex, type GuideLine, IncrementalLayoutOptions, ManualClock, MatchSizeOptions, type MeasureGuide, type MeasureSelectionOptions, type MeasureSelectionResult, type MultiNodeTransitionOptions, type MultiPolygon, NodeRectOptions, NodeTransition, type PathCommand, type PathShape, PlaceBesideOptions, Point, type PolygonBooleanOperation, type PolygonBooleanOptions, type PolygonFillRule, type PolygonInput, type PolygonOperand, type PolygonPiece, type PolygonRing, type PolygonToPathOptions, type PolygonWithHoles, Position, type PositionChangeLike, RESIZE_HANDLES, Rect, type RectShape, ReflowDisplacementOptions, type RegularPolygonShape, type ResizeHandle, SHAPE_DATA_KEY, SHAPE_KINDS, SHAPE_NODE_TYPE, SHAPE_OPERATIONS, type SerializedCanvasScenes, type ShapeDescription, type ShapeKind, type ShapeNodePolygonOptions, type ShapeOperation, type ShapePaint, type ShapeRenderData, type ShapeSize, Side, SizeDimension, type SnapGuidesOptions, type SnapNodeDragOptions, type SnapNodeDragResult, type SnapNodeResizeOptions, type SnapNodeResizeResult, type SnapResizeOptions, type SnapResizeResult, type SnapResult, type StarShape, StreamingLayoutManager, type StreamingLayoutManagerOptions, TrajectoryFunction, XYPosition, ZOrderOperation, applyConstraints, applyShapeCombination, blendLayout, boundsOf, calculateDagreReflowDisplacement, calculateDirectionalDisplacement, canCombineShapeNodes, canvasHeight, centerNodes, centre, clampLayoutSize, collectDescendantIds, combineShapeNodes, computeNodesBoundingBox, computeSnapGuides, connectedOnly, createBezierTrajectory, createCanvasArrangeController, createCanvasAutoLayoutController, createCanvasScenesStore, createFanOutTrajectory, createGuideIndex, createNodeGuideIndex, cubicPointAt, cubicsToPathData, defaultEasing, dividePolygons, ensureLayout, estimateCanvasHeight, estimateNodeSize, findConnectorSnap, fitCubicRun, fitCubics, fitFreehandPath, fitPathData, fitViewportToNodes, fitViewportToRect, flattenSvgPath, flowSide, formatNumber, getAutoLayout, getAutoLayoutGrid, getAutoLayoutInsertTarget, getCenteredNodePosition, getChildLayout, getFlowChildren, getLayoutParent, getLayoutSizing, getLayoutedNodes, getNodeShape, getResizingNodeRect, getShapeRenderData, getShapeSvg, handlePoint, inferResizeHandle, intersectPolygons, isAutoLayoutFrame, isEventFromTextInput, isMeasureModifierHeld, isShapeDescription, isShapeNode, isStraightCubic, isValidCanvasEdge, isValidCanvasNode, isValidCanvasScene, isValidUrl, layoutAll, layoutBounds, layoutFrame, layoutUp, layoutUpMany, linearPositionTrajectory, linearTrajectory, makeSizingCoherent, measureBetween, measureLabel, measureSelection, measureToLine, mergeNodeUpdates, moveLayoutChild, multiPolygonArea, multiPolygonBounds, nearestHandlePositions, oppositePosition, overlaps, pageHidden, parseCanvasClipboardData, parseCanvasScenes, parseSvgPath, placeBeside, pointInMultiPolygon, pointInRings, polygonArea, polygonBoolean, polygonToSvgPath, positionToSide, realClock, relayoutUpdates, remapPastedNodes, repositionNodesTo, resizeHandleAxes, resolvePadding, revertShapeCombination, ringSignedArea, runMultiNodeTransition, serializeCanvasNodes, shapeNodeToPolygon, shapeToPolygon, sideToPosition, simplifyRing, snapNodeDrag, snapNodeResize, snapResize, snapToGrid, subtractPolygons, unionPolygons, withStyleOpacity, xorPolygons };