react-native-smooth-clip-view 0.3.0 → 0.4.1

package/cpp/SmoothClipRegistry.h

@@ -18,9 +18,7 @@ struct Geometry {
   double width;
   double height;
   double radius;
-  // NaN means "use radius". Keeping the overrides at the end preserves every
-  // existing five-value aggregate initializer used by the V1 implementation
-  // and its native tests.
+  // NaN means "use radius", allowing concise uniform-radius presentations.
   double topLeftRadius = std::numeric_limits<double>::quiet_NaN();
   double topRightRadius = std::numeric_limits<double>::quiet_NaN();
   double bottomRightRadius = std::numeric_limits<double>::quiet_NaN();
@@ -28,16 +26,24 @@ struct Geometry {
   ClipCurve curve = ClipCurve::Circular;
 };
 
+struct Shadow {
+  bool enabled = false;
+  double red = 0;
+  double green = 0;
+  double blue = 0;
+  double alpha = 1;
+  double offsetX = 0;
+  double offsetY = 0;
+  double blurRadius = 0;
+  double spreadDistance = 0;
+};
+
 struct Presentation {
   Geometry clip;
   double contentTranslateX;
   double contentTranslateY;
   double contentScale = 1.0;
-};
-
-struct Keyframe {
-  double offset;
-  Presentation presentation;
+  Shadow shadow{};
 };
 
 struct TimingAnimation {
@@ -56,6 +62,7 @@ struct SpringAnimation {
   double initialVelocity;
   bool inheritVelocity;
   int32_t reduceMotion;
+  double energyThreshold = 6e-9;
 };
 
 struct AnimationStart {
@@ -92,12 +99,6 @@ struct GroupMotionEntry {
   bool hasFrom;
   Presentation from;
   Presentation target;
-  std::vector<Keyframe> keyframes;
-};
-
-enum class GroupSuspensionPolicy : int32_t {
-  Pause = 0,
-  Finish = 1,
 };
 
 enum class GroupCancelBehavior : int32_t {
@@ -105,19 +106,11 @@ enum class GroupCancelBehavior : int32_t {
   Finish = 1,
 };
 
-// The seven-scalar V1 bridge predates protocol-V2 host-normalization
-// preflight and strict spring/duration rejection. Keep that wire contract
-// selectable without widening any V1 entry point; V2 and grouped calls retain
-// the conservative validation required for portable native ownership.
-enum class AnimationValidationMode : int32_t {
-  LegacyV1 = 1,
-  ProtocolV2 = 2,
-};
-
 using CompletionCallback =
-    std::function<void(uint64_t, int32_t, bool)>;
+    std::function<void(uint64_t, int32_t, int32_t, bool)>;
 using GroupCompletionCallback =
-    std::function<void(uint64_t, int32_t, bool, std::vector<uint64_t>)>;
+    std::function<
+        void(uint64_t, int32_t, int32_t, bool, std::vector<DriverSnapshot>)>;
 
 void setCompletionCallback(
     const void *owner,
@@ -128,11 +121,8 @@ void setGroupCompletionCallback(
     GroupCompletionCallback callback);
 void clearGroupCompletionCallback(const void *owner);
 
-// recordVelocity gates the 'inherit' velocity-sample recording for this write.
-// Default true (the pre-flag behavior); Android's JS layer passes false for
-// setScalars hot writes on drivers without SmoothClipDriverOptions
-// .velocityTracking, so the per-frame drag stream skips the clock read and
-// channel copies. iOS callers never pass it and keep recording always.
+// Interactive writes always keep the two samples needed by a later
+// `initialVelocity: "inherit"` spring.
 void setPresentation(
     uint64_t driverId,
     Presentation presentation,
@@ -150,20 +140,13 @@ int32_t animateTimingGroup(
     uint64_t controllerId,
     std::vector<GroupMotionEntry> entries,
     TimingAnimation animation,
-    GroupSuspensionPolicy suspensionPolicy,
+    int32_t completionTag = 0,
     double startedAtHintS = std::numeric_limits<double>::quiet_NaN());
 int32_t animateSpringGroup(
     uint64_t controllerId,
     std::vector<GroupMotionEntry> entries,
     SpringAnimation animation,
-    GroupSuspensionPolicy suspensionPolicy,
-    double startedAtHintS = std::numeric_limits<double>::quiet_NaN());
-int32_t animateKeyframesGroup(
-    uint64_t controllerId,
-    std::vector<GroupMotionEntry> entries,
-    double durationMs,
-    int32_t reduceMotion,
-    GroupSuspensionPolicy suspensionPolicy,
+    int32_t completionTag = 0,
     double startedAtHintS = std::numeric_limits<double>::quiet_NaN());
 std::vector<DriverSnapshot> cancelAnimationGroup(
     int32_t groupId,
@@ -173,24 +156,13 @@ int32_t animateTiming(
     AnimationStart start,
     Presentation presentation,
     TimingAnimation animation,
-    AnimationValidationMode validationMode =
-        AnimationValidationMode::ProtocolV2);
+    int32_t completionTag = 0);
 int32_t animateSpring(
     uint64_t driverId,
     AnimationStart start,
     Presentation presentation,
     SpringAnimation animation,
-    AnimationValidationMode validationMode =
-        AnimationValidationMode::ProtocolV2);
-int32_t animateKeyframes(
-    uint64_t driverId,
-    AnimationStart start,
-    Presentation presentation,
-    double durationMs,
-    std::vector<Keyframe> keyframes,
-    int32_t reduceMotion,
-    AnimationValidationMode validationMode =
-        AnimationValidationMode::ProtocolV2);
+    int32_t completionTag = 0);
 int32_t rejectAnimation(uint64_t driverId);
 CancelResult cancelAnimation(
     uint64_t driverId,

package/cpp/SmoothClipSharedGeometry.h

@@ -7,7 +7,13 @@
 
 namespace smoothclip {
 
-struct NormalizedClip {
+/**
+ * Host-independent canonical clip geometry expressed as edges.
+ *
+ * The moving aperture is allowed to cross or sit outside any host. Hosts crop
+ * the rendered result; they never rewrite the geometry stored by the driver.
+ */
+struct CanonicalClip {
   double left = 0;
   double top = 0;
   double right = 0;
@@ -25,71 +31,13 @@ inline double SmoothClipResolvedRadius(double overrideValue, double radius) {
 }
 
 /**
- * Returns true only when host normalization is the identity for this geometry.
- *
- * Timing/keyframe renderers interpolate already-normalized native values on
- * iOS, while Android interpolates presentation scalars and normalizes each
- * delivered frame. Those operations commute exactly when every anchor stays
- * inside one host and the CSS corner-overlap rule never activates. Because
- * each condition below is linear, it also holds for every convex interpolation
- * between accepted anchors.
+ * Canonicalizes a requested rectangle without consulting host dimensions.
  *
- * Static clipping deliberately does not use this gate: out-of-bounds geometry
- * remains valid and is still clipped by SmoothClipNormalizeV2.
+ * Negative dimensions collapse to zero. Corner radii follow the CSS
+ * corner-overlap rule against the requested rectangle, using one common scale
+ * factor so their proportions are preserved.
  */
-inline bool SmoothClipGeometryNormalizationIsIdentity(
-    const Geometry &geometry,
-    double hostWidth,
-    double hostHeight) {
-  const double topLeft = SmoothClipResolvedRadius(
-      geometry.topLeftRadius, geometry.radius);
-  const double topRight = SmoothClipResolvedRadius(
-      geometry.topRightRadius, geometry.radius);
-  const double bottomRight = SmoothClipResolvedRadius(
-      geometry.bottomRightRadius, geometry.radius);
-  const double bottomLeft = SmoothClipResolvedRadius(
-      geometry.bottomLeftRadius, geometry.radius);
-  const double right = geometry.x + geometry.width;
-  const double bottom = geometry.y + geometry.height;
-  const double topRadii = topLeft + topRight;
-  const double bottomRadii = bottomLeft + bottomRight;
-  const double leftRadii = topLeft + bottomLeft;
-  const double rightRadii = topRight + bottomRight;
-  const double values[] = {
-      geometry.x,
-      geometry.y,
-      geometry.width,
-      geometry.height,
-      geometry.radius,
-      topLeft,
-      topRight,
-      bottomRight,
-      bottomLeft,
-      right,
-      bottom,
-      topRadii,
-      bottomRadii,
-      leftRadii,
-      rightRadii,
-      hostWidth,
-      hostHeight,
-  };
-  for (const double value : values) {
-    if (!std::isfinite(value)) return false;
-  }
-  return hostWidth >= 0 && hostHeight >= 0 &&
-      geometry.x >= 0 && geometry.y >= 0 &&
-      geometry.width >= 0 && geometry.height >= 0 &&
-      right <= hostWidth && bottom <= hostHeight &&
-      topLeft >= 0 && topRight >= 0 &&
-      bottomRight >= 0 && bottomLeft >= 0 &&
-      topRadii <= geometry.width &&
-      bottomRadii <= geometry.width &&
-      leftRadii <= geometry.height &&
-      rightRadii <= geometry.height;
-}
-
-inline bool SmoothClipNormalizeV2(
+inline bool SmoothClipCanonicalize(
     double x,
     double y,
     double width,
@@ -100,9 +48,7 @@ inline bool SmoothClipNormalizeV2(
     double bottomRightRadius,
     double bottomLeftRadius,
     ClipCurve curve,
-    double hostWidth,
-    double hostHeight,
-    NormalizedClip &out) {
+    CanonicalClip &out) {
   const double resolvedTopLeft =
       SmoothClipResolvedRadius(topLeftRadius, radius);
   const double resolvedTopRight =
@@ -117,20 +63,19 @@ inline bool SmoothClipNormalizeV2(
       !std::isfinite(resolvedTopRight) ||
       !std::isfinite(resolvedBottomRight) ||
       !std::isfinite(resolvedBottomLeft) ||
-      !std::isfinite(hostWidth) || !std::isfinite(hostHeight)) {
+      (curve != ClipCurve::Circular && curve != ClipCurve::Continuous)) {
     return false;
   }
 
-  const double boundedHostWidth = std::max(0.0, hostWidth);
-  const double boundedHostHeight = std::max(0.0, hostHeight);
-  const double requestedRight = x + std::max(0.0, width);
-  const double requestedBottom = y + std::max(0.0, height);
-  out.left = std::min(boundedHostWidth, std::max(0.0, x));
-  out.top = std::min(boundedHostHeight, std::max(0.0, y));
-  out.right = std::min(boundedHostWidth, std::max(0.0, requestedRight));
-  out.bottom = std::min(boundedHostHeight, std::max(0.0, requestedBottom));
-  const double visibleWidth = std::max(0.0, out.right - out.left);
-  const double visibleHeight = std::max(0.0, out.bottom - out.top);
+  const double canonicalWidth = std::max(0.0, width);
+  const double canonicalHeight = std::max(0.0, height);
+  const double right = x + canonicalWidth;
+  const double bottom = y + canonicalHeight;
+  if (!std::isfinite(right) || !std::isfinite(bottom)) return false;
+  out.left = x;
+  out.top = y;
+  out.right = right;
+  out.bottom = bottom;
 
   double topLeft = std::max(0.0, resolvedTopLeft);
   double topRight = std::max(0.0, resolvedTopRight);
@@ -140,11 +85,12 @@ inline bool SmoothClipNormalizeV2(
   const auto includeLimit = [&scale](double available, double requested) {
     if (requested > 0) scale = std::min(scale, available / requested);
   };
-  includeLimit(visibleWidth, topLeft + topRight);
-  includeLimit(visibleWidth, bottomLeft + bottomRight);
-  includeLimit(visibleHeight, topLeft + bottomLeft);
-  includeLimit(visibleHeight, topRight + bottomRight);
-  scale = std::max(0.0, std::min(1.0, scale));
+  includeLimit(canonicalWidth, topLeft + topRight);
+  includeLimit(canonicalWidth, bottomLeft + bottomRight);
+  includeLimit(canonicalHeight, topLeft + bottomLeft);
+  includeLimit(canonicalHeight, topRight + bottomRight);
+  scale = std::clamp(scale, 0.0, 1.0);
+
   out.topLeftRadius = topLeft * scale;
   out.topRightRadius = topRight * scale;
   out.bottomRightRadius = bottomRight * scale;
@@ -157,20 +103,31 @@ inline bool SmoothClipNormalizeV2(
   return true;
 }
 
-// Shared clip normalization emitting edges (Android's Outline consumes
-// edges). Mirrors ios/SmoothClipGeometry.h (SmoothClipNormalizeGeometry) and
-// ClipGeometryNormalizer.kt (normalizeClipGeometryPx); a change here must
-// land in all three.
-inline bool SmoothClipNormalize(
+inline bool SmoothClipCanonicalize(
+    const Geometry &geometry,
+    CanonicalClip &out) {
+  return SmoothClipCanonicalize(
+      geometry.x,
+      geometry.y,
+      geometry.width,
+      geometry.height,
+      geometry.radius,
+      geometry.topLeftRadius,
+      geometry.topRightRadius,
+      geometry.bottomRightRadius,
+      geometry.bottomLeftRadius,
+      geometry.curve,
+      out);
+}
+
+inline bool SmoothClipCanonicalize(
     double x,
     double y,
     double width,
     double height,
     double radius,
-    double hostWidth,
-    double hostHeight,
-    NormalizedClip &out) {
-  return SmoothClipNormalizeV2(
+    CanonicalClip &out) {
+  return SmoothClipCanonicalize(
       x,
       y,
       width,
@@ -181,9 +138,22 @@ inline bool SmoothClipNormalize(
       radius,
       radius,
       ClipCurve::Circular,
-      hostWidth,
-      hostHeight,
       out);
 }
 
+inline Geometry SmoothClipGeometry(const CanonicalClip &clip) {
+  Geometry geometry{
+      clip.left,
+      clip.top,
+      std::max(0.0, clip.right - clip.left),
+      std::max(0.0, clip.bottom - clip.top),
+      clip.radius};
+  geometry.topLeftRadius = clip.topLeftRadius;
+  geometry.topRightRadius = clip.topRightRadius;
+  geometry.bottomRightRadius = clip.bottomRightRadius;
+  geometry.bottomLeftRadius = clip.bottomLeftRadius;
+  geometry.curve = clip.curve;
+  return geometry;
+}
+
 } // namespace smoothclip

package/cpp/SmoothClipVelocityTracker.h

@@ -6,11 +6,11 @@
 namespace smoothclip {
 
 // The two most recent interactive samples used by `initialVelocity: 'inherit'`.
-// Channels are the eleven continuous V2 presentation scalars. Scale is stored
+// Channels are the eleven geometry/content presentation scalars. Scale is stored
 // so histories remain coherent but excluded from velocity projection; each of
-// the four radius channels contributes one quarter of the legacy radius weight.
-// iOS records normalized (host-clamped) geometry, Android raw DIP — the
-// projection only needs both samples and the target in the same space.
+// the four radius channels contributes one quarter of the uniform-radius weight.
+// Both platforms record raw canonical geometry, including off-host coordinates.
+// The projection only needs both samples and the target in the same space.
 // Shared by ios/SmoothClipView.mm and android/.../SmoothClipRegistry.cpp; a
 // behavior change here changes both platforms.
 struct VelocitySampleHistory {
@@ -69,7 +69,7 @@ inline void recordVelocitySample(
 }
 
 // Only explicit interactive writes route through this recorder. Native
-// freeze/join/resume/static-finalization paths deliberately do not, so an
+// Native freeze and endpoint-finalization paths deliberately do not, so an
 // animation cannot manufacture a later inherited velocity. During ordinary
 // interaction, the staleness decay below is the forgetting mechanism and it
 // forgets gradually rather than all at once.

package/ios/SmoothClipGeometry.h

@@ -16,12 +16,11 @@ typedef NS_ENUM(NSInteger, SmoothClipCornerCurve) {
 
 typedef struct {
   CGRect rect;
-  // Retained for the V1 uniform-radius contract. V2 callers should consume
-  // `radii`; this field is zero when the normalized radii are unequal.
+  // Uniform-radius fast-path value; zero when canonical radii are unequal.
   CGFloat radius;
   SmoothClipCornerRadii radii;
   SmoothClipCornerCurve curve;
-} SmoothNormalizedClipGeometry;
+} SmoothClipCanonicalGeometry;
 
 NS_INLINE BOOL SmoothClipCornerRadiiEqual(
     SmoothClipCornerRadii first,
@@ -48,13 +47,13 @@ NS_INLINE CGFloat SmoothClipSafeOverlapFactor(
 }
 
 /**
- * Normalizes the V2 rectangle and four radii without allocating.
+ * Canonicalizes the rectangle and four radii without allocating.
  *
  * The proportional overlap rule matches CSS border radii and the shared
  * Android/C++ contract: all corners use one scale factor, preserving their
  * relative shape while no opposing pair exceeds its edge.
  */
-NS_INLINE BOOL SmoothClipNormalizeGeometryV2(
+NS_INLINE BOOL SmoothClipCanonicalizeGeometry(
     CGFloat x,
     CGFloat y,
     CGFloat width,
@@ -64,30 +63,21 @@ NS_INLINE BOOL SmoothClipNormalizeGeometryV2(
     CGFloat bottomRightRadius,
     CGFloat bottomLeftRadius,
     NSInteger curveCode,
-    CGSize hostSize,
-    SmoothNormalizedClipGeometry *result) {
+    SmoothClipCanonicalGeometry *result) {
   if (!isfinite(x) || !isfinite(y) || !isfinite(width) ||
       !isfinite(height) || !isfinite(topLeftRadius) ||
       !isfinite(topRightRadius) || !isfinite(bottomRightRadius) ||
-      !isfinite(bottomLeftRadius) || !isfinite(hostSize.width) ||
-      !isfinite(hostSize.height) ||
+      !isfinite(bottomLeftRadius) ||
       (curveCode != SmoothClipCornerCurveCircular &&
        curveCode != SmoothClipCornerCurveContinuous)) {
     return NO;
   }
 
-  const CGFloat hostWidth = MAX(0, hostSize.width);
-  const CGFloat hostHeight = MAX(0, hostSize.height);
   const CGFloat requestedWidth = MAX(0, width);
   const CGFloat requestedHeight = MAX(0, height);
-  const CGFloat requestedRight = x + requestedWidth;
-  const CGFloat requestedBottom = y + requestedHeight;
-  const CGFloat left = MIN(hostWidth, MAX(0, x));
-  const CGFloat top = MIN(hostHeight, MAX(0, y));
-  const CGFloat right = MIN(hostWidth, MAX(0, requestedRight));
-  const CGFloat bottom = MIN(hostHeight, MAX(0, requestedBottom));
-  const CGFloat visibleWidth = MAX(0, right - left);
-  const CGFloat visibleHeight = MAX(0, bottom - top);
+  if (!isfinite(x + requestedWidth) || !isfinite(y + requestedHeight)) {
+    return NO;
+  }
 
   SmoothClipCornerRadii radii = {
       MAX(0, topLeftRadius),
@@ -100,20 +90,20 @@ NS_INLINE BOOL SmoothClipNormalizeGeometryV2(
       MIN(
           MIN(
               SmoothClipSafeOverlapFactor(
-                  visibleWidth, radii.topLeft, radii.topRight),
+                  requestedWidth, radii.topLeft, radii.topRight),
               SmoothClipSafeOverlapFactor(
-                  visibleWidth, radii.bottomLeft, radii.bottomRight)),
+                  requestedWidth, radii.bottomLeft, radii.bottomRight)),
           MIN(
               SmoothClipSafeOverlapFactor(
-                  visibleHeight, radii.topLeft, radii.bottomLeft),
+                  requestedHeight, radii.topLeft, radii.bottomLeft),
               SmoothClipSafeOverlapFactor(
-                  visibleHeight, radii.topRight, radii.bottomRight))));
+                  requestedHeight, radii.topRight, radii.bottomRight))));
   radii.topLeft *= overlapScale;
   radii.topRight *= overlapScale;
   radii.bottomRight *= overlapScale;
   radii.bottomLeft *= overlapScale;
 
-  result->rect = CGRectMake(left, top, visibleWidth, visibleHeight);
+  result->rect = CGRectMake(x, y, requestedWidth, requestedHeight);
   result->radii = radii;
   result->radius = SmoothClipCornerRadiiAreUniform(radii)
       ? radii.topLeft
@@ -123,15 +113,14 @@ NS_INLINE BOOL SmoothClipNormalizeGeometryV2(
 }
 
 /** Mirrors the Android and JavaScript geometry contract without allocating. */
-NS_INLINE BOOL SmoothClipNormalizeGeometry(
+NS_INLINE BOOL SmoothClipCanonicalizeGeometry(
     CGFloat x,
     CGFloat y,
     CGFloat width,
     CGFloat height,
     CGFloat radius,
-    CGSize hostSize,
-    SmoothNormalizedClipGeometry *result) {
-  return SmoothClipNormalizeGeometryV2(
+    SmoothClipCanonicalGeometry *result) {
+  return SmoothClipCanonicalizeGeometry(
       x,
       y,
       width,
@@ -141,20 +130,21 @@ NS_INLINE BOOL SmoothClipNormalizeGeometry(
       radius,
       radius,
       SmoothClipCornerCurveCircular,
-      hostSize,
       result);
 }
 
 /**
- * Creates the stable nine-segment rounded-rectangle topology used by the
- * unequal-corner CAShapeLayer mask. Every corner is one cubic, including a
- * zero-radius corner, so Core Animation can interpolate paths without a
- * topology change.
+ * Creates an empty path for an empty clip. Non-empty rounded rectangles use a
+ * stable nine-segment topology. Every corner is one cubic, including a
+ * zero-radius corner, so Core Animation can interpolate non-empty paths
+ * without a topology change.
  */
 NS_INLINE CGPathRef SmoothClipCreateRoundedRectPath(
     CGRect rect,
     SmoothClipCornerRadii radii,
     SmoothClipCornerCurve curve) CF_RETURNS_RETAINED {
+  CGMutablePathRef path = CGPathCreateMutable();
+  if (CGRectIsEmpty(rect)) return path;
   const CGFloat minX = CGRectGetMinX(rect);
   const CGFloat minY = CGRectGetMinY(rect);
   const CGFloat maxX = CGRectGetMaxX(rect);
@@ -171,7 +161,6 @@ NS_INLINE CGPathRef SmoothClipCreateRoundedRectPath(
       ? 1.0
       : 0.5522847498307936;
 
-  CGMutablePathRef path = CGPathCreateMutable();
   CGPathMoveToPoint(path, NULL, minX + radii.topLeft, minY);
   CGPathAddLineToPoint(path, NULL, maxX - radii.topRight, minY);
   CGPathAddCurveToPoint(