@rafaelaugusto/jolt 0.1.0-beta.15 → 0.1.0-beta.17

package/platforms/ios/src/JoltLiveSpring.m

@@ -0,0 +1,236 @@
+#import "JoltLiveSpring.h"
+#import "JoltSpringState.h"
+#import <QuartzCore/QuartzCore.h>
+
+static id decode(NSString *json) {
+    return [NSJSONSerialization JSONObjectWithData:[json dataUsingEncoding:NSUTF8StringEncoding] options:0 error:nil];
+}
+static double mapped(double value, NSArray *mappings) {
+    for (NSDictionary *mapping in mappings) {
+        NSArray *input = mapping[@"input"], *output = mapping[@"output"];
+        BOOL clamp = [mapping[@"clamp"] boolValue];
+        if (clamp && value <= [input.firstObject doubleValue]) { value = [output.firstObject doubleValue]; continue; }
+        if (clamp && value >= [input.lastObject doubleValue]) { value = [output.lastObject doubleValue]; continue; }
+        NSUInteger index = 0;
+        while (index < input.count - 2 && value > [input[index + 1] doubleValue]) index++;
+        double span = [input[index + 1] doubleValue] - [input[index] doubleValue];
+        double fraction = span > 0 ? (value - [input[index] doubleValue]) / span : value < [input[index] doubleValue] ? 0 : 1;
+        value = [output[index] doubleValue] + ([output[index + 1] doubleValue] - [output[index] doubleValue]) * fraction;
+    }
+    return value;
+}
+static BOOL inputRunning(NSDictionary *input, double anchor, double now) {
+    double repeat = [input[@"repeat"] doubleValue];
+    return [input[@"running"] boolValue] && (repeat < 0 || now - anchor + [input[@"elapsed"] doubleValue] <
+           [input[@"delay"] doubleValue] + [input[@"duration"] doubleValue] * (repeat + 1));
+}
+static double inputValue(NSDictionary *input, double anchor, double now) {
+    NSArray *values = input[@"values"], *times = input[@"times"];
+    if (![input[@"running"] boolValue] || values.count < 2) return [input[@"value"] doubleValue];
+    if (!inputRunning(input, anchor, now)) return [input[@"to"] doubleValue];
+    double time = MAX(0, now - anchor + [input[@"elapsed"] doubleValue] - [input[@"delay"] doubleValue]);
+    double duration = MAX(1, [input[@"duration"] doubleValue]);
+    double iteration = floor(time / duration), progress = fmod(time, duration) / duration;
+    if ([input[@"reverse"] boolValue] && fmod(iteration, 2) >= 1) progress = 1 - progress;
+    NSUInteger lo = 0, hi = times.count - 1;
+    while (lo + 1 < hi) { NSUInteger mid = (lo + hi) / 2; if ([times[mid] doubleValue] <= progress) lo = mid; else hi = mid; }
+    double start = [times[lo] doubleValue], end = [times[hi] doubleValue];
+    double fraction = end > start ? (progress - start) / (end - start) : 1;
+    return [values[lo] doubleValue] + ([values[hi] doubleValue] - [values[lo] doubleValue]) * MAX(0, MIN(1, fraction));
+}
+
+@interface JoltLiveSpring () {
+    JoltSpringState _state;
+}
+@property(nonatomic) double stiffness, damping, mass, restDelta, restSpeed;
+@property(nonatomic, readwrite) BOOL moving;
+@property(nonatomic) BOOL reduced, paused, disposed, direct, inputHeld;
+@property(nonatomic) double targetValue;
+@property(nonatomic, nullable) JoltLiveSpring *source;
+@property(nonatomic) NSArray *sourceMaps;
+@property(nonatomic) NSDictionary *input;
+@property(nonatomic) double anchor;
+@property(nonatomic) NSMutableArray<JoltLiveSpringBinding *> *bindings;
+- (void)step:(double)now seconds:(double)seconds;
+- (void)apply;
+- (void)wake;
+@end
+@interface JoltLiveSpringBinding ()
+@property(nonatomic, weak) UIView *view;
+@property(nonatomic, weak) JoltLiveSpring *node;
+@property(nonatomic) NSString *property;
+@property(nonatomic) NSArray *mappings;
+@property(nonatomic) BOOL stopped;
+@property(nonatomic) NSArray *sampledLayers;
+@property(nonatomic) double layerAnchor;
+- (BOOL)running:(double)now;
+- (void)apply;
+@end
+
+@implementation JoltLiveSpring
+static NSMutableArray<JoltLiveSpring *> *nodes;
+static CADisplayLink *displayLink;
+static double previousFrame;
++ (void)initialize {
+    if (self == [JoltLiveSpring class]) nodes = [NSMutableArray new];
+}
++ (void)schedule {
+    if (displayLink || !nodes.count) return;
+    displayLink = [CADisplayLink displayLinkWithTarget:self selector:@selector(tick:)];
+    if (@available(iOS 15.0, *)) {
+        float maximum = MIN(120, UIScreen.mainScreen.maximumFramesPerSecond);
+        displayLink.preferredFrameRateRange = CAFrameRateRangeMake(MIN(80, maximum), maximum, maximum);
+    }
+    [displayLink addToRunLoop:NSRunLoop.mainRunLoop forMode:NSRunLoopCommonModes];
+}
++ (void)tick:(CADisplayLink *)link {
+    double now = link.timestamp * 1000;
+    double remaining = previousFrame == 0 ? 1.0 / 120 : MIN(.064, MAX(0, link.timestamp - previousFrame));
+    previousFrame = link.timestamp;
+    while (remaining > 1e-9) {
+        double dt = MIN(remaining, 1.0 / 240);
+        remaining -= dt;
+        for (JoltLiveSpring *node in nodes) [node step:now - remaining * 1000 seconds:dt];
+    }
+    BOOL active = NO;
+    [CATransaction begin]; [CATransaction setDisableActions:YES];
+    for (JoltLiveSpring *node in nodes) {
+        [node apply]; active |= node.moving;
+        for (JoltLiveSpringBinding *binding in node.bindings) active |= [binding running:now];
+    }
+    [CATransaction commit];
+    if (!active) { [displayLink invalidate]; displayLink = nil; previousFrame = 0; }
+}
++ (instancetype)create:(double)initial stiffness:(double)stiffness damping:(double)damping mass:(double)mass
+             restDelta:(double)restDelta restSpeed:(double)restSpeed reduced:(BOOL)reduced {
+    JoltLiveSpring *node = [self new];
+    node->_state = (JoltSpringState){initial, 0};
+    node.stiffness = stiffness; node.damping = damping; node.mass = mass;
+    node.restDelta = restDelta; node.restSpeed = restSpeed; node->_reduced = reduced;
+    node.direct = YES; node.targetValue = initial;
+    node.bindings = [NSMutableArray new]; node.sourceMaps = @[];
+    [nodes addObject:node];
+    return node;
+}
+- (double)position { return _state.position; }
+- (double)velocity { return _state.velocity; }
++ (NSUInteger)activeCount { return displayLink ? 1 : 0; }
++ (NSUInteger)nodeCount { return nodes.count; }
+- (void)follow:(JoltLiveSpring *)source mappings:(NSString *)mappings {
+    if (self.disposed || source.disposed || [nodes indexOfObject:source] >= [nodes indexOfObject:self])
+        [NSException raise:NSInvalidArgumentException format:@"A spring can only follow an existing live node"];
+    self.sourceMaps = decode(mappings); self.source = source; [self wake];
+}
+- (void)updateInput:(NSString *)snapshot {
+    if (self.disposed) return;
+    self.input = decode(snapshot); self.direct = NO; self.anchor = CACurrentMediaTime() * 1000; [self wake];
+}
+- (void)setTarget:(double)value {
+    if (self.disposed) return;
+    self.direct = YES; self.targetValue = value; self.input = nil; [self wake];
+}
+- (void)holdInput:(double)value velocity:(double)velocity {
+    if (self.disposed) return;
+    self.inputHeld = YES; self.direct = YES; self.targetValue = value; self.input = nil;
+    _state = (JoltSpringState){value, velocity}; self.moving = YES;
+    [CATransaction begin]; [CATransaction setDisableActions:YES]; [self apply]; [CATransaction commit];
+    [JoltLiveSpring schedule];
+}
+- (void)releaseInput:(double)target velocity:(double)velocity {
+    if (self.disposed) return;
+    self.inputHeld = NO; _state.velocity = velocity; [self setTarget:target];
+}
+- (void)setReduced:(BOOL)value { _reduced = value; [self wake]; }
+- (void)setPaused:(BOOL)value {
+    _paused = value;
+    if (value) self.moving = NO; else [self wake];
+}
+- (void)wake {
+    if (self.disposed || self.paused) return;
+    self.moving = YES;
+    if (self.reduced) {
+        [self step:CACurrentMediaTime() * 1000 seconds:0];
+        [CATransaction begin]; [CATransaction setDisableActions:YES]; [self apply]; [CATransaction commit];
+    }
+    [JoltLiveSpring schedule];
+}
+- (void)step:(double)now seconds:(double)seconds {
+    if (self.disposed || self.paused || self.inputHeld) return;
+    double target = self.source ? mapped(self.source.position, self.sourceMaps) : (self.direct ? self.targetValue : inputValue(self.input, self.anchor, now));
+    BOOL inputMoving = self.source ? self.source.moving : (!self.direct && inputRunning(self.input, self.anchor, now));
+    if (self.reduced) _state = (JoltSpringState){target, 0};
+    else _state = JoltSpringAdvance(_state, target, self.stiffness, self.damping, self.mass, seconds);
+    BOOL rest = fabs(_state.position - target) <= self.restDelta && fabs(_state.velocity) <= self.restSpeed;
+    if (rest && !inputMoving) _state = (JoltSpringState){target, 0};
+    self.moving = inputMoving || !rest;
+}
+- (JoltLiveSpringBinding *)bind:(UIView *)view property:(NSString *)property mappings:(NSString *)mappings {
+    if (self.disposed) [NSException raise:NSInvalidArgumentException format:@"Spring disposed"];
+    JoltLiveSpringBinding *binding = [JoltLiveSpringBinding new];
+    binding.node = self; binding.view = view; binding.property = property; binding.mappings = decode(mappings);
+    [self.bindings addObject:binding];
+    [CATransaction begin]; [CATransaction setDisableActions:YES]; [binding apply]; [CATransaction commit];
+    return binding;
+}
+- (void)apply {
+    for (NSInteger i = self.bindings.count - 1; i >= 0; i--) {
+        JoltLiveSpringBinding *binding = self.bindings[i];
+        if (!binding.view) [self.bindings removeObjectAtIndex:i]; else [binding apply];
+    }
+}
++ (void)sync:(UIView *)view {
+    [CATransaction begin]; [CATransaction setDisableActions:YES];
+    for (JoltLiveSpring *node in nodes)
+        for (JoltLiveSpringBinding *binding in node.bindings)
+            if (binding.view == view) [binding apply];
+    [CATransaction commit];
+}
+- (void)dispose {
+    if (self.disposed) return;
+    self.disposed = YES; self.moving = NO; [self.bindings removeAllObjects]; [nodes removeObject:self];
+    for (JoltLiveSpring *child in nodes) if (child.source == self) {
+        child.source = nil; [child setTarget:mapped(self.position, child.sourceMaps)];
+    }
+    self.source = nil;
+    if (!nodes.count) { [displayLink invalidate]; displayLink = nil; previousFrame = 0; }
+}
+@end
+
+@implementation JoltLiveSpringBinding
+- (double)value { return mapped(self.node.position, self.mappings); }
+- (void)setLayers:(NSString *)inputs {
+    self.sampledLayers = decode(inputs); self.layerAnchor = CACurrentMediaTime() * 1000;
+    [CATransaction begin]; [CATransaction setDisableActions:YES]; [self apply]; [CATransaction commit];
+    [JoltLiveSpring schedule];
+}
+- (BOOL)running:(double)now {
+    for (NSDictionary *layer in self.sampledLayers) if (inputRunning(layer, self.layerAnchor, now)) return YES;
+    return NO;
+}
+- (void)cancel { self.stopped = YES; [self.node.bindings removeObject:self]; }
+- (void)apply {
+    UIView *view = self.view;
+    if (self.stopped || !view.window) return;
+    NSString *key = self.property;
+    double value = self.value;
+    BOOL multiply = [key isEqualToString:@"opacity"] || [key hasPrefix:@"scale"];
+    double now = CACurrentMediaTime() * 1000;
+    for (NSDictionary *layer in self.sampledLayers) {
+        double part = inputValue(layer, self.layerAnchor, now);
+        value = multiply ? value * part : value + part;
+    }
+    if ([key isEqualToString:@"opacity"]) { view.alpha = MAX(0, MIN(1, value)); return; }
+    if ([key isEqualToString:@"x"]) key = @"transform.translation.x";
+    else if ([key isEqualToString:@"y"]) key = @"transform.translation.y";
+    else if ([key isEqualToString:@"scaleX"]) key = @"transform.scale.x";
+    else if ([key isEqualToString:@"scaleY"]) key = @"transform.scale.y";
+    else if ([key isEqualToString:@"rotate"]) { key = @"transform.rotation.z"; value *= M_PI / 180; }
+    else if ([key isEqualToString:@"rotateX"]) { key = @"transform.rotation.x"; value *= M_PI / 180; }
+    else if ([key isEqualToString:@"rotateY"]) { key = @"transform.rotation.y"; value *= M_PI / 180; }
+    [view.layer setValue:@(value) forKeyPath:key];
+    if ([view respondsToSelector:NSSelectorFromString(@"outerShadowContainerLayer")]) {
+        CALayer *shadow = [view valueForKey:@"outerShadowContainerLayer"];
+        [shadow setValue:@(value) forKeyPath:key];
+    }
+}
+@end

package/platforms/ios/src/JoltReorderSession.h

@@ -0,0 +1,15 @@
+#import <UIKit/UIKit.h>
+
+@interface JoltReorderHandle : UIButton
+@property(nonatomic, copy) void (^onMove)(NSInteger direction);
+@end
+
+@interface JoltReorderSession : NSObject
++ (instancetype)attach:(UITableView *)list options:(NSString *)options onState:(void (^)(NSInteger state, NSInteger index, NSInteger toIndex))onState;
+- (void)registerHandle:(UIView *)view;
+- (void)setEnabled:(BOOL)enabled;
+- (void)setReducedMotion:(BOOL)reduced;
+- (void)cancel;
+- (void)dispose;
+@property(nonatomic, readonly) BOOL active;
+@end

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/JoltSpringState.h

@@ -0,0 +1,35 @@
+#ifndef JOLT_SPRING_STATE_H
+#define JOLT_SPRING_STATE_H
+#include <math.h>
+
+/* Exact constant-target solution. Position and velocity survive every retarget. */
+typedef struct { double position, velocity; } JoltSpringState;
+static inline JoltSpringState JoltSpringAdvance(JoltSpringState state, double target,
+        double stiffness, double damping, double mass, double seconds) {
+    if (seconds <= 0) return state;
+    const double x = state.position - target;
+    const double w = sqrt(stiffness / mass);
+    const double z = damping / (2 * sqrt(stiffness * mass));
+    double next, speed;
+    if (fabs(z - 1) < 1e-6) {
+        const double b = state.velocity + w * x, e = exp(-w * seconds);
+        next = e * (x + b * seconds);
+        speed = e * (b - w * (x + b * seconds));
+    } else if (z < 1) {
+        const double a = z * w, d = w * sqrt(1 - z * z);
+        const double b = (state.velocity + a * x) / d;
+        const double c = cos(d * seconds), s = sin(d * seconds), e = exp(-a * seconds);
+        next = e * (x * c + b * s);
+        speed = e * ((-a * x + b * d) * c + (-a * b - x * d) * s);
+    } else {
+        const double q = sqrt(z * z - 1);
+        /* Rationalized slow root avoids catastrophic cancellation at high damping. */
+        const double r1 = -w / (z + q), r2 = -w * (z + q);
+        const double c1 = (state.velocity - r2 * x) / (r1 - r2), c2 = x - c1;
+        const double e1 = exp(r1 * seconds), e2 = exp(r2 * seconds);
+        next = c1 * e1 + c2 * e2;
+        speed = c1 * r1 * e1 + c2 * r2 * e2;
+    }
+    return (JoltSpringState){target + next, speed};
+}
+#endif

package/platforms/ios/src/module.modulemap

@@ -2,5 +2,8 @@ module JoltMotion {
     header "JoltImageEffect.h"
     header "JoltPhotoZoom.h"
     header "JoltInteractiveAnimation.h"
+    header "JoltLiveSpring.h"
+    header "JoltGestureSession.h"
+    header "JoltReorderSession.h"
     export *
 }

package/src/android-plugin.d.ts

@@ -1,4 +1,97 @@
 declare namespace org.rafaelaugusto.jolt {
+  class ReorderSurface extends org.nativescript.widgets.GridLayout {
+    constructor(context: android.content.Context)
+  }
+  class ReorderHandle extends android.widget.Button {
+    constructor(context: android.content.Context)
+    setMoveListener(listener: ReorderHandle.MoveListener | null): void
+  }
+  namespace ReorderHandle {
+    class MoveListener {
+      constructor(implementation: { move(direction: number): void })
+    }
+  }
+  class ReorderSession {
+    constructor(
+      surface: ReorderSurface,
+      list: android.widget.ListView,
+      options: string,
+      listener: ReorderSession.Listener,
+    )
+    isActive(): boolean
+    registerHandle(view: android.view.View): void
+    setEnabled(enabled: boolean): void
+    setReducedMotion(reduced: boolean): void
+    cancel(): void
+    dispose(): void
+  }
+  namespace ReorderSession {
+    class Listener {
+      constructor(implementation: {
+        onState(state: number, index: number, toIndex: number): void
+      })
+    }
+  }
+  class GestureSurface extends org.nativescript.widgets.GridLayout {
+    constructor(context: android.content.Context)
+  }
+  class GestureSession {
+    static supportsContactEvents(): boolean
+    constructor(
+      surface: GestureSurface,
+      scroll: android.view.View | null,
+      x: LiveSpring,
+      y: LiveSpring,
+      scale: LiveSpring,
+      rotation: LiveSpring,
+      options: string,
+      listener: GestureSession.Listener,
+    )
+    isActive(): boolean
+    cancel(): void
+    setEnabled(value: boolean): void
+    settle(x: number, y: number, scale: number, rotation: number, animated: boolean): void
+    updateBounds(left: number, right: number, top: number, bottom: number): void
+    dispose(): void
+  }
+  namespace GestureSession {
+    class Listener {
+      constructor(implementation: {
+        onState(state: number, velocityX: number, velocityY: number): void
+      })
+    }
+  }
+  class LiveSpring {
+    constructor(
+      initial: number,
+      stiffness: number,
+      damping: number,
+      mass: number,
+      restDelta: number,
+      restSpeed: number,
+      reduced: boolean,
+    )
+    static activeCount(): number
+    static nodeCount(): number
+    static sync(view: android.view.View): void
+    getPosition(): number
+    getVelocity(): number
+    isMoving(): boolean
+    follow(source: LiveSpring, mappings: string): void
+    updateInput(snapshot: string): void
+    setTarget(value: number): void
+    setReduced(value: boolean): void
+    setPaused(value: boolean): void
+    bind(view: android.view.View, property: string, mappings: string): LiveSpring.Binding
+    dispose(): void
+  }
+  namespace LiveSpring {
+    class Binding {
+      getValue(): number
+      setLayers(inputs: string): void
+      cancel(): void
+    }
+  }
   class ParticleEmitter {
     constructor(
       target: android.view.View,