@bwp-web/canvas 1.0.0 → 1.1.1

package/dist/index.cjs

@@ -34,6 +34,7 @@ __export(index_exports, {
   FixedSizeContent: () => FixedSizeContent,
   ObjectOverlay: () => ObjectOverlay,
   OverlayBadge: () => OverlayBadge,
+  OverlayContainer: () => OverlayContainer,
   OverlayContent: () => OverlayContent,
   Point: () => import_fabric19.Point,
   Polygon: () => import_fabric19.Polygon,
@@ -3528,10 +3529,61 @@ function useViewCanvasState() {
 }
 
 // src/overlay/ObjectOverlay.tsx
+var import_react12 = require("react");
+var import_material2 = require("@mui/material");
+var import_fabric18 = require("fabric");
+
+// src/overlay/OverlayContainer.tsx
 var import_react11 = require("react");
 var import_material = require("@mui/material");
-var import_fabric18 = require("fabric");
 var import_jsx_runtime4 = require("react/jsx-runtime");
+var OverlayContainerContext = (0, import_react11.createContext)(false);
+function useIsInsideOverlayContainer() {
+  return (0, import_react11.useContext)(OverlayContainerContext);
+}
+function OverlayContainer({
+  canvasRef: canvasRefProp,
+  children
+}) {
+  const contextCanvasRef = useCanvasRef();
+  const canvasRef = canvasRefProp ?? contextCanvasRef;
+  const containerRef = (0, import_react11.useRef)(null);
+  (0, import_react11.useEffect)(() => {
+    const canvas = canvasRef?.current;
+    const el = containerRef.current;
+    if (!canvas || !el) return;
+    function updateContainer() {
+      if (!canvas || !el) return;
+      const vt = canvas.viewportTransform;
+      if (!vt) return;
+      el.style.transform = `translate(${vt[4]}px, ${vt[5]}px)`;
+    }
+    updateContainer();
+    canvas.on("after:render", updateContainer);
+    return () => {
+      canvas.off("after:render", updateContainer);
+    };
+  }, [canvasRef]);
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(OverlayContainerContext.Provider, { value: true, children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+    import_material.Stack,
+    {
+      ref: containerRef,
+      sx: {
+        position: "absolute",
+        left: 0,
+        top: 0,
+        width: "100%",
+        height: "100%",
+        pointerEvents: "none",
+        willChange: "transform"
+      },
+      children
+    }
+  ) });
+}
+
+// src/overlay/ObjectOverlay.tsx
+var import_jsx_runtime5 = require("react/jsx-runtime");
 function ObjectOverlay({
   canvasRef: canvasRefProp,
   object,
@@ -3541,8 +3593,10 @@ function ObjectOverlay({
 }) {
   const contextCanvasRef = useCanvasRef();
   const canvasRef = canvasRefProp ?? contextCanvasRef;
-  const stackRef = (0, import_react11.useRef)(null);
-  (0, import_react11.useEffect)(() => {
+  const insideContainer = useIsInsideOverlayContainer();
+  const stackRef = (0, import_react12.useRef)(null);
+  const prev = (0, import_react12.useRef)({ transform: "", w: "", h: "", z: "" });
+  (0, import_react12.useEffect)(() => {
     const canvas = canvasRef?.current;
     if (!canvas || !object) return;
     function update() {
@@ -3554,15 +3608,37 @@ function ObjectOverlay({
       const center = object.getCenterPoint();
       const actualWidth = (object.width ?? 0) * (object.scaleX ?? 1);
       const actualHeight = (object.height ?? 0) * (object.scaleY ?? 1);
-      const screenCoords = import_fabric18.util.transformPoint(center, vt);
       const screenWidth = actualWidth * zoom;
       const screenHeight = actualHeight * zoom;
       const angle = object.angle ?? 0;
-      el.style.left = `${screenCoords.x - screenWidth / 2}px`;
-      el.style.top = `${screenCoords.y - screenHeight / 2}px`;
-      el.style.width = `${screenWidth}px`;
-      el.style.height = `${screenHeight}px`;
-      el.style.transform = angle !== 0 ? `rotate(${angle}deg)` : "";
+      let tx;
+      let ty;
+      if (insideContainer) {
+        tx = center.x * zoom - screenWidth / 2;
+        ty = center.y * zoom - screenHeight / 2;
+      } else {
+        const screenCoords = import_fabric18.util.transformPoint(center, vt);
+        tx = screenCoords.x - screenWidth / 2;
+        ty = screenCoords.y - screenHeight / 2;
+      }
+      const transform = angle !== 0 ? `translate(${tx}px, ${ty}px) rotate(${angle}deg)` : `translate(${tx}px, ${ty}px)`;
+      if (transform !== prev.current.transform) {
+        el.style.transform = transform;
+        prev.current.transform = transform;
+      }
+      const z = String(zoom);
+      if (prev.current.z !== z) {
+        el.style.setProperty("--overlay-zoom", z);
+        prev.current.z = z;
+      }
+      const w = `${screenWidth}px`;
+      const h = `${screenHeight}px`;
+      if (prev.current.w !== w || prev.current.h !== h) {
+        el.style.width = w;
+        el.style.height = h;
+        prev.current.w = w;
+        prev.current.h = h;
+      }
     }
     update();
     canvas.on("after:render", update);
@@ -3574,19 +3650,23 @@ function ObjectOverlay({
       object.off("moving", update);
       object.off("scaling", update);
       object.off("rotating", update);
+      prev.current = { transform: "", w: "", h: "", z: "" };
     };
-  }, [canvasRef, object]);
+  }, [canvasRef, object, insideContainer]);
   if (!object) return null;
-  return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
-    import_material.Stack,
+  return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+    import_material2.Stack,
     {
       ref: stackRef,
       sx: {
         position: "absolute",
+        left: 0,
+        top: 0,
         pointerEvents: "none",
         alignItems: "center",
         justifyContent: "center",
         zIndex: 1,
+        willChange: "transform",
         ...sx
       },
       ...rest,
@@ -3596,28 +3676,28 @@ function ObjectOverlay({
 }
 
 // src/overlay/OverlayContent.tsx
-var import_material2 = require("@mui/material");
-var import_react12 = require("react");
-var import_jsx_runtime5 = require("react/jsx-runtime");
+var import_material3 = require("@mui/material");
+var import_react13 = require("react");
+var import_jsx_runtime6 = require("react/jsx-runtime");
 function OverlayContent({
   children,
-  padding = 4,
+  padding = 6,
   maxScale = 2,
   sx,
   ...rest
 }) {
-  const outerRef = (0, import_react12.useRef)(null);
-  const innerRef = (0, import_react12.useRef)(null);
-  (0, import_react12.useEffect)(() => {
+  const outerRef = (0, import_react13.useRef)(null);
+  const innerRef = (0, import_react13.useRef)(null);
+  (0, import_react13.useEffect)(() => {
     const outer = outerRef.current;
     const inner = innerRef.current;
     if (!outer || !inner) return;
+    let natW = 0;
+    let natH = 0;
     function fit() {
       if (!outer || !inner) return;
       const containerW = outer.clientWidth;
       const containerH = outer.clientHeight;
-      const natW = inner.scrollWidth;
-      const natH = inner.scrollHeight;
       if (natW === 0 || natH === 0 || containerW <= 0 || containerH <= 0) {
         inner.style.transform = "";
         inner.style.removeProperty("--overlay-scale");
@@ -3631,14 +3711,25 @@ function OverlayContent({
       inner.style.transform = `scale(${scale})`;
       inner.style.setProperty("--overlay-scale", String(scale));
     }
-    const observer = new ResizeObserver(fit);
+    const observer = new ResizeObserver((entries) => {
+      for (const entry of entries) {
+        if (entry.target === inner) {
+          natW = inner.scrollWidth;
+          natH = inner.scrollHeight;
+          break;
+        }
+      }
+      fit();
+    });
     observer.observe(outer);
     observer.observe(inner);
+    natW = inner.scrollWidth;
+    natH = inner.scrollHeight;
     fit();
     return () => observer.disconnect();
   }, [padding, maxScale]);
-  return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
-    import_material2.Stack,
+  return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(
+    import_material3.Stack,
     {
       ref: outerRef,
       sx: {
@@ -3650,8 +3741,8 @@ function OverlayContent({
         ...sx
       },
       ...rest,
-      children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
-        import_material2.Stack,
+      children: /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(
+        import_material3.Stack,
         {
           ref: innerRef,
           sx: {
@@ -3668,9 +3759,9 @@ function OverlayContent({
 }
 
 // src/overlay/FixedSizeContent.tsx
-var import_material3 = require("@mui/material");
-var import_react13 = require("react");
-var import_jsx_runtime6 = require("react/jsx-runtime");
+var import_material4 = require("@mui/material");
+var import_react14 = require("react");
+var import_jsx_runtime7 = require("react/jsx-runtime");
 function FixedSizeContent({
   children,
   hideOnOverflow = true,
@@ -3678,9 +3769,9 @@ function FixedSizeContent({
   sx,
   ...rest
 }) {
-  const ref = (0, import_react13.useRef)(null);
-  const totalContentHeightRef = (0, import_react13.useRef)(0);
-  (0, import_react13.useEffect)(() => {
+  const ref = (0, import_react14.useRef)(null);
+  const totalContentHeightRef = (0, import_react14.useRef)(0);
+  (0, import_react14.useEffect)(() => {
     const el = ref.current;
     if (!el) return;
     let clipAncestor = el.parentElement;
@@ -3691,34 +3782,45 @@ function FixedSizeContent({
     if (!clipAncestor) return;
     const ancestor = clipAncestor;
     totalContentHeightRef.current = el.parentElement?.scrollHeight ?? 0;
-    function check() {
-      requestAnimationFrame(() => {
-        if (!el) return;
-        const containerRect = ancestor.getBoundingClientRect();
-        el.style.maxWidth = `${Math.max(0, containerRect.width - truncationPadding * 2)}px`;
-        if (!hideOnOverflow) return;
-        const fits = containerRect.height >= totalContentHeightRef.current;
-        if (fits && el.style.display === "none") {
-          el.style.display = "";
-          totalContentHeightRef.current = el.parentElement?.scrollHeight ?? 0;
-          if (containerRect.height < totalContentHeightRef.current) {
-            el.style.display = "none";
-          }
-        } else if (!fits && el.style.display !== "none") {
+    let rafId = 0;
+    function doCheck() {
+      if (!el) return;
+      const containerW = ancestor.clientWidth;
+      const containerH = ancestor.clientHeight;
+      el.style.maxWidth = `${Math.max(0, containerW - truncationPadding * 2)}px`;
+      if (!hideOnOverflow) return;
+      const fits = containerH >= totalContentHeightRef.current;
+      if (fits && el.style.display === "none") {
+        el.style.display = "";
+        totalContentHeightRef.current = el.parentElement?.scrollHeight ?? 0;
+        if (containerH < totalContentHeightRef.current) {
           el.style.display = "none";
         }
-        if (el.style.display !== "none") {
-          totalContentHeightRef.current = el.parentElement?.scrollHeight ?? 0;
-        }
-      });
+      } else if (!fits && el.style.display !== "none") {
+        el.style.display = "none";
+      }
+      if (el.style.display !== "none") {
+        totalContentHeightRef.current = el.parentElement?.scrollHeight ?? 0;
+      }
     }
-    const observer = new ResizeObserver(check);
+    function scheduleCheck() {
+      if (!rafId) {
+        rafId = requestAnimationFrame(() => {
+          rafId = 0;
+          doCheck();
+        });
+      }
+    }
+    const observer = new ResizeObserver(scheduleCheck);
     observer.observe(ancestor);
-    check();
-    return () => observer.disconnect();
+    scheduleCheck();
+    return () => {
+      if (rafId) cancelAnimationFrame(rafId);
+      observer.disconnect();
+    };
   }, [hideOnOverflow, truncationPadding]);
-  return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(
-    import_material3.Stack,
+  return /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(
+    import_material4.Stack,
     {
       ref,
       sx: {
@@ -3742,9 +3844,9 @@ function FixedSizeContent({
 }
 
 // src/overlay/OverlayBadge.tsx
-var import_material4 = require("@mui/material");
-var import_react14 = require("react");
-var import_jsx_runtime7 = require("react/jsx-runtime");
+var import_material5 = require("@mui/material");
+var import_react15 = require("react");
+var import_jsx_runtime8 = require("react/jsx-runtime");
 function toPx(v) {
   if (v === void 0) return void 0;
   return typeof v === "number" ? `${v}px` : v;
@@ -3774,10 +3876,19 @@ function ellipsePosition(angleDeg) {
 function toNum(v) {
   return typeof v === "number" ? v : 0;
 }
+function readInlineProperty(el, prop) {
+  let node = el.parentElement;
+  while (node) {
+    const val = node.style.getPropertyValue(prop);
+    if (val) return parseFloat(val) || 1;
+    node = node.parentElement;
+  }
+  return 1;
+}
 function OverlayBadge({
   children,
-  maxScale = 2,
-  minScale = 0.75,
+  maxScale = 1.5,
+  minScale = 0.5,
   top,
   right,
   bottom,
@@ -3786,43 +3897,39 @@ function OverlayBadge({
   sx,
   ...rest
 }) {
-  const ref = (0, import_react14.useRef)(null);
-  const baseSize = (0, import_react14.useRef)(null);
-  (0, import_react14.useEffect)(() => {
+  const ref = (0, import_react15.useRef)(null);
+  (0, import_react15.useEffect)(() => {
     const el = ref.current;
     if (!el) return;
     const ancestor = el.parentElement;
     if (!ancestor) return;
-    function update() {
-      requestAnimationFrame(() => {
-        if (!el || !ancestor) return;
-        const containerW = ancestor.clientWidth;
-        const containerH = ancestor.clientHeight;
-        if (containerW <= 0 || containerH <= 0) {
-          el.style.transform = "";
-          return;
-        }
-        if (!baseSize.current) {
-          baseSize.current = { w: containerW, h: containerH };
-        }
-        const ratio = Math.min(
-          containerW / baseSize.current.w,
-          containerH / baseSize.current.h
-        );
-        const ownScale = Math.max(minScale, Math.min(ratio, maxScale));
-        const overlayScale = parseFloat(
-          getComputedStyle(el).getPropertyValue("--overlay-scale")
-        ) || 1;
-        const scale = `scale(${ownScale / overlayScale})`;
-        el.style.transform = circular ? `translate(-50%, -50%) ${scale}` : scale;
-      });
+    let rafId = 0;
+    function doUpdate() {
+      if (!el || !ancestor) return;
+      if (ancestor.clientWidth <= 0 || ancestor.clientHeight <= 0) {
+        el.style.transform = "";
+        return;
+      }
+      const zoom = readInlineProperty(el, "--overlay-zoom");
+      const ownScale = Math.max(minScale, Math.min(zoom, maxScale));
+      const overlayScale = readInlineProperty(el, "--overlay-scale");
+      const scale = `scale(${ownScale / overlayScale})`;
+      el.style.transform = circular ? `translate(-50%, -50%) ${scale}` : scale;
+    }
+    function scheduleUpdate() {
+      if (!rafId) {
+        rafId = requestAnimationFrame(() => {
+          rafId = 0;
+          doUpdate();
+        });
+      }
     }
-    const observer = new ResizeObserver(update);
+    const observer = new ResizeObserver(scheduleUpdate);
     observer.observe(ancestor);
-    update();
+    scheduleUpdate();
     return () => {
+      if (rafId) cancelAnimationFrame(rafId);
       observer.disconnect();
-      baseSize.current = null;
     };
   }, [maxScale, minScale, circular]);
   const positionSx = circular ? (() => {
@@ -3840,8 +3947,8 @@ function OverlayBadge({
     bottom: toPx(bottom),
     left: toPx(left)
   };
-  return /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(
-    import_material4.Stack,
+  return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
+    import_material5.Stack,
     {
       ref,
       sx: {
@@ -3878,6 +3985,7 @@ var import_fabric19 = require("fabric");
   FixedSizeContent,
   ObjectOverlay,
   OverlayBadge,
+  OverlayContainer,
   OverlayContent,
   Point,
   Polygon,