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

package/platforms/android/java/org/rafaelaugusto/jolt/ReorderSession.java

@@ -0,0 +1,213 @@
+package org.rafaelaugusto.jolt;
+
+import android.animation.Animator;
+import android.animation.AnimatorListenerAdapter;
+import android.animation.ValueAnimator;
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import android.graphics.Rect;
+import android.view.Choreographer;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.ViewConfiguration;
+import android.view.ViewGroup;
+import android.widget.ImageView;
+import android.widget.ListView;
+import org.json.JSONObject;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Set;
+import java.util.WeakHashMap;
+
+/** Core ListView input, snapshot, recycling and edge autoscroll stay on the UI thread. */
+public final class ReorderSession implements View.OnTouchListener, Choreographer.FrameCallback, View.OnLayoutChangeListener, View.OnAttachStateChangeListener {
+    public interface Listener { void onState(int state, int index, int toIndex); }
+    private static final class Cell {
+        final float translation, alpha;
+        final int index;
+        final SpringState spring = new SpringState(0, 0);
+        Cell(View view, int index) { this.translation = view.getTranslationY(); this.alpha = view.getAlpha(); this.index = index; }
+    }
+    final ListView list;
+    private final ReorderSurface surface;
+    private final Listener listener;
+    private final WeakHashMap<View, Cell> cells = new WeakHashMap<>();
+    private final Set<View> handles = Collections.newSetFromMap(new WeakHashMap<View, Boolean>());
+    private final float density, edgeSize, edgeSpeed, slop;
+    private final long longPress;
+    private final boolean handlesOnly;
+    private final Runnable activate = () -> begin();
+    private boolean enabled = true, disposed, active, settling, pending, reduced;
+    private int from, target, count, generation, width, height;
+    private float downX, downY, pointerX, pointerY, grabOffset, rowHeight, remainder;
+    private long previousTime;
+    private ImageView overlay;
+    private Bitmap bitmap;
+    private ValueAnimator drop;
+
+    public ReorderSession(ReorderSurface surface, ListView list, String options, Listener listener) {
+        this.surface = surface; this.list = list; this.listener = listener;
+        density = list.getResources().getDisplayMetrics().density;
+        slop = ViewConfiguration.get(list.getContext()).getScaledTouchSlop();
+        try {
+            JSONObject config = new JSONObject(options);
+            longPress = config.getLong("longPress"); edgeSize = (float)config.getDouble("edgeSize") * density;
+            edgeSpeed = (float)config.getDouble("edgeSpeed") * density;
+            reduced = config.getBoolean("reducedMotion"); handlesOnly = config.getBoolean("handles");
+        } catch (Exception error) { throw new IllegalArgumentException(error); }
+        surface.setSession(this); list.addOnLayoutChangeListener(this); list.addOnAttachStateChangeListener(this);
+    }
+    public boolean isActive() { return active; }
+    public void registerHandle(View view) {
+        if (!disposed && view != null) {
+            handles.add(view);
+        }
+    }
+    private boolean inHandle(float x, float y) {
+        if (!handlesOnly) return true;
+        Rect rect = new Rect();
+        for (View handle : handles) {
+            if (handle == null || !handle.isShown()) continue;
+            android.view.ViewParent parent = handle.getParent();
+            while (parent != null && parent != list) parent = parent.getParent();
+            if (parent != list) continue;
+            handle.getDrawingRect(rect); list.offsetDescendantRectToMyCoords(handle, rect);
+            if (rect.contains((int)x, (int)y)) return true;
+        }
+        return false;
+    }
+    @Override public boolean onTouch(View view, MotionEvent event) {
+        if (disposed) return false;
+        int action = event.getActionMasked();
+        if (action == MotionEvent.ACTION_DOWN) {
+            cancel();
+            downX = pointerX = event.getX(); downY = pointerY = event.getY();
+            if (enabled && list.isEnabled() && inHandle(downX, downY) && list.pointToPosition((int)downX, (int)downY) >= 0) {
+                pending = true; list.postDelayed(activate, longPress);
+            }
+        }
+        if (event.getPointerCount() > 1) { boolean handled = active; cancel(); return handled; }
+        if (action == MotionEvent.ACTION_MOVE) {
+            pointerX = event.getX(); pointerY = event.getY();
+            if (pending && Math.hypot(pointerX - downX, pointerY - downY) > slop) clearPending();
+            if (active && !settling) update(0);
+        }
+        boolean owned = active;
+        if (action == MotionEvent.ACTION_UP) { clearPending(); if (active && !settling) drop(); }
+        else if (action == MotionEvent.ACTION_CANCEL) { clearPending(); if (active) finish(false, 0); }
+        if (owned) return true;
+        return false;
+    }
+    private void clearPending() { pending = false; list.removeCallbacks(activate); }
+    private void emit(int state, int detail) { if (!disposed && listener != null) listener.onState(state, from, detail); }
+    private void begin() {
+        if (!pending || disposed || !enabled || !list.isAttachedToWindow()) return;
+        clearPending();
+        int index = list.pointToPosition((int)pointerX, (int)pointerY);
+        View cell = list.getChildAt(index - list.getFirstVisiblePosition());
+        if (cell == null || index < 0 || cell.getWidth() <= 0 || cell.getHeight() <= 0 || (long)cell.getWidth() * cell.getHeight() > 8000000) return;
+        bitmap = Bitmap.createBitmap(cell.getWidth(), cell.getHeight(), Bitmap.Config.ARGB_8888);
+        cell.draw(new Canvas(bitmap));
+        overlay = new ImageView(list.getContext()); overlay.setImageBitmap(bitmap);
+        overlay.setImportantForAccessibility(View.IMPORTANT_FOR_ACCESSIBILITY_NO);
+        overlay.layout(cell.getLeft(), 0, cell.getRight(), cell.getHeight());
+        overlay.setTranslationY(cell.getTop()); overlay.setElevation(12 * density);
+        list.getOverlay().add(overlay);
+        rowHeight = cell.getHeight() + list.getDividerHeight(); grabOffset = pointerY - cell.getTop();
+        width = list.getWidth(); height = list.getHeight(); count = list.getCount();
+        from = target = index; active = true; settling = false; remainder = 0; generation++;
+        // Stop the ListView's pending click/scroll, retaining this pointer stream.
+        MotionEvent cancel = MotionEvent.obtain(0, 0, MotionEvent.ACTION_CANCEL, pointerX, pointerY, 0);
+        list.onTouchEvent(cancel); cancel.recycle();
+        if (surface.getParent() != null) surface.getParent().requestDisallowInterceptTouchEvent(true);
+        previousTime = System.nanoTime();
+        emit(1, from);
+        if (!active || disposed) return;
+        update(0); Choreographer.getInstance().postFrameCallback(this);
+    }
+    @Override public void doFrame(long time) {
+        if (!active || settling || disposed) return;
+        if (!list.isAttachedToWindow() || count != list.getCount() || width != list.getWidth() || height != list.getHeight()) { finish(false, 1); return; }
+        double dt = Math.min(.04, Math.max(0, (time - previousTime) / 1e9)); previousTime = time;
+        float edge = Math.min(edgeSize, list.getHeight() / 3f), direction = 0;
+        if (pointerY < list.getPaddingTop() + edge) direction = -Math.min(1, (list.getPaddingTop() + edge - pointerY) / edge);
+        else if (pointerY > list.getHeight() - list.getPaddingBottom() - edge) direction = Math.min(1, (pointerY - list.getHeight() + list.getPaddingBottom() + edge) / edge);
+        float distance = (float)(direction * edgeSpeed * dt) + remainder;
+        int pixels = (int)distance; remainder = distance - pixels;
+        if (pixels != 0) list.scrollListBy(pixels);
+        update(dt);
+        if (active) Choreographer.getInstance().postFrameCallback(this);
+    }
+    private void restore(View view, Cell state) { view.setTranslationY(state.translation); view.setAlpha(state.alpha); }
+    private void update(double dt) {
+        if (!active || settling) return;
+        float top = pointerY - grabOffset;
+        overlay.setTranslationY(top);
+        int first = list.getFirstVisiblePosition(), visible = list.getChildCount(), destination = from;
+        for (int offset = 0; offset < visible; offset++) {
+            int index = first + offset; if (index == from) continue;
+            View view = list.getChildAt(offset);
+            float midpoint = view.getTop() + view.getHeight() / 2f - (index > from ? rowHeight : 0);
+            int insertion = index - (index > from ? 1 : 0);
+            destination = insertion;
+            if (top < midpoint) break;
+            destination = insertion + 1;
+        }
+        target = Math.max(0, Math.min(count - 1, destination));
+        for (View view : new ArrayList<>(cells.keySet())) {
+            int index = list.getPositionForView(view);
+            Cell state = cells.get(view);
+            if (index < first || index >= first + visible || index != state.index) { restore(view, state); cells.remove(view); }
+        }
+        for (int offset = 0; offset < visible; offset++) {
+            int index = first + offset; View view = list.getChildAt(offset);
+            Cell state = cells.get(view);
+            if (state == null) { state = new Cell(view, index); cells.put(view, state); }
+            float displacement = index > from && index <= target ? -rowHeight : index < from && index >= target ? rowHeight : 0;
+            if (reduced) { state.spring.position = displacement; state.spring.velocity = 0; }
+            else state.spring.advance(displacement, 360, 34, 1, dt);
+            view.setTranslationY(state.translation + (float)state.spring.position);
+            view.setAlpha(index == from ? 0 : state.alpha);
+        }
+    }
+    private void drop() {
+        if (!active || settling) return;
+        settling = true; Choreographer.getInstance().removeFrameCallback(this);
+        View destination = list.getChildAt(target - list.getFirstVisiblePosition());
+        float end = destination == null ? overlay.getTranslationY() : target > from ? destination.getBottom() - bitmap.getHeight() : destination.getTop();
+        if (reduced) { finish(true, 0); return; }
+        final int ticket = generation;
+        drop = ValueAnimator.ofFloat(overlay.getTranslationY(), end); drop.setDuration(180);
+        drop.addUpdateListener(animation -> { if (overlay != null) overlay.setTranslationY((float)animation.getAnimatedValue()); });
+        drop.addListener(new AnimatorListenerAdapter() {
+            @Override public void onAnimationEnd(Animator animation) { if (active && generation == ticket) finish(true, 0); }
+        });
+        drop.start();
+    }
+    private void finish(boolean commit, int detail) {
+        if (!active) return;
+        active = false; settling = false; generation++;
+        Choreographer.getInstance().removeFrameCallback(this);
+        if (drop != null) { ValueAnimator previous = drop; drop = null; previous.cancel(); }
+        if (overlay != null) { list.getOverlay().remove(overlay); overlay.setImageDrawable(null); overlay = null; }
+        if (bitmap != null) { bitmap.recycle(); bitmap = null; }
+        for (View view : new ArrayList<>(cells.keySet())) restore(view, cells.get(view));
+        cells.clear();
+        if (surface.getParent() != null) surface.getParent().requestDisallowInterceptTouchEvent(false);
+        emit(commit ? 2 : 3, commit ? target : detail);
+    }
+    public void cancel() { clearPending(); finish(false, 0); }
+    public void setEnabled(boolean value) { enabled = value; if (!value) cancel(); }
+    public void setReducedMotion(boolean value) { reduced = value; }
+    @Override public void onLayoutChange(View view, int l, int t, int r, int b, int ol, int ot, int or, int ob) {
+        if (active && (r - l != width || b - t != height)) finish(false, 1);
+    }
+    @Override public void onViewDetachedFromWindow(View view) { cancel(); }
+    @Override public void onViewAttachedToWindow(View view) {}
+    public void dispose() {
+        if (disposed) return;
+        cancel(); disposed = true; surface.setSession(null);
+        list.removeOnLayoutChangeListener(this); list.removeOnAttachStateChangeListener(this);
+        handles.clear();
+    }
+}

package/platforms/android/java/org/rafaelaugusto/jolt/ReorderSurface.java

@@ -0,0 +1,27 @@
+package org.rafaelaugusto.jolt;
+
+import android.content.Context;
+import android.graphics.Rect;
+import android.view.MotionEvent;
+
+/** Capture input above recycled cells without replacing any Core touch listener. */
+public final class ReorderSurface extends org.nativescript.widgets.GridLayout {
+    private ReorderSession session;
+    public ReorderSurface(Context context) { super(context); }
+    void setSession(ReorderSession value) { session = value; }
+    @Override public boolean dispatchTouchEvent(MotionEvent event) {
+        ReorderSession current = session;
+        if (current != null) {
+            Rect rect = new Rect(); current.list.getDrawingRect(rect);
+            offsetDescendantRectToMyCoords(current.list, rect);
+            MotionEvent local = MotionEvent.obtain(event); local.offsetLocation(-rect.left, -rect.top);
+            current.onTouch(current.list, local); local.recycle();
+        }
+        return super.dispatchTouchEvent(event) || current != null;
+    }
+    @Override public boolean onInterceptTouchEvent(MotionEvent event) {
+        return session != null && session.isActive() || super.onInterceptTouchEvent(event);
+    }
+    @Override public boolean onTouchEvent(MotionEvent event) { return session != null || super.onTouchEvent(event); }
+    @Override protected void onDetachedFromWindow() { if (session != null) session.cancel(); super.onDetachedFromWindow(); }
+}

package/platforms/android/java/org/rafaelaugusto/jolt/SpringState.java

@@ -0,0 +1,39 @@
+package org.rafaelaugusto.jolt;
+
+/** Exact constant-target solution, matching JoltSpringState.h. No per-step allocation. */
+public final class SpringState {
+    public double position, velocity;
+
+    public SpringState(double position, double velocity) {
+        this.position = position;
+        this.velocity = velocity;
+    }
+
+    public void advance(double target, double stiffness, double damping, double mass, double seconds) {
+        if (seconds <= 0) return;
+        double x = position - target;
+        double w = Math.sqrt(stiffness / mass);
+        double z = damping / (2 * Math.sqrt(stiffness * mass));
+        double next, speed;
+        if (Math.abs(z - 1) < 1e-6) {
+            double b = velocity + w * x, e = Math.exp(-w * seconds);
+            next = e * (x + b * seconds);
+            speed = e * (b - w * (x + b * seconds));
+        } else if (z < 1) {
+            double a = z * w, d = w * Math.sqrt(1 - z * z);
+            double b = (velocity + a * x) / d;
+            double c = Math.cos(d * seconds), s = Math.sin(d * seconds), e = Math.exp(-a * seconds);
+            next = e * (x * c + b * s);
+            speed = e * ((-a * x + b * d) * c + (-a * b - x * d) * s);
+        } else {
+            double q = Math.sqrt(z * z - 1);
+            double r1 = -w / (z + q), r2 = -w * (z + q);
+            double c1 = (velocity - r2 * x) / (r1 - r2), c2 = x - c1;
+            double e1 = Math.exp(r1 * seconds), e2 = Math.exp(r2 * seconds);
+            next = c1 * e1 + c2 * e2;
+            speed = c1 * r1 * e1 + c2 * r2 * e2;
+        }
+        position = target + next;
+        velocity = speed;
+    }
+}

package/platforms/android/proguard-rules.pro

@@ -21,3 +21,8 @@
 -keep class org.rafaelaugusto.jolt.GradientLayer$* { *; }
 -keep class org.rafaelaugusto.jolt.ParticleEmitter { *; }
 -keep class org.rafaelaugusto.jolt.ParticleEmitter$* { *; }
+-keep class org.rafaelaugusto.jolt.ReorderSession { *; }
+-keep class org.rafaelaugusto.jolt.ReorderSession$* { *; }
+-keep class org.rafaelaugusto.jolt.ReorderHandle { *; }
+-keep class org.rafaelaugusto.jolt.ReorderHandle$* { *; }
+-keep class org.rafaelaugusto.jolt.ReorderSurface { *; }

package/platforms/ios/src/JoltGestureSession.h

@@ -0,0 +1,18 @@
+#import <UIKit/UIKit.h>
+#import "JoltLiveSpring.h"
+
+NS_ASSUME_NONNULL_BEGIN
+@interface JoltGestureSession : NSObject
+@property(nonatomic, readonly) BOOL active;
++ (BOOL)supportsContactEvents;
++ (instancetype)attach:(UIView *)surface scroll:(nullable UIScrollView *)scroll
+                     x:(JoltLiveSpring *)x y:(JoltLiveSpring *)y scale:(JoltLiveSpring *)scale rotation:(JoltLiveSpring *)rotation
+               options:(NSString *)options onState:(void (^)(NSInteger, double, double))onState;
+- (void)cancel;
+- (void)refreshScrollDelegate;
+- (void)setEnabled:(BOOL)enabled;
+- (void)settleX:(double)x y:(double)y scale:(double)scale rotation:(double)rotation animated:(BOOL)animated;
+- (void)updateLeft:(double)left right:(double)right top:(double)top bottom:(double)bottom;
+- (void)dispose;
+@end
+NS_ASSUME_NONNULL_END

package/platforms/ios/src/JoltGestureSession.m

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

package/platforms/ios/src/JoltLiveSpring.h

@@ -0,0 +1,28 @@
+#import <UIKit/UIKit.h>
+NS_ASSUME_NONNULL_BEGIN
+@class JoltLiveSpringBinding;
+@interface JoltLiveSpring : NSObject
++ (instancetype)create:(double)initial stiffness:(double)stiffness damping:(double)damping mass:(double)mass
+             restDelta:(double)restDelta restSpeed:(double)restSpeed reduced:(BOOL)reduced;
+@property(nonatomic, readonly) double position;
+@property(nonatomic, readonly) double velocity;
+@property(nonatomic, readonly) BOOL moving;
++ (NSUInteger)activeCount;
++ (NSUInteger)nodeCount;
++ (void)sync:(UIView *)view;
+- (void)follow:(JoltLiveSpring *)source mappings:(NSString *)mappings;
+- (void)updateInput:(NSString *)snapshot;
+- (void)setTarget:(double)value;
+- (void)holdInput:(double)value velocity:(double)velocity;
+- (void)releaseInput:(double)target velocity:(double)velocity;
+- (void)setReduced:(BOOL)value;
+- (void)setPaused:(BOOL)value;
+- (JoltLiveSpringBinding *)bind:(UIView *)view property:(NSString *)property mappings:(NSString *)mappings;
+- (void)dispose;
+@end
+@interface JoltLiveSpringBinding : NSObject
+@property(nonatomic, readonly) double value;
+- (void)setLayers:(NSString *)inputs;
+- (void)cancel;
+@end
+NS_ASSUME_NONNULL_END