@pixerate/editor 0.22.0 → 0.23.0

package/dist/arrangeShortcuts-sLlD2rSX.d.ts

@@ -0,0 +1,184 @@
+import { R as Rect, X as XYPosition, C as CanvasNode, a as CanvasNodeStyle } from './types-DX4Mh4SL.js';
+
+/**
+ * Edge (or centre line) used by `alignNodes`.
+ * `center` aligns horizontal centres (a vertical line); `middle` aligns vertical centres.
+ */
+type AlignEdge = 'left' | 'center' | 'right' | 'top' | 'middle' | 'bottom';
+/** Axis used by `distributeNodes`. `both` distributes horizontally and vertically. */
+type DistributeAxis = 'horizontal' | 'vertical' | 'both';
+/**
+ * `gaps` leaves equal space between neighbouring nodes, `centres` spaces their centres equally.
+ */
+type DistributeMode = 'gaps' | 'centres';
+/** Dimension(s) copied by `matchSize`. */
+type SizeDimension = 'width' | 'height' | 'both';
+/**
+ * Partial node change produced by the arrange helpers. `position` is in the node's own
+ * coordinate space (relative to its `parentId` parent when it has one).
+ */
+interface CanvasNodeUpdate {
+    id: string;
+    position?: XYPosition;
+    width?: number;
+    height?: number;
+    zIndex?: number;
+}
+interface NodeRectOptions {
+    /** Width used when a node has no measured, explicit or style size and estimation is off. */
+    defaultWidth?: number;
+    /** Height used when a node has no measured, explicit or style size and estimation is off. */
+    defaultHeight?: number;
+    /** Estimate unmeasured node sizes from their label via `estimateNodeSize` (default `true`). */
+    estimate?: boolean;
+}
+/** Data key marking a node as locked. See `lockNodes`. */
+declare const LOCKED_DATA_KEY = "locked";
+/** Data key holding the interaction flags a node had before it was locked. */
+declare const LOCKED_PREVIOUS_FLAGS_KEY = "lockedPrevious";
+/**
+ * Reads a pixel `width` / `height` from a node style, which may be a CSS string (SvelteFlow)
+ * or a style object (React Flow). Non-pixel values (`%`, `auto`, ...) are ignored.
+ */
+declare function readStyleSize(style: CanvasNodeStyle | undefined | null): {
+    width?: number;
+    height?: number;
+};
+/**
+ * Returns `style` with its pixel `width` / `height` replaced, keeping its representation
+ * (string or object). Only dimensions already present in the style are rewritten, because
+ * xyflow applies the node's own `width` / `height` props otherwise.
+ */
+declare function withStyleSize(style: CanvasNodeStyle | undefined | null, size: {
+    width?: number;
+    height?: number;
+}): CanvasNodeStyle | undefined;
+/**
+ * Resolves a node's size: measured DOM size, then explicit `width` / `height`, then a pixel
+ * size in `style`, then a label-based estimate (or the defaults when `estimate` is `false`).
+ */
+declare function getNodeSize(node: CanvasNode, options?: NodeRectOptions): {
+    width: number;
+    height: number;
+};
+/**
+ * Absolute (flow-space) position of a node, following its `parentId` chain.
+ * Cycles and missing parents are tolerated.
+ */
+declare function getAbsolutePosition(node: CanvasNode, lookup: ReadonlyMap<string, CanvasNode>): XYPosition;
+/** Builds an id lookup for a node array. */
+declare function createNodeLookup<TNode extends CanvasNode>(nodes: TNode[]): Map<string, TNode>;
+/** Absolute flow-space rectangle of a node. */
+declare function getNodeRect(node: CanvasNode, lookup?: ReadonlyMap<string, CanvasNode>, options?: NodeRectOptions): Rect;
+/**
+ * Whether a node has been locked with `lockNodes`.
+ */
+declare function isLocked(node: CanvasNode | undefined | null): boolean;
+/**
+ * Locks nodes: marks `data.locked = true` and sets `draggable: false` and `deletable: false`
+ * so both SvelteFlow and React Flow stop dragging and deleting them. Nodes stay `selectable`
+ * so they can be unlocked again. The previous flags are kept in `data.lockedPrevious` and
+ * restored by `unlockNodes`. Returns a new array; untouched nodes keep their identity.
+ */
+declare function lockNodes<TNode extends CanvasNode>(nodes: TNode[], ids: Iterable<string>): TNode[];
+/**
+ * Reverses `lockNodes`, restoring the `draggable` / `deletable` flags the node had before.
+ */
+declare function unlockNodes<TNode extends CanvasNode>(nodes: TNode[], ids: Iterable<string>): TNode[];
+/** Locks the given nodes if any of them is unlocked, otherwise unlocks them all. */
+declare function toggleLockNodes<TNode extends CanvasNode>(nodes: TNode[], ids: Iterable<string>): TNode[];
+interface AlignNodesOptions extends NodeRectOptions {
+    /**
+     * What to align to: the selection bounding box (default) or a fixed rectangle.
+     * Locked nodes never move but still count towards the selection bounds, so they act as anchors.
+     */
+    to?: 'selection' | Rect;
+}
+/**
+ * Aligns nodes to a shared edge or centre line of their bounding box (Freeform's
+ * Align Left / Center / Right / Top / Middle / Bottom). Needs at least two nodes unless
+ * `options.to` is a rectangle. Locked nodes are not moved.
+ */
+declare function alignNodes(nodes: CanvasNode[], ids: Iterable<string>, edge: AlignEdge, options?: AlignNodesOptions): CanvasNodeUpdate[];
+interface DistributeNodesOptions extends NodeRectOptions {
+    /** Explicit gap between neighbours for `gaps` mode. Default: spread evenly between the outer nodes. */
+    gap?: number;
+}
+/**
+ * Distributes nodes along an axis (Freeform's Distribute Horizontally / Vertically / Evenly).
+ * The outermost nodes stay put and the others are spaced with equal gaps (`gaps`, default)
+ * or equally spaced centres (`centres`). Needs at least three nodes (two with an explicit
+ * `gap`). Locked nodes keep their place in the order but are not moved.
+ */
+declare function distributeNodes(nodes: CanvasNode[], ids: Iterable<string>, axis: DistributeAxis, mode?: DistributeMode, options?: DistributeNodesOptions): CanvasNodeUpdate[];
+interface MatchSizeOptions extends NodeRectOptions {
+    /**
+     * Size source: the `largest` (default) or `smallest` node, the `first` id given,
+     * or a specific node id.
+     */
+    reference?: 'largest' | 'smallest' | 'first' | {
+        id: string;
+    };
+    /** Keep each node's centre in place instead of its top-left corner (default `false`). */
+    keepCentre?: boolean;
+}
+/**
+ * Makes nodes the same width, height or both (Freeform's Make Same Size). Returns size
+ * updates (plus position updates with `keepCentre`). Locked nodes are not resized but can
+ * be the reference.
+ */
+declare function matchSize(nodes: CanvasNode[], ids: Iterable<string>, dimension: SizeDimension, options?: MatchSizeOptions): CanvasNodeUpdate[];
+/** Z-order operation. */
+type ZOrderOperation = 'bringForward' | 'sendBackward' | 'bringToFront' | 'sendToBack';
+/**
+ * Restacks nodes (Bring Forward / Send Backward / Bring to Front / Send to Back).
+ *
+ * Both SvelteFlow and React Flow stack nodes by `zIndex` (missing = 0) and, for equal
+ * `zIndex`, by array order. This computes that effective order for the siblings that share
+ * the targets' parent, applies the operation, and returns `zIndex` updates assigning each
+ * sibling its new rank. The array order is left alone, because xyflow requires parents to
+ * precede their children. Locked nodes are not restacked. "Forward" moves past the next
+ * sibling the node overlaps, falling back to the next sibling when nothing overlaps.
+ */
+declare function reorderNodes(nodes: CanvasNode[], ids: Iterable<string>, operation: ZOrderOperation, options?: NodeRectOptions): CanvasNodeUpdate[];
+/**
+ * Applies `CanvasNodeUpdate`s to a node array, returning a new array. Unchanged nodes keep
+ * their identity. Size updates set `width` / `height` and rewrite pixel sizes already present
+ * in `style` (string or object). An existing `measured` size is updated too, so geometry
+ * helpers see the new size before xyflow re-measures the node.
+ */
+declare function applyNodeUpdates<TNode extends CanvasNode>(nodes: TNode[], updates: CanvasNodeUpdate[]): TNode[];
+/**
+ * Inverse of a set of updates against the current nodes, for undo. Restores the previous
+ * position / size / zIndex of every node an update touches.
+ */
+declare function invertNodeUpdates(nodes: CanvasNode[], updates: CanvasNodeUpdate[]): CanvasNodeUpdate[];
+
+/**
+ * Canvas arrangement actions that have keyboard shortcuts.
+ */
+type CanvasArrangeAction = 'alignLeft' | 'alignCenter' | 'alignRight' | 'alignTop' | 'alignMiddle' | 'alignBottom' | 'distributeHorizontal' | 'distributeVertical' | 'lock' | 'unlock' | 'bringForward' | 'sendBackward' | 'bringToFront' | 'sendToBack' | 'nextScene' | 'previousScene';
+interface ArrangeShortcutBinding {
+    action: CanvasArrangeAction;
+    /** `KeyboardEvent.code` (layout- and Option-independent, e.g. `KeyA`, `BracketRight`). */
+    code: string;
+    mod?: boolean;
+    alt?: boolean;
+    shift?: boolean;
+    /** Human readable label, e.g. for menus. `Mod` is ⌘ on macOS and Ctrl elsewhere. */
+    label: string;
+}
+/**
+ * Default bindings. Align/distribute follow Figma (Option/Alt + letter), layer order follows
+ * the common `Mod+]` / `Mod+[` convention, lock follows Keynote/Freeform (`Mod+L`,
+ * `Mod+Alt+L` to unlock) and scenes step with PageDown / PageUp.
+ */
+declare const DEFAULT_ARRANGE_SHORTCUTS: readonly ArrangeShortcutBinding[];
+/**
+ * Resolves a keydown event to an arrange action, or `null`. Events from text inputs,
+ * textareas, selects, contenteditable and ProseMirror are ignored (see `isEventFromTextInput`).
+ * `Mod` is ⌘ or Ctrl. Built on the command system's `ShortcutMap` (matching `event.code`).
+ */
+declare function matchArrangeShortcut(event: KeyboardEvent, bindings?: readonly ArrangeShortcutBinding[]): CanvasArrangeAction | null;
+
+export { type AlignEdge as A, type CanvasArrangeAction as C, type DistributeAxis as D, LOCKED_DATA_KEY as L, type MatchSizeOptions as M, type NodeRectOptions as N, type SizeDimension as S, type ZOrderOperation as Z, type DistributeMode as a, type CanvasNodeUpdate as b, type AlignNodesOptions as c, type DistributeNodesOptions as d, type ArrangeShortcutBinding as e, DEFAULT_ARRANGE_SHORTCUTS as f, LOCKED_PREVIOUS_FLAGS_KEY as g, alignNodes as h, applyNodeUpdates as i, createNodeLookup as j, distributeNodes as k, getAbsolutePosition as l, getNodeRect as m, getNodeSize as n, invertNodeUpdates as o, isLocked as p, lockNodes as q, matchArrangeShortcut as r, matchSize as s, readStyleSize as t, reorderNodes as u, toggleLockNodes as v, unlockNodes as w, withStyleSize as x };