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

package/src/driverTypes.ts

@@ -1,5 +1,8 @@
 import type { SharedValue } from 'react-native-reanimated';
-import type { SmoothClipPresentation } from './geometry';
+import type {
+  CanonicalSmoothClipPresentation,
+  SmoothClipPresentation,
+} from './geometry';
 
 export type ClipReduceMotion = 'system' | 'always' | 'never';
 
@@ -13,12 +16,11 @@ type ClipAnimationBase = Readonly<{
    * reached native — a gated per-frame reaction may not have flushed it.
    * Also re-grabs from a running animation (which an implicit interactive
    * start would silently skip). Non-finite `from` rejects the whole call.
-   * On the native drivers `driver.presentation.value` is not written from
-   * `from` (it stays stale until success sets it to the target); the web
-   * fallback does write it — its presentation SharedValue is the render
-   * channel itself. Against a held pending-animation latch, explicit `from`
-   * is newer intent: the fused write cancels that latch once unfinished,
-   * applies `from`, and starts the replacement from that native value.
+   * `driver.presentation.value` is not written from `from`; it stays stale
+   * until success sets it to the target. Against a held pending-animation
+   * latch, explicit `from` is newer intent: the fused write cancels that latch
+   * once unfinished, applies `from`, and starts the replacement from that
+   * native value.
    *
    * Keyframes interpolate absolutely, so pass `frames[0].presentation` —
    * the seed renders it before the first animation frame, making the
@@ -69,10 +71,24 @@ export type ClipAnimationResult = Readonly<{
 export type SmoothClipDriverOptions = Readonly<{
   reduceMotion?: ClipReduceMotion;
   onAnimationComplete?: (result: ClipAnimationResult) => void;
+  /**
+   * Android only; captured at driver creation. Records two-sample velocity
+   * history on `setScalars` hot writes so a spring `initialVelocity: 'inherit'`
+   * can project its launch speed from the live drag. Off by default: the
+   * recording (a clock read plus channel copies) rides the per-frame
+   * `setScalars` hot path, and drivers that never hand off into an inherit
+   * spring should not pay it. Without this flag, `'inherit'` inherits 0 after
+   * a `setScalars` drag on Android (each skipped write also invalidates older
+   * samples, so stale pre-drag motion never leaks in). `set()`, the fused
+   * `animateTo` `from` seed, and the declarative `presentation.value` channel
+   * always record regardless of the flag. iOS always records; the flag is a
+   * no-op there.
+   */
+  velocityTracking?: boolean;
 }>;
 
 export type SmoothClipUIControls = Readonly<{
-  beginInteraction(): SmoothClipPresentation;
+  beginInteraction(): CanonicalSmoothClipPresentation;
   set(presentation: SmoothClipPresentation): void;
   /**
    * Per-frame hot path: writes geometry straight to native without touching
@@ -95,6 +111,24 @@ export type SmoothClipUIControls = Readonly<{
     contentTranslateX: number,
     contentTranslateY: number
   ): void;
+  /**
+   * V2 per-frame hot path. Curve code is 0 for circular and 1 for continuous;
+   * invalid codes reject the complete write.
+   */
+  setPresentationScalars(
+    x: number,
+    y: number,
+    width: number,
+    height: number,
+    topLeftRadius: number,
+    topRightRadius: number,
+    bottomRightRadius: number,
+    bottomLeftRadius: number,
+    curveCode: number,
+    contentTranslateX: number,
+    contentTranslateY: number,
+    contentScale: number
+  ): void;
   animateTo(
     presentation: SmoothClipPresentation,
     animation: SmoothClipAnimation
@@ -102,11 +136,11 @@ export type SmoothClipUIControls = Readonly<{
   cancel(
     animationId?: number,
     behavior?: 'current' | 'target'
-  ): SmoothClipPresentation;
+  ): CanonicalSmoothClipPresentation;
 }>;
 
 export type SmoothClipReactControls = Readonly<{
-  beginInteraction(): Promise<SmoothClipPresentation>;
+  beginInteraction(): Promise<CanonicalSmoothClipPresentation>;
   set(presentation: SmoothClipPresentation): Promise<void>;
   animateTo(
     presentation: SmoothClipPresentation,
@@ -115,7 +149,16 @@ export type SmoothClipReactControls = Readonly<{
   cancel(
     animationId?: number,
     behavior?: 'current' | 'target'
-  ): Promise<SmoothClipPresentation>;
+  ): Promise<CanonicalSmoothClipPresentation>;
+}>;
+
+/** @internal Worklet-serializable driver identity used by atomic groups. */
+export type SmoothClipDriverHandle = Readonly<{
+  driverId: number;
+  presentation: SharedValue<SmoothClipPresentation>;
+  ownership: SharedValue<number>;
+  activeAnimationId: SharedValue<number>;
+  disposed: SharedValue<number>;
 }>;
 
 export type SmoothClipDriver = Readonly<{
@@ -123,4 +166,6 @@ export type SmoothClipDriver = Readonly<{
   presentation: SharedValue<SmoothClipPresentation>;
   ui: SmoothClipUIControls;
   react: SmoothClipReactControls;
+  /** @internal Do not read or mutate directly. */
+  __smoothClipHandle?: SmoothClipDriverHandle;
 }>;