@rafaelaugusto/jolt 0.1.0-beta.6 → 0.1.0-beta.8

package/platforms/ios/src/JoltInteractiveAnimation.m

@@ -0,0 +1,123 @@
+#import "JoltInteractiveAnimation.h"
+#import <QuartzCore/QuartzCore.h>
+
+@interface JoltInteractiveAnimation ()
+@property(nonatomic, weak) UIView *view;
+@property(nonatomic, copy) NSArray<CALayer *> *layers;
+@property(nonatomic, copy) NSString *keyPath;
+@property(nonatomic, copy) NSArray<NSNumber *> *values;
+@property(nonatomic, copy) NSArray<NSNumber *> *times;
+@property(nonatomic) double duration, delay, repeats, anchor, offset, finalValue;
+@property(nonatomic) BOOL reverse, paused, stopped;
+@property(nonatomic, copy, nullable) void (^completion)(BOOL);
+@end
+
+@implementation JoltInteractiveAnimation
+static NSMapTable<UIView *, NSMutableDictionary<NSString *, JoltInteractiveAnimation *> *> *views;
+static NSMutableSet<JoltInteractiveAnimation *> *playing;
+static CADisplayLink *displayLink;
+
++ (void)initialize {
+    if (self != [JoltInteractiveAnimation class]) return;
+    views = [NSMapTable weakToStrongObjectsMapTable];
+    playing = [NSMutableSet new];
+}
++ (void)schedule {
+    if (playing.count && !displayLink) {
+        displayLink = [CADisplayLink displayLinkWithTarget:self selector:@selector(tick:)];
+        if (@available(iOS 15.0, *)) {
+            float maximum = MIN(120, UIScreen.mainScreen.maximumFramesPerSecond);
+            displayLink.preferredFrameRateRange = CAFrameRateRangeMake(MIN(80, maximum), maximum, maximum);
+        }
+        [displayLink addToRunLoop:NSRunLoop.mainRunLoop forMode:NSRunLoopCommonModes];
+    } else if (!playing.count && displayLink) {
+        [displayLink invalidate]; displayLink = nil;
+    }
+}
++ (void)tick:(CADisplayLink *)link {
+    for (JoltInteractiveAnimation *track in playing.allObjects) {
+        if (track.stopped || track.paused) continue;
+        if (!track.view) { [track finish:NO]; continue; }
+        double elapsed = track.elapsed;
+        [track apply:elapsed];
+        if (isfinite(track.repeats) && elapsed >= track.delay + track.duration * (track.repeats + 1))
+            [track finish:YES];
+    }
+}
++ (instancetype)startView:(UIView *)view layers:(NSArray<CALayer *> *)layers keyPath:(NSString *)keyPath
+                  values:(NSArray<NSNumber *> *)values times:(NSArray<NSNumber *> *)times
+                duration:(double)duration delay:(double)delay repeat:(double)repeat
+                 reverse:(BOOL)reverse finalValue:(double)finalValue
+               startedAt:(double)startedAt completion:(void (^)(BOOL))completion {
+    JoltInteractiveAnimation *track = [self new];
+    track.view = view; track.layers = layers; track.keyPath = keyPath; track.values = values; track.times = times;
+    track.duration = MAX(1, duration); track.delay = delay; track.repeats = repeat;
+    track.reverse = reverse; track.finalValue = finalValue;
+    track.anchor = startedAt; track.completion = completion;
+    NSMutableDictionary *properties = [views objectForKey:view];
+    if (!properties) { properties = [NSMutableDictionary new]; [views setObject:properties forKey:view]; }
+    JoltInteractiveAnimation *previous = properties[keyPath];
+    [previous cancel];
+    // Cancelling the last property can remove the dictionary from the weak map.
+    [views setObject:properties forKey:view];
+    properties[keyPath] = track;
+    [track apply:track.elapsed];
+    [playing addObject:track]; [self schedule];
+    return track;
+}
+- (double)elapsed { return self.offset + (self.paused ? 0 : CACurrentMediaTime() * 1000 - self.anchor); }
+- (double)value:(double)elapsed {
+    double total = self.delay + self.duration * (self.repeats + 1);
+    if (isfinite(total) && elapsed >= total) return self.finalValue;
+    double time = MAX(0, elapsed - self.delay);
+    double iteration = floor(time / self.duration);
+    double progress = fmod(time, self.duration) / self.duration;
+    if (self.reverse && fmod(iteration, 2) >= 1) progress = 1 - progress;
+    NSUInteger low = 0, high = self.times.count - 1;
+    while (low + 1 < high) {
+        NSUInteger middle = (low + high) / 2;
+        if (self.times[middle].doubleValue <= progress) low = middle; else high = middle;
+    }
+    double start = self.times[low].doubleValue, end = self.times[high].doubleValue;
+    double fraction = end > start ? MIN(1, MAX(0, (progress - start) / (end - start))) : 1;
+    return self.values[low].doubleValue + (self.values[high].doubleValue - self.values[low].doubleValue) * fraction;
+}
+- (void)apply:(double)elapsed {
+    UIView *view = self.view;
+    if (!view || self.stopped) return;
+    double value = [self value:elapsed];
+    [CATransaction begin]; [CATransaction setDisableActions:YES];
+    if ([self.keyPath isEqualToString:@"opacity"]) view.alpha = value;
+    for (CALayer *layer in self.layers) [layer setValue:@(value) forKeyPath:self.keyPath];
+    [CATransaction commit];
+}
+- (void)control:(double)elapsed paused:(BOOL)paused {
+    if (self.stopped) return;
+    self.offset = elapsed; self.anchor = CACurrentMediaTime() * 1000; self.paused = paused;
+    [self apply:elapsed];
+    if (paused) [playing removeObject:self]; else [playing addObject:self];
+    [[self class] schedule];
+}
+- (void)finish:(BOOL)completed {
+    if (self.stopped) return;
+    self.stopped = YES;
+    [playing removeObject:self];
+    UIView *view = self.view;
+    NSMutableDictionary *properties = view ? [views objectForKey:view] : nil;
+    if (properties[self.keyPath] == self) [properties removeObjectForKey:self.keyPath];
+    if (view && !properties.count) [views removeObjectForKey:view];
+    void (^callback)(BOOL) = self.completion; self.completion = nil;
+    [[self class] schedule];
+    if (callback) callback(completed);
+}
+- (void)cancel { [self finish:NO]; }
++ (void)syncView:(UIView *)view excluding:(NSString *)keyPath {
+    for (JoltInteractiveAnimation *track in [views objectForKey:view].allValues)
+        if (![track.keyPath isEqualToString:keyPath]) [track apply:track.elapsed];
+}
++ (NSNumber *)valueForView:(UIView *)view keyPath:(NSString *)keyPath {
+    JoltInteractiveAnimation *track = [views objectForKey:view][keyPath];
+    return track ? [view.layer valueForKeyPath:keyPath] : nil;
+}
++ (NSUInteger)activeCount { return playing.count; }
+@end

package/platforms/ios/src/JoltPhotoZoom.h

@@ -0,0 +1,23 @@
+#import <UIKit/UIKit.h>
+NS_ASSUME_NONNULL_BEGIN
+@interface JoltPhotoZoom : NSObject
++ (instancetype)attachImage:(UIImageView *)image viewport:(UIView *)viewport
+                    minimum:(double)minimum maximum:(double)maximum doubleTap:(double)doubleTap
+                    dismiss:(BOOL)dismiss reduced:(BOOL)reduced
+                   backdrop:(nullable UIView *)backdrop chrome:(nullable UIView *)chrome
+                  onDismiss:(void (^)(double,double,double,double,double))onDismiss
+                  onSettled:(void (^)(double,double,double))onSettled;
+@property(nonatomic, readonly) double x;
+@property(nonatomic, readonly) double y;
+@property(nonatomic, readonly) double scale;
+@property(nonatomic, readonly) double dismissProgress;
+@property(nonatomic, readonly) BOOL dismissPending;
+- (void)zoom:(double)scale focusX:(double)x focusY:(double)y animated:(BOOL)animated;
+- (void)reset:(BOOL)animated;
+- (void)requestDismiss;
+- (void)setReduced:(BOOL)reduced;
+- (void)setActive:(BOOL)active;
+- (void)layout;
+- (void)stop;
+@end
+NS_ASSUME_NONNULL_END

package/platforms/ios/src/JoltPhotoZoom.m

@@ -0,0 +1,229 @@
+#import "JoltPhotoZoom.h"
+#import <QuartzCore/QuartzCore.h>
+
+static double JoltClamp(double v,double lo,double hi){return MAX(lo,MIN(hi,v));}
+static double JoltRubber(double v,double lo,double hi,double size){
+    double edge=JoltClamp(v,lo,hi),d=v-edge;
+    return edge+copysign(size*(1-1/(fabs(d)*.55/MAX(size,1)+1)),d);
+}
+
+@interface JoltPhotoZoom () <UIGestureRecognizerDelegate>
+@property(nonatomic,weak) UIImageView *image;
+@property(nonatomic,weak) UIView *viewport,*backdrop,*chrome;
+@property(nonatomic,strong) UIPinchGestureRecognizer *pinch;
+@property(nonatomic,strong) UIPanGestureRecognizer *pan;
+@property(nonatomic,strong) UITapGestureRecognizer *tap;
+@property(nonatomic,strong) CADisplayLink *clock;
+@property(nonatomic,copy) void (^onDismiss)(double,double,double,double,double);
+@property(nonatomic,copy) void (^onSettled)(double,double,double);
+@property(nonatomic) CGAffineTransform original;
+@property(nonatomic) BOOL originalInteraction,originalClip,reduced,active,disposed,dismiss,closing;
+@property(nonatomic) double minimum,maximum,doubleTap,backdropAlpha,chromeAlpha;
+@property(nonatomic,readwrite) double x,y,scale,dismissProgress;
+@property(nonatomic,readwrite) BOOL dismissPending;
+@property(nonatomic) CGPoint anchor,lastFocus,lastPan,initialTranslation;
+@property(nonatomic) CGPoint rawPan;
+@property(nonatomic) double pinchFloor;
+@property(nonatomic) CGRect content;
+@property(nonatomic) CGSize viewportSize,imageSize;
+@property(nonatomic) NSInteger mode,touches;
+@property(nonatomic) double vx,vy,startTime,startX,startY,startScale,startProgress,targetX,targetY,targetScale;
+@end
+
+@implementation JoltPhotoZoom
++ (instancetype)attachImage:(UIImageView *)image viewport:(UIView *)viewport
+                    minimum:(double)minimum maximum:(double)maximum doubleTap:(double)doubleTap
+                    dismiss:(BOOL)dismiss reduced:(BOOL)reduced backdrop:(UIView *)backdrop chrome:(UIView *)chrome
+                  onDismiss:(void (^)(double,double,double,double,double))onDismiss
+                  onSettled:(void (^)(double,double,double))onSettled {
+    JoltPhotoZoom *z=[JoltPhotoZoom new];
+    z.image=image;z.viewport=viewport;z.backdrop=backdrop;z.chrome=chrome;
+    z.minimum=minimum;z.maximum=maximum;z.doubleTap=doubleTap;z.dismiss=dismiss;z->_reduced=reduced;z.active=YES;
+    z.onDismiss=onDismiss;z.onSettled=onSettled;
+    z.original=image.transform;z.originalInteraction=viewport.userInteractionEnabled;z.originalClip=viewport.clipsToBounds;
+    z.backdropAlpha=backdrop?backdrop.alpha:1;z.chromeAlpha=chrome?chrome.alpha:1;z.scale=minimum;
+    z.pan=[[UIPanGestureRecognizer alloc] initWithTarget:z action:@selector(panned:)];
+    z.pinch=[[UIPinchGestureRecognizer alloc] initWithTarget:z action:@selector(pinched:)];
+    z.tap=[[UITapGestureRecognizer alloc] initWithTarget:z action:@selector(tapped:)];
+    z.tap.numberOfTapsRequired=2;z.pan.delegate=z;z.pinch.delegate=z;z.tap.delegate=z;
+    [viewport addGestureRecognizer:z.pan];[viewport addGestureRecognizer:z.pinch];[viewport addGestureRecognizer:z.tap];
+    viewport.userInteractionEnabled=YES;viewport.clipsToBounds=YES;
+    [z measure];[z apply];
+    return z;
+}
+- (void)measure {
+    self.viewportSize=self.viewport.bounds.size;self.imageSize=self.image.bounds.size;
+    CGSize intrinsic=self.image.image.size;
+    double iw=self.imageSize.width,ih=self.imageSize.height,dw=intrinsic.width,dh=intrinsic.height;
+    if(dw<=0 || dh<=0){dw=iw;dh=ih;}
+    UIViewContentMode fit=self.image.contentMode;
+    double factor=fit==UIViewContentModeScaleAspectFill?MAX(iw/dw,ih/dh):MIN(iw/dw,ih/dh);
+    if(fit==UIViewContentModeScaleToFill){dw=iw;dh=ih;}
+    else if(fit!=UIViewContentModeCenter && fit!=UIViewContentModeTopLeft){dw*=factor;dh*=factor;}
+    CGPoint pivot=CGPointMake(self.image.layer.anchorPoint.x*iw,self.image.layer.anchorPoint.y*ih);
+    self.anchor=CGPointMake(self.image.layer.position.x+self.original.tx,self.image.layer.position.y+self.original.ty);
+    double ox=fit==UIViewContentModeTopLeft?0:(iw-dw)/2,oy=fit==UIViewContentModeTopLeft?0:(ih-dh)/2;
+    double left=MAX(0,ox),top=MAX(0,oy),right=MIN(iw,ox+dw),bottom=MIN(ih,oy+dh);
+    self.content=CGRectMake((left-pivot.x)*self.original.a,(top-pivot.y)*self.original.d,(right-left)*self.original.a,(bottom-top)*self.original.d);
+}
+- (CGRect)boundsFor:(double)scale {
+    double loX=self.viewportSize.width-self.anchor.x-CGRectGetMaxX(self.content)*scale;
+    double hiX=-self.anchor.x-CGRectGetMinX(self.content)*scale;
+    double loY=self.viewportSize.height-self.anchor.y-CGRectGetMaxY(self.content)*scale;
+    double hiY=-self.anchor.y-CGRectGetMinY(self.content)*scale;
+    if(loX>hiX)loX=hiX=(loX+hiX)/2;
+    if(loY>hiY)loY=hiY=(loY+hiY)/2;
+    return CGRectMake(loX,loY,hiX-loX,hiY-loY);
+}
+- (void)apply {
+    self.image.transform=CGAffineTransformMake(self.original.a*self.scale,0,0,self.original.d*self.scale,self.original.tx+self.x,self.original.ty+self.y);
+    self.backdrop.alpha=self.backdropAlpha*(1-self.dismissProgress);
+    self.chrome.alpha=self.chromeAlpha*(1-self.dismissProgress);
+}
+- (void)zoom:(double)value focusX:(double)fx focusY:(double)fy animated:(BOOL)animated {
+    if(self.disposed || self.dismissPending)return;
+    [self cancelAnimation];double next=JoltClamp(value,self.minimum,self.maximum);
+    double x=fx-self.anchor.x-(fx-self.anchor.x-self.x)*next/self.scale;
+    double y=fy-self.anchor.y-(fy-self.anchor.y-self.y)*next/self.scale;
+    CGRect b=[self boundsFor:next];
+    [self springX:JoltClamp(x,CGRectGetMinX(b),CGRectGetMaxX(b)) y:JoltClamp(y,CGRectGetMinY(b),CGRectGetMaxY(b)) scale:next vx:0 vy:0 animated:animated close:NO];
+}
+- (void)reset:(BOOL)animated {
+    if(self.disposed)return;
+    self.dismissPending=NO;self.mode=0;CGRect b=[self boundsFor:self.minimum];
+    [self springX:JoltClamp(0,CGRectGetMinX(b),CGRectGetMaxX(b)) y:JoltClamp(0,CGRectGetMinY(b),CGRectGetMaxY(b)) scale:self.minimum vx:0 vy:0 animated:animated close:NO];
+}
+- (void)requestDismiss {
+    if(self.disposed || self.dismissPending || !self.dismiss)return;
+    CGRect b=[self boundsFor:self.minimum];
+    [self springX:JoltClamp(0,CGRectGetMinX(b),CGRectGetMaxX(b)) y:JoltClamp(0,CGRectGetMinY(b),CGRectGetMaxY(b)) scale:self.minimum vx:0 vy:0 animated:YES close:YES];
+}
+- (void)setReduced:(BOOL)reduced { _reduced=reduced;if(reduced){if(self.dismissPending)[self reset:NO];else [self settle:NO];} }
+- (void)setActive:(BOOL)active {
+    _active=active;self.pan.enabled=active;self.pinch.enabled=active;self.tap.enabled=active;
+    if(!active){[self cancelAnimation];self.dismissPending=NO;[self reset:NO];}
+}
+- (void)layout {
+    if(self.disposed)return;
+    if(CGSizeEqualToSize(self.viewportSize,self.viewport.bounds.size) && CGSizeEqualToSize(self.imageSize,self.image.bounds.size))return;
+    [self cancelAnimation];self.dismissPending=NO;[self measure];self.vx=0;self.vy=0;self.mode=0;[self settle:NO];
+}
+- (void)stop {
+    if(self.disposed)return;
+    self.disposed=YES;[self cancelAnimation];
+    [self.viewport removeGestureRecognizer:self.pan];[self.viewport removeGestureRecognizer:self.pinch];[self.viewport removeGestureRecognizer:self.tap];
+    self.viewport.userInteractionEnabled=self.originalInteraction;self.viewport.clipsToBounds=self.originalClip;
+    self.image.transform=self.original;self.backdrop.alpha=self.backdropAlpha;self.chrome.alpha=self.chromeAlpha;
+    self.onDismiss=nil;self.onSettled=nil;
+}
+- (void)cancelAnimation { [self.clock invalidate];self.clock=nil;self.closing=NO; }
+- (void)springX:(double)x y:(double)y scale:(double)scale vx:(double)vx vy:(double)vy animated:(BOOL)animated close:(BOOL)close {
+    [self cancelAnimation];
+    if(!animated || self.reduced){
+        self.x=x;self.y=y;self.scale=scale;self.dismissProgress=0;[self apply];
+        if(close)[self emitDismiss:0];else if(self.onSettled)self.onSettled(x,y,scale);
+        return;
+    }
+    self.startX=self.x;self.startY=self.y;self.startScale=self.scale;self.startProgress=self.dismissProgress;
+    self.targetX=x;self.targetY=y;self.targetScale=scale;self.vx=vx;self.vy=vy;self.closing=close;
+    self.startTime=CACurrentMediaTime();self.clock=[CADisplayLink displayLinkWithTarget:self selector:@selector(tick:)];
+    self.clock.preferredFramesPerSecond=MIN(120,self.viewport.window.screen.maximumFramesPerSecond);
+    [self.clock addToRunLoop:NSRunLoop.mainRunLoop forMode:NSRunLoopCommonModes];
+}
+- (void)tick:(CADisplayLink *)clock {
+    double t=MIN(.55,MAX(0,CACurrentMediaTime()-self.startTime)),decay=exp(-16*t);
+    self.x=self.targetX+((self.startX-self.targetX)+(self.vx+16*(self.startX-self.targetX))*t)*decay;
+    self.y=self.targetY+((self.startY-self.targetY)+(self.vy+16*(self.startY-self.targetY))*t)*decay;
+    self.scale=self.targetScale+(self.startScale-self.targetScale)*(1+16*t)*decay;
+    self.dismissProgress=self.startProgress*(1+16*t)*decay;
+    if(t>=.55){self.x=self.targetX;self.y=self.targetY;self.scale=self.targetScale;self.dismissProgress=0;}
+    [self apply];
+    if(t>=.55){BOOL close=self.closing;[self cancelAnimation];if(close)[self emitDismiss:0];else if(self.onSettled)self.onSettled(self.x,self.y,self.scale);}
+}
+- (void)settle:(BOOL)animated {
+    if(self.disposed)return;
+    double s=JoltClamp(self.scale,self.minimum,self.maximum);CGRect b=[self boundsFor:s];
+    double x=JoltClamp(self.x+self.vx*.12,CGRectGetMinX(b),CGRectGetMaxX(b));
+    double y=JoltClamp(self.y+self.vy*.12,CGRectGetMinY(b),CGRectGetMaxY(b));
+    if(self.mode==2){s=self.minimum;b=[self boundsFor:s];x=JoltClamp(0,CGRectGetMinX(b),CGRectGetMaxX(b));y=JoltClamp(0,CGRectGetMinY(b),CGRectGetMaxY(b));}
+    [self springX:x y:y scale:s vx:self.vx vy:self.vy animated:animated close:NO];
+}
+- (void)emitDismiss:(double)velocity {
+    if(self.disposed || self.dismissPending)return;
+    self.dismissPending=YES;
+    if(self.onDismiss)self.onDismiss(self.x,self.y,self.scale,velocity,self.dismissProgress);
+}
+- (void)pinched:(UIPinchGestureRecognizer *)gesture {
+    if(self.disposed || self.dismissPending)return;
+    CGPoint focus=[gesture locationInView:self.viewport];
+    if(gesture.state==UIGestureRecognizerStateBegan){
+        [self cancelAnimation];self.mode=1;self.pinchFloor=MIN(self.minimum,self.scale);self.lastFocus=focus;gesture.scale=1;
+    } else if(gesture.state==UIGestureRecognizerStateChanged){
+        double next=JoltClamp(self.scale*gesture.scale,self.pinchFloor,self.maximum);
+        self.x=focus.x-self.anchor.x-(self.lastFocus.x-self.anchor.x-self.x)*next/self.scale;
+        self.y=focus.y-self.anchor.y-(self.lastFocus.y-self.anchor.y-self.y)*next/self.scale;
+        self.scale=next;self.lastFocus=focus;gesture.scale=1;
+        self.dismissProgress=JoltClamp((self.minimum-self.scale)/(self.minimum*.15),0,1);
+        [self rebasePan];[self apply];
+    } else if(gesture.state==UIGestureRecognizerStateEnded || gesture.state==UIGestureRecognizerStateCancelled){
+        self.lastPan=[self.pan translationInView:self.viewport];self.touches=self.pan.numberOfTouches;
+        self.vx=0;self.vy=0;
+        if(self.pan.state!=UIGestureRecognizerStateChanged && self.pan.state!=UIGestureRecognizerStateBegan)[self settle:YES];
+    }
+}
+- (void)panned:(UIPanGestureRecognizer *)gesture {
+    if(self.disposed || self.dismissPending)return;
+    CGPoint translation=[gesture translationInView:self.viewport];
+    if(gesture.state==UIGestureRecognizerStateBegan){
+        [self cancelAnimation];self.vx=0;self.vy=0;self.lastPan=CGPointZero;self.touches=gesture.numberOfTouches;
+        [self rebasePan];
+        self.mode=self.scale<=self.minimum+.001 && self.pinch.state!=UIGestureRecognizerStateBegan && self.pinch.state!=UIGestureRecognizerStateChanged?2:1;
+    }
+    if(gesture.state==UIGestureRecognizerStateBegan || gesture.state==UIGestureRecognizerStateChanged){
+        if(self.pinch.state==UIGestureRecognizerStateBegan || self.pinch.state==UIGestureRecognizerStateChanged || self.touches!=gesture.numberOfTouches){
+            self.lastPan=translation;self.touches=gesture.numberOfTouches;[self rebasePan];return;
+        }
+        double dx=translation.x-self.lastPan.x,dy=translation.y-self.lastPan.y;
+        self.lastPan=translation;
+        if(self.mode==2){
+            self.x+=dx*.4;self.y+=dy;self.dismissProgress=JoltClamp(fabs(self.y)/MAX(self.viewportSize.height*.5,1),0,1);
+            self.scale=self.minimum*(1-self.dismissProgress*.15);
+        }else{
+            CGRect b=[self boundsFor:self.scale];
+            self.rawPan=CGPointMake(self.rawPan.x+dx,self.rawPan.y+dy);
+            self.x=JoltRubber(self.rawPan.x,CGRectGetMinX(b),CGRectGetMaxX(b),self.viewportSize.width);
+            self.y=JoltRubber(self.rawPan.y,CGRectGetMinY(b),CGRectGetMaxY(b),self.viewportSize.height);
+        }
+        [self apply];
+    }else if(gesture.state==UIGestureRecognizerStateEnded || gesture.state==UIGestureRecognizerStateCancelled || gesture.state==UIGestureRecognizerStateFailed){
+        CGPoint velocity=[gesture velocityInView:self.viewport];self.vx=velocity.x;self.vy=velocity.y;
+        BOOL commit=gesture.state==UIGestureRecognizerStateEnded && self.mode==2 &&
+            (self.dismissProgress>.35 || (fabs(velocity.y)>1000 && velocity.y*self.y>0));
+        if(commit)[self emitDismiss:velocity.y];
+        else if(self.pinch.state!=UIGestureRecognizerStateChanged && self.pinch.state!=UIGestureRecognizerStateBegan)[self settle:YES];
+    }
+}
+- (void)tapped:(UITapGestureRecognizer *)gesture {
+    if(gesture.state!=UIGestureRecognizerStateEnded || self.dismissPending)return;
+    CGPoint point=[gesture locationInView:self.viewport];
+    [self zoom:self.scale>self.minimum+.01?self.minimum:MIN(self.maximum,self.doubleTap) focusX:point.x focusY:point.y animated:YES];
+}
+- (void)rebasePan {
+    CGRect b=[self boundsFor:self.scale];
+    double ex=JoltClamp(self.x,CGRectGetMinX(b),CGRectGetMaxX(b)),ey=JoltClamp(self.y,CGRectGetMinY(b),CGRectGetMaxY(b));
+    double dx=self.x-ex,dy=self.y-ey;
+    self.rawPan=CGPointMake(ex+dx/(.55*MAX(.001,1-fabs(dx)/MAX(1,self.viewportSize.width))),
+                           ey+dy/(.55*MAX(.001,1-fabs(dy)/MAX(1,self.viewportSize.height))));
+}
+- (BOOL)gestureRecognizerShouldBegin:(UIGestureRecognizer *)gesture {
+    if(self.disposed || !self.active || self.dismissPending)return NO;
+    if(gesture==self.pan && self.scale<=self.minimum+.001){
+        CGPoint velocity=[self.pan velocityInView:self.viewport];
+        return self.dismiss && fabs(velocity.y)>fabs(velocity.x)*1.2;
+    }
+    return YES;
+}
+- (BOOL)gestureRecognizer:(UIGestureRecognizer *)one shouldRecognizeSimultaneouslyWithGestureRecognizer:(UIGestureRecognizer *)other {
+    return (one==self.pan && other==self.pinch)||(one==self.pinch && other==self.pan);
+}
+@end

package/platforms/ios/src/module.modulemap

@@ -0,0 +1,6 @@
+module JoltMotion {
+    header "JoltImageEffect.h"
+    header "JoltPhotoZoom.h"
+    header "JoltInteractiveAnimation.h"
+    export *
+}

package/src/android-plugin.d.ts

@@ -1,4 +1,82 @@
 declare namespace org.rafaelaugusto.jolt {
+  class PhotoZoom {
+    constructor(
+      image: android.widget.ImageView,
+      viewport: android.view.View,
+      bitmapWidth: number,
+      bitmapHeight: number,
+      minimum: number,
+      maximum: number,
+      doubleTap: number,
+      dismiss: boolean,
+      reduced: boolean,
+      backdrop: android.view.View | null,
+      chrome: android.view.View | null,
+      previousTouch: android.view.View.OnTouchListener | null,
+      previousImageTouch: android.view.View.OnTouchListener | null,
+      listener: PhotoZoom.Listener,
+    )
+    getX(): number
+    getY(): number
+    getScale(): number
+    getDismissProgress(): number
+    isDismissPending(): boolean
+    zoom(scale: number, x: number, y: number, animated: boolean): void
+    reset(animated: boolean): void
+    requestDismiss(): void
+    setReduced(value: boolean): void
+    setActive(value: boolean): void
+    stop(): void
+  }
+  namespace PhotoZoom {
+    class Listener {
+      constructor(implementation: {
+        onDismiss(
+          x: number,
+          y: number,
+          scale: number,
+          velocity: number,
+          progress: number,
+        ): void
+        onSettled(x: number, y: number, scale: number): void
+      })
+    }
+  }
+  class ImageEffect {
+    constructor(
+      image: android.widget.ImageView,
+      source: android.graphics.Bitmap | null,
+      destination: android.graphics.Bitmap | null,
+      geometry: androidNative.Array<number>,
+      mode: number,
+      x: number,
+      y: number,
+      amplitude: number,
+      radius: number,
+      duration: number,
+      seed: number,
+      previousTouch: android.view.View.OnTouchListener | null,
+      listener: ImageEffect.Listener,
+    )
+    isSupported(): boolean
+    getFailureReason(): string
+    getProgress(): number
+    getFrames(): number
+    getTextureBytes(): number
+    getLongestFrameNanos(): number
+    play(endpoint: number): void
+    pause(): void
+    resume(): void
+    seek(progress: number): void
+    finish(endpoint: number): void
+    stop(): void
+    stopPreservingImage(): void
+  }
+  namespace ImageEffect {
+    class Listener {
+      constructor(implementation: { onEnd(completed: boolean, progress: number): void })
+    }
+  }
   class KeyboardFollower {
     constructor(
       view: android.view.View,

package/src/animate.ts

@@ -67,6 +67,15 @@ export function animate(
   animation: Keyframes | PresetName,
   options?: AnimateOptions | SpringName,
 ): PlaybackAnimation {
+  return prepareAnimation(target, animation, options)()
+}
+
+/** Validate and snapshot a complete animation before changing any view ownership. */
+export function prepareAnimation(
+  target: Target | readonly Target[],
+  animation: Keyframes | PresetName,
+  options?: AnimateOptions | SpringName,
+): () => PlaybackAnimation {
   const { keyframes, base, overrides, stagger, relative, haptic, path } = prepare(
     animation,
     options,
@@ -78,11 +87,8 @@ export function animate(
     for (const property of Object.keys(keyframes))
       if (isColorProperty(property)) validateColorTarget(view, property)
       else if (isDecorationProperty(property)) validateDecorationTarget(view, property)
-    return new ViewAnimation(
-      view,
-      plan(keyframes, base, overrides, 0, relative, path),
-      feedback,
-    )
+    const plans = plan(keyframes, base, overrides, 0, relative, path)
+    return () => new ViewAnimation(view, plans, feedback)
   }
 
   const views = target.map(toView)
@@ -100,9 +106,10 @@ export function animate(
       path,
     ),
   )
-  return playbackGroup(
-    views.map((view, index) => new ViewAnimation(view, plans[index]!, feedback, true)),
-  )
+  return () =>
+    playbackGroup(
+      views.map((view, index) => new ViewAnimation(view, plans[index]!, feedback, true)),
+    )
 }
 
 /** Starts at the current translation and slows down from a velocity in DIPs per second. */

package/src/drag-input.ts

@@ -0,0 +1,74 @@
+import { Utils, type PanGestureEventData, type View } from '@nativescript/core'
+import { getDriver } from './driver/index.js'
+
+interface Sample {
+  x: number
+  y: number
+  time: number
+}
+
+/** Android's raw coordinates avoid feedback from translating the touched view. */
+export class DragInput {
+  private samples: Sample[] = []
+  private lastMoved = 0
+  reset() {
+    this.samples = []
+    this.lastMoved = 0
+  }
+  read(event: PanGestureEventData, view: View) {
+    const ios = event.ios as UIPanGestureRecognizer | undefined
+    const android = event.android?.current as android.view.MotionEvent | undefined
+    const parent = view.parent?.nativeViewProtected ?? view.nativeViewProtected
+    const delta = ios
+      ? ios.translationInView(parent)
+      : { x: event.deltaX, y: event.deltaY }
+    const density = Utils.layout.getDisplayDensity()
+    const sample: Sample = android
+      ? {
+          x: android.getRawX() / density,
+          y: android.getRawY() / density,
+          time: Number(android.getEventTime()),
+        }
+      : { ...delta, time: getDriver().now() }
+    if (
+      Number.isFinite(sample.x) &&
+      Number.isFinite(sample.y) &&
+      Number.isFinite(sample.time)
+    ) {
+      const previous = this.samples.at(-1)
+      if (!previous || sample.x !== previous.x || sample.y !== previous.y)
+        this.lastMoved = sample.time
+      // Replace duplicate times (Android sends began + changed for the same event).
+      if (this.samples.at(-1)?.time === sample.time) this.samples.pop()
+      this.samples.push(sample)
+      while (this.samples.length > 2 && this.samples[1]!.time < sample.time - 100)
+        this.samples.shift()
+    }
+    const first = this.samples[0]
+    const elapsed = first ? sample.time - first.time : 0
+    // UIKit may retain its last movement velocity when the finger holds still
+    // before lifting. A stale velocity must not turn that hold into a fling.
+    const nativeVelocity = ios
+      ? sample.time - this.lastMoved > 100
+        ? { x: 0, y: 0 }
+        : ios.velocityInView(parent)
+      : undefined
+    const velocity = nativeVelocity ?? {
+      x: elapsed > 0 && elapsed <= 150 ? ((sample.x - first!.x) * 1000) / elapsed : 0,
+      y: elapsed > 0 && elapsed <= 150 ? ((sample.y - first!.y) * 1000) / elapsed : 0,
+    }
+    const action = android?.getActionMasked()
+    return {
+      x: delta.x,
+      y: delta.y,
+      velocityX: Number.isFinite(velocity.x) ? velocity.x : 0,
+      velocityY: Number.isFinite(velocity.y) ? velocity.y : 0,
+      cancelled:
+        event.state === 0 ||
+        action === 3 ||
+        action === 5 ||
+        action === 6 ||
+        (android ? android.getPointerCount() > 1 : (ios?.numberOfTouches ?? 1) > 1),
+    }
+  }
+}