@pixerate/editor-react 0.13.0 → 0.15.0

package/dist/canvas/index.d.ts

@@ -1,8 +1,9 @@
+import * as React$1 from 'react';
 import React__default from 'react';
 import { AgentPresence } from '@pixerate/editor/agent';
 import * as _pixerate_editor_canvas from '@pixerate/editor/canvas';
-import { CanvasNode, CanvasEdge, IncrementalLayoutOptions, XYPosition, GraphDifferences, Rect, CanvasLayoutOptions, Side, PlaceBesideOptions, getCenteredNodePosition, CanvasDockingCallbacks, DockStrategy, ExplodeNodeOptions, CollapseNodeOptions, ExplosionSnapshot, ArrangeHistoryTarget, SnapGuidesOptions, NodeRectOptions, GuideLine, CanvasArrangeAction, ArrangeShortcutBinding, CanvasScenesOptions, CanvasViewport, CanvasScenesStore, CanvasScene, FitViewportOptions } from '@pixerate/editor/canvas';
-export { AlignEdge, ArrangeShortcutBinding, CONNECTION_LINE_TYPES, CanvasArrangeAction, CanvasClipboardPayload, CanvasConnectionLineType, CanvasDockingCallbacks, CanvasEdge, CanvasHeightOptions, CanvasLayoutOptions, CanvasNode, CanvasNodeUpdate, CanvasScene, CanvasScenesState, CanvasScenesStore, CanvasViewport, Clock, CollapseNodeOptions, ConnectorSnap, ConnectorSnapTarget, DEFAULT_ARRANGE_SHORTCUTS, DirectionalDisplacementOptions, DisplacementDirection, DistributeAxis, DistributeMode, DockStrategy, ExplodeNodeOptions, ExplosionSnapshot, FanOutTrajectoryOptions, GraphDifferences, GuideIndex, GuideLine, IncrementalLayoutOptions, ManualClock, NodeTransition, PlaceBesideOptions, Point, Position, Rect, ReflowDisplacementOptions, Side, SizeDimension, SnapGuidesOptions, SnapResult, TrajectoryFunction, TrajectoryPoint, XYPosition, ZOrderOperation, alignNodes, applyNodeUpdates, blendLayout, boundsOf, calculateDagreReflowDisplacement, calculateDirectionalDisplacement, canvasHeight, centerNodes, centre, computeNodesBoundingBox, computeSnapGuides, connectedOnly, createBezierTrajectory, createCanvasScenesStore, createFanOutTrajectory, createGuideIndex, createNodeGuideIndex, defaultEasing, distributeNodes, ensureLayout, estimateCanvasHeight, estimateNodeSize, findConnectorSnap, fitViewportToNodes, fitViewportToRect, flowSide, getAbsolutePosition, getCenteredNodePosition, getLayoutedNodes, getNodeRect, getNodeSize, handlePoint, invertNodeUpdates, isEventFromTextInput, isLocked, isValidCanvasNode, isValidUrl, layoutBounds, linearPositionTrajectory, linearTrajectory, lockNodes, matchArrangeShortcut, matchSize, nearestHandlePositions, oppositePosition, overlaps, parseCanvasClipboardData, parseCanvasScenes, placeBeside, positionToSide, readStyleSize, realClock, remapPastedNodes, reorderNodes, repositionNodesTo, runMultiNodeTransition, serializeCanvasNodes, sideToPosition, snapNodeDrag, toggleLockNodes, unlockNodes, withStyleSize } from '@pixerate/editor/canvas';
+import { CanvasNode, CanvasEdge, IncrementalLayoutOptions, XYPosition, GraphDifferences, Rect, CanvasLayoutOptions, Side, PlaceBesideOptions, getCenteredNodePosition, CanvasDockingCallbacks, DockStrategy, ExplodeNodeOptions, CollapseNodeOptions, ExplosionSnapshot, ArrangeHistoryTarget, SnapGuidesOptions, NodeRectOptions, GuideLine, CanvasArrangeAction, ArrangeShortcutBinding, CanvasScenesOptions, CanvasViewport, CanvasScenesStore, CanvasScene, FitViewportOptions, ShapeDescription } from '@pixerate/editor/canvas';
+export { AlignEdge, ArrangeShortcutBinding, CONNECTION_LINE_TYPES, CanvasArrangeAction, CanvasClipboardPayload, CanvasConnectionLineType, CanvasDockingCallbacks, CanvasEdge, CanvasHeightOptions, CanvasLayoutOptions, CanvasNode, CanvasNodeUpdate, CanvasScene, CanvasScenesState, CanvasScenesStore, CanvasViewport, Clock, CollapseNodeOptions, CombineShapeNodesOptions, CombineShapeNodesRefusal, CombineShapeNodesResult, ConnectorSnap, ConnectorSnapTarget, CubicSegment, DEFAULT_ARRANGE_SHORTCUTS, DirectionalDisplacementOptions, DisplacementDirection, DistributeAxis, DistributeMode, DockStrategy, EllipseShape, ExplodeNodeOptions, ExplosionSnapshot, FanOutTrajectoryOptions, FitCubicsOptions, FitPathDataOptions, FlattenOptions, GraphDifferences, GuideIndex, GuideLine, IncrementalLayoutOptions, ManualClock, MeasureGuide, MeasureSelectionOptions, MeasureSelectionResult, MultiPolygon, NodeTransition, PathCommand, PathShape, PlaceBesideOptions, Point, PolygonBooleanOperation, PolygonBooleanOptions, PolygonFillRule, PolygonInput, PolygonOperand, PolygonPiece, PolygonRing, PolygonToPathOptions, PolygonWithHoles, Position, RESIZE_HANDLES, Rect, RectShape, ReflowDisplacementOptions, RegularPolygonShape, ResizeHandle, SHAPE_DATA_KEY, SHAPE_KINDS, SHAPE_NODE_TYPE, SHAPE_OPERATIONS, ShapeDescription, ShapeKind, ShapeNodePolygonOptions, ShapeOperation, ShapePaint, ShapeRenderData, ShapeSize, Side, SizeDimension, SnapGuidesOptions, SnapNodeResizeOptions, SnapNodeResizeResult, SnapResizeOptions, SnapResizeResult, SnapResult, StarShape, TrajectoryFunction, TrajectoryPoint, XYPosition, ZOrderOperation, alignNodes, applyNodeUpdates, applyShapeCombination, blendLayout, boundsOf, calculateDagreReflowDisplacement, calculateDirectionalDisplacement, canCombineShapeNodes, canvasHeight, centerNodes, centre, combineShapeNodes, computeNodesBoundingBox, computeSnapGuides, connectedOnly, createBezierTrajectory, createCanvasScenesStore, createFanOutTrajectory, createGuideIndex, createNodeGuideIndex, cubicPointAt, cubicsToPathData, defaultEasing, distributeNodes, dividePolygons, ensureLayout, estimateCanvasHeight, estimateNodeSize, findConnectorSnap, fitCubicRun, fitCubics, fitFreehandPath, fitPathData, fitViewportToNodes, fitViewportToRect, flattenSvgPath, flowSide, getAbsolutePosition, getCenteredNodePosition, getLayoutedNodes, getNodeRect, getNodeShape, getNodeSize, getResizingNodeRect, getShapeRenderData, getShapeSvg, handlePoint, inferResizeHandle, intersectPolygons, invertNodeUpdates, isEventFromTextInput, isLocked, isMeasureModifierHeld, isShapeDescription, isShapeNode, isStraightCubic, isValidCanvasNode, isValidUrl, layoutBounds, linearPositionTrajectory, linearTrajectory, lockNodes, matchArrangeShortcut, matchSize, measureBetween, measureLabel, measureSelection, measureToLine, multiPolygonArea, multiPolygonBounds, nearestHandlePositions, oppositePosition, overlaps, parseCanvasClipboardData, parseCanvasScenes, parseSvgPath, placeBeside, pointInMultiPolygon, pointInRings, polygonArea, polygonBoolean, polygonToSvgPath, positionToSide, readStyleSize, realClock, remapPastedNodes, reorderNodes, repositionNodesTo, resizeHandleAxes, revertShapeCombination, ringSignedArea, runMultiNodeTransition, serializeCanvasNodes, shapeNodeToPolygon, shapeToPolygon, sideToPosition, simplifyRing, snapNodeDrag, snapNodeResize, snapResize, snapToGrid, subtractPolygons, toggleLockNodes, unionPolygons, unlockNodes, withStyleSize, xorPolygons } from '@pixerate/editor/canvas';
 
 interface AgentPresenceLayerProps {
     presences: AgentPresence[];
@@ -187,10 +188,21 @@ declare function useCanvasArrange<TNode extends CanvasNode = CanvasNode>(options
     unlock: (ids?: Iterable<string>) => string[];
     toggleLock(ids?: Iterable<string>): string[];
     isLocked: (id: string) => boolean;
+    combineShapes(operation: _pixerate_editor_canvas.ShapeOperation, ids?: Iterable<string>, combineOptions?: _pixerate_editor_canvas.CombineShapeNodesOptions): _pixerate_editor_canvas.CombineShapeNodesResult<TNode>;
+    unite: (ids?: Iterable<string>, o?: _pixerate_editor_canvas.CombineShapeNodesOptions) => _pixerate_editor_canvas.CombineShapeNodesResult<TNode>;
+    intersect: (ids?: Iterable<string>, o?: _pixerate_editor_canvas.CombineShapeNodesOptions) => _pixerate_editor_canvas.CombineShapeNodesResult<TNode>;
+    subtract: (ids?: Iterable<string>, o?: _pixerate_editor_canvas.CombineShapeNodesOptions) => _pixerate_editor_canvas.CombineShapeNodesResult<TNode>;
+    exclude: (ids?: Iterable<string>, o?: _pixerate_editor_canvas.CombineShapeNodesOptions) => _pixerate_editor_canvas.CombineShapeNodesResult<TNode>;
+    divide: (ids?: Iterable<string>, o?: _pixerate_editor_canvas.CombineShapeNodesOptions) => _pixerate_editor_canvas.CombineShapeNodesResult<TNode>;
+    canCombineShapes: (ids?: Iterable<string>) => boolean;
     runAction(action: CanvasArrangeAction): boolean;
     beginDrag(ids?: Iterable<string>): void;
     drag(ids?: Iterable<string>): _pixerate_editor_canvas.SnapNodeDragResult | null;
     snapPositionChanges<TChange extends _pixerate_editor_canvas.PositionChangeLike>(changes: TChange[]): TChange[];
+    beginResize(id: string): void;
+    resize(id: string, handle?: _pixerate_editor_canvas.ResizeHandle): _pixerate_editor_canvas.SnapNodeResizeResult | null;
+    endResize(): void;
+    snapResizeChanges<TChange extends _pixerate_editor_canvas.PositionChangeLike>(changes: TChange[]): TChange[];
     endDrag(): void;
 };
 type CanvasArrange = ReturnType<typeof useCanvasArrange>;
@@ -273,12 +285,78 @@ interface CanvasGuidesLayerProps {
     color?: string;
     /** Colour of equal-spacing guides. */
     spacingColor?: string;
+    /** Colour of measuring lines, their labels and extension lines. */
+    measureColor?: string;
     className?: string;
 }
 /**
  * Smart-guide overlay for React Flow. Place it inside the flow container (it is absolutely
  * positioned over the whole pane) and pass the live viewport.
  */
-declare function CanvasGuidesLayer({ guides, viewport, color, spacingColor, className }: CanvasGuidesLayerProps): React__default.JSX.Element | null;
+declare function CanvasGuidesLayer({ guides, viewport, color, spacingColor, measureColor, className }: CanvasGuidesLayerProps): React__default.JSX.Element | null;
 
-export { AgentPresenceLayer, type AgentPresenceLayerProps, type CanvasArrange, type CanvasGraphTarget, CanvasGuidesLayer, type CanvasGuidesLayerProps, type CanvasScenes, type UseCanvasArrangeOptions, type UseCanvasArrangeShortcutsOptions, type UseCanvasClipboardOptions, type UseCanvasDockingOptions, type UseCanvasGraphOptions, type UseCanvasLayoutOptions, type UseCanvasScenesOptions, type UseCanvasShortcutsOptions, type UseStreamingCanvasOptions, useCanvasArrange, useCanvasArrangeShortcuts, useCanvasClipboard, useCanvasDocking, useCanvasExplosion, useCanvasGraph, useCanvasLayout, useCanvasScenes, useCanvasShortcuts, useStreamingCanvas };
+interface UseCanvasMeasureOptions<TNode extends CanvasNode = CanvasNode> {
+    nodes: TNode[];
+    /** Ids measured from (default: nodes with `selected: true`). */
+    getSelectedIds?: () => string[];
+    /** Turns measuring off (default `true`). */
+    enabled?: boolean;
+    /** Measure only while Alt / Option is held (default `true`); `false` always measures. */
+    requireModifier?: boolean;
+    /** Element receiving the Alt key events (default `window`). */
+    targetElement?: HTMLElement | Window | null;
+    rectOptions?: NodeRectOptions;
+}
+/**
+ * Alt-hover distance measuring for React Flow: hold Alt / Option and hover a node to see
+ * red distance lines with labels from the selection to it (or to the selection's parent
+ * when hovering the selection or empty space). Wire `onNodeMouseEnter` / `onNodeMouseLeave`
+ * to `<ReactFlow>` and render `guides` with `<CanvasGuidesLayer>` (concatenate them with
+ * `arrange.guides` to share one layer).
+ */
+declare function useCanvasMeasure<TNode extends CanvasNode = CanvasNode>(options: UseCanvasMeasureOptions<TNode>): {
+    /** Measuring lines (flow coordinates) to pass to `<CanvasGuidesLayer>`. */
+    guides: _pixerate_editor_canvas.MeasureGuide[];
+    /** The box measured to (outline it), or `null`. */
+    target: _pixerate_editor_canvas.Rect | null;
+    /** Whether measuring is showing (enabled and Alt held, unless `requireModifier: false`). */
+    active: boolean;
+    hoveredId: string | null;
+    setHoveredId: React$1.Dispatch<React$1.SetStateAction<string | null>>;
+    /** Sets the modifier state by hand (e.g. from a toolbar toggle). */
+    setModifier: React$1.Dispatch<React$1.SetStateAction<boolean>>;
+    onNodeMouseEnter: (event: {
+        altKey?: boolean;
+    } | null, node: {
+        id: string;
+    }) => void;
+    onNodeMouseLeave: (_event: unknown, node: {
+        id: string;
+    }) => void;
+};
+type CanvasMeasure = ReturnType<typeof useCanvasMeasure>;
+
+interface ShapeNodeProps {
+    /** Node data; `data.shape` holds the shape description. */
+    data: {
+        shape?: ShapeDescription;
+        [key: string]: any;
+    };
+    /** Node width / height (React Flow passes them to custom nodes). */
+    width?: number;
+    height?: number;
+    selected?: boolean;
+    className?: string;
+    /** Rendered over the shape, e.g. React Flow `<Handle>`s or a label. */
+    children?: React__default.ReactNode;
+    [key: string]: any;
+}
+/**
+ * Headless shape node: draws `data.shape` as one SVG path that fills the node box.
+ * Register it as a React Flow node type (`nodeTypes={{ shape: ShapeNode }}`), or wrap it
+ * to add handles. Strokes keep their width when the node is resized
+ * (`vector-effect: non-scaling-stroke`). Renders nothing when `data.shape` is missing.
+ */
+declare function ShapeNode({ data, width, height, selected, className, children }: ShapeNodeProps): React__default.JSX.Element | null;
+
+export { AgentPresenceLayer, type AgentPresenceLayerProps, type CanvasArrange, type CanvasGraphTarget, CanvasGuidesLayer, type CanvasGuidesLayerProps, type CanvasMeasure, type CanvasScenes, ShapeNode, type ShapeNodeProps, type UseCanvasArrangeOptions, type UseCanvasArrangeShortcutsOptions, type UseCanvasClipboardOptions, type UseCanvasDockingOptions, type UseCanvasGraphOptions, type UseCanvasLayoutOptions, type UseCanvasMeasureOptions, type UseCanvasScenesOptions, type UseCanvasShortcutsOptions, type UseStreamingCanvasOptions, useCanvasArrange, useCanvasArrangeShortcuts, useCanvasClipboard, useCanvasDocking, useCanvasExplosion, useCanvasGraph, useCanvasLayout, useCanvasMeasure, useCanvasScenes, useCanvasShortcuts, useStreamingCanvas };

package/dist/canvas/index.js

@@ -891,19 +891,20 @@ function useCanvasScenes(options = {}) {
 }
 
 // src/canvas/CanvasGuidesLayer.tsx
-import { jsx as jsx2 } from "react/jsx-runtime";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
 var DEFAULT_VIEWPORT = { x: 0, y: 0, zoom: 1 };
 function CanvasGuidesLayer({
   guides,
   viewport = DEFAULT_VIEWPORT,
   color = "#f59e0b",
   spacingColor = "#ec4899",
+  measureColor = "#ef4444",
   className = ""
 }) {
   if (!guides || guides.length === 0) return null;
   const sx = (x) => x * viewport.zoom + viewport.x;
   const sy = (y) => y * viewport.zoom + viewport.y;
-  return /* @__PURE__ */ jsx2(
+  return /* @__PURE__ */ jsxs2(
     "svg",
     {
       className: `pixerate-canvas-guides ${className}`,
@@ -917,26 +918,141 @@ function CanvasGuidesLayer({
         zIndex: 10
       },
       "aria-hidden": "true",
-      children: guides.map((guide, i) => /* @__PURE__ */ jsx2(
-        "line",
-        {
-          "data-kind": guide.kind,
-          x1: sx(guide.x1),
-          y1: sy(guide.y1),
-          x2: sx(guide.x2),
-          y2: sy(guide.y2),
-          stroke: guide.kind === "spacing" ? spacingColor : color,
-          strokeWidth: 1,
-          strokeDasharray: guide.kind === "centre" ? "4 3" : void 0,
-          shapeRendering: "crispEdges"
-        },
-        i
-      ))
+      children: [
+        guides.map((guide, i) => {
+          const measuring = guide.kind === "measure" || guide.kind === "extension";
+          return /* @__PURE__ */ jsx2(
+            "line",
+            {
+              "data-kind": guide.kind,
+              x1: sx(guide.x1),
+              y1: sy(guide.y1),
+              x2: sx(guide.x2),
+              y2: sy(guide.y2),
+              stroke: measuring ? measureColor : guide.kind === "spacing" ? spacingColor : color,
+              strokeWidth: 1,
+              strokeDasharray: guide.kind === "centre" ? "4 3" : guide.kind === "extension" ? "3 3" : void 0,
+              shapeRendering: "crispEdges"
+            },
+            i
+          );
+        }),
+        guides.map((guide, i) => {
+          if (!guide.label) return null;
+          const x = sx((guide.x1 + guide.x2) / 2);
+          const y = sy((guide.y1 + guide.y2) / 2);
+          const vertical = guide.orientation === "vertical";
+          const width = guide.label.length * 6.5 + 8;
+          return /* @__PURE__ */ jsxs2(
+            "g",
+            {
+              className: "pixerate-canvas-guides__label",
+              "data-label": guide.label,
+              transform: `translate(${vertical ? x + 4 : x - width / 2} ${vertical ? y - 8 : y + 4})`,
+              children: [
+                /* @__PURE__ */ jsx2("rect", { width, height: 16, rx: 3, fill: measureColor }),
+                /* @__PURE__ */ jsx2(
+                  "text",
+                  {
+                    x: width / 2,
+                    y: 11.5,
+                    textAnchor: "middle",
+                    fontSize: 11,
+                    fontFamily: "system-ui, sans-serif",
+                    fill: "#fff",
+                    children: guide.label
+                  }
+                )
+              ]
+            },
+            `label-${i}`
+          );
+        })
+      ]
     }
   );
 }
 
+// src/canvas/useCanvasMeasure.ts
+import { useCallback as useCallback7, useEffect as useEffect4, useMemo as useMemo3, useRef as useRef7, useState as useState3 } from "react";
+import {
+  isMeasureModifierHeld,
+  measureSelection
+} from "@pixerate/editor/canvas";
+var EMPTY = { guides: [], target: null, selection: null };
+function useCanvasMeasure(options) {
+  const { nodes, enabled = true, requireModifier = true, targetElement, rectOptions } = options;
+  const [hoveredId, setHoveredId] = useState3(null);
+  const [modifier, setModifier] = useState3(false);
+  const optionsRef = useRef7(options);
+  optionsRef.current = options;
+  useEffect4(() => {
+    if (!enabled) return;
+    const target = targetElement ?? (typeof window !== "undefined" ? window : null);
+    if (!target) return;
+    const onKey = (event) => setModifier(isMeasureModifierHeld(event));
+    const onBlur = () => setModifier(false);
+    target.addEventListener("keydown", onKey);
+    target.addEventListener("keyup", onKey);
+    const win = typeof window !== "undefined" ? window : null;
+    win?.addEventListener("blur", onBlur);
+    return () => {
+      target.removeEventListener("keydown", onKey);
+      target.removeEventListener("keyup", onKey);
+      win?.removeEventListener("blur", onBlur);
+    };
+  }, [enabled, targetElement]);
+  const active = enabled && (!requireModifier || modifier);
+  const result = useMemo3(() => {
+    if (!active) return EMPTY;
+    const ids = optionsRef.current.getSelectedIds?.() ?? nodes.filter((n) => n.selected).map((n) => n.id);
+    return measureSelection(nodes, ids, hoveredId, rectOptions);
+  }, [active, nodes, hoveredId, rectOptions]);
+  const onNodeMouseEnter = useCallback7((event, node) => {
+    setHoveredId(node.id);
+    if (event && typeof event.altKey === "boolean") setModifier(event.altKey);
+  }, []);
+  const onNodeMouseLeave = useCallback7((_event, node) => {
+    setHoveredId((current) => current === node.id ? null : current);
+  }, []);
+  return {
+    /** Measuring lines (flow coordinates) to pass to `<CanvasGuidesLayer>`. */
+    guides: result.guides,
+    /** The box measured to (outline it), or `null`. */
+    target: result.target,
+    /** Whether measuring is showing (enabled and Alt held, unless `requireModifier: false`). */
+    active,
+    hoveredId,
+    setHoveredId,
+    /** Sets the modifier state by hand (e.g. from a toolbar toggle). */
+    setModifier,
+    onNodeMouseEnter,
+    onNodeMouseLeave
+  };
+}
+
 // src/canvas/index.ts
+import {
+  measureBetween,
+  measureToLine,
+  measureSelection as measureSelection2,
+  measureLabel,
+  isMeasureModifierHeld as isMeasureModifierHeld2,
+  snapToGrid,
+  snapResize,
+  snapNodeResize,
+  inferResizeHandle,
+  resizeHandleAxes,
+  getResizingNodeRect,
+  RESIZE_HANDLES,
+  fitCubics,
+  fitCubicRun,
+  fitPathData,
+  fitFreehandPath,
+  cubicsToPathData,
+  cubicPointAt,
+  isStraightCubic
+} from "@pixerate/editor/canvas";
 import {
   alignNodes,
   distributeNodes,
@@ -972,6 +1088,86 @@ import {
   matchArrangeShortcut as matchArrangeShortcut2,
   DEFAULT_ARRANGE_SHORTCUTS
 } from "@pixerate/editor/canvas";
+
+// src/canvas/ShapeNode.tsx
+import { getShapeRenderData, isShapeDescription } from "@pixerate/editor/canvas";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function ShapeNode({ data, width, height, selected, className = "", children }) {
+  const shape = data?.shape;
+  if (!isShapeDescription(shape)) return null;
+  const render = getShapeRenderData(shape, { width, height });
+  return /* @__PURE__ */ jsxs3(
+    "div",
+    {
+      className: `pixerate-shape-node ${className}`.trim(),
+      "data-shape-kind": shape.kind,
+      "data-selected": selected ? "true" : void 0,
+      style: { position: "relative", width: "100%", height: "100%" },
+      children: [
+        /* @__PURE__ */ jsx3(
+          "svg",
+          {
+            viewBox: render.viewBox,
+            preserveAspectRatio: "none",
+            width: "100%",
+            height: "100%",
+            style: { display: "block", overflow: "visible" },
+            "aria-hidden": "true",
+            children: /* @__PURE__ */ jsx3(
+              "path",
+              {
+                d: render.d,
+                transform: render.transform,
+                fill: render.fill,
+                fillRule: render.fillRule,
+                stroke: render.stroke,
+                strokeWidth: render.strokeWidth,
+                opacity: render.opacity,
+                vectorEffect: "non-scaling-stroke"
+              }
+            )
+          }
+        ),
+        children
+      ]
+    }
+  );
+}
+
+// src/canvas/index.ts
+import {
+  combineShapeNodes,
+  canCombineShapeNodes,
+  applyShapeCombination,
+  revertShapeCombination,
+  shapeNodeToPolygon,
+  isShapeNode,
+  getNodeShape,
+  SHAPE_DATA_KEY,
+  SHAPE_NODE_TYPE,
+  SHAPE_OPERATIONS,
+  SHAPE_KINDS,
+  isShapeDescription as isShapeDescription2,
+  shapeToPolygon,
+  getShapeSvg,
+  getShapeRenderData as getShapeRenderData2,
+  parseSvgPath,
+  flattenSvgPath,
+  polygonToSvgPath,
+  simplifyRing,
+  polygonBoolean,
+  unionPolygons,
+  intersectPolygons,
+  subtractPolygons,
+  xorPolygons,
+  dividePolygons,
+  polygonArea,
+  multiPolygonArea,
+  multiPolygonBounds,
+  ringSignedArea,
+  pointInRings,
+  pointInMultiPolygon
+} from "@pixerate/editor/canvas";
 import {
   getLayoutedNodes as getLayoutedNodes2,
   ensureLayout as ensureLayout2,
@@ -1014,15 +1210,24 @@ export {
   CanvasScenesStore2 as CanvasScenesStore,
   DEFAULT_ARRANGE_SHORTCUTS,
   ManualClock,
+  RESIZE_HANDLES,
+  SHAPE_DATA_KEY,
+  SHAPE_KINDS,
+  SHAPE_NODE_TYPE,
+  SHAPE_OPERATIONS,
+  ShapeNode,
   alignNodes,
   applyNodeUpdates,
+  applyShapeCombination,
   blendLayout,
   boundsOf,
   calculateDagreReflowDisplacement,
   calculateDirectionalDisplacement2 as calculateDirectionalDisplacement,
+  canCombineShapeNodes,
   canvasHeight,
   centerNodes2 as centerNodes,
   centre,
+  combineShapeNodes,
   computeNodesBoundingBox,
   computeSnapGuides,
   connectedOnly,
@@ -1031,24 +1236,42 @@ export {
   createFanOutTrajectory2 as createFanOutTrajectory,
   createGuideIndex,
   createNodeGuideIndex,
+  cubicPointAt,
+  cubicsToPathData,
   defaultEasing,
   distributeNodes,
+  dividePolygons,
   ensureLayout2 as ensureLayout,
   estimateCanvasHeight,
   estimateNodeSize,
   findConnectorSnap,
+  fitCubicRun,
+  fitCubics,
+  fitFreehandPath,
+  fitPathData,
   fitViewportToNodes2 as fitViewportToNodes,
   fitViewportToRect,
+  flattenSvgPath,
   flowSide,
   getAbsolutePosition,
   getCenteredNodePosition2 as getCenteredNodePosition,
   getLayoutedNodes2 as getLayoutedNodes,
   getNodeRect,
+  getNodeShape,
   getNodeSize,
+  getResizingNodeRect,
+  getShapeRenderData2 as getShapeRenderData,
+  getShapeSvg,
   handlePoint,
+  inferResizeHandle,
+  intersectPolygons,
   invertNodeUpdates,
   isEventFromTextInput3 as isEventFromTextInput,
   isLocked,
+  isMeasureModifierHeld2 as isMeasureModifierHeld,
+  isShapeDescription2 as isShapeDescription,
+  isShapeNode,
+  isStraightCubic,
   isValidCanvasNode,
   isValidUrl2 as isValidUrl,
   layoutBounds,
@@ -1057,23 +1280,46 @@ export {
   lockNodes,
   matchArrangeShortcut2 as matchArrangeShortcut,
   matchSize,
+  measureBetween,
+  measureLabel,
+  measureSelection2 as measureSelection,
+  measureToLine,
+  multiPolygonArea,
+  multiPolygonBounds,
   nearestHandlePositions,
   oppositePosition,
   overlaps,
   parseCanvasClipboardData2 as parseCanvasClipboardData,
   parseCanvasScenes,
+  parseSvgPath,
   placeBeside2 as placeBeside,
+  pointInMultiPolygon,
+  pointInRings,
+  polygonArea,
+  polygonBoolean,
+  polygonToSvgPath,
   positionToSide,
   readStyleSize,
   realClock,
   remapPastedNodes2 as remapPastedNodes,
   reorderNodes,
   repositionNodesTo,
+  resizeHandleAxes,
+  revertShapeCombination,
+  ringSignedArea,
   runMultiNodeTransition2 as runMultiNodeTransition,
   serializeCanvasNodes2 as serializeCanvasNodes,
+  shapeNodeToPolygon,
+  shapeToPolygon,
   sideToPosition,
+  simplifyRing,
   snapNodeDrag,
+  snapNodeResize,
+  snapResize,
+  snapToGrid,
+  subtractPolygons,
   toggleLockNodes,
+  unionPolygons,
   unlockNodes,
   useCanvasArrange,
   useCanvasArrangeShortcuts,
@@ -1082,9 +1328,11 @@ export {
   useCanvasExplosion,
   useCanvasGraph,
   useCanvasLayout,
+  useCanvasMeasure,
   useCanvasScenes,
   useCanvasShortcuts,
   useStreamingCanvas,
-  withStyleSize
+  withStyleSize,
+  xorPolygons
 };
 //# sourceMappingURL=index.js.map