@rafaelaugusto/jolt 0.1.0-beta.8 → 0.1.0-rc.1

package/platforms/ios/src/JoltCircleWorld.m

@@ -0,0 +1,203 @@
+#import "JoltCircleWorld.h"
+#import "JoltCircleMath.h"
+#import <QuartzCore/QuartzCore.h>
+
+@interface JoltCircleWorld () <UIGestureRecognizerDelegate> {
+    JoltCircleState state;
+    BOOL originalInteraction[16];
+    double touchOffsetX[16],touchOffsetY[16];
+    double initialX[16],initialY[16],initialVX[16],initialVY[16],originalX[16],originalY[16];
+}
+@property(nonatomic) UIView *container;
+@property(nonatomic) NSMutableArray *views,*pans,*guides;
+@property(nonatomic) CADisplayLink *link;
+@property(nonatomic) BOOL enabled,disposed,background,fits;
+@property(nonatomic) double previous,accumulator,processingMs,droppedMs,offsetX,offsetY;
+@property(nonatomic) NSUInteger frames,dragStarts,dragMoves,dragEnds,dragCancels;
+@property(nonatomic) NSInteger dragging;
+- (void)refresh;
+- (void)apply;
+- (void)cancelDrag;
+- (void)configureAttachment:(id)value index:(int)index;
+@end
+
+@implementation JoltCircleWorld
+static NSMutableSet<JoltCircleWorld *> *worlds;
++ (void)initialize { if(self==JoltCircleWorld.class)worlds=[NSMutableSet new]; }
++ (NSUInteger)worldCount{return worlds.count;}
++ (NSUInteger)activeCount{NSUInteger count=0;for(JoltCircleWorld *w in worlds)if(w.link)count++;return count;}
++ (instancetype)create:(UIView *)container options:(NSString *)options {
+    NSDictionary *config=[NSJSONSerialization JSONObjectWithData:[options dataUsingEncoding:NSUTF8StringEncoding] options:0 error:nil];
+    NSArray *bodies=config[@"bodies"];
+    if(bodies.count<1||bodies.count>16)[NSException raise:NSInvalidArgumentException format:@"Physics needs 1–16 circles"];
+    JoltCircleWorld *w=[self new];w.container=container;w.views=[NSMutableArray new];w.pans=[NSMutableArray new];w.guides=[NSMutableArray new];w.dragging=-1;
+    w->state.count=(int)bodies.count;w->state.width=[config[@"width"] doubleValue];w->state.height=[config[@"height"] doubleValue];
+    w->state.gx=[config[@"gravity"][@"x"] doubleValue];w->state.gy=[config[@"gravity"][@"y"] doubleValue];
+    w->state.restitution=[config[@"restitution"] doubleValue];w->state.damping=[config[@"damping"] doubleValue];
+    for(int i=0;i<bodies.count;i++){
+        NSDictionary *v=bodies[i];JoltCircle *b=&w->state.bodies[i];
+        b->x=[v[@"x"] doubleValue];b->y=[v[@"y"] doubleValue];b->r=[v[@"radius"] doubleValue];b->m=[v[@"mass"] doubleValue];
+        b->vx=[v[@"vx"] doubleValue];b->vy=[v[@"vy"] doubleValue];
+        w->initialX[i]=b->x/w->state.width;w->initialY[i]=b->y/w->state.height;w->initialVX[i]=b->vx;w->initialVY[i]=b->vy;
+        [w.views addObject:NSNull.null];[w.pans addObject:NSNull.null];[w.guides addObject:NSNull.null];
+        [w configureAttachment:v[@"attachment"] index:i];
+        id snap=v[@"snap"];
+        if([snap isKindOfClass:NSDictionary.class]){
+            NSArray *points=snap[@"points"];if(points.count>JOLT_CIRCLE_SNAP_LIMIT)[NSException raise:NSInvalidArgumentException format:@"Too many snap points"];
+            b->snap.count=(int)points.count;b->snap.stiffness=[snap[@"stiffness"] doubleValue];b->snap.damping=[snap[@"damping"] doubleValue];b->snap.projection=[snap[@"projection"] doubleValue];
+            for(int j=0;j<points.count;j++){b->snap.u[j]=[points[j][@"x"] doubleValue]/w->state.width;b->snap.v[j]=[points[j][@"y"] doubleValue]/w->state.height;}
+        }
+    }
+    w.fits=JoltCircleFits(&w->state,w->state.width,w->state.height);
+    w.background=UIApplication.sharedApplication.applicationState==UIApplicationStateBackground;
+    [[NSNotificationCenter defaultCenter] addObserver:w selector:@selector(backgrounded) name:UIApplicationDidEnterBackgroundNotification object:nil];
+    [[NSNotificationCenter defaultCenter] addObserver:w selector:@selector(foregrounded) name:UIApplicationDidBecomeActiveNotification object:nil];
+    [worlds addObject:w];return w;
+}
+- (void)configureAttachment:(id)value index:(int)index {
+    BOOL active=[value isKindOfClass:NSDictionary.class];
+    if(active)JoltCircleAttach(&state,index,true,[value[@"x"] doubleValue],[value[@"y"] doubleValue],[value[@"length"] doubleValue],[value[@"stiffness"] doubleValue],[value[@"damping"] doubleValue]);
+    else JoltCircleAttach(&state,index,false,0,0,0,180,24);
+    if(self.guides[index]!=NSNull.null){[(CALayer *)self.guides[index] removeFromSuperlayer];self.guides[index]=NSNull.null;}
+    id line=active?value[@"line"]:nil;
+    if([line isKindOfClass:NSDictionary.class]){
+        CAShapeLayer *guide=[CAShapeLayer layer];unsigned int color=[line[@"color"] unsignedIntValue];
+        guide.strokeColor=[UIColor colorWithRed:((color>>16)&255)/255.0 green:((color>>8)&255)/255.0 blue:(color&255)/255.0 alpha:1].CGColor;
+        guide.fillColor=nil;guide.contentsScale=UIScreen.mainScreen.scale;guide.lineWidth=[line[@"width"] doubleValue];guide.lineCap=kCALineCapRound;
+        [self.container.layer addSublayer:guide];self.guides[index]=guide;
+    }
+}
+- (void)attach:(NSInteger)index options:(NSString *)options {
+    if(self.disposed||index<0||index>=state.count)return;
+    id value=[NSJSONSerialization JSONObjectWithData:[options dataUsingEncoding:NSUTF8StringEncoding] options:NSJSONReadingFragmentsAllowed error:nil];
+    [self configureAttachment:value index:(int)index];[self apply];[self refresh];
+}
+- (void)snapTo:(NSInteger)index target:(NSInteger)target {
+    if(self.disposed||index<0||index>=state.count)return;
+    JoltCircleSnapTo(&state,(int)index,(int)target);[self apply];[self refresh];
+}
+- (void)connect:(UIView *)view index:(NSInteger)index {
+    if(self.disposed||index<0||index>=state.count)return;
+    if(view.superview!=self.container)[NSException raise:NSInvalidArgumentException format:@"Physics circles must be direct native children"];
+    self.views[index]=view;originalInteraction[index]=view.userInteractionEnabled;view.userInteractionEnabled=YES;originalX[index]=[[view.layer valueForKeyPath:@"transform.translation.x"] doubleValue];originalY[index]=[[view.layer valueForKeyPath:@"transform.translation.y"] doubleValue];
+    UIPanGestureRecognizer *pan=[[UIPanGestureRecognizer alloc] initWithTarget:self action:@selector(panned:)];
+    pan.maximumNumberOfTouches=1;pan.delegate=self;pan.enabled=NO;pan.cancelsTouchesInView=YES;
+    self.pans[index]=pan;[view addGestureRecognizer:pan];
+    [self apply];
+}
+- (BOOL)ready {return self.enabled&&!self.disposed&&!self.background&&self.fits&&self.container.window!=nil;}
+- (void)refresh {
+    BOOL ready=[self ready];
+    for(id candidate in self.pans)if(candidate!=NSNull.null){UIPanGestureRecognizer *pan=candidate;if(pan.enabled!=ready)pan.enabled=ready;}
+    if(ready&&!state.sleeping){
+        if(!self.link){self.previous=0;self.accumulator=0;self.link=[CADisplayLink displayLinkWithTarget:self selector:@selector(tick:)];[self.link addToRunLoop:NSRunLoop.mainRunLoop forMode:NSRunLoopCommonModes];}
+    }else if(self.link){[self.link invalidate];self.link=nil;self.previous=0;self.accumulator=0;}
+}
+- (void)tick:(CADisplayLink *)link {
+    if(![self ready]){[self cancelDrag];[self refresh];return;}
+    double started=CACurrentMediaTime(),elapsed=self.previous?MAX(0,link.timestamp-self.previous):0;self.previous=link.timestamp;
+    self.droppedMs+=MAX(0,elapsed-1.0/15)*1000;self.accumulator+=MIN(elapsed,1.0/15);
+    int budget=16;
+    while(self.accumulator+1e-10>=JOLT_CIRCLE_DT&&budget-->0&&!state.sleeping){JoltCircleStep(&state);self.accumulator-=JOLT_CIRCLE_DT;}
+    [self apply];self.frames++;self.processingMs+=(CACurrentMediaTime()-started)*1000;[self refresh];
+}
+- (void)apply {
+    [CATransaction begin];[CATransaction setDisableActions:YES];
+    for(int i=0;i<state.count;i++){
+        if(self.views[i]==NSNull.null)continue;UIView *v=self.views[i];
+        if(v.superview!=self.container){self.enabled=NO;continue;}
+        // layer.position is the untransformed layout center; body coordinates use container DIPs.
+        [v.layer setValue:@(state.bodies[i].x-v.layer.position.x) forKeyPath:@"transform.translation.x"];
+        [v.layer setValue:@(state.bodies[i].y-v.layer.position.y) forKeyPath:@"transform.translation.y"];
+    }
+    for(int i=0;i<state.count;i++)if(self.guides[i]!=NSNull.null){
+        JoltCircle *b=&state.bodies[i];CAShapeLayer *guide=self.guides[i];
+        double x=b->snap.active?JoltCircleSnapX(&state,b,b->snap.index):b->attachment.u*state.width;
+        double y=b->snap.active?JoltCircleSnapY(&state,b,b->snap.index):b->attachment.v*state.height;
+        double dx=b->x-x,dy=b->y-y,d=hypot(dx,dy);
+        UIBezierPath *path=[UIBezierPath bezierPath];
+        if(d>b->r){[path moveToPoint:CGPointMake(x,y)];[path addLineToPoint:CGPointMake(b->x-dx/d*b->r,b->y-dy/d*b->r)];[path appendPath:[UIBezierPath bezierPathWithOvalInRect:CGRectMake(x-2.5,y-2.5,5,5)]];}
+        guide.path=path.CGPath;
+    }
+    [CATransaction commit];
+}
+- (BOOL)gestureRecognizer:(UIGestureRecognizer *)gesture shouldReceiveTouch:(UITouch *)touch {
+    if(![self ready]||self.dragging>=0)return NO;
+    NSInteger i=[self.pans indexOfObject:gesture];if(i==NSNotFound)return NO;
+    CGPoint p=[touch locationInView:self.container];JoltCircle *b=&state.bodies[i];
+    touchOffsetX[i]=b->x-p.x;touchOffsetY[i]=b->y-p.y;
+    return hypot(p.x-b->x,p.y-b->y)<=b->r;
+}
+- (BOOL)gestureRecognizerShouldBegin:(UIGestureRecognizer *)gesture {
+    return [self ready]&&self.dragging<0;
+}
+- (void)panned:(UIPanGestureRecognizer *)pan {
+    NSInteger i=[self.pans indexOfObject:pan];if(i==NSNotFound)return;
+    CGPoint point=[pan locationInView:self.container];
+    if(pan.state==UIGestureRecognizerStateBegan){
+        if(![self ready]||self.dragging>=0)return;
+        self.dragging=i;self.offsetX=touchOffsetX[i];self.offsetY=touchOffsetY[i];self.dragStarts++;
+    }
+    if(self.dragging!=i)return;
+    if(pan.state==UIGestureRecognizerStateBegan||pan.state==UIGestureRecognizerStateChanged){
+        JoltCircleDrag(&state,(int)i,point.x+self.offsetX,point.y+self.offsetY);self.dragMoves++;[self refresh];
+    }else if(pan.state==UIGestureRecognizerStateEnded){
+        CGPoint velocity=[pan velocityInView:self.container];JoltCircleRelease(&state,(int)i,velocity.x,velocity.y);
+        self.dragging=-1;self.dragEnds++;[self refresh];
+    }else if(pan.state==UIGestureRecognizerStateCancelled||pan.state==UIGestureRecognizerStateFailed)[self cancelDrag];
+}
+- (void)cancelDrag {
+    if(self.dragging<0)return;
+    JoltCircleCancel(&state,(int)self.dragging);self.dragging=-1;self.dragCancels++;[self apply];
+}
+- (void)setEnabled:(BOOL)enabled {
+    if(self.disposed)return;BOOL changed=_enabled!=enabled;_enabled=enabled;
+    if(!enabled)[self cancelDrag];else if(changed)JoltCircleWake(&state);
+    [self refresh];
+}
+- (void)backgrounded {self.background=YES;[self cancelDrag];[self refresh];}
+- (void)foregrounded {self.background=NO;[self refresh];}
+- (void)resize:(double)width height:(double)height {
+    if(self.disposed)return;
+    self.fits=JoltCircleFits(&state,width,height);
+    if(!self.fits){[self cancelDrag];[self refresh];return;}
+    if(fabs(width-state.width)>.1||fabs(height-state.height)>.1){[self cancelDrag];JoltCircleResize(&state,width,height);}
+    [self apply];[self refresh];
+}
+- (void)impulse:(NSInteger)index x:(double)x y:(double)y {
+    if(![self ready]||index<0||index>=state.count||state.bodies[index].held||!isfinite(x)||!isfinite(y))return;
+    JoltCircle *b=&state.bodies[index];b->vx+=x/b->m;b->vy+=y/b->m;JoltCircleLimitVelocity(b);JoltCircleWake(&state);[self refresh];
+}
+- (void)reset {
+    if(self.disposed)return;[self cancelDrag];
+    for(int i=0;i<state.count;i++){JoltCircle *b=&state.bodies[i];b->x=initialX[i]*state.width;b->y=initialY[i]*state.height;b->vx=initialVX[i];b->vy=initialVY[i];b->snap.active=b->snap.previousActive=false;b->released=false;}
+    JoltCircleContacts(&state,false,64);JoltCircleWake(&state);[self apply];[self refresh];
+}
+- (NSString *)snapshot {
+    NSMutableArray *bodies=[NSMutableArray new];
+    NSUInteger guideCount=0;
+    for(id guide in self.guides)if(guide!=NSNull.null)guideCount++;
+    for(int i=0;i<state.count;i++){
+        JoltCircle *b=&state.bodies[i];
+        id attachment=b->attachment.enabled?@{@"anchor":@{@"x":@(b->attachment.u*state.width),@"y":@(b->attachment.v*state.height)},@"length":@(b->attachment.length),@"stiffness":@(b->attachment.stiffness),@"damping":@(b->attachment.damping)}:NSNull.null;
+        id snap=NSNull.null;
+        if(b->snap.active){double x=JoltCircleSnapX(&state,b,b->snap.index),y=JoltCircleSnapY(&state,b,b->snap.index);snap=@{@"index":@(b->snap.index),@"point":@{@"x":@(x),@"y":@(y)},@"settled":[NSNumber numberWithBool:hypot(b->x-x,b->y-y)<=.25&&hypot(b->vx,b->vy)<=4&&!b->held]};}
+        id release=b->released?@{@"x":@(b->releaseX),@"y":@(b->releaseY),@"vx":@(b->releaseVX),@"vy":@(b->releaseVY)}:NSNull.null;
+        [bodies addObject:@{@"x":@(b->x),@"y":@(b->y),@"vx":@(b->vx),@"vy":@(b->vy),@"radius":@(b->r),@"held":@(b->held),@"attachment":attachment,@"snap":snap,@"release":release}];
+    }
+    NSString *status=self.disposed?@"disposed":!self.enabled?@"paused":self.background||!self.container.window?@"detached":!self.fits?@"invalid-bounds":state.sleeping?@"sleeping":@"running";
+    NSDictionary *data=@{@"status":status,@"guides":@(guideCount),@"bodies":bodies,@"frames":@(self.frames),@"steps":@(state.steps),@"contacts":@(state.contacts),@"dragStarts":@(self.dragStarts),@"dragMoves":@(self.dragMoves),@"dragEnds":@(self.dragEnds),@"dragCancels":@(self.dragCancels),@"processingMs":@(self.processingMs),@"droppedMs":@(self.droppedMs),@"clock":[NSNumber numberWithBool:self.link!=nil]};
+    return [[NSString alloc]initWithData:[NSJSONSerialization dataWithJSONObject:data options:0 error:nil] encoding:NSUTF8StringEncoding];
+}
+- (void)dispose {
+    if(self.disposed)return;self.enabled=NO;self.disposed=YES;[self cancelDrag];[self refresh];
+    [[NSNotificationCenter defaultCenter]removeObserver:self];
+    [CATransaction begin];[CATransaction setDisableActions:YES];
+    for(int i=0;i<state.count;i++)if(self.views[i]!=NSNull.null){
+        UIView *v=self.views[i];v.userInteractionEnabled=originalInteraction[i];if(self.pans[i]!=NSNull.null)[v removeGestureRecognizer:self.pans[i]];
+        [v.layer setValue:@(originalX[i]) forKeyPath:@"transform.translation.x"];[v.layer setValue:@(originalY[i]) forKeyPath:@"transform.translation.y"];
+    }
+    for(id guide in self.guides)if(guide!=NSNull.null)[guide removeFromSuperlayer];[self.guides removeAllObjects];
+    [CATransaction commit];[self.views removeAllObjects];[self.pans removeAllObjects];self.container=nil;[worlds removeObject:self];
+}
+@end

package/platforms/ios/src/JoltGestureSession.h

@@ -0,0 +1,23 @@
+#import <UIKit/UIKit.h>
+#import "JoltLiveSpring.h"
+
+NS_ASSUME_NONNULL_BEGIN
+@interface JoltGestureSession : NSObject
+@property(nonatomic, readonly) BOOL active;
++ (BOOL)supportsContactEvents;
+// Development-only semantic input. Requires the isolated "replay" option.
++ (BOOL)supportsScrollReplay;
++ (BOOL)hasSession:(UIView *)surface;
+- (void)replayScroll:(NSInteger)phase delta:(double)delta velocity:(double)velocity;
+- (void)replayScrollOffset:(double)offset;
++ (instancetype)attach:(UIView *)surface scroll:(nullable UIScrollView *)scroll
+                     x:(JoltLiveSpring *)x y:(JoltLiveSpring *)y scale:(JoltLiveSpring *)scale rotation:(JoltLiveSpring *)rotation
+               options:(NSString *)options onState:(void (^)(NSInteger, double, double))onState;
+- (void)cancel;
+- (void)refreshScrollDelegate;
+- (void)setEnabled:(BOOL)enabled;
+- (void)settleX:(double)x y:(double)y scale:(double)scale rotation:(double)rotation animated:(BOOL)animated;
+- (void)updateLeft:(double)left right:(double)right top:(double)top bottom:(double)bottom;
+- (void)dispose;
+@end
+NS_ASSUME_NONNULL_END

package/platforms/ios/src/JoltGestureSession.m

@@ -0,0 +1,251 @@
+#import "JoltGestureSession.h"
+#import <UIKit/UIGestureRecognizerSubclass.h>
+
+static double clamp(double value, double minimum, double maximum) { return MAX(minimum, MIN(maximum, value)); }
+@class JoltGestureSession;
+
+/* Centroid tracking in window coordinates. Pointer membership changes rebase without movement. */
+@interface JoltAxisPan : UIGestureRecognizer
+@property(nonatomic, weak) JoltGestureSession *owner;
+@property(nonatomic) NSMutableSet<UITouch *> *contacts;
+@property(nonatomic) CGPoint previous, origin, delta, velocity;
+@property(nonatomic) double previousTime, threshold, failOffset;
+@property(nonatomic) NSInteger axis;
+- (void)rebase;
+@end
+
+@interface JoltGestureSession () <UIGestureRecognizerDelegate, UIScrollViewDelegate>
+@property(nonatomic, weak) UIView *surface;
+@property(nonatomic, weak) UIScrollView *scroll;
+@property(nonatomic) id<UIScrollViewDelegate> previousDelegate;
+@property(nonatomic) JoltAxisPan *pan;
+@property(nonatomic) UIPinchGestureRecognizer *pinch;
+@property(nonatomic) UIRotationGestureRecognizer *rotate;
+@property(nonatomic) UITapGestureRecognizer *tap, *doubleTap;
+@property(nonatomic) JoltLiveSpring *x, *y, *scale, *rotation;
+@property(nonatomic) double minX, maxX, minY, maxY, minScale, maxScale, velocityX, velocityY, scrollPosition;
+@property(nonatomic, readwrite) BOOL active;
+@property(nonatomic) BOOL enabled, disposed, contactEvents, contact, fromScroll, adjusting, ending, replayOnly;
+@property(nonatomic, copy) void (^onState)(NSInteger, double, double);
+- (void)touchStarted:(UITouch *)touch;
+- (void)finish:(BOOL)cancelled;
+- (void)applyScroll;
+@end
+
+@implementation JoltAxisPan
+- (instancetype)initWithTarget:(id)target action:(SEL)action {
+    if ((self = [super initWithTarget:target action:action])) self.contacts = [NSMutableSet new];
+    return self;
+}
+- (CGPoint)centroid {
+    CGPoint point = CGPointZero;
+    for (UITouch *touch in self.contacts) { CGPoint p = [touch locationInView:nil]; point.x += p.x; point.y += p.y; }
+    if (self.contacts.count) { point.x /= self.contacts.count; point.y /= self.contacts.count; }
+    return point;
+}
+- (void)rebase { self.previous = [self centroid]; self.previousTime = CACurrentMediaTime(); self.delta = CGPointZero; self.velocity = CGPointZero; }
+- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
+    BOOL first = !self.contacts.count;
+    [self.contacts unionSet:touches]; [self rebase];
+    if (self.state == UIGestureRecognizerStatePossible) self.origin = self.previous;
+    if (first) { self.origin = self.previous; [self.owner touchStarted:touches.anyObject]; }
+}
+- (void)touchesMoved:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
+    CGPoint point = [self centroid]; double now = CACurrentMediaTime(), dt = MAX(.001, now - self.previousTime);
+    self.delta = CGPointMake(point.x - self.previous.x, point.y - self.previous.y);
+    self.velocity = CGPointMake(self.delta.x / dt, self.delta.y / dt);
+    self.previous = point; self.previousTime = now;
+    if (self.state == UIGestureRecognizerStatePossible) {
+        double dx = fabs(point.x - self.origin.x), dy = fabs(point.y - self.origin.y);
+        if ((self.axis == 1 && dy > self.failOffset) || (self.axis == 2 && dx > self.failOffset)) { self.state = UIGestureRecognizerStateFailed; return; }
+        double distance = self.axis == 1 ? dx : self.axis == 2 ? dy : hypot(dx, dy);
+        if (self.axis && distance >= self.threshold) self.state = UIGestureRecognizerStateBegan;
+    } else if (self.state == UIGestureRecognizerStateBegan || self.state == UIGestureRecognizerStateChanged) self.state = UIGestureRecognizerStateChanged;
+}
+- (void)touchesEnded:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
+    [self.contacts minusSet:touches];
+    if (self.contacts.count) [self rebase];
+    else {
+        if (CACurrentMediaTime() - self.previousTime > .08) self.velocity = CGPointZero;
+        self.owner.velocityX = (self.axis & 1) ? self.velocity.x : 0; self.owner.velocityY = (self.axis & 2) ? self.velocity.y : 0;
+        self.state = self.state == UIGestureRecognizerStatePossible ? UIGestureRecognizerStateFailed : UIGestureRecognizerStateEnded;
+        [self.owner finish:NO];
+    }
+}
+- (void)touchesCancelled:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event { self.state = UIGestureRecognizerStateCancelled; [self.owner finish:YES]; }
+- (void)reset { [super reset]; [self.contacts removeAllObjects]; self.delta = CGPointZero; self.velocity = CGPointZero; }
+@end
+
+@implementation JoltGestureSession
++ (BOOL)supportsContactEvents { return YES; }
++ (BOOL)hasSession:(UIView *)surface {
+    for (UIGestureRecognizer *g in surface.gestureRecognizers) if ([g isKindOfClass:JoltAxisPan.class]) return YES;
+    return NO;
+}
++ (instancetype)attach:(UIView *)surface scroll:(UIScrollView *)scroll x:(JoltLiveSpring *)x y:(JoltLiveSpring *)y scale:(JoltLiveSpring *)scale rotation:(JoltLiveSpring *)rotation options:(NSString *)options onState:(void (^)(NSInteger,double,double))onState {
+    NSDictionary *config = [NSJSONSerialization JSONObjectWithData:[options dataUsingEncoding:NSUTF8StringEncoding] options:0 error:nil];
+    if ([config[@"replay"] boolValue] && [self hasSession:surface])
+        [NSException raise:NSInvalidArgumentException format:@"Replay requires an unowned gesture surface"];
+    JoltGestureSession *s = [self new]; s.surface = surface; s.scroll = scroll; s.x = x; s.y = y; s.scale = scale; s.rotation = rotation;
+    s.minX = [config[@"minX"] doubleValue]; s.maxX = [config[@"maxX"] doubleValue]; s.minY = [config[@"minY"] doubleValue]; s.maxY = [config[@"maxY"] doubleValue];
+    s.minScale = [config[@"minScale"] doubleValue]; s.maxScale = [config[@"maxScale"] doubleValue]; s.onState = onState; s.enabled = YES;
+    s.pan = [[JoltAxisPan alloc] initWithTarget:s action:@selector(panned:)]; s.pan.owner = s;
+    s.pan.axis = [config[@"axis"] integerValue]; s.pan.threshold = [config[@"threshold"] doubleValue]; s.pan.failOffset = [config[@"failOffset"] doubleValue];
+    s.pinch = [[UIPinchGestureRecognizer alloc] initWithTarget:s action:@selector(pinched:)];
+    s.rotate = [[UIRotationGestureRecognizer alloc] initWithTarget:s action:@selector(rotated:)];
+    s.tap = [[UITapGestureRecognizer alloc] initWithTarget:s action:@selector(tapped:)];
+    s.doubleTap = [[UITapGestureRecognizer alloc] initWithTarget:s action:@selector(tapped:)]; s.doubleTap.numberOfTapsRequired = 2;
+    [s.tap requireGestureRecognizerToFail:s.doubleTap];
+    for (UIGestureRecognizer *g in @[s.pan, s.pinch, s.rotate, s.tap, s.doubleTap]) { g.delegate = s; [surface addGestureRecognizer:g]; }
+    s.pinch.enabled = [config[@"pinch"] boolValue]; s.rotate.enabled = [config[@"rotate"] boolValue];
+    s.contactEvents = [config[@"contactEvents"] boolValue];
+    s.replayOnly = [config[@"replay"] boolValue];
+    s.tap.enabled = [config[@"tap"] boolValue]; s.doubleTap.enabled = [config[@"doubleTap"] boolValue];
+    if (s.replayOnly) for (UIGestureRecognizer *g in @[s.pan, s.pinch, s.rotate, s.tap, s.doubleTap]) g.enabled = NO;
+    // NativeScript's scroll delegate is forwarded, never replaced with a JS per-frame bridge.
+    if (scroll) { s.previousDelegate = scroll.delegate; scroll.delegate = s; }
+    return s;
+}
+- (BOOL)respondsToSelector:(SEL)selector { return [super respondsToSelector:selector] || [self.previousDelegate respondsToSelector:selector]; }
+- (void)refreshScrollDelegate {
+    if (!self.disposed && self.scroll && self.scroll.delegate != self) {
+        self.previousDelegate = self.scroll.delegate; self.scroll.delegate = self;
+    }
+}
+- (id)forwardingTargetForSelector:(SEL)selector { return [self.previousDelegate respondsToSelector:selector] ? self.previousDelegate : [super forwardingTargetForSelector:selector]; }
+- (BOOL)gestureRecognizer:(UIGestureRecognizer *)first shouldRecognizeSimultaneouslyWithGestureRecognizer:(UIGestureRecognizer *)second {
+    if ([first isKindOfClass:UITapGestureRecognizer.class] || [second isKindOfClass:UITapGestureRecognizer.class]) return NO;
+    return YES;
+}
+- (BOOL)gestureRecognizer:(UIGestureRecognizer *)gesture shouldReceiveTouch:(UITouch *)touch {
+    return self.enabled && !self.disposed;
+}
+- (void)touchStarted:(UITouch *)touch {
+    if (self.disposed || !self.enabled) return;
+    self.contact = YES; self.fromScroll = self.scroll && [touch.view isDescendantOfView:self.scroll];
+    self.scrollPosition = MAX(-self.scroll.adjustedContentInset.top, self.scroll.contentOffset.y);
+    self.velocityX = self.velocityY = 0;
+    for (JoltLiveSpring *node in @[self.x, self.y, self.scale, self.rotation]) [node releaseInput:node.position velocity:0];
+    if (self.contactEvents) [self emit:6];
+}
+- (void)emit:(NSInteger)state { if (!self.disposed && self.onState) self.onState(state, self.velocityX, self.velocityY); }
+- (void)begin {
+    if (self.active || self.disposed || !self.enabled) return;
+    self.active = YES;
+    for (JoltLiveSpring *node in @[self.x, self.y, self.scale, self.rotation]) [node holdInput:node.position velocity:0];
+    [self emit:1];
+}
+- (void)panned:(JoltAxisPan *)pan {
+    if (self.disposed || !self.enabled) return;
+    if (pan.state == UIGestureRecognizerStateBegan || pan.state == UIGestureRecognizerStateChanged) {
+        [self begin]; if (self.disposed || !self.enabled || !self.active) return;
+        self.velocityX = (pan.axis & 1) ? pan.velocity.x : 0; self.velocityY = (pan.axis & 2) ? pan.velocity.y : 0;
+        double dx = pan.delta.x, dy = pan.delta.y;
+        if (self.fromScroll) {
+            [self consumeScrollDelta:dy];
+        } else {
+            if (pan.axis & 1) [self.x holdInput:clamp(self.x.position + dx, self.minX, self.maxX) velocity:self.velocityX];
+            if (pan.axis & 2) [self.y holdInput:clamp(self.y.position + dy, self.minY, self.maxY) velocity:self.velocityY];
+        }
+    } else if (pan.state == UIGestureRecognizerStateEnded) [self finish:NO];
+    else if (pan.state == UIGestureRecognizerStateCancelled || pan.state == UIGestureRecognizerStateFailed) [self finish:YES];
+}
+// Shared by the OS recognizer and the isolated semantic replay adapter.
+- (void)consumeScrollDelta:(double)dy {
+    double oldY = self.y.position, nextY = oldY, top = -self.scroll.adjustedContentInset.top;
+    if (dy < 0) { nextY = MAX(self.minY, oldY + dy); dy -= nextY - oldY; }
+    else {
+        double consumed = MIN(dy, MAX(0, self.scrollPosition - top));
+        self.scrollPosition -= consumed; dy -= consumed;
+        nextY = MIN(self.maxY, oldY + dy); dy -= nextY - oldY;
+    }
+    double bottom = MAX(top, self.scroll.contentSize.height - self.scroll.bounds.size.height + self.scroll.adjustedContentInset.bottom);
+    self.scrollPosition = clamp(self.scrollPosition - dy, top, bottom);
+    [self.y holdInput:nextY velocity:self.velocityY]; [self applyScroll];
+}
++ (BOOL)supportsScrollReplay { return YES; }
+- (void)replayScroll:(NSInteger)phase delta:(double)dy velocity:(double)velocity {
+    if (!self.replayOnly || self.disposed || !self.scroll || !isfinite(dy) || !isfinite(velocity))
+        [NSException raise:NSInvalidArgumentException format:@"Scroll replay needs an isolated replay session and finite input"];
+    if (phase == 1) {
+        [self cancel]; self.contact = YES; self.fromScroll = YES;
+        self.scrollPosition = MAX(-self.scroll.adjustedContentInset.top, self.scroll.contentOffset.y);
+        self.velocityX = self.velocityY = 0; [self begin];
+    } else if (phase == 2 && self.contact) {
+        self.velocityY = velocity; [self consumeScrollDelta:dy];
+    } else if (phase == 3 || phase == 4) [self finish:phase == 4];
+}
+- (void)replayScrollOffset:(double)offset {
+    if (!self.replayOnly || self.disposed || !isfinite(offset))
+        [NSException raise:NSInvalidArgumentException format:@"Invalid scroll replay offset"];
+    self.scrollPosition = -self.scroll.adjustedContentInset.top + offset; [self applyScroll];
+}
+- (void)pinched:(UIPinchGestureRecognizer *)gesture {
+    if (self.fromScroll || self.disposed || !self.enabled) return;
+    if (gesture.state == UIGestureRecognizerStateBegan || gesture.state == UIGestureRecognizerStateChanged) {
+        [self begin]; if (self.disposed || !self.active) return;
+        [self.scale holdInput:clamp(self.scale.position * gesture.scale, self.minScale, self.maxScale) velocity:0]; gesture.scale = 1;
+    } else if (!self.pan.contacts.count) [self finish:gesture.state == UIGestureRecognizerStateCancelled];
+}
+- (void)rotated:(UIRotationGestureRecognizer *)gesture {
+    if (self.fromScroll || self.disposed || !self.enabled) return;
+    if (gesture.state == UIGestureRecognizerStateBegan || gesture.state == UIGestureRecognizerStateChanged) {
+        [self begin]; if (self.disposed || !self.active) return;
+        [self.rotation holdInput:self.rotation.position + gesture.rotation * 180 / M_PI velocity:0]; gesture.rotation = 0;
+    } else if (!self.pan.contacts.count) [self finish:gesture.state == UIGestureRecognizerStateCancelled];
+}
+- (void)tapped:(UITapGestureRecognizer *)gesture { if (gesture.state == UIGestureRecognizerStateRecognized) [self emit:gesture == self.doubleTap ? 5 : 4]; }
+- (void)applyScroll {
+    if (!self.scroll || self.adjusting) return;
+    self.adjusting = YES;
+    [self.scroll setContentOffset:CGPointMake(self.scroll.contentOffset.x, self.scrollPosition) animated:NO];
+    self.adjusting = NO;
+}
+- (void)scrollViewDidScroll:(UIScrollView *)scroll {
+    if (self.contact && self.fromScroll && !self.adjusting) [self applyScroll];
+    if (!self.adjusting && [self.previousDelegate respondsToSelector:_cmd]) [self.previousDelegate scrollViewDidScroll:scroll];
+}
+- (void)scrollViewWillEndDragging:(UIScrollView *)scroll withVelocity:(CGPoint)velocity targetContentOffset:(inout CGPoint *)target {
+    if (self.y.position > self.minY + .01) target->y = scroll.contentOffset.y;
+    if ([self.previousDelegate respondsToSelector:_cmd]) [self.previousDelegate scrollViewWillEndDragging:scroll withVelocity:velocity targetContentOffset:target];
+}
+- (void)finish:(BOOL)cancelled {
+    BOOL hadContact = self.contact;
+    self.contact = NO;
+    if (!self.active) { if (hadContact && self.contactEvents) [self emit:7]; return; }
+    self.active = NO;
+    for (JoltLiveSpring *node in @[self.x, self.y, self.scale, self.rotation]) [node releaseInput:node.position velocity:0];
+    self.ending = !cancelled;
+    @try { [self emit:cancelled ? 3 : 2]; } @finally { self.ending = NO; }
+    if (hadContact && self.contactEvents) [self emit:7];
+}
+- (void)cancel {
+    if (self.active) [self finish:YES];
+    else {
+        [self finish:YES];
+        for (JoltLiveSpring *node in @[self.x, self.y, self.scale, self.rotation]) [node releaseInput:node.position velocity:0];
+    }
+    for (UIGestureRecognizer *g in @[self.pan, self.pinch, self.rotate, self.tap, self.doubleTap]) if (g.enabled) { g.enabled = NO; g.enabled = YES; }
+}
+- (void)setEnabled:(BOOL)value { _enabled = value; if (!value) [self cancel]; }
+- (void)settleX:(double)x y:(double)y scale:(double)scale rotation:(double)rotation animated:(BOOL)animated {
+    if (self.disposed) return;
+    double vx = self.ending ? self.velocityX : self.x.velocity, vy = self.ending ? self.velocityY : self.y.velocity;
+    [self cancel];
+    double targets[] = {clamp(x, self.minX, self.maxX), clamp(y, self.minY, self.maxY), clamp(scale, self.minScale, self.maxScale), rotation};
+    NSArray *nodes = @[self.x, self.y, self.scale, self.rotation];
+    for (NSUInteger i = 0; i < nodes.count; i++) {
+        JoltLiveSpring *node = nodes[i];
+        if (!animated) [node holdInput:targets[i] velocity:0];
+        [node releaseInput:targets[i] velocity:animated ? i == 0 ? vx : i == 1 ? vy : 0 : 0];
+    }
+}
+- (void)updateLeft:(double)left right:(double)right top:(double)top bottom:(double)bottom { self.minX = left; self.maxX = right; self.minY = top; self.maxY = bottom; }
+- (void)dispose {
+    if (self.disposed) return;
+    [self cancel]; self.disposed = YES;
+    for (UIGestureRecognizer *g in @[self.pan, self.pinch, self.rotate, self.tap, self.doubleTap]) [self.surface removeGestureRecognizer:g];
+    if (self.scroll.delegate == self) self.scroll.delegate = self.previousDelegate;
+    self.previousDelegate = nil; self.onState = nil;
+}
+@end

package/platforms/ios/src/JoltInteractiveNavigation.h

@@ -0,0 +1,23 @@
+#import <UIKit/UIKit.h>
+NS_ASSUME_NONNULL_BEGIN
+
+/** Frame's delegate supplies this object to UIKit; it never replaces that delegate. */
+@interface JoltInteractiveNavigation : NSObject <UIViewControllerAnimatedTransitioning, UIViewControllerInteractiveTransitioning, UIGestureRecognizerDelegate>
++ (instancetype)attach:(UINavigationController *)navigation stiffness:(double)stiffness
+                damping:(double)damping mass:(double)mass
+            shouldBegin:(BOOL (^)(void))shouldBegin onEvent:(void (^)(NSInteger))onEvent;
++ (NSUInteger)activeCount;
++ (NSUInteger)recognizerCount;
+@property(nonatomic, readonly) BOOL interactive;
+@property(nonatomic, readonly) double progress;
+@property(nonatomic, readonly) double velocity;
+@property(nonatomic) BOOL sharedEnabled;
+@property(nonatomic) BOOL sharedDeferred;
+- (void)completeSharedPreparation;
+- (BOOL)prepareSharedFrom:(UIView *)from to:(UIView *)to image:(BOOL)image fromRadius:(double)fromRadius toRadius:(double)toRadius maxPixels:(double)maxPixels;
+- (void)prepareOperation:(NSInteger)operation presented:(UIViewController *)presented reduced:(BOOL)reduced timeScale:(double)timeScale;
+- (void)sync;
+- (void)cancel;
+- (void)disposeRestoringSwipe:(BOOL)enabled;
+@end
+NS_ASSUME_NONNULL_END