@rafaelaugusto/jolt 0.1.0-beta.9 → 0.1.0-rc.2

package/platforms/ios/src/JoltReorderSession.m

@@ -0,0 +1,205 @@
+#import "JoltReorderSession.h"
+
+@implementation JoltReorderHandle
+- (BOOL)canBecomeFirstResponder { return YES; }
+- (BOOL)beginTrackingWithTouch:(UITouch *)touch withEvent:(UIEvent *)event {
+    [self becomeFirstResponder]; return [super beginTrackingWithTouch:touch withEvent:event];
+}
+- (NSArray<UIKeyCommand *> *)keyCommands {
+    if (!self.onMove) return [super keyCommands];
+    UIKeyCommand *up = [UIKeyCommand keyCommandWithInput:UIKeyInputUpArrow modifierFlags:UIKeyModifierAlternate action:@selector(moveUp:)];
+    UIKeyCommand *down = [UIKeyCommand keyCommandWithInput:UIKeyInputDownArrow modifierFlags:UIKeyModifierAlternate action:@selector(moveDown:)];
+    if (@available(iOS 15.0, *)) { up.wantsPriorityOverSystemBehavior = YES; down.wantsPriorityOverSystemBehavior = YES; }
+    return @[up, down];
+}
+- (void)moveUp:(UIKeyCommand *)command { if (self.onMove) self.onMove(-1); }
+- (void)moveDown:(UIKeyCommand *)command { if (self.onMove) self.onMove(1); }
+@end
+
+@interface JoltReorderCellState : NSObject
+@property(nonatomic) CATransform3D transform;
+@property(nonatomic) BOOL cellClips, contentClips;
+@property(nonatomic) CGFloat alpha, offset;
+@property(nonatomic) NSInteger index;
+@end
+@implementation JoltReorderCellState
+@end
+
+@interface JoltReorderSession () <UIGestureRecognizerDelegate>
+@property(nonatomic, weak) UITableView *list;
+@property(nonatomic) UILongPressGestureRecognizer *press;
+@property(nonatomic) NSHashTable<UIView *> *handles;
+@property(nonatomic) NSMapTable<UITableViewCell *, JoltReorderCellState *> *cells;
+@property(nonatomic) UIView *overlay;
+@property(nonatomic) CADisplayLink *clock;
+@property(nonatomic, copy) void (^onState)(NSInteger, NSInteger, NSInteger);
+@property(nonatomic) NSInteger from, target, count, generation;
+@property(nonatomic) CGFloat edgeSize, edgeSpeed, height, grabOffset, pointerY, pointerX;
+@property(nonatomic) CGSize viewport;
+@property(nonatomic) double previousTime;
+@property(nonatomic) BOOL enabled, disposed, handlesOnly, reduced, settling, scrollEnabled, cancelling;
+@property(nonatomic, readwrite) BOOL active;
+@end
+
+@implementation JoltReorderSession
++ (instancetype)attach:(UITableView *)list options:(NSString *)options onState:(void (^)(NSInteger, NSInteger, NSInteger))onState {
+    if (![list isKindOfClass:UITableView.class]) @throw [NSException exceptionWithName:NSInvalidArgumentException reason:@"Reorder requires a UITableView" userInfo:nil];
+    NSDictionary *config = [NSJSONSerialization JSONObjectWithData:[options dataUsingEncoding:NSUTF8StringEncoding] options:0 error:nil];
+    JoltReorderSession *s = [self new]; s.list = list; s.onState = onState; s.enabled = YES;
+    s.edgeSize = [config[@"edgeSize"] doubleValue]; s.edgeSpeed = [config[@"edgeSpeed"] doubleValue];
+    s.reduced = [config[@"reducedMotion"] boolValue]; s.handlesOnly = [config[@"handles"] boolValue];
+    s.handles = [NSHashTable weakObjectsHashTable]; s.cells = [NSMapTable weakToStrongObjectsMapTable];
+    s.press = [[UILongPressGestureRecognizer alloc] initWithTarget:s action:@selector(pressed:)];
+    s.press.minimumPressDuration = [config[@"longPress"] doubleValue] / 1000.; s.press.numberOfTouchesRequired = 1;
+    s.press.allowableMovement = 10; s.press.delegate = s;
+    [list addGestureRecognizer:s.press];
+    return s;
+}
+- (void)registerHandle:(UIView *)view { if (!self.disposed && view) [self.handles addObject:view]; }
+- (BOOL)gestureRecognizer:(UIGestureRecognizer *)recognizer shouldReceiveTouch:(UITouch *)touch {
+    if (self.active) { [self cancel]; return NO; }
+    if (!self.enabled || self.disposed || self.active || !self.list.window) return NO;
+    if (!self.handlesOnly) return YES;
+    for (UIView *view = touch.view; view && view != self.list; view = view.superview)
+        if ([self.handles containsObject:view]) return YES;
+    return NO;
+}
+- (BOOL)gestureRecognizerShouldBegin:(UIGestureRecognizer *)recognizer {
+    NSIndexPath *path = [self.list indexPathForRowAtPoint:[recognizer locationInView:self.list]];
+    return path && path.section == 0 && self.list.numberOfSections == 1 && !self.list.dragging && !self.list.decelerating;
+}
+- (void)emit:(NSInteger)state detail:(NSInteger)detail { if (!self.disposed && self.onState) self.onState(state, self.from, detail); }
+- (void)pressed:(UILongPressGestureRecognizer *)press {
+    if (press.state == UIGestureRecognizerStateBegan) [self begin];
+    else if (press.state == UIGestureRecognizerStateChanged && self.active && !self.settling) {
+        CGPoint p = [press locationInView:self.list.window]; self.pointerY = p.y; self.pointerX = p.x; [self update];
+    } else if (press.state == UIGestureRecognizerStateEnded && self.active) [self drop];
+    else if (press.state == UIGestureRecognizerStateCancelled || press.state == UIGestureRecognizerStateFailed) [self cancel];
+}
+- (void)begin {
+    UITableView *list = self.list;
+    NSIndexPath *path = [list indexPathForRowAtPoint:[self.press locationInView:list]];
+    UITableViewCell *cell = path ? [list cellForRowAtIndexPath:path] : nil;
+    if (!cell || path.section != 0 || !list.window) return;
+    UIView *snapshot = [cell snapshotViewAfterScreenUpdates:NO];
+    if (!snapshot) return;
+    CGRect frame = [list convertRect:[list rectForRowAtIndexPath:path] toView:list.window];
+    self.overlay = snapshot; snapshot.frame = frame; snapshot.userInteractionEnabled = NO;
+    snapshot.accessibilityElementsHidden = YES;
+    snapshot.layer.shadowColor = UIColor.blackColor.CGColor; snapshot.layer.shadowRadius = 12;
+    snapshot.layer.shadowOpacity = .18; snapshot.layer.shadowOffset = CGSizeMake(0, 6);
+    [list.window addSubview:snapshot];
+    CGPoint p = [self.press locationInView:list.window];
+    self.pointerY = p.y; self.pointerX = p.x; self.grabOffset = p.y - CGRectGetMidY(frame);
+    self.height = frame.size.height; self.viewport = list.bounds.size;
+    self.count = [list numberOfRowsInSection:0]; self.from = self.target = path.row;
+    self.scrollEnabled = list.scrollEnabled; list.scrollEnabled = NO;
+    self.active = YES; self.settling = NO; self.previousTime = CACurrentMediaTime(); self.generation++;
+    [self emit:1 detail:self.from];
+    if (!self.active || self.disposed) return;
+    self.clock = [CADisplayLink displayLinkWithTarget:self selector:@selector(tick:)];
+    [self.clock addToRunLoop:NSRunLoop.mainRunLoop forMode:NSRunLoopCommonModes];
+    [self update];
+}
+- (void)tick:(CADisplayLink *)clock {
+    if (!self.active || self.settling) return;
+    UITableView *list = self.list;
+    if (!list.window || !CGSizeEqualToSize(self.viewport, list.bounds.size) || self.count != [list numberOfRowsInSection:0]) {
+        [self finish:NO detail:1]; return;
+    }
+    double now = CACurrentMediaTime(), dt = MIN(.04, MAX(0, now - self.previousTime)); self.previousTime = now;
+    CGRect viewport = [list convertRect:list.bounds toView:list.window];
+    CGFloat inset = MIN(self.edgeSize, viewport.size.height / 3), distance = 0;
+    if (self.pointerY < CGRectGetMinY(viewport) + inset) distance = -MIN(1, (CGRectGetMinY(viewport) + inset - self.pointerY) / inset);
+    else if (self.pointerY > CGRectGetMaxY(viewport) - inset) distance = MIN(1, (self.pointerY - CGRectGetMaxY(viewport) + inset) / inset);
+    CGFloat top = -list.adjustedContentInset.top, bottom = MAX(top, list.contentSize.height - list.bounds.size.height + list.adjustedContentInset.bottom);
+    CGFloat next = MAX(top, MIN(bottom, list.contentOffset.y + distance * self.edgeSpeed * dt));
+    if (fabs(next - list.contentOffset.y) > .01) { [list setContentOffset:CGPointMake(list.contentOffset.x, next) animated:NO]; [list layoutIfNeeded]; }
+    [self update];
+}
+- (void)restore:(UITableViewCell *)cell state:(JoltReorderCellState *)state {
+    [cell.contentView.layer removeAnimationForKey:@"jolt.reorder"];
+    cell.contentView.layer.sublayerTransform = state.transform; cell.alpha = state.alpha; state.offset = 0;
+    cell.clipsToBounds = state.cellClips; cell.contentView.clipsToBounds = state.contentClips;
+}
+- (void)update {
+    if (!self.active || self.settling) return;
+    UITableView *list = self.list;
+    CGFloat center = self.pointerY - self.grabOffset;
+    CGPoint inList = [list convertPoint:CGPointMake(self.pointerX, center) fromView:list.window];
+    CGFloat draggedTop = inList.y - self.height / 2;
+    self.overlay.center = CGPointMake(self.overlay.center.x, center);
+    NSArray<NSIndexPath *> *paths = [[list indexPathsForVisibleRows] sortedArrayUsingSelector:@selector(compare:)];
+    NSInteger destination = self.from;
+    for (NSIndexPath *path in paths) {
+        if (path.section || path.row == self.from) continue;
+        CGRect frame = [list rectForRowAtIndexPath:path];
+        CGFloat midpoint = CGRectGetMidY(frame) - (path.row > self.from ? self.height : 0);
+        NSInteger insertion = path.row - (path.row > self.from ? 1 : 0);
+        destination = insertion;
+        if (draggedTop < midpoint) break;
+        destination = insertion + 1;
+    }
+    self.target = MAX(0, MIN(self.count - 1, destination));
+    NSSet *visible = [NSSet setWithArray:list.visibleCells];
+    for (UITableViewCell *cell in self.cells.keyEnumerator.allObjects)
+        if (![visible containsObject:cell]) { [self restore:cell state:[self.cells objectForKey:cell]]; [self.cells removeObjectForKey:cell]; }
+    for (NSIndexPath *path in paths) {
+        UITableViewCell *cell = [list cellForRowAtIndexPath:path]; if (!cell) continue;
+        JoltReorderCellState *state = [self.cells objectForKey:cell];
+        if (state && state.index != path.row) { [self restore:cell state:state]; [self.cells removeObjectForKey:cell]; state = nil; }
+        if (!state) { state = [JoltReorderCellState new]; state.transform = cell.contentView.layer.sublayerTransform; state.cellClips = cell.clipsToBounds; state.contentClips = cell.contentView.clipsToBounds; state.alpha = cell.alpha; state.index = path.row; [self.cells setObject:state forKey:cell]; }
+        cell.clipsToBounds = NO; cell.contentView.clipsToBounds = NO;
+        cell.alpha = path.row == self.from ? 0 : state.alpha;
+        CGFloat offset = path.row > self.from && path.row <= self.target ? -self.height : path.row < self.from && path.row >= self.target ? self.height : 0;
+        if (fabs(offset - state.offset) < .01) continue;
+        // UITableView owns cell/contentView frames. Move only the contents of
+        // the layer so height estimation and recycling cannot corrupt geometry.
+        CALayer *layer = cell.contentView.layer;
+        CATransform3D previous = ((CALayer *)layer.presentationLayer ?: layer).sublayerTransform;
+        state.offset = offset; layer.sublayerTransform = CATransform3DTranslate(state.transform, 0, offset, 0);
+        [layer removeAnimationForKey:@"jolt.reorder"];
+        if (!self.reduced) {
+            CASpringAnimation *spring = [CASpringAnimation animationWithKeyPath:@"sublayerTransform"];
+            spring.mass = 1; spring.stiffness = 360; spring.damping = 34;
+            spring.fromValue = [NSValue valueWithCATransform3D:previous]; spring.toValue = [NSValue valueWithCATransform3D:layer.sublayerTransform]; spring.duration = spring.settlingDuration;
+            [layer addAnimation:spring forKey:@"jolt.reorder"];
+        }
+    }
+}
+- (void)drop {
+    if (!self.active || self.settling) return;
+    self.settling = YES; [self.clock invalidate]; self.clock = nil;
+    NSInteger generation = self.generation;
+    CGRect row = [self.list rectForRowAtIndexPath:[NSIndexPath indexPathForRow:self.target inSection:0]];
+    CGFloat top = self.target > self.from ? CGRectGetMaxY(row) - self.height : row.origin.y;
+    CGPoint end = [self.list convertPoint:CGPointMake(row.origin.x + row.size.width / 2, top + self.height / 2) toView:self.list.window];
+    if (self.reduced) { [self finish:YES detail:0]; return; }
+    [UIView animateWithDuration:.18 delay:0 options:UIViewAnimationOptionBeginFromCurrentState | UIViewAnimationOptionCurveEaseOut animations:^{ self.overlay.center = end; } completion:^(BOOL finished) {
+        if (self.active && generation == self.generation) [self finish:YES detail:0];
+    }];
+}
+- (void)finish:(BOOL)commit detail:(NSInteger)detail {
+    if (!self.active) return;
+    self.active = NO; self.settling = NO; self.generation++;
+    [self.clock invalidate]; self.clock = nil;
+    [self.overlay.layer removeAllAnimations]; [self.overlay removeFromSuperview]; self.overlay = nil;
+    for (UITableViewCell *cell in self.cells.keyEnumerator.allObjects) [self restore:cell state:[self.cells objectForKey:cell]];
+    [self.cells removeAllObjects]; self.list.scrollEnabled = self.scrollEnabled;
+    [self emit:commit ? 2 : 3 detail:commit ? self.target : detail];
+}
+- (void)cancel {
+    if (self.cancelling) return;
+    self.cancelling = YES;
+    [self finish:NO detail:0];
+    if (self.press.enabled) { self.press.enabled = NO; self.press.enabled = YES; }
+    self.cancelling = NO;
+}
+- (void)setEnabled:(BOOL)value { _enabled = value; if (!value) [self cancel]; }
+- (void)setReducedMotion:(BOOL)value { self.reduced = value; }
+- (void)dispose {
+    if (self.disposed) return;
+    [self cancel]; self.disposed = YES; [self.list removeGestureRecognizer:self.press]; self.onState = nil;
+    [self.handles removeAllObjects];
+}
+@end

package/platforms/ios/src/JoltScrollHeader.h

@@ -0,0 +1,13 @@
+#import <UIKit/UIKit.h>
+#import "JoltLiveSpring.h"
+NS_ASSUME_NONNULL_BEGIN
+@interface JoltScrollHeader : NSObject
++ (instancetype)attach:(UITableView *)list node:(JoltLiveSpring *)node title:(UIView *)title toolbarTitle:(UIView *)toolbarTitle toolbar:(UIView *)toolbar diagnostic:(nullable UILabel *)diagnostic options:(NSString *)options onState:(void (^)(void))onState;
++ (NSInteger)activeCount;
+- (void)configure:(NSString *)options;
+- (NSString *)snapshot;
+- (void)scroll:(double)offset animated:(BOOL)animated;
+- (void)setEnabled:(BOOL)enabled;
+- (void)dispose;
+@end
+NS_ASSUME_NONNULL_END

package/platforms/ios/src/JoltScrollHeader.m

@@ -0,0 +1,101 @@
+#import "JoltScrollHeader.h"
+#import <QuartzCore/QuartzCore.h>
+
+@interface JoltScrollHeaderDelegate : NSObject <UITableViewDelegate>
+@property(nonatomic) id<UITableViewDelegate> forwarded;
+@property(nonatomic) double spacer, rowHeight;
+@end
+@implementation JoltScrollHeaderDelegate
+- (BOOL)respondsToSelector:(SEL)selector { return [super respondsToSelector:selector] || [self.forwarded respondsToSelector:selector]; }
+- (id)forwardingTargetForSelector:(SEL)selector { return self.forwarded; }
+- (CGFloat)tableView:(UITableView *)tableView heightForRowAtIndexPath:(NSIndexPath *)path { return path.row == 0 ? self.spacer : self.rowHeight; }
+- (CGFloat)tableView:(UITableView *)tableView estimatedHeightForRowAtIndexPath:(NSIndexPath *)path { return path.row == 0 ? self.spacer : self.rowHeight; }
+@end
+
+@interface JoltScrollHeader ()
+@property(nonatomic) JoltScrollHeaderDelegate *proxy;
+@property(nonatomic,weak) UITableView *list;
+@property(nonatomic) JoltLiveSpring *node;
+@property(nonatomic,weak) UIView *title, *toolbarTitle, *toolbar;
+@property(nonatomic,weak) UILabel *diagnostic;
+@property(nonatomic,copy) void (^onState)(void);
+@property(nonatomic) BOOL observing, disposed, titleHidden, toolbarTitleHidden, toolbarTouch;
+@property(nonatomic) double handoff, minimumOffset, maximumOffset, range, spacer, rowHeight, offset;
+@property(nonatomic) CGFloat estimatedSectionHeaderHeight, estimatedSectionFooterHeight;
+@property(nonatomic) NSInteger phase, updates, callbacks;
+@end
+static NSInteger JoltScrollHeaderActive = 0;
+static void *JoltScrollHeaderContext = &JoltScrollHeaderContext;
+@implementation JoltScrollHeader
++ (NSInteger)activeCount { return JoltScrollHeaderActive; }
++ (instancetype)attach:(UITableView *)list node:(JoltLiveSpring *)node title:(UIView *)title toolbarTitle:(UIView *)toolbarTitle toolbar:(UIView *)toolbar diagnostic:(UILabel *)diagnostic options:(NSString *)options onState:(void (^)(void))onState {
+    if(![list isKindOfClass:UITableView.class]) [NSException raise:NSInvalidArgumentException format:@"scrollHeader requires UITableView"];
+    JoltScrollHeader *owner=[self new];owner.list=list;owner.node=node;owner.title=title;owner.toolbarTitle=toolbarTitle;owner.toolbar=toolbar;owner.diagnostic=diagnostic;owner.onState=onState;
+    owner.titleHidden=title.accessibilityElementsHidden;owner.toolbarTitleHidden=toolbarTitle.accessibilityElementsHidden;owner.toolbarTouch=toolbar.userInteractionEnabled;owner.phase=-1;owner.offset=NAN;
+    owner.proxy=[JoltScrollHeaderDelegate new];owner.proxy.forwarded=list.delegate;
+    // Flat lists have no section headers/footers. UIKit's automatic estimates
+    // otherwise adjust the scroll anchor during width/safe-area changes.
+    owner.estimatedSectionHeaderHeight=list.estimatedSectionHeaderHeight;
+    owner.estimatedSectionFooterHeight=list.estimatedSectionFooterHeight;
+    list.estimatedSectionHeaderHeight=0;list.estimatedSectionFooterHeight=0;
+    [owner configure:options];list.delegate=owner.proxy;[list reloadData];[list layoutIfNeeded];[owner setEnabled:YES];return owner;
+}
+- (void)configure:(NSString *)options {
+    NSDictionary *config=[NSJSONSerialization JSONObjectWithData:[options dataUsingEncoding:NSUTF8StringEncoding] options:0 error:nil];
+    self.handoff=[config[@"handoff"] doubleValue];self.range=[config[@"range"] doubleValue];self.spacer=[config[@"spacer"] doubleValue];self.rowHeight=[config[@"rowHeight"] doubleValue];
+    self.proxy.spacer=self.spacer;self.proxy.rowHeight=self.rowHeight;
+    [self.list reloadData];
+    if(self.observing)[self update:YES];
+}
+- (void)setEnabled:(BOOL)enabled {
+    if(self.disposed || enabled==self.observing)return;
+    self.observing=enabled;
+    if(enabled) {
+        for(NSString *key in @[@"contentOffset",@"contentSize",@"bounds"]) [self.list addObserver:self forKeyPath:key options:0 context:JoltScrollHeaderContext];
+        JoltScrollHeaderActive++;[self update:YES];
+    } else {
+        for(NSString *key in @[@"contentOffset",@"contentSize",@"bounds"]) [self.list removeObserver:self forKeyPath:key context:JoltScrollHeaderContext];
+        JoltScrollHeaderActive--;
+    }
+}
+- (void)observeValueForKeyPath:(NSString *)key ofObject:(id)object change:(NSDictionary *)change context:(void *)context {
+    if(context==JoltScrollHeaderContext) [self update:NO];
+    else [super observeValueForKeyPath:key ofObject:object change:change context:context];
+}
+- (void)update:(BOOL)force {
+    if(self.disposed || !self.list)return;
+    double offset=self.list.contentOffset.y+self.list.adjustedContentInset.top;
+    if(!isfinite(offset) || (!force && fabs(offset-self.offset)<.001))return;
+    self.offset=offset;self.minimumOffset=MIN(self.minimumOffset,offset);self.maximumOffset=MAX(self.maximumOffset,offset);self.updates++;
+    // Existing native value graph applies all derived bindings in one transaction.
+    [self.node setTarget:offset];
+    BOOL compact=offset>=self.range*self.handoff;
+    self.title.accessibilityElementsHidden=self.titleHidden || compact;
+    self.toolbarTitle.accessibilityElementsHidden=self.toolbarTitleHidden || !compact;
+    self.toolbar.userInteractionEnabled=self.toolbarTouch && compact;
+    NSInteger phase=offset<=.5?0:offset>=self.range-.5?2:1;
+    if(phase!=self.phase){self.phase=phase;self.callbacks++;if(self.onState)self.onState();}
+    if(self.diagnostic)self.diagnostic.text=[NSString stringWithFormat:@"y %.0f · range %.0f · native %ld · JS %ld",offset,self.range,(long)self.updates,(long)self.callbacks];
+}
+- (NSString *)snapshot {
+    NSArray *rows=self.list.indexPathsForVisibleRows;
+    NSInteger first=rows.count?((NSIndexPath *)rows.firstObject).row:0;
+    NSDictionary *value=@{@"minimumOffset":@(self.minimumOffset),@"maximumOffset":@(self.maximumOffset),@"offset":@(isfinite(self.offset)?self.offset:0),@"phase":@[@"expanded",@"between",@"collapsed"][MAX(0,self.phase)],@"updates":@(self.updates),@"callbacks":@(self.callbacks),@"first":@(first),@"visible":@(rows.count),@"total":@([self.list numberOfRowsInSection:0])};
+    return [[NSString alloc]initWithData:[NSJSONSerialization dataWithJSONObject:value options:0 error:nil] encoding:NSUTF8StringEncoding];
+}
+- (void)scroll:(double)offset animated:(BOOL)animated {
+    if(self.disposed || !isfinite(offset))return;
+    UIEdgeInsets inset=self.list.adjustedContentInset;
+    double maximum=MAX(0,self.list.contentSize.height+inset.top+inset.bottom-self.list.bounds.size.height);
+    [self.list setContentOffset:CGPointMake(self.list.contentOffset.x,MIN(maximum,MAX(0,offset))-inset.top) animated:animated];
+    if(!animated)[self update:YES];
+}
+- (void)dispose {
+    if(self.disposed)return;[self setEnabled:NO];self.disposed=YES;
+    self.title.accessibilityElementsHidden=self.titleHidden;self.toolbarTitle.accessibilityElementsHidden=self.toolbarTitleHidden;self.toolbar.userInteractionEnabled=self.toolbarTouch;
+    if(self.list.delegate==self.proxy)self.list.delegate=self.proxy.forwarded;
+    if(self.list.estimatedSectionHeaderHeight==0)self.list.estimatedSectionHeaderHeight=self.estimatedSectionHeaderHeight;
+    if(self.list.estimatedSectionFooterHeight==0)self.list.estimatedSectionFooterHeight=self.estimatedSectionFooterHeight;
+    self.proxy=nil;self.node=nil;self.onState=nil;
+}
+@end

package/platforms/ios/src/JoltSensorMath.h

@@ -0,0 +1,39 @@
+// Canonical sensor math: device-to-reference Hamilton quaternions, xyzw.
+#ifndef JOLT_SENSOR_MATH_H
+#define JOLT_SENSOR_MATH_H
+#include <math.h>
+#include <stdbool.h>
+#include <string.h>
+static inline bool JoltSensorNormalize(double *q) {
+    double length = 0;
+    for (int i = 0; i < 4; i++) { if (!isfinite(q[i])) return false; length += q[i]*q[i]; }
+    length = sqrt(length);
+    if (!isfinite(length) || length < 1e-8) return false;
+    for (int i = 0; i < 4; i++) q[i] /= length;
+    return true;
+}
+static inline void JoltSensorMultiply(const double *a, const double *b, double *result) {
+    double q[] = { a[3]*b[0]+a[0]*b[3]+a[1]*b[2]-a[2]*b[1],
+        a[3]*b[1]-a[0]*b[2]+a[1]*b[3]+a[2]*b[0],
+        a[3]*b[2]+a[0]*b[1]-a[1]*b[0]+a[2]*b[3],
+        a[3]*b[3]-a[0]*b[0]-a[1]*b[1]-a[2]*b[2] };
+    memcpy(result, q, sizeof(q));
+}
+static inline void JoltSensorInverse(const double *q, double *result) {
+    for (int i=0;i<4;i++) result[i] = i == 3 ? q[i] : -q[i];
+}
+static inline void JoltSensorVector(const double *v, double degrees, double *out) {
+    double a = degrees*M_PI/180, c=cos(a), s=sin(a);
+    out[0]=c*v[0]+s*v[1]; out[1]=-s*v[0]+c*v[1]; out[2]=v[2];
+}
+static inline void JoltSensorRotation(const double *q, double degrees, const double *previous, double *out) {
+    double r[4]; JoltSensorVector(q, degrees, r); r[3]=q[3];
+    double dot=0; for(int i=0;i<4;i++) dot += r[i]*previous[i];
+    if(dot < 0) for(int i=0;i<4;i++) r[i]=-r[i];
+    double x=r[0], y=r[1], z=r[2], w=r[3];
+    out[0]=atan2(2*(w*x+y*z), 1-2*(x*x+y*y));
+    out[1]=asin(fmax(-1,fmin(1,2*(w*y-z*x))));
+    out[2]=atan2(2*(w*z+x*y),1-2*(y*y+z*z));
+    memcpy(out+3,r,sizeof(r));
+}
+#endif

package/platforms/ios/src/JoltSensorSource.h

@@ -0,0 +1,13 @@
+#import <Foundation/Foundation.h>
+#import "JoltLiveSpring.h"
+@interface JoltSensorSource : NSObject
++ (instancetype)create:(NSString *)kind options:(NSString *)options onState:(void (^)(void))onState;
++ (NSUInteger)activeCount;
++ (NSUInteger)sourceCount;
+- (void)connect:(JoltLiveSpring *)node index:(NSInteger)index;
+- (void)setEnabled:(BOOL)enabled paused:(BOOL)paused;
+- (void)recenter;
+- (void)replay:(NSString *)trace;
+- (NSString *)snapshot;
+- (void)dispose;
+@end

package/platforms/ios/src/JoltSensorSource.m

@@ -0,0 +1,201 @@
+#import "JoltSensorSource.h"
+#import "JoltSensorMath.h"
+#import <CoreMotion/CoreMotion.h>
+#import <UIKit/UIKit.h>
+#import <QuartzCore/QuartzCore.h>
+
+@interface JoltSensorSource () {
+    double reference[4], relative[4], output[7], pending[4];
+}
+@property(nonatomic) BOOL rotation, interfaceCoordinates, enabled, disposed, dirty, rebase, reset, available;
+@property(nonatomic) double interval, timestamp, pendingTimestamp, receivedAt, committedAt, processingMs;
+@property(nonatomic) NSUInteger samples, frames, callbacks, replayIndex;
+@property(nonatomic) NSString *status, *error, *configurationError;
+@property(nonatomic) NSMutableArray *nodes;
+@property(nonatomic,copy) void (^onState)(void);
+@property(nonatomic) NSArray *trace;
+@property(nonatomic) double replayStart, replayElapsed, replayOrientation;
+- (void)receive:(const double *)values timestamp:(double)timestamp;
+- (void)frame:(double)now;
+- (void)state:(NSString *)state;
+@end
+
+@implementation JoltSensorSource
+static NSMutableArray<JoltSensorSource *> *sources;
+static CMMotionManager *manager;
+static CADisplayLink *sensorDisplayLink;
+static BOOL suspended;
+static double hardwareInterval;
++ (void)initialize {
+    if (self != JoltSensorSource.class) return;
+    sources = [NSMutableArray new];
+    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(background) name:UIApplicationDidEnterBackgroundNotification object:nil];
+    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(foreground) name:UIApplicationWillEnterForegroundNotification object:nil];
+}
++ (void)background {
+    suspended=YES;
+    for(JoltSensorSource *s in sources) if(s.trace && s.replayStart) { s.replayElapsed=MAX(0,CACurrentMediaTime()*1000-s.replayStart); s.replayStart=0; }
+    [self refresh];
+}
++ (void)foreground {
+    suspended=NO;
+    for(JoltSensorSource *s in sources) { s.rebase=YES; s.receivedAt=CACurrentMediaTime()*1000; s.replayStart=0; }
+    [self refresh];
+}
++ (void)refresh {
+    double interval=INFINITY; BOOL ticking=NO;
+    for(JoltSensorSource *s in sources) if(s.enabled && !s.disposed && !suspended) {
+        if(s.trace) ticking=YES;
+        else if(s.available && !s.error) { interval=MIN(interval,s.interval); ticking=YES; }
+    }
+    if(isfinite(interval)) {
+        // Updating a shared rate must not restart Core Motion's arbitrary heading reference.
+        if(manager.deviceMotionActive && hardwareInterval!=interval) {
+            hardwareInterval=interval; manager.deviceMotionUpdateInterval=interval/1000;
+        }
+        if(!manager.deviceMotionActive) {
+            for(JoltSensorSource *s in sources) if(s.enabled && !s.trace) s.rebase=YES;
+            hardwareInterval=interval;
+            manager.deviceMotionUpdateInterval=interval/1000;
+            [manager startDeviceMotionUpdatesUsingReferenceFrame:CMAttitudeReferenceFrameXArbitraryZVertical toQueue:NSOperationQueue.mainQueue withHandler:^(CMDeviceMotion *motion,NSError *error){
+                if(suspended) return;
+                if(error) {
+                    for(JoltSensorSource *s in [sources copy]) if(s.enabled && !s.trace) { s.error=error.localizedDescription ?: @"motion-access-failed"; [s state:@"error"]; }
+                    [self refresh]; return;
+                }
+                if(!motion) return;
+                CMQuaternion q=motion.attitude.quaternion;
+                // Core Motion reports reference-to-device attitude; canonical inputs are device-to-reference.
+                double rotation[]={-q.x,-q.y,-q.z,q.w};
+                double gravity[]={motion.gravity.x*9.80665,motion.gravity.y*9.80665,motion.gravity.z*9.80665};
+                for(JoltSensorSource *s in [sources copy]) if(s.enabled && !s.trace && !s.error)
+                    [s receive:s.rotation ? rotation : gravity timestamp:motion.timestamp*1000];
+            }];
+        }
+    } else { [manager stopDeviceMotionUpdates]; hardwareInterval=0; }
+    if(ticking && !sensorDisplayLink) {
+        sensorDisplayLink=[CADisplayLink displayLinkWithTarget:self selector:@selector(tick:)];
+        [sensorDisplayLink addToRunLoop:NSRunLoop.mainRunLoop forMode:NSRunLoopCommonModes];
+    } else if(!ticking && sensorDisplayLink) { [sensorDisplayLink invalidate]; sensorDisplayLink=nil; }
+}
++ (void)tick:(CADisplayLink *)link {
+    for(JoltSensorSource *s in [sources copy]) if(s.enabled && !suspended) [s frame:link.timestamp*1000];
+}
++ (NSUInteger)activeCount { return manager.deviceMotionActive ? 1 : 0; }
++ (NSUInteger)sourceCount { return sources.count; }
++ (instancetype)create:(NSString *)kind options:(NSString *)options onState:(void (^)(void))onState {
+    if(!manager) manager=[CMMotionManager new];
+    NSDictionary *config=[NSJSONSerialization JSONObjectWithData:[options dataUsingEncoding:NSUTF8StringEncoding] options:0 error:nil];
+    JoltSensorSource *s=[self new];
+    s.rotation=[kind isEqual:@"rotation"]; s.interfaceCoordinates=[config[@"coordinates"] isEqual:@"interface"];
+    s.interval=[config[@"interval"] doubleValue];
+    if(s.interval==0) s.interval=1000.0/MAX(60,UIScreen.mainScreen.maximumFramesPerSecond);
+    s.interval=MAX(5,MIN(1000,s.interval)); s.timestamp=-1;
+    s.available=manager.deviceMotionAvailable; s.nodes=[NSMutableArray new];
+    for(int i=0;i<(s.rotation?7:3);i++) [s.nodes addObject:NSNull.null];
+    s->reference[3]=s->relative[3]=s->output[6]=1; s.rebase=YES;
+    id usage=NSBundle.mainBundle.infoDictionary[@"NSMotionUsageDescription"];
+    if(s.available && (![usage isKindOfClass:NSString.class] || ![usage length])) s.configurationError=@"missing-motion-usage-description";
+    s.error=s.configurationError;
+    s.status=s.error?@"error":(s.available?@"idle":@"unavailable"); s.onState=onState;
+    [sources addObject:s]; return s;
+}
+- (void)connect:(JoltLiveSpring *)node index:(NSInteger)index { if(index>=0 && index<self.nodes.count) self.nodes[index]=node; }
+- (void)state:(NSString *)state {
+    if([self.status isEqual:state]) return;
+    self.status=state;
+    if(self.onState) { self.callbacks++; self.onState(); }
+}
+- (void)setEnabled:(BOOL)enabled paused:(BOOL)paused {
+    if(self.disposed) return;
+    BOOL changed=self.enabled!=enabled; self.enabled=enabled;
+    if(changed) {
+        self.dirty=NO; self.committedAt=0; self.rebase=YES;
+        if(enabled) { self.receivedAt=CACurrentMediaTime()*1000; self.error=self.configurationError; self.replayStart=0; }
+        else if(self.trace && self.replayStart) {
+            self.replayElapsed=MAX(0,CACurrentMediaTime()*1000-self.replayStart); self.replayStart=0;
+        }
+    }
+    if(!enabled) [self state:paused?@"paused":(self.available?@"idle":@"unavailable")];
+    else if(changed) [self state:self.trace?@"replaying":(self.error?@"error":(self.available?@"starting":@"unavailable"))];
+    [JoltSensorSource refresh];
+}
+- (void)recenter { if(!self.disposed && self.rotation) { self.reset=YES; self.rebase=YES; } }
+- (void)replay:(NSString *)trace {
+    if(self.disposed) return;
+    NSArray *frames=[NSJSONSerialization JSONObjectWithData:[trace dataUsingEncoding:NSUTF8StringEncoding] options:0 error:nil];
+    if(![frames isKindOfClass:NSArray.class] || frames.count<2) return;
+    self.trace=frames; self.replayIndex=0; self.replayStart=0; self.replayElapsed=0; self.error=nil;
+    self.reset=YES; self.rebase=YES; self.dirty=NO; self.committedAt=0;
+    if(self.enabled) [self state:@"replaying"];
+    [JoltSensorSource refresh];
+}
+- (void)receive:(const double *)values timestamp:(double)timestamp {
+    if(!isfinite(timestamp) || timestamp<0) return;
+    if(!self.trace && self.timestamp>=0 && timestamp<=self.pendingTimestamp) return;
+    int count=self.rotation?4:3;
+    for(int i=0;i<count;i++) if(!isfinite(values[i])) return;
+    double input[4]={0}; memcpy(input,values,count*sizeof(double));
+    if(self.rotation && !JoltSensorNormalize(input)) return;
+    memcpy(pending,input,sizeof(input)); self.pendingTimestamp=timestamp; self.samples++; self.dirty=YES;
+    self.receivedAt=CACurrentMediaTime()*1000;
+}
+- (double)orientation {
+    if(!self.interfaceCoordinates) return 0;
+    if(self.trace) return self.replayOrientation;
+    for(UIScene *scene in UIApplication.sharedApplication.connectedScenes) if([scene isKindOfClass:UIWindowScene.class] && scene.activationState==UISceneActivationStateForegroundActive) {
+        switch(((UIWindowScene *)scene).interfaceOrientation) {
+            case UIInterfaceOrientationLandscapeLeft:return 90;
+            case UIInterfaceOrientationLandscapeRight:return 270;
+            case UIInterfaceOrientationPortraitUpsideDown:return 180;
+            default:return 0;
+        }
+    }
+    return 0;
+}
+- (void)frame:(double)now {
+    if(self.disposed || self.error) return;
+    if(self.trace) {
+        if(!self.replayStart) self.replayStart=now-self.replayElapsed;
+        double elapsed=now-self.replayStart;
+        while(self.replayIndex<self.trace.count && [self.trace[self.replayIndex][@"time"] doubleValue]<=elapsed) {
+            NSDictionary *sample=self.trace[self.replayIndex++]; NSArray *values=sample[@"values"];
+            if(values.count!=(self.rotation?4:3)) continue;
+            double input[4]={0}; for(int i=0;i<values.count;i++) input[i]=[values[i] doubleValue];
+            self.replayOrientation=[sample[@"orientation"] doubleValue];
+            [self receive:input timestamp:[sample[@"time"] doubleValue]];
+        }
+    } else if(self.available && now-self.receivedAt>MAX(3000,self.interval*3)) {
+        self.error=@"no-data"; [self state:@"error"]; [JoltSensorSource refresh]; return;
+    }
+    if(self.dirty && (!self.committedAt || now-self.committedAt>=self.interval-0.5)) {
+        double start=CACurrentMediaTime();
+        if(self.rotation) {
+            if(self.rebase) {
+                if(self.reset) { memset(relative,0,sizeof(relative)); relative[3]=1; }
+                double inverse[4]; JoltSensorInverse(relative,inverse); JoltSensorMultiply(pending,inverse,reference);
+                self.rebase=NO; self.reset=NO;
+            }
+            double inverse[4]; JoltSensorInverse(reference,inverse); JoltSensorMultiply(inverse,pending,relative);
+            JoltSensorRotation(relative,[self orientation],output+3,output);
+        } else JoltSensorVector(pending,[self orientation],output);
+        for(int i=0;i<self.nodes.count;i++) if(self.nodes[i]!=NSNull.null) [self.nodes[i] setSensorInput:output[i]];
+        self.dirty=NO; self.timestamp=self.pendingTimestamp; self.frames++; self.committedAt=now;
+        self.processingMs+=(CACurrentMediaTime()-start)*1000;
+        if(!self.trace) [self state:@"active"];
+    }
+    if(self.trace && self.replayIndex>=self.trace.count && !self.dirty) {
+        self.trace=nil; self.replayStart=0; self.replayElapsed=0; self.rebase=YES; self.receivedAt=now; self.error=self.configurationError;
+        [self state:self.error?@"error":self.available?@"starting":@"unavailable"]; [JoltSensorSource refresh];
+    }
+}
+- (NSString *)snapshot {
+    NSMutableArray *values=[NSMutableArray new];for(int i=0;i<(self.rotation?7:3);i++)[values addObject:@(output[i])];
+    NSDictionary *snapshot=@{@"status":self.status,@"available":@(self.available),@"error":self.error?:NSNull.null,@"timestamp":self.timestamp<0?NSNull.null:@(self.timestamp),@"samples":@(self.samples),@"frames":@(self.frames),@"callbacks":@(self.callbacks),@"processingMs":@(self.processingMs),@"interval":@(self.interval),@"values":values};
+    return [[NSString alloc]initWithData:[NSJSONSerialization dataWithJSONObject:snapshot options:0 error:nil] encoding:NSUTF8StringEncoding];
+}
+- (void)dispose {
+    if(self.disposed)return; self.disposed=YES;self.enabled=NO;self.status=@"disposed";self.onState=nil;
+    self.trace=nil;[self.nodes removeAllObjects];[sources removeObject:self];[JoltSensorSource refresh];
+}
+@end

package/platforms/ios/src/JoltSharedLayoutFlight.h

@@ -0,0 +1,19 @@
+#import <UIKit/UIKit.h>
+@interface JoltSharedLayoutFlight : UIView
++ (instancetype)capture:(UIView *)view image:(BOOL)image radius:(double)radius maxPixels:(double)maxPixels;
++ (instancetype)captureNavigationImage:(UIView *)view radius:(double)radius maxPixels:(double)maxPixels;
+- (NSString *)prepareNavigationImage:(UIView *)view radius:(double)radius maxPixels:(double)maxPixels;
++ (instancetype)captureClippedNavigationImage:(UIView *)view radius:(double)radius maxPixels:(double)maxPixels;
++ (NSInteger)activeCount;
+- (BOOL)holdPage:(UIView *)page maxPixels:(double)maxPixels;
+- (void)fade:(double)duration onEnd:(void (^)(BOOL))onEnd;
+- (double)pixels;
+- (NSString *)state;
+- (NSString *)prepare:(UIView *)view image:(BOOL)image radius:(double)radius maxPixels:(double)maxPixels;
+- (BOOL)freeze:(double)maxPixels;
+- (void)play:(NSString *)configuration onEnd:(void (^)(BOOL))onEnd;
+- (BOOL)beginInteractive:(NSString *)geometry;
+- (void)updateInteractive:(double)progress;
+- (BOOL)destinationIsStable;
+- (void)dispose;
+@end