canvu-react 0.4.72 → 0.4.74

package/dist/react.cjs

@@ -2260,6 +2260,7 @@ function ImagesMenu({
   onItemsChange,
   onFocusItem,
   labels,
+  hiddenActions,
   defaultOpen = false,
   collapsedButtonClassName,
   collapsedButtonStyle,
@@ -2275,6 +2276,10 @@ function ImagesMenu({
   react.useEffect(() => {
     ensureOpenKeyframe();
   }, []);
+  const hiddenActionSet = react.useMemo(
+    () => new Set(hiddenActions ?? []),
+    [hiddenActions]
+  );
   if (managed.length === 0) {
     return null;
   }
@@ -2349,6 +2354,7 @@ function ImagesMenu({
               {
                 item,
                 labels: resolvedLabels,
+                hiddenActionSet,
                 onFocus: onFocusItem ? () => onFocusItem(item) : void 0,
                 onCopy: () => onItemsChange(copyManagedImage(items, item.id)),
                 onRotate: () => onItemsChange(rotateManagedImage(items, item.id)),
@@ -2365,6 +2371,7 @@ function ImagesMenu({
 function ImagesMenuRow({
   item,
   labels,
+  hiddenActionSet,
   onFocus,
   onCopy,
   onRotate,
@@ -2404,9 +2411,9 @@ function ImagesMenuRow({
     ),
     /* @__PURE__ */ jsxRuntime.jsx(FocusTarget, { label: labels.focus, onFocus, children: /* @__PURE__ */ jsxRuntime.jsx("div", { style: thumbBoxStyle, children: src ? /* @__PURE__ */ jsxRuntime.jsx("img", { src, alt: "", style: thumbImgStyle, draggable: false }) : null }) }),
     /* @__PURE__ */ jsxRuntime.jsxs("div", { style: actionsColumnStyle, children: [
-      /* @__PURE__ */ jsxRuntime.jsx(ImagesMenuAction, { label: labels.duplicate, onClick: onCopy, children: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.CopyPlus, { size: 18 }) }),
-      /* @__PURE__ */ jsxRuntime.jsx(ImagesMenuAction, { label: labels.rotate, onClick: onRotate, children: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.RotateCw, { size: 18 }) }),
-      /* @__PURE__ */ jsxRuntime.jsx(ImagesMenuAction, { label: labels.delete, onClick: onDelete, danger: true, children: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Trash2, { size: 18 }) })
+      !hiddenActionSet.has("duplicate") ? /* @__PURE__ */ jsxRuntime.jsx(ImagesMenuAction, { label: labels.duplicate, onClick: onCopy, children: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.CopyPlus, { size: 18 }) }) : null,
+      !hiddenActionSet.has("rotate") ? /* @__PURE__ */ jsxRuntime.jsx(ImagesMenuAction, { label: labels.rotate, onClick: onRotate, children: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.RotateCw, { size: 18 }) }) : null,
+      !hiddenActionSet.has("delete") ? /* @__PURE__ */ jsxRuntime.jsx(ImagesMenuAction, { label: labels.delete, onClick: onDelete, danger: true, children: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Trash2, { size: 18 }) }) : null
     ] })
   ] });
 }
@@ -8554,6 +8561,11 @@ function shallowEqualStringArray(a, b) {
 
 // src/react/stroke-input.ts
 var MAX_INTERPOLATED_POINTS_PER_SAMPLE = 192;
+var MIN_CURVED_INTERPOLATION_DOT = -0.15;
+var MAX_STRAIGHT_INTERPOLATION_DOT = 0.985;
+var CURVED_INTERPOLATION_TENSION = 0.22;
+var MAX_CURVED_CONTROL_DISTANCE_RATIO = 0.5;
+var MIN_POINT_DISTANCE_SQUARED = 1e-12;
 function getPointerEventSamples(event) {
   if (typeof event.getCoalescedEvents !== "function") {
     return [event];
@@ -8568,6 +8580,62 @@ var resolveInterpolatedPressure = (lastPoint, nextPoint, ratio) => {
   return ratio === 1 ? nextPoint.pressure : void 0;
 };
 var resolveMaxStepWorld = (maxStepWorld) => Number.isFinite(maxStepWorld) && maxStepWorld > 0 ? maxStepWorld : Number.POSITIVE_INFINITY;
+var squaredDistance = (firstPoint, secondPoint) => {
+  const deltaX = secondPoint.x - firstPoint.x;
+  const deltaY = secondPoint.y - firstPoint.y;
+  return deltaX * deltaX + deltaY * deltaY;
+};
+var resolvePreviousDistinctPoint = (points, lastPoint) => {
+  for (let index = points.length - 2; index >= 0; index--) {
+    const candidatePoint = points[index];
+    if (candidatePoint && squaredDistance(candidatePoint, lastPoint) > MIN_POINT_DISTANCE_SQUARED) {
+      return candidatePoint;
+    }
+  }
+  return void 0;
+};
+var shouldUseCurvedInterpolation = (previousPoint, lastPoint, nextPoint) => {
+  if (!previousPoint) return false;
+  const incomingX = lastPoint.x - previousPoint.x;
+  const incomingY = lastPoint.y - previousPoint.y;
+  const outgoingX = nextPoint.x - lastPoint.x;
+  const outgoingY = nextPoint.y - lastPoint.y;
+  const incomingLengthSquared = incomingX * incomingX + incomingY * incomingY;
+  const outgoingLengthSquared = outgoingX * outgoingX + outgoingY * outgoingY;
+  if (incomingLengthSquared <= MIN_POINT_DISTANCE_SQUARED || outgoingLengthSquared <= MIN_POINT_DISTANCE_SQUARED) {
+    return false;
+  }
+  const directionDot = (incomingX * outgoingX + incomingY * outgoingY) / Math.sqrt(incomingLengthSquared * outgoingLengthSquared);
+  return directionDot >= MIN_CURVED_INTERPOLATION_DOT && directionDot <= MAX_STRAIGHT_INTERPOLATION_DOT;
+};
+var resolveCurvedControlPoint = (previousPoint, lastPoint, nextPoint, distance) => {
+  const tangentX = nextPoint.x - previousPoint.x;
+  const tangentY = nextPoint.y - previousPoint.y;
+  const tangentLength = Math.sqrt(tangentX * tangentX + tangentY * tangentY);
+  if (tangentLength <= MIN_POINT_DISTANCE_SQUARED) return void 0;
+  const controlDistance = Math.min(
+    distance * MAX_CURVED_CONTROL_DISTANCE_RATIO,
+    tangentLength * CURVED_INTERPOLATION_TENSION
+  );
+  const scale = controlDistance / tangentLength;
+  return {
+    x: lastPoint.x + tangentX * scale,
+    y: lastPoint.y + tangentY * scale
+  };
+};
+var resolveInterpolatedPosition = (lastPoint, nextPoint, controlPoint, ratio) => {
+  if (!controlPoint) {
+    return {
+      x: lastPoint.x + (nextPoint.x - lastPoint.x) * ratio,
+      y: lastPoint.y + (nextPoint.y - lastPoint.y) * ratio
+    };
+  }
+  const inverseRatio = 1 - ratio;
+  return {
+    x: inverseRatio * inverseRatio * lastPoint.x + 2 * inverseRatio * ratio * controlPoint.x + ratio * ratio * nextPoint.x,
+    y: inverseRatio * inverseRatio * lastPoint.y + 2 * inverseRatio * ratio * controlPoint.y + ratio * ratio * nextPoint.y
+  };
+};
 function appendInterpolatedStrokePoint(points, nextPoint, maxStepWorld) {
   if (points.length === 0) return [nextPoint];
   const lastPoint = points[points.length - 1];
@@ -8575,19 +8643,31 @@ function appendInterpolatedStrokePoint(points, nextPoint, maxStepWorld) {
   const deltaX = nextPoint.x - lastPoint.x;
   const deltaY = nextPoint.y - lastPoint.y;
   const distanceSquared = deltaX * deltaX + deltaY * deltaY;
-  if (distanceSquared < 1e-12) return points;
+  if (distanceSquared < MIN_POINT_DISTANCE_SQUARED) return points;
   const distance = Math.sqrt(distanceSquared);
   const stepCount = Math.min(
     MAX_INTERPOLATED_POINTS_PER_SAMPLE,
     Math.max(1, Math.ceil(distance / resolveMaxStepWorld(maxStepWorld)))
   );
   if (stepCount === 1) return [...points, nextPoint];
+  const previousPoint = resolvePreviousDistinctPoint(points, lastPoint);
+  const controlPoint = shouldUseCurvedInterpolation(
+    previousPoint,
+    lastPoint,
+    nextPoint
+  ) ? resolveCurvedControlPoint(previousPoint, lastPoint, nextPoint, distance) : void 0;
   const interpolatedPoints = Array.from({ length: stepCount }, (_, index) => {
     const ratio = (index + 1) / stepCount;
     const pressure = resolveInterpolatedPressure(lastPoint, nextPoint, ratio);
+    const position = resolveInterpolatedPosition(
+      lastPoint,
+      nextPoint,
+      controlPoint,
+      ratio
+    );
     return {
-      x: lastPoint.x + deltaX * ratio,
-      y: lastPoint.y + deltaY * ratio,
+      x: position.x,
+      y: position.y,
       ...pressure != null ? { pressure } : {}
     };
   });