@tsdraw/react 0.9.1 → 0.9.3

package/dist/index.cjs

@@ -98,6 +98,167 @@ function SelectionOverlay({
     )
   ] });
 }
+function parseAnchor(anchor) {
+  const parts = anchor.split("-");
+  let vertical = "center";
+  let horizontal = "center";
+  for (const part of parts) {
+    if (part === "top" || part === "bottom") vertical = part;
+    else if (part === "left" || part === "right") horizontal = part;
+  }
+  return { vertical, horizontal };
+}
+function resolvePlacementStyle(placement, fallbackAnchor, fallbackEdgeOffset) {
+  const anchor = placement?.anchor ?? fallbackAnchor;
+  const edgeOffset = placement?.edgeOffset ?? fallbackEdgeOffset;
+  const { vertical, horizontal } = parseAnchor(anchor);
+  const result = {};
+  const transforms = [];
+  if (horizontal === "left") {
+    result.left = edgeOffset;
+  } else if (horizontal === "right") {
+    result.right = edgeOffset;
+  } else {
+    result.left = "50%";
+    transforms.push("translateX(-50%)");
+  }
+  if (vertical === "top") {
+    result.top = edgeOffset;
+  } else if (vertical === "bottom") {
+    result.bottom = edgeOffset;
+  } else {
+    result.top = "50%";
+    transforms.push("translateY(-50%)");
+  }
+  if (transforms.length > 0) result.transform = transforms.join(" ");
+  return placement?.style ? { ...result, ...placement.style } : result;
+}
+function resolveOrientation(anchor) {
+  const { vertical, horizontal } = parseAnchor(anchor);
+  if ((horizontal === "left" || horizontal === "right") && vertical === "center") return "vertical";
+  return "horizontal";
+}
+var SNAP_TARGETS = [
+  { anchor: "top-center", nx: 0.5, ny: 0 },
+  { anchor: "bottom-center", nx: 0.5, ny: 1 },
+  { anchor: "left-center", nx: 0, ny: 0.5 },
+  { anchor: "right-center", nx: 1, ny: 0.5 },
+  { anchor: "top-left", nx: 0, ny: 0 },
+  { anchor: "top-right", nx: 1, ny: 0 },
+  { anchor: "bottom-left", nx: 0, ny: 1 },
+  { anchor: "bottom-right", nx: 1, ny: 1 }
+];
+function calculateSnap(payload, containerRect, disabledPositions) {
+  const nx = Math.max(0, Math.min(1, (payload.centerX - containerRect.left) / containerRect.width));
+  const ny = Math.max(0, Math.min(1, (payload.centerY - containerRect.top) / containerRect.height));
+  let closestAnchor = "bottom-center";
+  let closestDistSq = Infinity;
+  for (const target of SNAP_TARGETS) {
+    if (disabledPositions && disabledPositions.has(target.anchor)) continue;
+    const dx = nx - target.nx;
+    const dy = ny - target.ny;
+    const distSq = dx * dx + dy * dy;
+    if (distSq < closestDistSq) {
+      closestDistSq = distSq;
+      closestAnchor = target.anchor;
+    }
+  }
+  return { anchor: closestAnchor };
+}
+function BaseComponent({ children, className, style, draggable = false, onDragEnd, "aria-label": ariaLabel }) {
+  const componentRef = react.useRef(null);
+  const dragStateRef = react.useRef(null);
+  const suppressClickRef = react.useRef(false);
+  const pendingSnapRef = react.useRef(false);
+  const [isDragging, setIsDragging] = react.useState(false);
+  react.useLayoutEffect(() => {
+    if (!pendingSnapRef.current) return;
+    const componentNode = componentRef.current;
+    if (componentNode) componentNode.style.translate = "";
+    pendingSnapRef.current = false;
+    setIsDragging(false);
+  });
+  const finishDrag = (event, shouldSnap) => {
+    const componentNode = componentRef.current;
+    const dragState = dragStateRef.current;
+    if (!componentNode || !dragState || dragState.pointerId !== event.pointerId) return;
+    if (componentNode.hasPointerCapture(event.pointerId)) {
+      componentNode.releasePointerCapture(event.pointerId);
+    }
+    if (dragState.isDragging && shouldSnap && onDragEnd) {
+      const rect = componentNode.getBoundingClientRect();
+      onDragEnd({
+        left: rect.left,
+        top: rect.top,
+        width: rect.width,
+        height: rect.height,
+        centerX: rect.left + rect.width / 2,
+        centerY: rect.top + rect.height / 2
+      });
+      pendingSnapRef.current = true;
+    } else {
+      componentNode.style.translate = "";
+      setIsDragging(false);
+    }
+    suppressClickRef.current = dragState.didDrag;
+    dragStateRef.current = null;
+  };
+  const handlePointerDown = (event) => {
+    if (!draggable || event.button !== 0) return;
+    dragStateRef.current = {
+      pointerId: event.pointerId,
+      startX: event.clientX,
+      startY: event.clientY,
+      didDrag: false,
+      isDragging: false
+    };
+  };
+  const handlePointerMove = (event) => {
+    const componentNode = componentRef.current;
+    const dragState = dragStateRef.current;
+    if (!draggable || !componentNode || !dragState || dragState.pointerId !== event.pointerId) return;
+    const deltaX = event.clientX - dragState.startX;
+    const deltaY = event.clientY - dragState.startY;
+    if (!dragState.isDragging && deltaX * deltaX + deltaY * deltaY >= 25) {
+      dragState.isDragging = true;
+      dragState.didDrag = true;
+      componentNode.setPointerCapture(event.pointerId);
+      setIsDragging(true);
+    }
+    if (dragState.isDragging) {
+      componentNode.style.translate = `${deltaX}px ${deltaY}px`;
+    }
+  };
+  const handlePointerUp = (event) => {
+    finishDrag(event, true);
+  };
+  const handlePointerCancel = (event) => {
+    finishDrag(event, false);
+  };
+  const handleClickCapture = (event) => {
+    if (!draggable || !suppressClickRef.current) return;
+    suppressClickRef.current = false;
+    event.preventDefault();
+    event.stopPropagation();
+  };
+  const draggableClass = draggable ? " tsdraw-component--draggable" : "";
+  const draggingClass = isDragging ? " tsdraw-component--dragging" : "";
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "div",
+    {
+      ref: componentRef,
+      className: `tsdraw-component${draggableClass}${draggingClass}${className ? ` ${className}` : ""}`,
+      style,
+      "aria-label": ariaLabel,
+      onPointerDown: handlePointerDown,
+      onPointerMove: handlePointerMove,
+      onPointerUp: handlePointerUp,
+      onPointerCancel: handlePointerCancel,
+      onClickCapture: handleClickCapture,
+      children
+    }
+  );
+}
 var STYLE_COLORS = Object.entries(core.DEFAULT_COLORS).filter(([key]) => key !== "white").map(([value]) => ({ value }));
 var STYLE_DASHES = ["draw", "solid", "dashed", "dotted"];
 var STYLE_FILLS = ["none", "blank", "semi", "solid"];
@@ -129,7 +290,7 @@ function StylePanel({
     onSizeSelect
   };
   const customPartMap = new Map((customParts ?? []).map((customPart) => [customPart.id, customPart]));
-  return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "tsdraw-style-panel", style, "aria-label": "Draw style panel", children: parts.map((part) => {
+  return /* @__PURE__ */ jsxRuntime.jsx(BaseComponent, { className: "tsdraw-style-panel", style, "aria-label": "Draw style panel", children: parts.map((part) => {
     if (part === "colors") {
       return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "tsdraw-style-colors", children: STYLE_COLORS.map((item) => /* @__PURE__ */ jsxRuntime.jsx(
         "button",
@@ -249,8 +410,9 @@ function getActionIcon(actionId) {
   if (actionId === "undo") return /* @__PURE__ */ jsxRuntime.jsx(iconsReact.IconArrowBackUp, { size: 16, stroke: 1.8 });
   return /* @__PURE__ */ jsxRuntime.jsx(iconsReact.IconArrowForwardUp, { size: 16, stroke: 1.8 });
 }
-function Toolbar({ parts, currentTool, onToolChange, disabled, style }) {
-  return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "tsdraw-toolbar", style, children: parts.map((part, partIndex) => /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "tsdraw-toolbar-part", children: [
+function Toolbar({ parts, currentTool, onToolChange, disabled, style, orientation = "horizontal", draggable = false, onDragEnd }) {
+  const orientationClass = orientation === "vertical" ? " tsdraw-toolbar--vertical" : "";
+  return /* @__PURE__ */ jsxRuntime.jsx(BaseComponent, { className: `tsdraw-toolbar${orientationClass}`, style, draggable, onDragEnd, children: parts.map((part, partIndex) => /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "tsdraw-toolbar-part", children: [
     part.items.map((item) => {
       if (item.type === "action") {
         return /* @__PURE__ */ jsxRuntime.jsx(
@@ -1613,6 +1775,10 @@ function useTsdrawCanvasController(options = {}) {
       if (ignorePersistenceChanges) return;
       schedulePersist();
     });
+    const cleanupRenderRequest = editor.onRequestRender(() => {
+      render();
+      refreshSelectionBounds(editor);
+    });
     resize();
     const ro = new ResizeObserver(resize);
     ro.observe(container);
@@ -1681,6 +1847,7 @@ function useTsdrawCanvasController(options = {}) {
       schedulePersistRef.current = null;
       cleanupEditorListener();
       cleanupHistoryListener();
+      cleanupRenderRequest();
       disposeMount?.();
       ro.disconnect();
       canvas.removeEventListener("pointerdown", handlePointerDown);
@@ -1850,47 +2017,9 @@ var DEFAULT_TOOL_LABELS = {
   eraser: "Eraser",
   hand: "Hand"
 };
-function parseAnchor(anchor) {
-  const parts = anchor.split("-");
-  let vertical = "center";
-  let horizontal = "center";
-  for (const part of parts) {
-    if (part === "top" || part === "bottom") vertical = part;
-    else if (part === "left" || part === "right") horizontal = part;
-  }
-  return { vertical, horizontal };
-}
 function isToolbarAction(item) {
   return item === "undo" || item === "redo";
 }
-function resolvePlacementStyle(placement, fallbackAnchor, fallbackOffsetX, fallbackOffsetY) {
-  const anchor = placement?.anchor ?? fallbackAnchor;
-  const offsetX = placement?.offsetX ?? fallbackOffsetX;
-  const offsetY = placement?.offsetY ?? fallbackOffsetY;
-  const { vertical, horizontal } = parseAnchor(anchor);
-  const result = {};
-  const transforms = [];
-  if (horizontal === "left") {
-    result.left = offsetX;
-  } else if (horizontal === "right") {
-    result.right = offsetX;
-  } else {
-    result.left = "50%";
-    transforms.push("translateX(-50%)");
-    if (offsetX) transforms.push(`translateX(${offsetX}px)`);
-  }
-  if (vertical === "top") {
-    result.top = offsetY;
-  } else if (vertical === "bottom") {
-    result.bottom = offsetY;
-  } else {
-    result.top = "50%";
-    transforms.push("translateY(-50%)");
-    if (offsetY) transforms.push(`translateY(${offsetY}px)`);
-  }
-  if (transforms.length > 0) result.transform = transforms.join(" ");
-  return placement?.style ? { ...result, ...placement.style } : result;
-}
 function Tsdraw(props) {
   const [systemTheme, setSystemTheme] = react.useState(() => {
     if (typeof window === "undefined") return "light";
@@ -1898,6 +2027,20 @@ function Tsdraw(props) {
   });
   const customTools = props.customTools ?? EMPTY_CUSTOM_TOOLS;
   const toolbarPartIds = props.uiOptions?.toolbar?.parts ?? DEFAULT_TOOLBAR_PARTS;
+  const toolbarPlacement = props.uiOptions?.toolbar?.placement;
+  const toolbarEdgeOffset = toolbarPlacement?.edgeOffset ?? 14;
+  const isToolbarDraggable = props.uiOptions?.toolbar?.draggable === true;
+  const shouldSaveDraggedToolbarPosition = props.uiOptions?.toolbar?.saveDraggedPosition === true;
+  const disabledDragPositionsArray = props.uiOptions?.toolbar?.disabledDragPositions;
+  const disabledDragPositionsSet = react.useMemo(
+    () => disabledDragPositionsArray && disabledDragPositionsArray.length > 0 ? new Set(disabledDragPositionsArray) : void 0,
+    [disabledDragPositionsArray]
+  );
+  const toolbarDraggedSessionKey = react.useMemo(
+    () => `tsdraw-toolbar-pos-${props.persistenceKey ?? "default"}`,
+    [props.persistenceKey]
+  );
+  const [draggedToolbarPosition, setDraggedToolbarPosition] = react.useState(null);
   const customToolMap = react.useMemo(
     () => new Map(customTools.map((customTool) => [customTool.id, customTool])),
     [customTools]
@@ -1982,9 +2125,35 @@ function Tsdraw(props) {
     onCameraChange: props.onCameraChange,
     onToolChange: props.onToolChange
   });
-  const toolbarPlacementStyle = resolvePlacementStyle(props.uiOptions?.toolbar?.placement, "bottom-center", 0, 14);
-  const stylePanelPlacementStyle = resolvePlacementStyle(props.uiOptions?.stylePanel?.placement, "top-right", 8, 8);
+  const toolbarPlacementAnchor = draggedToolbarPosition?.anchor ?? toolbarPlacement?.anchor ?? "bottom-center";
+  const effectiveToolbarPlacement = draggedToolbarPosition ? { anchor: draggedToolbarPosition.anchor, edgeOffset: toolbarEdgeOffset, style: toolbarPlacement?.style } : toolbarPlacement;
+  const toolbarPlacementStyle = resolvePlacementStyle(effectiveToolbarPlacement, "bottom-center", 14);
+  const toolbarOrientation = resolveOrientation(toolbarPlacementAnchor);
+  const stylePanelPlacementStyle = resolvePlacementStyle(props.uiOptions?.stylePanel?.placement, "top-right", 8);
   const isToolbarHidden = props.uiOptions?.toolbar?.hide === true;
+  react.useEffect(() => {
+    if (!isToolbarDraggable || !shouldSaveDraggedToolbarPosition || typeof window === "undefined") return;
+    try {
+      const rawPosition = window.sessionStorage.getItem(toolbarDraggedSessionKey);
+      if (!rawPosition) return;
+      const parsedPosition = JSON.parse(rawPosition);
+      if (typeof parsedPosition.anchor !== "string") return;
+      setDraggedToolbarPosition({ anchor: parsedPosition.anchor });
+    } catch {
+    }
+  }, [isToolbarDraggable, shouldSaveDraggedToolbarPosition, toolbarDraggedSessionKey]);
+  react.useEffect(() => {
+    if (isToolbarDraggable) return;
+    setDraggedToolbarPosition(null);
+  }, [isToolbarDraggable]);
+  const handleToolbarDragEnd = react.useCallback((payload) => {
+    const containerNode = containerRef.current;
+    if (!containerNode) return;
+    const nextPosition = calculateSnap(payload, containerNode.getBoundingClientRect(), disabledDragPositionsSet);
+    setDraggedToolbarPosition(nextPosition);
+    if (!shouldSaveDraggedToolbarPosition || typeof window === "undefined") return;
+    window.sessionStorage.setItem(toolbarDraggedSessionKey, JSON.stringify(nextPosition));
+  }, [containerRef, disabledDragPositionsSet, shouldSaveDraggedToolbarPosition, toolbarDraggedSessionKey]);
   const isStylePanelHidden = props.uiOptions?.stylePanel?.hide === true || props.readOnly === true;
   const canvasCursor = props.uiOptions?.cursor?.getCursor?.(cursorContext) ?? defaultCanvasCursor;
   const defaultToolOverlay = /* @__PURE__ */ jsxRuntime.jsx(
@@ -2137,7 +2306,7 @@ function Tsdraw(props) {
               position: "absolute",
               zIndex: 130,
               pointerEvents: "all",
-              ...resolvePlacementStyle(customElement.placement, "top-left", 8, 8)
+              ...resolvePlacementStyle(customElement.placement, "top-left", 8)
             },
             children: customElement.render({ currentTool, setTool, applyDrawStyle })
           },
@@ -2148,9 +2317,12 @@ function Tsdraw(props) {
           {
             parts: toolbarParts,
             style: toolbarPlacementStyle,
+            orientation: toolbarOrientation,
             currentTool: isPersistenceReady ? currentTool : null,
             onToolChange: setTool,
-            disabled: !isPersistenceReady
+            disabled: !isPersistenceReady,
+            draggable: isToolbarDraggable,
+            onDragEnd: handleToolbarDragEnd
           }
         ) : null
       ]