@pixerate/editor-react 0.14.0 → 0.15.0

package/README.md

@@ -88,9 +88,10 @@ useAgentToolProvider(registry, provider);
 
 | Import | Exports |
 | :--- | :--- |
-| `@pixerate/editor-react` | `usePromptEditor`, `useEditor`, `EditorContent`, `BubbleMenu`, `TemplateRenderer`, `useHistory`, `useHistoryShortcuts`, `useNavigationGuard`, `useDismissGuard`, `EditorSlotsProvider` / `useEditorSlots`, `SpreadsheetEditor` / `useSpreadsheetEditor`, `FormulaHints`, `DirtyTracker` |
+| `@pixerate/editor-react` | `usePromptEditor`, `useEditor`, `EditorContent`, `BubbleMenu`, `TemplateRenderer`, `useHistory`, `useHistoryDirty`, `useHistoryShortcuts`, `useNavigationGuard`, `useDismissGuard`, `EditorSlotsProvider` / `useEditorSlots`, `SpreadsheetEditor` / `useSpreadsheetEditor`, `FormulaHints`, `DirtyTracker` |
 | `@pixerate/editor-react/spreadsheet` | `SpreadsheetEditor`, `useSpreadsheetEditor`, `useSpreadsheetTableInteractions`, `FormulaHints`, `SpreadsheetContextMenu`, `SpreadsheetGroupRow` (also re-exported from the root entry) |
 | `@pixerate/editor-react/image-editor` | `ImageEditor`, `useImageEditor`: crop, rotate/flip, adjustments, annotations, depth masks, and `onInpaint` / `onRemoveBackground` AI hooks |
+| `@pixerate/editor-react/commands` | `CommandPalette`, `useCommandPalette` (`hotkey: "Mod+K"`), `useCommandShortcuts`, `useRegisterCommands` over a `CommandRegistry` from `@pixerate/editor/commands` (also re-exported from the root entry) |
 | `@pixerate/editor-react/canvas` | `useCanvasGraph`, `useCanvasLayout`, `useCanvasClipboard`, `useCanvasDocking`, `useCanvasShortcuts`, `useCanvasExplosion`, `useStreamingCanvas`, `AgentPresenceLayer`, plus the pure layout helpers from `@pixerate/editor/canvas` |
 
 ## Styling (Tailwind CSS required)

package/dist/canvas/index.cjs

@@ -21,103 +21,122 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var canvas_exports = {};
 __export(canvas_exports, {
   AgentPresenceLayer: () => AgentPresenceLayer,
-  CONNECTION_LINE_TYPES: () => import_canvas9.CONNECTION_LINE_TYPES,
+  CONNECTION_LINE_TYPES: () => import_canvas11.CONNECTION_LINE_TYPES,
   CanvasGuidesLayer: () => CanvasGuidesLayer,
-  CanvasScenesStore: () => import_canvas9.CanvasScenesStore,
-  DEFAULT_ARRANGE_SHORTCUTS: () => import_canvas9.DEFAULT_ARRANGE_SHORTCUTS,
-  ManualClock: () => import_canvas11.ManualClock,
-  SHAPE_DATA_KEY: () => import_canvas10.SHAPE_DATA_KEY,
-  SHAPE_KINDS: () => import_canvas10.SHAPE_KINDS,
-  SHAPE_NODE_TYPE: () => import_canvas10.SHAPE_NODE_TYPE,
-  SHAPE_OPERATIONS: () => import_canvas10.SHAPE_OPERATIONS,
+  CanvasScenesStore: () => import_canvas11.CanvasScenesStore,
+  DEFAULT_ARRANGE_SHORTCUTS: () => import_canvas11.DEFAULT_ARRANGE_SHORTCUTS,
+  ManualClock: () => import_canvas13.ManualClock,
+  RESIZE_HANDLES: () => import_canvas10.RESIZE_HANDLES,
+  SHAPE_DATA_KEY: () => import_canvas12.SHAPE_DATA_KEY,
+  SHAPE_KINDS: () => import_canvas12.SHAPE_KINDS,
+  SHAPE_NODE_TYPE: () => import_canvas12.SHAPE_NODE_TYPE,
+  SHAPE_OPERATIONS: () => import_canvas12.SHAPE_OPERATIONS,
   ShapeNode: () => ShapeNode,
-  alignNodes: () => import_canvas9.alignNodes,
-  applyNodeUpdates: () => import_canvas9.applyNodeUpdates,
-  applyShapeCombination: () => import_canvas10.applyShapeCombination,
-  blendLayout: () => import_canvas11.blendLayout,
-  boundsOf: () => import_canvas11.boundsOf,
-  calculateDagreReflowDisplacement: () => import_canvas11.calculateDagreReflowDisplacement,
-  calculateDirectionalDisplacement: () => import_canvas11.calculateDirectionalDisplacement,
-  canCombineShapeNodes: () => import_canvas10.canCombineShapeNodes,
-  canvasHeight: () => import_canvas11.canvasHeight,
-  centerNodes: () => import_canvas11.centerNodes,
-  centre: () => import_canvas11.centre,
-  combineShapeNodes: () => import_canvas10.combineShapeNodes,
-  computeNodesBoundingBox: () => import_canvas11.computeNodesBoundingBox,
-  computeSnapGuides: () => import_canvas9.computeSnapGuides,
-  connectedOnly: () => import_canvas11.connectedOnly,
-  createBezierTrajectory: () => import_canvas11.createBezierTrajectory,
-  createCanvasScenesStore: () => import_canvas9.createCanvasScenesStore,
-  createFanOutTrajectory: () => import_canvas11.createFanOutTrajectory,
-  createGuideIndex: () => import_canvas9.createGuideIndex,
-  createNodeGuideIndex: () => import_canvas9.createNodeGuideIndex,
-  defaultEasing: () => import_canvas11.defaultEasing,
-  distributeNodes: () => import_canvas9.distributeNodes,
-  dividePolygons: () => import_canvas10.dividePolygons,
-  ensureLayout: () => import_canvas11.ensureLayout,
-  estimateCanvasHeight: () => import_canvas11.estimateCanvasHeight,
-  estimateNodeSize: () => import_canvas11.estimateNodeSize,
-  findConnectorSnap: () => import_canvas9.findConnectorSnap,
-  fitViewportToNodes: () => import_canvas9.fitViewportToNodes,
-  fitViewportToRect: () => import_canvas9.fitViewportToRect,
-  flattenSvgPath: () => import_canvas10.flattenSvgPath,
-  flowSide: () => import_canvas11.flowSide,
-  getAbsolutePosition: () => import_canvas9.getAbsolutePosition,
-  getCenteredNodePosition: () => import_canvas11.getCenteredNodePosition,
-  getLayoutedNodes: () => import_canvas11.getLayoutedNodes,
-  getNodeRect: () => import_canvas9.getNodeRect,
-  getNodeShape: () => import_canvas10.getNodeShape,
-  getNodeSize: () => import_canvas9.getNodeSize,
-  getShapeRenderData: () => import_canvas10.getShapeRenderData,
-  getShapeSvg: () => import_canvas10.getShapeSvg,
-  handlePoint: () => import_canvas9.handlePoint,
-  intersectPolygons: () => import_canvas10.intersectPolygons,
-  invertNodeUpdates: () => import_canvas9.invertNodeUpdates,
-  isEventFromTextInput: () => import_canvas11.isEventFromTextInput,
-  isLocked: () => import_canvas9.isLocked,
-  isShapeDescription: () => import_canvas10.isShapeDescription,
-  isShapeNode: () => import_canvas10.isShapeNode,
-  isValidCanvasNode: () => import_canvas11.isValidCanvasNode,
-  isValidUrl: () => import_canvas11.isValidUrl,
-  layoutBounds: () => import_canvas11.layoutBounds,
-  linearPositionTrajectory: () => import_canvas11.linearPositionTrajectory,
-  linearTrajectory: () => import_canvas11.linearTrajectory,
-  lockNodes: () => import_canvas9.lockNodes,
-  matchArrangeShortcut: () => import_canvas9.matchArrangeShortcut,
-  matchSize: () => import_canvas9.matchSize,
-  multiPolygonArea: () => import_canvas10.multiPolygonArea,
-  multiPolygonBounds: () => import_canvas10.multiPolygonBounds,
-  nearestHandlePositions: () => import_canvas9.nearestHandlePositions,
-  oppositePosition: () => import_canvas9.oppositePosition,
-  overlaps: () => import_canvas11.overlaps,
-  parseCanvasClipboardData: () => import_canvas11.parseCanvasClipboardData,
-  parseCanvasScenes: () => import_canvas9.parseCanvasScenes,
-  parseSvgPath: () => import_canvas10.parseSvgPath,
-  placeBeside: () => import_canvas11.placeBeside,
-  pointInMultiPolygon: () => import_canvas10.pointInMultiPolygon,
-  pointInRings: () => import_canvas10.pointInRings,
-  polygonArea: () => import_canvas10.polygonArea,
-  polygonBoolean: () => import_canvas10.polygonBoolean,
-  polygonToSvgPath: () => import_canvas10.polygonToSvgPath,
-  positionToSide: () => import_canvas9.positionToSide,
-  readStyleSize: () => import_canvas9.readStyleSize,
-  realClock: () => import_canvas11.realClock,
-  remapPastedNodes: () => import_canvas11.remapPastedNodes,
-  reorderNodes: () => import_canvas9.reorderNodes,
-  repositionNodesTo: () => import_canvas11.repositionNodesTo,
-  revertShapeCombination: () => import_canvas10.revertShapeCombination,
-  ringSignedArea: () => import_canvas10.ringSignedArea,
-  runMultiNodeTransition: () => import_canvas11.runMultiNodeTransition,
-  serializeCanvasNodes: () => import_canvas11.serializeCanvasNodes,
-  shapeNodeToPolygon: () => import_canvas10.shapeNodeToPolygon,
-  shapeToPolygon: () => import_canvas10.shapeToPolygon,
-  sideToPosition: () => import_canvas9.sideToPosition,
-  simplifyRing: () => import_canvas10.simplifyRing,
-  snapNodeDrag: () => import_canvas9.snapNodeDrag,
-  subtractPolygons: () => import_canvas10.subtractPolygons,
-  toggleLockNodes: () => import_canvas9.toggleLockNodes,
-  unionPolygons: () => import_canvas10.unionPolygons,
-  unlockNodes: () => import_canvas9.unlockNodes,
+  alignNodes: () => import_canvas11.alignNodes,
+  applyNodeUpdates: () => import_canvas11.applyNodeUpdates,
+  applyShapeCombination: () => import_canvas12.applyShapeCombination,
+  blendLayout: () => import_canvas13.blendLayout,
+  boundsOf: () => import_canvas13.boundsOf,
+  calculateDagreReflowDisplacement: () => import_canvas13.calculateDagreReflowDisplacement,
+  calculateDirectionalDisplacement: () => import_canvas13.calculateDirectionalDisplacement,
+  canCombineShapeNodes: () => import_canvas12.canCombineShapeNodes,
+  canvasHeight: () => import_canvas13.canvasHeight,
+  centerNodes: () => import_canvas13.centerNodes,
+  centre: () => import_canvas13.centre,
+  combineShapeNodes: () => import_canvas12.combineShapeNodes,
+  computeNodesBoundingBox: () => import_canvas13.computeNodesBoundingBox,
+  computeSnapGuides: () => import_canvas11.computeSnapGuides,
+  connectedOnly: () => import_canvas13.connectedOnly,
+  createBezierTrajectory: () => import_canvas13.createBezierTrajectory,
+  createCanvasScenesStore: () => import_canvas11.createCanvasScenesStore,
+  createFanOutTrajectory: () => import_canvas13.createFanOutTrajectory,
+  createGuideIndex: () => import_canvas11.createGuideIndex,
+  createNodeGuideIndex: () => import_canvas11.createNodeGuideIndex,
+  cubicPointAt: () => import_canvas10.cubicPointAt,
+  cubicsToPathData: () => import_canvas10.cubicsToPathData,
+  defaultEasing: () => import_canvas13.defaultEasing,
+  distributeNodes: () => import_canvas11.distributeNodes,
+  dividePolygons: () => import_canvas12.dividePolygons,
+  ensureLayout: () => import_canvas13.ensureLayout,
+  estimateCanvasHeight: () => import_canvas13.estimateCanvasHeight,
+  estimateNodeSize: () => import_canvas13.estimateNodeSize,
+  findConnectorSnap: () => import_canvas11.findConnectorSnap,
+  fitCubicRun: () => import_canvas10.fitCubicRun,
+  fitCubics: () => import_canvas10.fitCubics,
+  fitFreehandPath: () => import_canvas10.fitFreehandPath,
+  fitPathData: () => import_canvas10.fitPathData,
+  fitViewportToNodes: () => import_canvas11.fitViewportToNodes,
+  fitViewportToRect: () => import_canvas11.fitViewportToRect,
+  flattenSvgPath: () => import_canvas12.flattenSvgPath,
+  flowSide: () => import_canvas13.flowSide,
+  getAbsolutePosition: () => import_canvas11.getAbsolutePosition,
+  getCenteredNodePosition: () => import_canvas13.getCenteredNodePosition,
+  getLayoutedNodes: () => import_canvas13.getLayoutedNodes,
+  getNodeRect: () => import_canvas11.getNodeRect,
+  getNodeShape: () => import_canvas12.getNodeShape,
+  getNodeSize: () => import_canvas11.getNodeSize,
+  getResizingNodeRect: () => import_canvas10.getResizingNodeRect,
+  getShapeRenderData: () => import_canvas12.getShapeRenderData,
+  getShapeSvg: () => import_canvas12.getShapeSvg,
+  handlePoint: () => import_canvas11.handlePoint,
+  inferResizeHandle: () => import_canvas10.inferResizeHandle,
+  intersectPolygons: () => import_canvas12.intersectPolygons,
+  invertNodeUpdates: () => import_canvas11.invertNodeUpdates,
+  isEventFromTextInput: () => import_canvas13.isEventFromTextInput,
+  isLocked: () => import_canvas11.isLocked,
+  isMeasureModifierHeld: () => import_canvas10.isMeasureModifierHeld,
+  isShapeDescription: () => import_canvas12.isShapeDescription,
+  isShapeNode: () => import_canvas12.isShapeNode,
+  isStraightCubic: () => import_canvas10.isStraightCubic,
+  isValidCanvasNode: () => import_canvas13.isValidCanvasNode,
+  isValidUrl: () => import_canvas13.isValidUrl,
+  layoutBounds: () => import_canvas13.layoutBounds,
+  linearPositionTrajectory: () => import_canvas13.linearPositionTrajectory,
+  linearTrajectory: () => import_canvas13.linearTrajectory,
+  lockNodes: () => import_canvas11.lockNodes,
+  matchArrangeShortcut: () => import_canvas11.matchArrangeShortcut,
+  matchSize: () => import_canvas11.matchSize,
+  measureBetween: () => import_canvas10.measureBetween,
+  measureLabel: () => import_canvas10.measureLabel,
+  measureSelection: () => import_canvas10.measureSelection,
+  measureToLine: () => import_canvas10.measureToLine,
+  multiPolygonArea: () => import_canvas12.multiPolygonArea,
+  multiPolygonBounds: () => import_canvas12.multiPolygonBounds,
+  nearestHandlePositions: () => import_canvas11.nearestHandlePositions,
+  oppositePosition: () => import_canvas11.oppositePosition,
+  overlaps: () => import_canvas13.overlaps,
+  parseCanvasClipboardData: () => import_canvas13.parseCanvasClipboardData,
+  parseCanvasScenes: () => import_canvas11.parseCanvasScenes,
+  parseSvgPath: () => import_canvas12.parseSvgPath,
+  placeBeside: () => import_canvas13.placeBeside,
+  pointInMultiPolygon: () => import_canvas12.pointInMultiPolygon,
+  pointInRings: () => import_canvas12.pointInRings,
+  polygonArea: () => import_canvas12.polygonArea,
+  polygonBoolean: () => import_canvas12.polygonBoolean,
+  polygonToSvgPath: () => import_canvas12.polygonToSvgPath,
+  positionToSide: () => import_canvas11.positionToSide,
+  readStyleSize: () => import_canvas11.readStyleSize,
+  realClock: () => import_canvas13.realClock,
+  remapPastedNodes: () => import_canvas13.remapPastedNodes,
+  reorderNodes: () => import_canvas11.reorderNodes,
+  repositionNodesTo: () => import_canvas13.repositionNodesTo,
+  resizeHandleAxes: () => import_canvas10.resizeHandleAxes,
+  revertShapeCombination: () => import_canvas12.revertShapeCombination,
+  ringSignedArea: () => import_canvas12.ringSignedArea,
+  runMultiNodeTransition: () => import_canvas13.runMultiNodeTransition,
+  serializeCanvasNodes: () => import_canvas13.serializeCanvasNodes,
+  shapeNodeToPolygon: () => import_canvas12.shapeNodeToPolygon,
+  shapeToPolygon: () => import_canvas12.shapeToPolygon,
+  sideToPosition: () => import_canvas11.sideToPosition,
+  simplifyRing: () => import_canvas12.simplifyRing,
+  snapNodeDrag: () => import_canvas11.snapNodeDrag,
+  snapNodeResize: () => import_canvas10.snapNodeResize,
+  snapResize: () => import_canvas10.snapResize,
+  snapToGrid: () => import_canvas10.snapToGrid,
+  subtractPolygons: () => import_canvas12.subtractPolygons,
+  toggleLockNodes: () => import_canvas11.toggleLockNodes,
+  unionPolygons: () => import_canvas12.unionPolygons,
+  unlockNodes: () => import_canvas11.unlockNodes,
   useCanvasArrange: () => useCanvasArrange,
   useCanvasArrangeShortcuts: () => useCanvasArrangeShortcuts,
   useCanvasClipboard: () => useCanvasClipboard,
@@ -125,11 +144,12 @@ __export(canvas_exports, {
   useCanvasExplosion: () => useCanvasExplosion,
   useCanvasGraph: () => useCanvasGraph,
   useCanvasLayout: () => useCanvasLayout,
+  useCanvasMeasure: () => useCanvasMeasure,
   useCanvasScenes: () => useCanvasScenes,
   useCanvasShortcuts: () => useCanvasShortcuts,
   useStreamingCanvas: () => useStreamingCanvas,
-  withStyleSize: () => import_canvas9.withStyleSize,
-  xorPolygons: () => import_canvas10.xorPolygons
+  withStyleSize: () => import_canvas11.withStyleSize,
+  xorPolygons: () => import_canvas12.xorPolygons
 });
 module.exports = __toCommonJS(canvas_exports);
 
@@ -1008,12 +1028,13 @@ function CanvasGuidesLayer({
   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__ */ (0, import_jsx_runtime2.jsx)(
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(
     "svg",
     {
       className: `pixerate-canvas-guides ${className}`,
@@ -1027,35 +1048,127 @@ function CanvasGuidesLayer({
         zIndex: 10
       },
       "aria-hidden": "true",
-      children: guides.map((guide, i) => /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
-        "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__ */ (0, import_jsx_runtime2.jsx)(
+            "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__ */ (0, import_jsx_runtime2.jsxs)(
+            "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__ */ (0, import_jsx_runtime2.jsx)("rect", { width, height: 16, rx: 3, fill: measureColor }),
+                /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+                  "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
+var import_react10 = require("react");
+var import_canvas8 = require("@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] = (0, import_react10.useState)(null);
+  const [modifier, setModifier] = (0, import_react10.useState)(false);
+  const optionsRef = (0, import_react10.useRef)(options);
+  optionsRef.current = options;
+  (0, import_react10.useEffect)(() => {
+    if (!enabled) return;
+    const target = targetElement ?? (typeof window !== "undefined" ? window : null);
+    if (!target) return;
+    const onKey = (event) => setModifier((0, import_canvas8.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 = (0, import_react10.useMemo)(() => {
+    if (!active) return EMPTY;
+    const ids = optionsRef.current.getSelectedIds?.() ?? nodes.filter((n) => n.selected).map((n) => n.id);
+    return (0, import_canvas8.measureSelection)(nodes, ids, hoveredId, rectOptions);
+  }, [active, nodes, hoveredId, rectOptions]);
+  const onNodeMouseEnter = (0, import_react10.useCallback)((event, node) => {
+    setHoveredId(node.id);
+    if (event && typeof event.altKey === "boolean") setModifier(event.altKey);
+  }, []);
+  const onNodeMouseLeave = (0, import_react10.useCallback)((_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
-var import_canvas9 = require("@pixerate/editor/canvas");
+var import_canvas10 = require("@pixerate/editor/canvas");
+var import_canvas11 = require("@pixerate/editor/canvas");
 
 // src/canvas/ShapeNode.tsx
-var import_canvas8 = require("@pixerate/editor/canvas");
+var import_canvas9 = require("@pixerate/editor/canvas");
 var import_jsx_runtime3 = require("react/jsx-runtime");
 function ShapeNode({ data, width, height, selected, className = "", children }) {
   const shape = data?.shape;
-  if (!(0, import_canvas8.isShapeDescription)(shape)) return null;
-  const render = (0, import_canvas8.getShapeRenderData)(shape, { width, height });
+  if (!(0, import_canvas9.isShapeDescription)(shape)) return null;
+  const render = (0, import_canvas9.getShapeRenderData)(shape, { width, height });
   return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(
     "div",
     {
@@ -1095,8 +1208,8 @@ function ShapeNode({ data, width, height, selected, className = "", children })
 }
 
 // src/canvas/index.ts
-var import_canvas10 = require("@pixerate/editor/canvas");
-var import_canvas11 = require("@pixerate/editor/canvas");
+var import_canvas12 = require("@pixerate/editor/canvas");
+var import_canvas13 = require("@pixerate/editor/canvas");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AgentPresenceLayer,
@@ -1105,6 +1218,7 @@ var import_canvas11 = require("@pixerate/editor/canvas");
   CanvasScenesStore,
   DEFAULT_ARRANGE_SHORTCUTS,
   ManualClock,
+  RESIZE_HANDLES,
   SHAPE_DATA_KEY,
   SHAPE_KINDS,
   SHAPE_NODE_TYPE,
@@ -1130,6 +1244,8 @@ var import_canvas11 = require("@pixerate/editor/canvas");
   createFanOutTrajectory,
   createGuideIndex,
   createNodeGuideIndex,
+  cubicPointAt,
+  cubicsToPathData,
   defaultEasing,
   distributeNodes,
   dividePolygons,
@@ -1137,6 +1253,10 @@ var import_canvas11 = require("@pixerate/editor/canvas");
   estimateCanvasHeight,
   estimateNodeSize,
   findConnectorSnap,
+  fitCubicRun,
+  fitCubics,
+  fitFreehandPath,
+  fitPathData,
   fitViewportToNodes,
   fitViewportToRect,
   flattenSvgPath,
@@ -1147,15 +1267,19 @@ var import_canvas11 = require("@pixerate/editor/canvas");
   getNodeRect,
   getNodeShape,
   getNodeSize,
+  getResizingNodeRect,
   getShapeRenderData,
   getShapeSvg,
   handlePoint,
+  inferResizeHandle,
   intersectPolygons,
   invertNodeUpdates,
   isEventFromTextInput,
   isLocked,
+  isMeasureModifierHeld,
   isShapeDescription,
   isShapeNode,
+  isStraightCubic,
   isValidCanvasNode,
   isValidUrl,
   layoutBounds,
@@ -1164,6 +1288,10 @@ var import_canvas11 = require("@pixerate/editor/canvas");
   lockNodes,
   matchArrangeShortcut,
   matchSize,
+  measureBetween,
+  measureLabel,
+  measureSelection,
+  measureToLine,
   multiPolygonArea,
   multiPolygonBounds,
   nearestHandlePositions,
@@ -1184,6 +1312,7 @@ var import_canvas11 = require("@pixerate/editor/canvas");
   remapPastedNodes,
   reorderNodes,
   repositionNodesTo,
+  resizeHandleAxes,
   revertShapeCombination,
   ringSignedArea,
   runMultiNodeTransition,
@@ -1193,6 +1322,9 @@ var import_canvas11 = require("@pixerate/editor/canvas");
   sideToPosition,
   simplifyRing,
   snapNodeDrag,
+  snapNodeResize,
+  snapResize,
+  snapToGrid,
   subtractPolygons,
   toggleLockNodes,
   unionPolygons,
@@ -1204,6 +1336,7 @@ var import_canvas11 = require("@pixerate/editor/canvas");
   useCanvasExplosion,
   useCanvasGraph,
   useCanvasLayout,
+  useCanvasMeasure,
   useCanvasScenes,
   useCanvasShortcuts,
   useStreamingCanvas,