@pixldocs/canvas-renderer 0.5.396 → 0.5.397

package/dist/{index-DQYnrYMM.cjs → index-BgYo0VtS.cjs}

@@ -10592,6 +10592,56 @@ const collectFabricObjectWorldPoints = (objects) => {
   }
   return points;
 };
+const collectFabricObjectWorldCenters = (objects) => {
+  var _a2;
+  const centers = [];
+  for (const obj of objects) {
+    try {
+      obj.setCoords();
+    } catch {
+    }
+    const coords = typeof obj.getCoords === "function" ? obj.getCoords() : null;
+    if (Array.isArray(coords) && coords.length >= 4) {
+      const pts = coords.slice(0, 4).map((p) => ({ x: Number(p.x), y: Number(p.y) })).filter((p) => Number.isFinite(p.x) && Number.isFinite(p.y));
+      if (pts.length) centers.push({ x: pts.reduce((sum, p) => sum + p.x, 0) / pts.length, y: pts.reduce((sum, p) => sum + p.y, 0) / pts.length });
+      continue;
+    }
+    try {
+      const center = (_a2 = obj.getCenterPoint) == null ? void 0 : _a2.call(obj);
+      if (center && Number.isFinite(center.x) && Number.isFinite(center.y)) centers.push({ x: center.x, y: center.y });
+    } catch {
+    }
+  }
+  return centers;
+};
+const logicalFrameContainsWorldCenters = (frame, angle, centers) => {
+  if (!isValidLogicalGroupFrame(frame) || centers.length === 0) return true;
+  const a = typeof angle === "number" && Number.isFinite(angle) ? normalizeAngle180(angle) : 0;
+  const cx = frame.left + frame.width / 2;
+  const cy = frame.top + frame.height / 2;
+  const rad = -a * Math.PI / 180;
+  const c = Math.cos(rad);
+  const s = Math.sin(rad);
+  const tolerance = Math.max(8, Math.min(frame.width, frame.height) * 0.08);
+  return centers.every((p) => {
+    const dx = p.x - cx;
+    const dy = p.y - cy;
+    const localX = cx + dx * c - dy * s;
+    const localY = cy + dx * s + dy * c;
+    return localX >= frame.left - tolerance && localX <= frame.left + frame.width + tolerance && localY >= frame.top - tolerance && localY <= frame.top + frame.height + tolerance;
+  });
+};
+const shouldRepairUnrotatedLogicalGroupFrame = (storedFrame, contentFrame, angle) => {
+  if (!isValidLogicalGroupFrame(storedFrame) || !isValidLogicalGroupFrame(contentFrame)) return false;
+  if (Math.abs(normalizeAngle180(typeof angle === "number" && Number.isFinite(angle) ? angle : 0)) > 0.5) return false;
+  const storedArea = storedFrame.width * storedFrame.height;
+  const contentArea = contentFrame.width * contentFrame.height;
+  const areaRatio = storedArea / Math.max(1, contentArea);
+  const dx = Math.abs(storedFrame.left + storedFrame.width / 2 - (contentFrame.left + contentFrame.width / 2));
+  const dy = Math.abs(storedFrame.top + storedFrame.height / 2 - (contentFrame.top + contentFrame.height / 2));
+  const driftTolerance = Math.max(12, Math.min(storedFrame.width, storedFrame.height) * 0.08);
+  return areaRatio > 1.35 || dx > driftTolerance || dy > driftTolerance;
+};
 let ensureCanvaControlRenders = () => {
 };
 try {
@@ -11585,13 +11635,40 @@ function applyWarpAwareSelectionBorders(selection, preferredGroupAngle, preferre
         for (const b of buckets) b.area = orientedAreaForAngle(b.angle);
         buckets.sort((a, b) => b.count - a.count || a.area - b.area || Math.abs(b.angle) - Math.abs(a.angle));
         const dominant = buckets[0];
-        const rawPreferredGroupAngle = typeof preferredGroupAngle === "number" && Number.isFinite(preferredGroupAngle) ? preferredGroupAngle : typeof selection.__pixldocsGroupAngle === "number" && Number.isFinite(selection.__pixldocsGroupAngle) ? selection.__pixldocsGroupAngle : null;
+        let effectivePreferredGroupAngle = preferredGroupAngle;
+        let effectivePreferredGroupFrame = preferredGroupFrame;
+        const logicalGroupId = selection.__pixldocsGroupSelection;
+        if (logicalGroupId && (!(typeof effectivePreferredGroupAngle === "number" && Number.isFinite(effectivePreferredGroupAngle)) || !isValidLogicalGroupFrame(effectivePreferredGroupFrame))) {
+          try {
+            const stateNow = useEditorStore.getState();
+            const pageNow = stateNow.canvas.pages.find((p) => p.id === stateNow.canvas.currentPageId);
+            const groupNode = pageNow ? findNodeById(pageNow.children ?? [], logicalGroupId) : null;
+            if (groupNode && isGroup(groupNode)) {
+              if (!(typeof effectivePreferredGroupAngle === "number" && Number.isFinite(effectivePreferredGroupAngle)) && typeof groupNode.angle === "number") {
+                effectivePreferredGroupAngle = groupNode.angle;
+              }
+              if (!isValidLogicalGroupFrame(effectivePreferredGroupFrame)) {
+                effectivePreferredGroupFrame = frameFromStoredGroupNode(groupNode, (pageNow == null ? void 0 : pageNow.children) ?? []);
+              }
+            }
+          } catch {
+          }
+        }
+        const rawPreferredGroupAngle = typeof effectivePreferredGroupAngle === "number" && Number.isFinite(effectivePreferredGroupAngle) ? effectivePreferredGroupAngle : typeof selection.__pixldocsGroupAngle === "number" && Number.isFinite(selection.__pixldocsGroupAngle) ? selection.__pixldocsGroupAngle : null;
         const preferredAngle = rawPreferredGroupAngle != null ? normalizeAngle180(rawPreferredGroupAngle) : null;
         let targetAngle = preferredAngle;
-        const isLogicalGroupSelection = !!selection.__pixldocsGroupSelection;
+        const isLogicalGroupSelection = !!logicalGroupId;
         if (targetAngle == null && dominant && Math.abs(dominant.angle) > 0.5 && (isLogicalGroupSelection || kids.length === 1 || dominant.count >= 2 || dominant.count === kids.length)) {
           targetAngle = dominant.angle;
         }
+        if (isLogicalGroupSelection && isValidLogicalGroupFrame(effectivePreferredGroupFrame) && targetAngle != null) {
+          const contentFrame = orientedFrameFromWorldPoints(worldPoints, targetAngle);
+          if (shouldRepairUnrotatedLogicalGroupFrame(effectivePreferredGroupFrame, contentFrame, targetAngle)) {
+            effectivePreferredGroupFrame = contentFrame;
+          } else if (!logicalFrameContainsWorldCenters(effectivePreferredGroupFrame, targetAngle, collectFabricObjectWorldCenters(kids))) {
+            effectivePreferredGroupFrame = null;
+          }
+        }
         if (targetAngle != null) {
           const restoreKidsFromWorld = () => {
             const invSelection = fabric__namespace.util.invertTransform(
@@ -11630,7 +11707,7 @@ function applyWarpAwareSelectionBorders(selection, preferredGroupAngle, preferre
             targetAngle,
             worldAngles
           });
-          const fixedFrame = preferredGroupFrame && Number.isFinite(preferredGroupFrame.left) && Number.isFinite(preferredGroupFrame.top) && Number.isFinite(preferredGroupFrame.width) && preferredGroupFrame.width > 0 && Number.isFinite(preferredGroupFrame.height) && preferredGroupFrame.height > 0 ? preferredGroupFrame : null;
+          const fixedFrame = effectivePreferredGroupFrame && Number.isFinite(effectivePreferredGroupFrame.left) && Number.isFinite(effectivePreferredGroupFrame.top) && Number.isFinite(effectivePreferredGroupFrame.width) && effectivePreferredGroupFrame.width > 0 && Number.isFinite(effectivePreferredGroupFrame.height) && effectivePreferredGroupFrame.height > 0 ? effectivePreferredGroupFrame : null;
           selection.set({ angle: targetAngle, scaleX: 1, scaleY: 1, skewX: 0, skewY: 0 });
           if (fixedFrame) {
             selection.set({ width: fixedFrame.width, height: fixedFrame.height, originX: "center", originY: "center" });
@@ -11781,8 +11858,17 @@ const PageCanvas = react.forwardRef(
       }
       let groupFrame = groupNode && isGroup(groupNode) ? frameFromStoredGroupNode(groupNode, (pageNow == null ? void 0 : pageNow.children) ?? []) : null;
       let groupFrameWasInferred = false;
+      const memberWorldPoints = collectFabricObjectWorldPoints(members);
+      const memberWorldCenters = collectFabricObjectWorldCenters(members);
+      const contentFrame = typeof groupAngle === "number" && Number.isFinite(groupAngle) ? orientedFrameFromWorldPoints(memberWorldPoints, normalizeAngle180(groupAngle)) : null;
+      if (shouldRepairUnrotatedLogicalGroupFrame(groupFrame, contentFrame, groupAngle)) {
+        groupFrame = contentFrame;
+        groupFrameWasInferred = true;
+      } else if (groupFrame && !logicalFrameContainsWorldCenters(groupFrame, groupAngle, memberWorldCenters)) {
+        groupFrame = null;
+      }
       if (!groupFrame && groupNode && isGroup(groupNode) && typeof groupAngle === "number" && Number.isFinite(groupAngle)) {
-        groupFrame = orientedFrameFromWorldPoints(collectFabricObjectWorldPoints(members), normalizeAngle180(groupAngle));
+        groupFrame = contentFrame ?? orientedFrameFromWorldPoints(memberWorldPoints, normalizeAngle180(groupAngle));
         groupFrameWasInferred = isValidLogicalGroupFrame(groupFrame);
       }
       if (groupNode && isGroup(groupNode)) {
@@ -25351,9 +25437,9 @@ function captureFabricCanvasSvgForPdf(fabricInstance, canvasWidth, canvasHeight)
   }
   return svgString;
 }
-const resolvedPackageVersion = "0.5.396";
+const resolvedPackageVersion = "0.5.397";
 const PACKAGE_VERSION = resolvedPackageVersion;
-const DEPLOYMENT_VERSION_MARKER = "__PIXLDOCS_CANVAS_RENDERER_VERSION__:0.5.396";
+const DEPLOYMENT_VERSION_MARKER = "__PIXLDOCS_CANVAS_RENDERER_VERSION__:0.5.397";
 const roundParityValue = (value) => {
   if (typeof value !== "number") return value;
   return Number.isFinite(value) ? Number(value.toFixed(3)) : value;
@@ -26167,7 +26253,7 @@ class PixldocsRenderer {
         await this.waitForCanvasScene(container, cloned, i);
       }
       console.log(`[canvas-renderer][pdf-unified] mounted ${cloned.pages.length} page(s), handing off to client exportMultiPagePdf`);
-      const { exportMultiPagePdf, preparePagesForExport } = await Promise.resolve().then(() => require("./vectorPdfExport-oL70Zv8c.cjs"));
+      const { exportMultiPagePdf, preparePagesForExport } = await Promise.resolve().then(() => require("./vectorPdfExport-o6mqay90.cjs"));
       const prepared = preparePagesForExport(
         cloned.pages,
         canvasWidth,
@@ -28487,7 +28573,7 @@ async function prepareLiveCanvasSvgForPdf(rawSvg, pageWidth, pageHeight, pageKey
     if (options == null ? void 0 : options.stripPageBackground) stripRootPageBackgroundFromSvg(svgToDraw);
     sanitizeSvgTreeForPdf(svgToDraw);
     try {
-      const { bakeTextAnchorPositionsFromLiveSvg, logTextMeasurementDiagnostic } = await Promise.resolve().then(() => require("./vectorPdfExport-oL70Zv8c.cjs"));
+      const { bakeTextAnchorPositionsFromLiveSvg, logTextMeasurementDiagnostic } = await Promise.resolve().then(() => require("./vectorPdfExport-o6mqay90.cjs"));
       try {
         await logTextMeasurementDiagnostic(svgToDraw);
       } catch {
@@ -28884,4 +28970,4 @@ exports.setAutoShrinkDebug = setAutoShrinkDebug;
 exports.setBundledAssetPrefixes = setBundledAssetPrefixes;
 exports.warmResolvedTemplateForPreview = warmResolvedTemplateForPreview;
 exports.warmTemplateFromForm = warmTemplateFromForm;
-//# sourceMappingURL=index-DQYnrYMM.cjs.map
+//# sourceMappingURL=index-BgYo0VtS.cjs.map