@rafaelaugusto/jolt 0.1.0-beta.14 → 0.1.0-beta.16

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

@@ -0,0 +1,270 @@
+package org.rafaelaugusto.jolt;
+
+import android.os.SystemClock;
+import android.view.Choreographer;
+import android.view.View;
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/** Persistent native follower graph. The frame callback never enters JavaScript. */
+public final class LiveSpring {
+    private static final ArrayList<LiveSpring> nodes = new ArrayList<>();
+    private static boolean scheduled;
+    private static long previousFrame;
+    private static final Choreographer.FrameCallback clock = new Choreographer.FrameCallback() {
+        @Override public void doFrame(long nanos) {
+            scheduled = false;
+            double now = nanos / 1e6;
+            double remaining = previousFrame == 0 ? 1.0 / 120 : Math.min(.064, Math.max(0, (nanos - previousFrame) / 1e9));
+            previousFrame = nanos;
+            // Older nodes precede their followers. Substeps bound chain phase error at 60/120Hz.
+            while (remaining > 1e-9) {
+                double dt = Math.min(remaining, 1.0 / 240);
+                remaining -= dt;
+                for (int i = 0; i < nodes.size(); i++) nodes.get(i).step(now - remaining * 1000, dt);
+            }
+            boolean active = false;
+            for (int i = 0; i < nodes.size(); i++) {
+                LiveSpring node = nodes.get(i);
+                node.apply();
+                active |= node.moving || node.layersMoving(now);
+            }
+            if (active) schedule(); else previousFrame = 0;
+        }
+    };
+    private static void schedule() {
+        if (scheduled || nodes.isEmpty()) return;
+        scheduled = true;
+        Choreographer.getInstance().postFrameCallback(clock);
+    }
+
+    private final SpringState state;
+    private final double stiffness, damping, mass, restDelta, restSpeed;
+    private final ArrayList<Binding> bindings = new ArrayList<>();
+    private LiveSpring source;
+    private Mapping[] sourceMaps = new Mapping[0];
+    private SampledInput input;
+    private boolean direct = true;
+    private double targetValue;
+    private boolean moving, reduced, disposed, paused, inputHeld;
+
+    public LiveSpring(double initial, double stiffness, double damping, double mass,
+                      double restDelta, double restSpeed, boolean reduced) {
+        state = new SpringState(initial, 0);
+        this.stiffness = stiffness; this.damping = damping; this.mass = mass;
+        this.restDelta = restDelta; this.restSpeed = restSpeed; this.reduced = reduced;
+        targetValue = initial;
+        nodes.add(this);
+    }
+    public double getPosition() { return state.position; }
+    public double getVelocity() { return state.velocity; }
+    public boolean isMoving() { return moving; }
+    public static int activeCount() { return scheduled ? 1 : 0; }
+    public static int nodeCount() { return nodes.size(); }
+
+    public void follow(LiveSpring parent, String mappings) {
+        if (disposed || parent.disposed || nodes.indexOf(parent) >= nodes.indexOf(this))
+            throw new IllegalArgumentException("A spring can only follow an existing live node");
+        sourceMaps = maps(mappings);
+        source = parent;
+        wake();
+    }
+    public void updateInput(String snapshot) {
+        if (disposed) return;
+        try { input = new SampledInput(new JSONObject(snapshot)); }
+        catch (JSONException error) { throw new IllegalArgumentException(error); }
+        direct = false;
+        wake();
+    }
+    public void setTarget(double value) {
+        if (disposed) return;
+        direct = true; targetValue = value; input = null;
+        wake();
+    }
+    public void holdInput(double value, double velocity) {
+        if (disposed) return;
+        inputHeld = true; direct = true; targetValue = value; input = null;
+        state.position = value; state.velocity = velocity; moving = true;
+        apply(); schedule();
+    }
+    public void releaseInput(double target, double velocity) {
+        if (disposed) return;
+        inputHeld = false; state.velocity = velocity; setTarget(target);
+    }
+    public void setReduced(boolean value) { reduced = value; wake(); }
+    public void setPaused(boolean value) {
+        paused = value;
+        if (value) moving = false; else wake();
+    }
+    private void wake() {
+        if (disposed || paused) return;
+        moving = true;
+        if (reduced) { step(SystemClock.uptimeMillis(), 0); apply(); }
+        schedule();
+    }
+    private void step(double now, double dt) {
+        if (disposed || paused || inputHeld) return;
+        double target = source == null ? (direct ? targetValue : input.value(now)) : map(source.state.position, sourceMaps);
+        boolean inputMoving = source == null ? !direct && input.running(now) : source.moving;
+        if (reduced) { state.position = target; state.velocity = 0; }
+        else state.advance(target, stiffness, damping, mass, dt);
+        boolean rest = Math.abs(state.position - target) <= restDelta && Math.abs(state.velocity) <= restSpeed;
+        if (rest && !inputMoving) { state.position = target; state.velocity = 0; }
+        moving = inputMoving || !rest;
+    }
+    public Binding bind(View view, String property, String mappings) {
+        if (disposed) throw new IllegalStateException("Spring disposed");
+        Binding binding = new Binding(view, property, maps(mappings));
+        bindings.add(binding);
+        binding.apply();
+        return binding;
+    }
+    private void apply() {
+        for (int i = bindings.size() - 1; i >= 0; i--) {
+            Binding binding = bindings.get(i);
+            if (binding.view.get() == null) bindings.remove(i); else binding.apply();
+        }
+    }
+    private boolean layersMoving(double now) {
+        for (int i = 0; i < bindings.size(); i++)
+            for (SampledInput layer : bindings.get(i).layers)
+                if (layer.running(now)) return true;
+        return false;
+    }
+    public static void sync(View view) {
+        for (int i = 0; i < nodes.size(); i++) {
+            LiveSpring node = nodes.get(i);
+            for (int j = 0; j < node.bindings.size(); j++) {
+                Binding binding = node.bindings.get(j);
+                if (binding.view.get() == view) binding.apply();
+            }
+        }
+    }
+    public void dispose() {
+        if (disposed) return;
+        disposed = true; moving = false;
+        bindings.clear();
+        nodes.remove(this);
+        // A retained child continues from its own state toward the parent's last value.
+        for (int i = 0; i < nodes.size(); i++) {
+            LiveSpring child = nodes.get(i);
+            if (child.source == this) {
+                child.source = null;
+                child.setTarget(map(state.position, child.sourceMaps));
+            }
+        }
+        source = null;
+        if (nodes.isEmpty() && scheduled) {
+            Choreographer.getInstance().removeFrameCallback(clock);
+            scheduled = false; previousFrame = 0;
+        }
+    }
+
+    public final class Binding {
+        private final WeakReference<View> view;
+        private final String property;
+        private final Mapping[] mappings;
+        private final float density;
+        private boolean stopped;
+        private SampledInput[] layers = new SampledInput[0];
+        Binding(View view, String property, Mapping[] mappings) {
+            this.view = new WeakReference<>(view); this.property = property; this.mappings = mappings;
+            density = view.getResources().getDisplayMetrics().density;
+        }
+        public double getValue() { return map(state.position, mappings); }
+        public void setLayers(String inputs) {
+            try {
+                JSONArray array = new JSONArray(inputs);
+                SampledInput[] next = new SampledInput[array.length()];
+                for (int i = 0; i < next.length; i++) next[i] = new SampledInput(array.getJSONObject(i));
+                layers = next;
+            } catch (JSONException error) { throw new IllegalArgumentException(error); }
+            apply(); schedule();
+        }
+        public void cancel() { stopped = true; bindings.remove(this); }
+        private void apply() {
+            View target = view.get();
+            if (stopped || target == null || !target.isAttachedToWindow()) return;
+            double composed = getValue();
+            boolean multiply = property.equals("opacity") || property.startsWith("scale");
+            double now = SystemClock.uptimeMillis();
+            for (SampledInput layer : layers) composed = multiply ? composed * layer.value(now) : composed + layer.value(now);
+            float value = (float)composed;
+            switch (property) {
+                case "x": target.setTranslationX(value * density); break;
+                case "y": target.setTranslationY(value * density); break;
+                case "scaleX": target.setScaleX(value); break;
+                case "scaleY": target.setScaleY(value); break;
+                case "rotate": target.setRotation(value); break;
+                case "rotateX": target.setRotationX(value); break;
+                case "rotateY": target.setRotationY(value); break;
+                case "opacity": target.setAlpha(Math.max(0, Math.min(1, value))); break;
+                default: throw new IllegalArgumentException("Unsupported live property " + property);
+            }
+        }
+    }
+    private static final class Mapping {
+        final double[] input, output;
+        final boolean clamp;
+        Mapping(JSONObject json) throws JSONException {
+            input = array(json.getJSONArray("input")); output = array(json.getJSONArray("output"));
+            clamp = json.getBoolean("clamp");
+        }
+        double value(double value) {
+            if (clamp && value <= input[0]) return output[0];
+            if (clamp && value >= input[input.length - 1]) return output[output.length - 1];
+            int index = 0;
+            while (index < input.length - 2 && value > input[index + 1]) index++;
+            double span = input[index + 1] - input[index];
+            double fraction = span > 0 ? (value - input[index]) / span : value < input[index] ? 0 : 1;
+            return output[index] + (output[index + 1] - output[index]) * fraction;
+        }
+    }
+    private static Mapping[] maps(String json) {
+        try {
+            JSONArray array = new JSONArray(json);
+            Mapping[] result = new Mapping[array.length()];
+            for (int i = 0; i < result.length; i++) result[i] = new Mapping(array.getJSONObject(i));
+            return result;
+        } catch (JSONException error) { throw new IllegalArgumentException(error); }
+    }
+    private static double map(double value, Mapping[] maps) {
+        for (Mapping mapping : maps) value = mapping.value(value);
+        return value;
+    }
+    private static double[] array(JSONArray input) throws JSONException {
+        double[] result = new double[input.length()];
+        for (int i = 0; i < result.length; i++) result[i] = input.getDouble(i);
+        return result;
+    }
+    private static final class SampledInput {
+        final double value, anchor, elapsed, duration, delay, repeat, end;
+        final double[] values, times;
+        final boolean reverse, playing;
+        SampledInput(JSONObject json) throws JSONException {
+            value = json.getDouble("value");
+            anchor = SystemClock.uptimeMillis(); elapsed = json.getDouble("elapsed");
+            playing = json.getBoolean("running");
+            duration = json.getDouble("duration"); delay = json.getDouble("delay");
+            repeat = json.getDouble("repeat"); end = json.getDouble("to");
+            reverse = json.getBoolean("reverse");
+            values = array(json.getJSONArray("values")); times = array(json.getJSONArray("times"));
+        }
+        boolean running(double now) { return playing && (repeat < 0 || now - anchor + elapsed < delay + duration * (repeat + 1)); }
+        double value(double now) {
+            if (!playing || values.length < 2) return value;
+            if (!running(now)) return end;
+            double time = Math.max(0, now - anchor + elapsed - delay);
+            double iteration = Math.floor(time / Math.max(1, duration));
+            double progress = (time % Math.max(1, duration)) / Math.max(1, duration);
+            if (reverse && iteration % 2 >= 1) progress = 1 - progress;
+            int lo = 0, hi = times.length - 1;
+            while (lo + 1 < hi) { int mid = (lo + hi) / 2; if (times[mid] <= progress) lo = mid; else hi = mid; }
+            double fraction = times[hi] > times[lo] ? (progress - times[lo]) / (times[hi] - times[lo]) : 1;
+            return values[lo] + (values[hi] - values[lo]) * Math.max(0, Math.min(1, fraction));
+        }
+    }
+}

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/ios/src/JoltGestureSession.h

@@ -0,0 +1,17 @@
+#import <UIKit/UIKit.h>
+#import "JoltLiveSpring.h"
+
+NS_ASSUME_NONNULL_BEGIN
+@interface JoltGestureSession : NSObject
+@property(nonatomic, readonly) BOOL active;
++ (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,217 @@
+#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, 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
++ (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.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];
+}
+- (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 {
+    self.contact = NO;
+    if (!self.active) 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; }
+}
+- (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