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

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,15 @@
+#import <UIKit/UIKit.h>
+#import "JoltLiveSpring.h"
+NS_ASSUME_NONNULL_BEGIN
+@interface JoltScrollHeader : NSObject
++ (instancetype)attach:(UIScrollView *)list node:(JoltLiveSpring *)node header:(UIView *)header title:(UIView *)title toolbarTitle:(UIView *)toolbarTitle toolbar:(UIView *)toolbar diagnostic:(nullable UILabel *)diagnostic options:(NSString *)options onState:(void (^)(void))onState;
+- (void)setRows:(NSArray<UIView *> *)rows;
++ (NSInteger)activeCount;
+- (void)configure:(NSString *)options;
+- (NSString *)snapshot;
+- (void)scroll:(double)offset animated:(BOOL)animated;
+- (void)setEnabled:(BOOL)enabled;
+- (void)setRefreshing:(BOOL)refreshing;
+- (void)dispose;
+@end
+NS_ASSUME_NONNULL_END

package/platforms/ios/src/JoltScrollHeader.m

@@ -0,0 +1,244 @@
+#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) UIScrollView *list;
+@property(nonatomic) NSArray<UIView *> *rows;
+@property(nonatomic) JoltLiveSpring *node;
+@property(nonatomic,weak) UIView *header, *title, *toolbarTitle, *toolbar;
+@property(nonatomic,weak) UILabel *diagnostic;
+@property(nonatomic,copy) void (^onState)(void);
+@property(nonatomic) BOOL observing, disposed, headerHidden, titleHidden, toolbarTitleHidden, toolbarHidden, toolbarTouch, titleElement, toolbarTitleElement;
+@property(nonatomic) double handoff, minimumOffset, maximumOffset, range, spacer, rowHeight, offset;
+@property(nonatomic) CGFloat estimatedSectionHeaderHeight, estimatedSectionFooterHeight;
+@property(nonatomic) NSInteger phase, accessibilityPhase, updates, callbacks;
+@property(nonatomic) BOOL refreshEnabled, reduced, pullEligible, panObserving;
+@property(nonatomic) double refreshThreshold, pull;
+@property(nonatomic) NSInteger refreshState, refreshRequests;
+@property(nonatomic) UIView *refreshIndicator;
+@property(nonatomic) CAShapeLayer *refreshRing;
+@property(nonatomic) NSMapTable<UIView *,NSNumber *> *coveredRows;
+@end
+static NSInteger JoltScrollHeaderActive = 0;
+static void *JoltScrollHeaderContext = &JoltScrollHeaderContext;
+@implementation JoltScrollHeader
++ (NSInteger)activeCount { return JoltScrollHeaderActive; }
++ (instancetype)attach:(UIScrollView *)list node:(JoltLiveSpring *)node header:(UIView *)header title:(UIView *)title toolbarTitle:(UIView *)toolbarTitle toolbar:(UIView *)toolbar diagnostic:(UILabel *)diagnostic options:(NSString *)options onState:(void (^)(void))onState {
+    if(![list isKindOfClass:UIScrollView.class]) [NSException raise:NSInvalidArgumentException format:@"scrollHeader requires UIScrollView"];
+    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.toolbarHidden=toolbar.accessibilityElementsHidden;owner.titleElement=title.isAccessibilityElement;owner.toolbarTitleElement=toolbarTitle.isAccessibilityElement;owner.accessibilityPhase=-1;
+    owner.coveredRows=[NSMapTable weakToStrongObjectsMapTable];
+    owner.header=header;owner.headerHidden=header.accessibilityElementsHidden;
+    if([list isKindOfClass:UITableView.class]) {
+    UITableView *table=(UITableView *)list;
+    owner.proxy=[JoltScrollHeaderDelegate new];owner.proxy.forwarded=table.delegate;
+    // Flat lists have no section headers/footers. UIKit's automatic estimates
+    // otherwise adjust the scroll anchor during width/safe-area changes.
+    owner.estimatedSectionHeaderHeight=table.estimatedSectionHeaderHeight;
+    owner.estimatedSectionFooterHeight=table.estimatedSectionFooterHeight;
+    table.estimatedSectionHeaderHeight=0;table.estimatedSectionFooterHeight=0;
+    table.delegate=owner.proxy;
+    }
+    [owner configure:options];[list layoutIfNeeded];[owner setEnabled:YES];return owner;
+}
+- (void)setRows:(NSArray<UIView *> *)rows {
+    if(self.disposed)return;
+    for(UIView *row in self.coveredRows.keyEnumerator.allObjects){NSNumber *saved=[self.coveredRows objectForKey:row];row.accessibilityElementsHidden=(saved.integerValue&1)!=0;row.isAccessibilityElement=(saved.integerValue&2)!=0;}
+    [self.coveredRows removeAllObjects];_rows=[rows copy];
+    if(self.observing)[self update:YES];
+}
+- (void)configure:(NSString *)options {
+    NSDictionary *config=[NSJSONSerialization JSONObjectWithData:[options dataUsingEncoding:NSUTF8StringEncoding] options:0 error:nil];
+    self.handoff=[config[[config[@"reduced"] boolValue]?@"handoff":@"focusHandoff"] 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.reduced=[config[@"reduced"] boolValue];self.refreshEnabled=[config[@"refresh"] boolValue];self.refreshThreshold=[config[@"refreshThreshold"] doubleValue];
+    if(self.refreshEnabled && !self.refreshIndicator){
+        if(self.list.refreshControl) [NSException raise:NSInvalidArgumentException format:@"scrollHeader cannot replace an app-owned refresh control"];
+        self.refreshIndicator=[[UIView alloc]initWithFrame:CGRectMake(0,0,36,36)];
+        self.refreshIndicator.backgroundColor=[UIColor colorWithRed:.957 green:.941 blue:.906 alpha:1];
+        self.refreshIndicator.layer.cornerRadius=18;self.refreshIndicator.userInteractionEnabled=NO;
+        self.refreshIndicator.accessibilityElementsHidden=YES;self.refreshIndicator.hidden=YES;
+        self.refreshRing=[CAShapeLayer layer];self.refreshRing.frame=self.refreshIndicator.bounds;
+        self.refreshRing.path=[UIBezierPath bezierPathWithArcCenter:CGPointMake(18,18) radius:11 startAngle:-M_PI_2 endAngle:M_PI*1.5 clockwise:YES].CGPath;
+        self.refreshRing.fillColor=UIColor.clearColor.CGColor;
+        self.refreshRing.strokeColor=[UIColor colorWithRed:.098 green:.239 blue:.204 alpha:1].CGColor;
+        self.refreshRing.lineWidth=3;self.refreshRing.lineCap=kCALineCapRound;
+        [self.refreshIndicator.layer addSublayer:self.refreshRing];
+        [self.list.superview addSubview:self.refreshIndicator];
+    }
+    [self updateRefreshIndicator];
+    if([self.list isKindOfClass:UITableView.class])[(UITableView *)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];
+        if(self.refreshEnabled){[self.list.panGestureRecognizer addTarget:self action:@selector(refreshPan:)];self.panObserving=YES;}
+        JoltScrollHeaderActive++;[self update:YES];
+    } else {
+        for(NSString *key in @[@"contentOffset",@"contentSize",@"bounds"]) [self.list removeObserver:self forKeyPath:key context:JoltScrollHeaderContext];
+        if(self.panObserving){[self.list.panGestureRecognizer removeTarget:self action:@selector(refreshPan:)];self.panObserving=NO;}
+        self.pullEligible=NO;self.pull=0;if(self.refreshState!=3)[self changeRefreshState:0];
+        JoltScrollHeaderActive--;
+    }
+    [self updateRefreshIndicator];
+}
+- (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;
+    if(self.refreshEnabled && self.pullEligible && self.refreshState!=3){
+        self.pull=MAX(0,-offset);
+        [self changeRefreshState:self.pull>=self.refreshThreshold?2:self.pull>0?1:0];
+    }
+    [self updateRefreshIndicator];
+    self.minimumOffset=MIN(self.minimumOffset,offset);self.maximumOffset=MAX(self.maximumOffset,offset);self.updates++;
+    BOOL compact=offset>=self.range*self.handoff;
+    UIView *outgoing=compact?self.title:self.toolbarTitle, *incoming=compact?self.toolbarTitle:self.title;
+    // Inspect focus only at a semantic boundary while VoiceOver is running.
+    // An unrelated row/control never triggers a title handoff.
+    BOOL transfer=NO;
+    if(self.accessibilityPhase>=0 && self.accessibilityPhase!=(compact?1:0) && UIAccessibilityIsVoiceOverRunning()) {
+        id focused=UIAccessibilityFocusedElement(UIAccessibilityNotificationVoiceOverIdentifier);
+        transfer=focused==outgoing || ([focused isKindOfClass:UIView.class] && [(UIView *)focused isDescendantOfView:compact?self.header:self.toolbar]);
+    }
+    // Existing native value graph applies all derived bindings in one transaction.
+    [self.node setTarget:offset];
+    [self updateAccessibleRows];
+    if(self.accessibilityPhase!=(compact?1:0)) {
+        self.accessibilityPhase=compact?1:0;
+        self.header.accessibilityElementsHidden=self.headerHidden || compact;
+        self.title.accessibilityElementsHidden=self.titleHidden || compact;
+        self.title.isAccessibilityElement=self.titleElement && !compact;
+        self.toolbarTitle.accessibilityElementsHidden=self.toolbarTitleHidden || !compact;
+        self.toolbarTitle.isAccessibilityElement=self.toolbarTitleElement && compact;
+        self.toolbar.accessibilityElementsHidden=self.toolbarHidden || !compact;
+        self.toolbar.userInteractionEnabled=self.toolbarTouch && compact;
+        if(transfer && incoming.isAccessibilityElement && !incoming.accessibilityElementsHidden && !(compact?self.toolbarHidden:self.headerHidden)) {
+            // Let the current accessibility scroll/activation finish first.
+            // UIKit can otherwise replace a synchronous handoff with its own
+            // fallback focus after the outgoing element becomes hidden.
+            __weak JoltScrollHeader *weakSelf=self;
+            NSInteger expected=self.accessibilityPhase;
+            dispatch_async(dispatch_get_main_queue(), ^{
+                JoltScrollHeader *owner=weakSelf;
+                if(!owner || owner.disposed || !owner.observing || owner.accessibilityPhase!=expected || !UIAccessibilityIsVoiceOverRunning())return;
+                UIView *target=expected?owner.toolbarTitle:owner.title;
+                if(target.isAccessibilityElement && !target.accessibilityElementsHidden)
+                    UIAccessibilityPostNotification(UIAccessibilityLayoutChangedNotification,target);
+            });
+        }
+    }
+    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];
+}
+- (void)updateAccessibleRows {
+    UITableView *table=[self.list isKindOfClass:UITableView.class]?(UITableView *)self.list:nil;
+    NSArray<UIView *> *visible=table?table.visibleCells:(self.rows?:@[]);
+    for(UIView *cell in self.coveredRows.keyEnumerator.allObjects) {
+        if(![visible containsObject:cell]){NSInteger saved=[[self.coveredRows objectForKey:cell] integerValue];cell.accessibilityElementsHidden=(saved&1)!=0;cell.isAccessibilityElement=(saved&2)!=0;[self.coveredRows removeObjectForKey:cell];}
+    }
+    double edge=self.spacer-MIN(self.range,MAX(0,self.offset));
+    for(UIView *cell in visible) {
+        if(![cell isDescendantOfView:self.list])continue;
+        NSIndexPath *path=table?[table indexPathForCell:(UITableViewCell *)cell]:nil;
+        CGRect frame=[cell convertRect:cell.bounds toView:self.list];
+        BOOL hidden=(table && path.row==0) || CGRectGetMaxY(frame)-self.list.contentOffset.y<=edge+.5;
+        NSNumber *saved=[self.coveredRows objectForKey:cell];
+        if(hidden){
+            if(!saved)[self.coveredRows setObject:@((cell.accessibilityElementsHidden?1:0)|(cell.isAccessibilityElement?2:0)) forKey:cell];
+            if(!cell.accessibilityElementsHidden)cell.accessibilityElementsHidden=YES;
+            if(cell.isAccessibilityElement)cell.isAccessibilityElement=NO;
+        } else if(saved){cell.accessibilityElementsHidden=(saved.integerValue&1)!=0;cell.isAccessibilityElement=(saved.integerValue&2)!=0;[self.coveredRows removeObjectForKey:cell];}
+    }
+}
+- (NSString *)snapshot {
+    UITableView *table=[self.list isKindOfClass:UITableView.class]?(UITableView *)self.list:nil;
+    NSArray *rows=table.indexPathsForVisibleRows;
+    NSInteger first=rows.count?((NSIndexPath *)rows.firstObject).row:0, visible=rows.count, total=table?[table numberOfRowsInSection:0]:self.rows.count;
+    if(!table){visible=0;for(NSUInteger i=0;i<self.rows.count;i++){UIView *row=self.rows[i];if(![row isDescendantOfView:self.list])continue;if(CGRectIntersectsRect([row convertRect:row.bounds toView:self.list],self.list.bounds)){if(!visible)first=i;visible++;}}}
+    NSDictionary *value=@{@"minimumOffset":@(self.minimumOffset),@"maximumOffset":@(self.maximumOffset),@"offset":@(isfinite(self.offset)?self.offset:0),@"phase":@[@"expanded",@"between",@"collapsed"][MAX(0,self.phase)],@"refresh":@[@"idle",@"pulling",@"armed",@"refreshing"][self.refreshState],@"refreshRequests":@(self.refreshRequests),@"updates":@(self.updates),@"callbacks":@(self.callbacks),@"first":@(first),@"visible":@(visible),@"total":@(total)};
+    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)changeRefreshState:(NSInteger)state {
+    if(self.refreshState==state)return;
+    self.refreshState=state;if(state==3)self.refreshRequests++;
+    [self updateRefreshIndicator];self.callbacks++;if(self.onState)self.onState();
+}
+- (void)setRefreshing:(BOOL)value {
+    if(self.disposed || (value && (!self.observing || !self.refreshEnabled)))return;
+    self.pullEligible=NO;self.pull=0;[self changeRefreshState:value?3:0];
+}
+- (void)refreshPan:(UIPanGestureRecognizer *)pan {
+    if(self.disposed || !self.observing || !self.refreshEnabled || self.refreshState==3)return;
+    if(pan.state==UIGestureRecognizerStateBegan){
+        self.pullEligible=self.offset<=.5;
+    } else if(pan.state==UIGestureRecognizerStateEnded){
+        BOOL trigger=self.pullEligible && self.pull>=self.refreshThreshold;
+        self.pullEligible=NO;self.pull=0;[self changeRefreshState:0];
+        if(trigger)[self setRefreshing:YES];
+    } else if(pan.state==UIGestureRecognizerStateCancelled || pan.state==UIGestureRecognizerStateFailed){
+        self.pullEligible=NO;self.pull=0;[self changeRefreshState:0];
+    }
+}
+- (void)updateRefreshIndicator {
+    if(!self.refreshIndicator)return;
+    BOOL visible=self.observing && self.refreshState>0;
+    self.refreshIndicator.hidden=!visible;
+    if(!visible){[self.refreshRing removeAnimationForKey:@"refresh"];return;}
+    UIView *host=self.list.superview;
+    self.refreshIndicator.center=CGPointMake(CGRectGetMidX(self.list.frame),CGRectGetMinY(self.list.frame)+(self.refreshState==3?32:MIN(60,self.pull)*.6+16));
+    [host bringSubviewToFront:self.refreshIndicator];
+    [CATransaction begin];[CATransaction setDisableActions:YES];
+    self.refreshRing.strokeEnd=self.refreshState==3?.75:MAX(.08,MIN(1,self.pull/self.refreshThreshold)*.92);
+    [CATransaction commit];
+    if(self.refreshState==3 && !self.reduced){
+        if(![self.refreshRing animationForKey:@"refresh"]){
+            CABasicAnimation *spin=[CABasicAnimation animationWithKeyPath:@"transform.rotation.z"];
+            spin.fromValue=@0;spin.toValue=@(M_PI*2);spin.duration=.9;spin.repeatCount=HUGE_VALF;
+            [self.refreshRing addAnimation:spin forKey:@"refresh"];
+        }
+    } else [self.refreshRing removeAnimationForKey:@"refresh"];
+}
+- (void)dispose {
+    if(self.disposed)return;[self setRefreshing:NO];[self setEnabled:NO];self.disposed=YES;
+    [self.refreshRing removeAllAnimations];[self.refreshIndicator removeFromSuperview];self.refreshIndicator=nil;self.refreshRing=nil;
+    self.title.accessibilityElementsHidden=self.titleHidden;self.toolbarTitle.accessibilityElementsHidden=self.toolbarTitleHidden;self.toolbar.userInteractionEnabled=self.toolbarTouch;
+    self.title.isAccessibilityElement=self.titleElement;self.toolbarTitle.isAccessibilityElement=self.toolbarTitleElement;self.toolbar.accessibilityElementsHidden=self.toolbarHidden;
+    self.header.accessibilityElementsHidden=self.headerHidden;
+    for(UIView *cell in self.coveredRows.keyEnumerator.allObjects){NSInteger saved=[[self.coveredRows objectForKey:cell] integerValue];cell.accessibilityElementsHidden=(saved&1)!=0;cell.isAccessibilityElement=(saved&2)!=0;}[self.coveredRows removeAllObjects];
+    UITableView *table=[self.list isKindOfClass:UITableView.class]?(UITableView *)self.list:nil;
+    if(self.proxy && table.delegate==self.proxy)table.delegate=self.proxy.forwarded;
+    if(table && table.estimatedSectionHeaderHeight==0)table.estimatedSectionHeaderHeight=self.estimatedSectionHeaderHeight;
+    if(table && table.estimatedSectionFooterHeight==0)table.estimatedSectionFooterHeight=self.estimatedSectionFooterHeight;
+    self.proxy=nil;self.node=nil;self.onState=nil;_rows=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