react-native-smooth-clip-view 0.1.0 → 0.2.1

package/android/src/main/java/com/smoothclipview/SmoothClipViewPackage.kt

@@ -4,6 +4,7 @@ import com.facebook.react.BaseReactPackage
 import com.facebook.react.bridge.NativeModule
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.module.model.ReactModuleInfoProvider
+import com.facebook.react.module.model.ReactModuleInfo
 import com.facebook.react.uimanager.ViewManager
 
 class SmoothClipViewPackage : BaseReactPackage() {
@@ -14,8 +15,23 @@ class SmoothClipViewPackage : BaseReactPackage() {
     override fun getModule(
         name: String,
         reactContext: ReactApplicationContext,
-    ): NativeModule? = null
+    ): NativeModule? = if (name == NativeSmoothClipModuleSpec.NAME) {
+        SmoothClipModule(reactContext)
+    } else {
+        null
+    }
 
     override fun getReactModuleInfoProvider() =
-        ReactModuleInfoProvider { emptyMap() }
+        ReactModuleInfoProvider {
+            mapOf(
+                NativeSmoothClipModuleSpec.NAME to ReactModuleInfo(
+                    NativeSmoothClipModuleSpec.NAME,
+                    SmoothClipModule::class.java.name,
+                    false,
+                    false,
+                    false,
+                    true,
+                ),
+            )
+        }
 }

package/cpp/SmoothClipRegistry.h

@@ -0,0 +1,93 @@
+#pragma once
+
+#include <cstdint>
+#include <functional>
+#include <vector>
+
+namespace smoothclip {
+
+struct Geometry {
+  double x;
+  double y;
+  double width;
+  double height;
+  double radius;
+};
+
+struct Presentation {
+  Geometry clip;
+  double contentTranslateX;
+  double contentTranslateY;
+};
+
+struct Keyframe {
+  double offset;
+  Presentation presentation;
+};
+
+struct TimingAnimation {
+  double durationMs;
+  double controlPoint1X;
+  double controlPoint1Y;
+  double controlPoint2X;
+  double controlPoint2Y;
+  int32_t reduceMotion;
+};
+
+struct SpringAnimation {
+  double mass;
+  double stiffness;
+  double damping;
+  double initialVelocity;
+  bool inheritVelocity;
+  int32_t reduceMotion;
+};
+
+struct AnimationStart {
+  bool hasInteractiveStart;
+  Presentation interactiveStart;
+};
+
+struct CancelResult {
+  bool handled;
+  Presentation presentation;
+};
+
+using CompletionCallback =
+    std::function<void(uint64_t, int32_t, bool)>;
+
+void setCompletionCallback(
+    const void *owner,
+    CompletionCallback callback);
+void clearCompletionCallback(const void *owner);
+
+void setPresentation(
+    uint64_t driverId,
+    Presentation presentation,
+    bool takeOwnership);
+Presentation beginInteraction(uint64_t driverId);
+int32_t animateTiming(
+    uint64_t driverId,
+    AnimationStart start,
+    Presentation presentation,
+    TimingAnimation animation);
+int32_t animateSpring(
+    uint64_t driverId,
+    AnimationStart start,
+    Presentation presentation,
+    SpringAnimation animation);
+int32_t animateKeyframes(
+    uint64_t driverId,
+    AnimationStart start,
+    Presentation presentation,
+    double durationMs,
+    std::vector<Keyframe> keyframes,
+    int32_t reduceMotion);
+int32_t rejectAnimation(uint64_t driverId);
+CancelResult cancelAnimation(
+    uint64_t driverId,
+    int32_t animationId,
+    bool useTarget);
+void destroyDriver(uint64_t driverId);
+
+} // namespace smoothclip

package/cpp/SmoothClipSharedGeometry.h

@@ -0,0 +1,50 @@
+#pragma once
+
+#include <algorithm>
+#include <cmath>
+
+namespace smoothclip {
+
+struct NormalizedClip {
+  double left = 0;
+  double top = 0;
+  double right = 0;
+  double bottom = 0;
+  double radius = 0;
+};
+
+// 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(
+    double x,
+    double y,
+    double width,
+    double height,
+    double radius,
+    double hostWidth,
+    double hostHeight,
+    NormalizedClip &out) {
+  if (!std::isfinite(x) || !std::isfinite(y) || !std::isfinite(width) ||
+      !std::isfinite(height) || !std::isfinite(radius) ||
+      !std::isfinite(hostWidth) || !std::isfinite(hostHeight)) {
+    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);
+  out.radius = std::min(
+      std::max(0.0, radius), std::min(visibleWidth, visibleHeight) / 2.0);
+  return true;
+}
+
+} // namespace smoothclip

package/ios/SmoothClipModuleProvider.h

@@ -0,0 +1,9 @@
+#import <Foundation/Foundation.h>
+#import <ReactCommon/RCTTurboModule.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface SmoothClipModuleProvider : NSObject <RCTModuleProvider>
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/SmoothClipModuleProvider.mm

@@ -0,0 +1,16 @@
+#import "SmoothClipModuleProvider.h"
+
+#import "SmoothClipTurboModule.h"
+
+#import <ReactCommon/CallInvoker.h>
+#import <ReactCommon/TurboModule.h>
+
+@implementation SmoothClipModuleProvider
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params {
+  return std::make_shared<facebook::react::SmoothClipTurboModule>(
+      params.jsInvoker);
+}
+
+@end