@pixerate/editor-react 0.13.0 → 0.14.0

package/README.md

@@ -68,14 +68,14 @@ import { CommentsPanel, ReviewToolbar, CommentButton, BubbleMenu } from "@pixera
 
 const editor = useEditor({ extensions: [Comments.configure({ author: me }), TrackChanges.configure({ author: me })] });
 
-<ReviewToolbar editor={editor} />        {/* toggle tracking, prev/next, accept/reject (all) */}
+<ReviewToolbar editor={editor} />        {/* toggle tracking, prev/next, accept/reject (all), current change description */}
 <BubbleMenu editor={editor}><CommentButton editor={editor} /></BubbleMenu>
 <CommentsPanel editor={editor} />        {/* threads: reply, resolve, delete, click to select */}
 ```
 
-`useComments(editorOrStore)` and `useTrackChanges(editor)` expose the same state for custom UIs.
+`ReviewToolbar` steps through insertions, deletions, formatting and block changes and shows the current one's author and description (e.g. "Ada: Changed Paragraph to Heading 2"); hide it with `showDescription={false}` or restyle it with `descriptionClassName`. `useComments(editorOrStore)` and `useTrackChanges(editor)` expose the same state for custom UIs (each change has `type` and `description`).
 
-`useEditor({ fileImport: true, richClipboard: true })` imports dropped/pasted `.md`, `.html`, `.txt` and `.rtf` files at the drop position and copies lossless slices between editors. `useFileImport(editor)` returns `{ openFilePicker, importFiles, accept, isImporting, error }` for an import button. `usePromptEditor({ fileImport: true })` imports dropped files as plain text.
+`useEditor({ fileImport: true, richClipboard: true })` imports dropped/pasted `.md`, `.html`, `.txt`, `.rtf` and `.docx` files (plus any adapter you register, e.g. PDF or zipped exports) at the drop position and copies lossless slices between editors. `useFileImport(editor)` returns `{ openFilePicker, importFiles, accept, isImporting, error }` for an import button. `usePromptEditor({ fileImport: true })` imports dropped files as plain text.
 
 `useAgentToolProvider(registry, provider)` registers an agent tool provider (see `ToolRegistry` in `@pixerate/editor/agent`) while the component is mounted. Memoize the provider:
 

package/dist/canvas/index.cjs

@@ -21,72 +21,103 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var canvas_exports = {};
 __export(canvas_exports, {
   AgentPresenceLayer: () => AgentPresenceLayer,
-  CONNECTION_LINE_TYPES: () => import_canvas8.CONNECTION_LINE_TYPES,
+  CONNECTION_LINE_TYPES: () => import_canvas9.CONNECTION_LINE_TYPES,
   CanvasGuidesLayer: () => CanvasGuidesLayer,
-  CanvasScenesStore: () => import_canvas8.CanvasScenesStore,
-  DEFAULT_ARRANGE_SHORTCUTS: () => import_canvas8.DEFAULT_ARRANGE_SHORTCUTS,
-  ManualClock: () => import_canvas9.ManualClock,
-  alignNodes: () => import_canvas8.alignNodes,
-  applyNodeUpdates: () => import_canvas8.applyNodeUpdates,
-  blendLayout: () => import_canvas9.blendLayout,
-  boundsOf: () => import_canvas9.boundsOf,
-  calculateDagreReflowDisplacement: () => import_canvas9.calculateDagreReflowDisplacement,
-  calculateDirectionalDisplacement: () => import_canvas9.calculateDirectionalDisplacement,
-  canvasHeight: () => import_canvas9.canvasHeight,
-  centerNodes: () => import_canvas9.centerNodes,
-  centre: () => import_canvas9.centre,
-  computeNodesBoundingBox: () => import_canvas9.computeNodesBoundingBox,
-  computeSnapGuides: () => import_canvas8.computeSnapGuides,
-  connectedOnly: () => import_canvas9.connectedOnly,
-  createBezierTrajectory: () => import_canvas9.createBezierTrajectory,
-  createCanvasScenesStore: () => import_canvas8.createCanvasScenesStore,
-  createFanOutTrajectory: () => import_canvas9.createFanOutTrajectory,
-  createGuideIndex: () => import_canvas8.createGuideIndex,
-  createNodeGuideIndex: () => import_canvas8.createNodeGuideIndex,
-  defaultEasing: () => import_canvas9.defaultEasing,
-  distributeNodes: () => import_canvas8.distributeNodes,
-  ensureLayout: () => import_canvas9.ensureLayout,
-  estimateCanvasHeight: () => import_canvas9.estimateCanvasHeight,
-  estimateNodeSize: () => import_canvas9.estimateNodeSize,
-  findConnectorSnap: () => import_canvas8.findConnectorSnap,
-  fitViewportToNodes: () => import_canvas8.fitViewportToNodes,
-  fitViewportToRect: () => import_canvas8.fitViewportToRect,
-  flowSide: () => import_canvas9.flowSide,
-  getAbsolutePosition: () => import_canvas8.getAbsolutePosition,
-  getCenteredNodePosition: () => import_canvas9.getCenteredNodePosition,
-  getLayoutedNodes: () => import_canvas9.getLayoutedNodes,
-  getNodeRect: () => import_canvas8.getNodeRect,
-  getNodeSize: () => import_canvas8.getNodeSize,
-  handlePoint: () => import_canvas8.handlePoint,
-  invertNodeUpdates: () => import_canvas8.invertNodeUpdates,
-  isEventFromTextInput: () => import_canvas9.isEventFromTextInput,
-  isLocked: () => import_canvas8.isLocked,
-  isValidCanvasNode: () => import_canvas9.isValidCanvasNode,
-  isValidUrl: () => import_canvas9.isValidUrl,
-  layoutBounds: () => import_canvas9.layoutBounds,
-  linearPositionTrajectory: () => import_canvas9.linearPositionTrajectory,
-  linearTrajectory: () => import_canvas9.linearTrajectory,
-  lockNodes: () => import_canvas8.lockNodes,
-  matchArrangeShortcut: () => import_canvas8.matchArrangeShortcut,
-  matchSize: () => import_canvas8.matchSize,
-  nearestHandlePositions: () => import_canvas8.nearestHandlePositions,
-  oppositePosition: () => import_canvas8.oppositePosition,
-  overlaps: () => import_canvas9.overlaps,
-  parseCanvasClipboardData: () => import_canvas9.parseCanvasClipboardData,
-  parseCanvasScenes: () => import_canvas8.parseCanvasScenes,
-  placeBeside: () => import_canvas9.placeBeside,
-  positionToSide: () => import_canvas8.positionToSide,
-  readStyleSize: () => import_canvas8.readStyleSize,
-  realClock: () => import_canvas9.realClock,
-  remapPastedNodes: () => import_canvas9.remapPastedNodes,
-  reorderNodes: () => import_canvas8.reorderNodes,
-  repositionNodesTo: () => import_canvas9.repositionNodesTo,
-  runMultiNodeTransition: () => import_canvas9.runMultiNodeTransition,
-  serializeCanvasNodes: () => import_canvas9.serializeCanvasNodes,
-  sideToPosition: () => import_canvas8.sideToPosition,
-  snapNodeDrag: () => import_canvas8.snapNodeDrag,
-  toggleLockNodes: () => import_canvas8.toggleLockNodes,
-  unlockNodes: () => import_canvas8.unlockNodes,
+  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,
+  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,
   useCanvasArrange: () => useCanvasArrange,
   useCanvasArrangeShortcuts: () => useCanvasArrangeShortcuts,
   useCanvasClipboard: () => useCanvasClipboard,
@@ -97,7 +128,8 @@ __export(canvas_exports, {
   useCanvasScenes: () => useCanvasScenes,
   useCanvasShortcuts: () => useCanvasShortcuts,
   useStreamingCanvas: () => useStreamingCanvas,
-  withStyleSize: () => import_canvas8.withStyleSize
+  withStyleSize: () => import_canvas9.withStyleSize,
+  xorPolygons: () => import_canvas10.xorPolygons
 });
 module.exports = __toCommonJS(canvas_exports);
 
@@ -1015,8 +1047,56 @@ function CanvasGuidesLayer({
 }
 
 // src/canvas/index.ts
-var import_canvas8 = require("@pixerate/editor/canvas");
 var import_canvas9 = require("@pixerate/editor/canvas");
+
+// src/canvas/ShapeNode.tsx
+var import_canvas8 = 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 });
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(
+    "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__ */ (0, import_jsx_runtime3.jsx)(
+          "svg",
+          {
+            viewBox: render.viewBox,
+            preserveAspectRatio: "none",
+            width: "100%",
+            height: "100%",
+            style: { display: "block", overflow: "visible" },
+            "aria-hidden": "true",
+            children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+              "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
+var import_canvas10 = require("@pixerate/editor/canvas");
+var import_canvas11 = require("@pixerate/editor/canvas");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AgentPresenceLayer,
@@ -1025,15 +1105,23 @@ var import_canvas9 = require("@pixerate/editor/canvas");
   CanvasScenesStore,
   DEFAULT_ARRANGE_SHORTCUTS,
   ManualClock,
+  SHAPE_DATA_KEY,
+  SHAPE_KINDS,
+  SHAPE_NODE_TYPE,
+  SHAPE_OPERATIONS,
+  ShapeNode,
   alignNodes,
   applyNodeUpdates,
+  applyShapeCombination,
   blendLayout,
   boundsOf,
   calculateDagreReflowDisplacement,
   calculateDirectionalDisplacement,
+  canCombineShapeNodes,
   canvasHeight,
   centerNodes,
   centre,
+  combineShapeNodes,
   computeNodesBoundingBox,
   computeSnapGuides,
   connectedOnly,
@@ -1044,22 +1132,30 @@ var import_canvas9 = require("@pixerate/editor/canvas");
   createNodeGuideIndex,
   defaultEasing,
   distributeNodes,
+  dividePolygons,
   ensureLayout,
   estimateCanvasHeight,
   estimateNodeSize,
   findConnectorSnap,
   fitViewportToNodes,
   fitViewportToRect,
+  flattenSvgPath,
   flowSide,
   getAbsolutePosition,
   getCenteredNodePosition,
   getLayoutedNodes,
   getNodeRect,
+  getNodeShape,
   getNodeSize,
+  getShapeRenderData,
+  getShapeSvg,
   handlePoint,
+  intersectPolygons,
   invertNodeUpdates,
   isEventFromTextInput,
   isLocked,
+  isShapeDescription,
+  isShapeNode,
   isValidCanvasNode,
   isValidUrl,
   layoutBounds,
@@ -1068,23 +1164,38 @@ var import_canvas9 = require("@pixerate/editor/canvas");
   lockNodes,
   matchArrangeShortcut,
   matchSize,
+  multiPolygonArea,
+  multiPolygonBounds,
   nearestHandlePositions,
   oppositePosition,
   overlaps,
   parseCanvasClipboardData,
   parseCanvasScenes,
+  parseSvgPath,
   placeBeside,
+  pointInMultiPolygon,
+  pointInRings,
+  polygonArea,
+  polygonBoolean,
+  polygonToSvgPath,
   positionToSide,
   readStyleSize,
   realClock,
   remapPastedNodes,
   reorderNodes,
   repositionNodesTo,
+  revertShapeCombination,
+  ringSignedArea,
   runMultiNodeTransition,
   serializeCanvasNodes,
+  shapeNodeToPolygon,
+  shapeToPolygon,
   sideToPosition,
+  simplifyRing,
   snapNodeDrag,
+  subtractPolygons,
   toggleLockNodes,
+  unionPolygons,
   unlockNodes,
   useCanvasArrange,
   useCanvasArrangeShortcuts,
@@ -1096,6 +1207,7 @@ var import_canvas9 = require("@pixerate/editor/canvas");
   useCanvasScenes,
   useCanvasShortcuts,
   useStreamingCanvas,
-  withStyleSize
+  withStyleSize,
+  xorPolygons
 });
 //# sourceMappingURL=index.cjs.map