canvu-react 0.4.73 → 0.4.74

package/dist/react.js

@@ -8554,6 +8554,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 +8573,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 +8636,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 } : {}
     };
   });