@rafaelaugusto/jolt 0.1.0-rc.2 → 0.1.0-rc.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rafaelaugusto/jolt",
-  "version": "0.1.0-rc.2",
+  "version": "0.1.0-rc.3",
   "description": "Native animations for NativeScript: presets, springs, keyframes and stagger in one call.",
   "keywords": [
     "nativescript",

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

@@ -0,0 +1,26 @@
+package org.rafaelaugusto.jolt;
+
+import android.animation.Keyframe;
+import android.animation.ObjectAnimator;
+import android.animation.PropertyValuesHolder;
+import android.util.Property;
+import android.view.View;
+
+/** Builds a numeric track without creating a JavaScript proxy for every keyframe. */
+public final class KeyframeFactory {
+    private KeyframeFactory() {}
+
+    public static ObjectAnimator create(View view, Property<View, Float> property,
+            double[] times, double[] values, double unit) {
+        if (times.length != values.length || values.length < 2) {
+            throw new IllegalArgumentException("A track needs matching times and at least two values");
+        }
+        Keyframe[] frames = new Keyframe[values.length];
+        for (int i = 0; i < values.length; i++) {
+            // Scale in double precision before the same float conversion as Keyframe.ofFloat.
+            frames[i] = Keyframe.ofFloat((float) times[i], (float) (values[i] * unit));
+        }
+        return ObjectAnimator.ofPropertyValuesHolder(view,
+            PropertyValuesHolder.ofKeyframe(property, frames));
+    }
+}

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

@@ -68,12 +68,13 @@ public final class ScrollHeader implements ViewTreeObserver.OnScrollChangedListe
     public void scroll(double target,boolean animated) {
         if(disposed || !Double.isFinite(target))return;
         target=Math.max(0,target);
-        if(animated){list.smoothScrollBy((int)Math.round((target-current())*density),300);return;}
         double divider=list.getDividerHeight()/density, stride=rowHeight+divider;
         int index=target<spacer+divider?0:1+(int)Math.floor((target-spacer-divider)/stride);
         index=Math.max(0,Math.min(list.getCount()-1,index));
         double start=index==0?0:spacer+divider+(index-1)*stride;
-        list.setSelectionFromTop(index,(int)Math.round((start-target)*density));
+        int top=(int)Math.round((start-target)*density);
+        if(animated){list.smoothScrollToPositionFromTop(index,top,300);return;}
+        list.setSelectionFromTop(index,top);
         list.post(new Runnable(){public void run(){if(!disposed)update(true);}});
     }
     public void dispose() {

package/platforms/android/proguard-rules.pro

@@ -1,4 +1,5 @@
 -keep class org.rafaelaugusto.jolt.ColorTarget { *; }
+-keep class org.rafaelaugusto.jolt.KeyframeFactory { *; }
 -keep class org.rafaelaugusto.jolt.CircleWorld { *; }
 -keep class org.rafaelaugusto.jolt.CircleWorld$* { *; }
 -keep class org.rafaelaugusto.jolt.MotionProbe { *; }

package/platforms/ios/src/JoltInteractiveModal.h

@@ -0,0 +1,16 @@
+#import <UIKit/UIKit.h>
+NS_ASSUME_NONNULL_BEGIN
+
+/** Animator supplied through Core's modal transition delegate. No delegate replacement. */
+@interface JoltInteractiveModal : NSObject <UIViewControllerAnimatedTransitioning, UIViewControllerInteractiveTransitioning, UIGestureRecognizerDelegate>
++ (instancetype)attach:(UIViewController *)controller stiffness:(double)stiffness damping:(double)damping mass:(double)mass shouldBegin:(BOOL (^)(void))shouldBegin onEvent:(void (^)(NSInteger))onEvent;
++ (NSUInteger)activeCount;
++ (NSUInteger)recognizerCount;
+@property(nonatomic, readonly) BOOL interactive;
+@property(nonatomic, readonly) double progress;
+@property(nonatomic, readonly) double velocity;
+- (void)preparePresenting:(BOOL)presenting reduced:(BOOL)reduced timeScale:(double)timeScale;
+- (void)cancel;
+- (void)dispose;
+@end
+NS_ASSUME_NONNULL_END

package/platforms/ios/src/JoltInteractiveModal.m

@@ -0,0 +1,178 @@
+#import "JoltInteractiveModal.h"
+#import "JoltSpringState.h"
+
+@interface JoltInteractiveModal () {
+    JoltSpringState _spring;
+}
+@property(nonatomic, weak) UIViewController *controller;
+@property(nonatomic) UIPanGestureRecognizer *pan;
+@property(nonatomic, copy) BOOL (^shouldBegin)(void);
+@property(nonatomic, copy) void (^onEvent)(NSInteger);
+@property(nonatomic) id<UIViewControllerContextTransitioning> context;
+@property(nonatomic) UIView *moving;
+@property(nonatomic) CGAffineTransform originalTransform;
+@property(nonatomic) CGRect bounds;
+@property(nonatomic) CADisplayLink *link;
+@property(nonatomic) double stiffness, damping, mass, previous, started, target, timeScale;
+@property(nonatomic) NSNumber *pendingEnd;
+@property(nonatomic, readwrite) BOOL interactive;
+@property(nonatomic) BOOL presenting, reduced, settling, committed, disposed;
+@end
+
+@implementation JoltInteractiveModal
+static NSUInteger active = 0, recognizers = 0;
++ (NSUInteger)activeCount { return active; }
++ (NSUInteger)recognizerCount { return recognizers; }
++ (instancetype)attach:(UIViewController *)controller stiffness:(double)stiffness damping:(double)damping mass:(double)mass shouldBegin:(BOOL (^)(void))shouldBegin onEvent:(void (^)(NSInteger))onEvent {
+    JoltInteractiveModal *owner = [self new];
+    owner.controller = controller;
+    owner.stiffness = stiffness; owner.damping = damping; owner.mass = mass;
+    owner.timeScale = 1;
+    owner.shouldBegin = shouldBegin; owner.onEvent = onEvent;
+    owner.pan = [[UIPanGestureRecognizer alloc] initWithTarget:owner action:@selector(pan:)];
+    owner.pan.maximumNumberOfTouches = 1;
+    owner.pan.delegate = owner;
+    [controller.view addGestureRecognizer:owner.pan]; recognizers++;
+    [[NSNotificationCenter defaultCenter] addObserver:owner selector:@selector(cancel) name:UIApplicationWillResignActiveNotification object:nil];
+    return owner;
+}
+- (BOOL)gestureRecognizer:(UIGestureRecognizer *)recognizer shouldReceiveTouch:(UITouch *)touch {
+    // Scrolling content and native controls keep their own interaction. A modal
+    // can expose an ordinary, non-scrolling header as its dismissal surface.
+    for (UIView *view = touch.view; view; view = view.superview) {
+        if ([view isKindOfClass:UIControl.class] || [view isKindOfClass:UIScrollView.class]) return NO;
+        if (view == self.controller.view) break;
+    }
+    return YES;
+}
+- (BOOL)gestureRecognizerShouldBegin:(UIGestureRecognizer *)recognizer {
+    UIViewController *controller = self.controller;
+    CGPoint velocity = [self.pan velocityInView:controller.view];
+    return !self.disposed && !self.context && controller.presentingViewController &&
+        !controller.presentedViewController && !controller.transitionCoordinator && !controller.modalInPresentation &&
+        velocity.y > fabs(velocity.x) && self.shouldBegin && self.shouldBegin();
+}
+- (void)preparePresenting:(BOOL)presenting reduced:(BOOL)reduced timeScale:(double)timeScale {
+    self.presenting = presenting; self.reduced = reduced; self.timeScale = timeScale;
+}
+- (void)pan:(UIPanGestureRecognizer *)pan {
+    if (pan.state == UIGestureRecognizerStateBegan) {
+        self.pendingEnd = nil; self.interactive = YES;
+        _spring = (JoltSpringState){0, 0};
+        if (self.onEvent) self.onEvent(2);
+    }
+    if (!self.interactive || self.settling) return;
+    double height = MAX(1, self.context ? self.bounds.size.height : self.controller.view.bounds.size.height);
+    double progress = MAX(0, MIN(1, [pan translationInView:self.controller.view].y / height));
+    double velocity = [pan velocityInView:self.controller.view].y / height;
+    _spring = (JoltSpringState){progress, velocity};
+    if (self.context) { [self render:progress]; [self.context updateInteractiveTransition:progress]; }
+    if (pan.state == UIGestureRecognizerStateEnded || pan.state == UIGestureRecognizerStateCancelled || pan.state == UIGestureRecognizerStateFailed) {
+        BOOL finish = pan.state == UIGestureRecognizerStateEnded && progress + velocity * .16 > .5;
+        if (self.context) [self settle:finish velocity:velocity];
+        else self.pendingEnd = @(finish);
+    }
+}
+- (NSTimeInterval)transitionDuration:(id<UIViewControllerContextTransitioning>)context { return self.reduced ? 0 : .55; }
+- (BOOL)wantsInteractiveStart { return self.interactive; }
+- (CGFloat)completionSpeed { return 1; }
+- (UIViewAnimationCurve)completionCurve { return UIViewAnimationCurveLinear; }
+- (double)progress { return _spring.position; }
+- (double)velocity { return _spring.velocity; }
+- (void)prepare:(id<UIViewControllerContextTransitioning>)context {
+    self.context = context; active++;
+    UIViewController *controller = [context viewControllerForKey:self.presenting ? UITransitionContextToViewControllerKey : UITransitionContextFromViewControllerKey];
+    self.moving = [context viewForKey:self.presenting ? UITransitionContextToViewKey : UITransitionContextFromViewKey] ?: controller.view;
+    self.originalTransform = self.moving.transform;
+    if (self.presenting) {
+        self.moving.frame = [context finalFrameForViewController:controller];
+        [context.containerView addSubview:self.moving];
+    }
+    [self.moving setNeedsLayout]; [self.moving layoutIfNeeded];
+    self.bounds = context.containerView.bounds;
+    _spring = (JoltSpringState){0, 0};
+    [self render:0];
+}
+- (void)startInteractiveTransition:(id<UIViewControllerContextTransitioning>)context {
+    JoltSpringState held = _spring;
+    [self prepare:context]; _spring = held;
+    [self render:_spring.position]; [context updateInteractiveTransition:_spring.position];
+    [self startLink];
+    if (self.pendingEnd || self.disposed) {
+        [self settle:!self.disposed && self.pendingEnd.boolValue velocity:_spring.velocity];
+        self.pendingEnd = nil;
+    }
+}
+- (void)animateTransition:(id<UIViewControllerContextTransitioning>)context {
+    [self prepare:context];
+    if (self.onEvent) self.onEvent(0);
+    [self settle:YES velocity:0];
+}
+- (void)render:(double)progress {
+    double p = MAX(0, MIN(1, progress));
+    double translation = self.bounds.size.height * (self.presenting ? 1 - p : p);
+    [CATransaction begin]; [CATransaction setDisableActions:YES];
+    self.moving.transform = CGAffineTransformConcat(self.originalTransform, CGAffineTransformMakeTranslation(0, translation));
+    [CATransaction commit];
+}
+- (void)startLink {
+    if (self.link || !self.context) return;
+    self.previous = CACurrentMediaTime();
+    self.link = [CADisplayLink displayLinkWithTarget:self selector:@selector(tick:)];
+    if (@available(iOS 15.0, *)) {
+        float maximum = MIN(120, UIScreen.mainScreen.maximumFramesPerSecond);
+        self.link.preferredFrameRateRange = CAFrameRateRangeMake(MIN(80, maximum), maximum, maximum);
+    }
+    [self.link addToRunLoop:NSRunLoop.mainRunLoop forMode:NSRunLoopCommonModes];
+}
+- (void)settle:(BOOL)finish velocity:(double)velocity {
+    if (!self.context || self.settling) return;
+    self.committed = finish; self.settling = YES; self.target = finish ? 1 : 0;
+    _spring.velocity = velocity;
+    if (self.interactive) {
+        // Core must know cancellation BEFORE UIKit executes dismissal completion.
+        if (self.onEvent) self.onEvent(finish ? 3 : 4);
+        if (!self.context) return;
+        if (finish) [self.context finishInteractiveTransition]; else [self.context cancelInteractiveTransition];
+    }
+    self.started = CACurrentMediaTime(); self.previous = self.started;
+    if (self.reduced || self.disposed) { [self finish]; return; }
+    [self startLink];
+}
+- (void)tick:(CADisplayLink *)link {
+    if (!CGRectEqualToRect(self.bounds, self.context.containerView.bounds) || !self.context.containerView.window) { [self cancel]; return; }
+    if (!self.settling) return;
+    double now = CACurrentMediaTime(), seconds = MAX(0, now - self.previous); self.previous = now;
+    _spring = JoltSpringAdvance(_spring, self.target, self.stiffness*self.timeScale*self.timeScale, self.damping*self.timeScale, self.mass, seconds);
+    if (!isfinite(_spring.position) || !isfinite(_spring.velocity)) { [self finish]; return; }
+    [self render:_spring.position];
+    if ((fabs(_spring.position-self.target)<.0005 && fabs(_spring.velocity)<.005) || now-self.started>=3) [self finish];
+}
+- (void)finish {
+    if (!self.context) return;
+    [self.link invalidate]; self.link = nil;
+    BOOL completed = self.committed, presenting = self.presenting;
+    _spring = (JoltSpringState){completed ? 1 : 0, 0}; [self render:_spring.position];
+    self.moving.transform = self.originalTransform;
+    id<UIViewControllerContextTransitioning> context = self.context;
+    self.context = nil; self.moving = nil; self.settling = NO; self.interactive = NO; active--;
+    [context completeTransition:completed];
+    if (self.onEvent) self.onEvent(presenting ? 1 : completed ? 5 : 6);
+}
+- (void)cancel {
+    if (!self.context) { if (self.interactive) self.pendingEnd = @NO; return; }
+    if (!self.settling) [self settle:!self.interactive velocity:0];
+    [self finish];
+}
+- (void)dispose {
+    if (self.disposed) return;
+    self.disposed = YES;
+    [self cancel];
+    [self.pan.view removeGestureRecognizer:self.pan];
+    self.pan.delegate = nil;
+    if (self.pan) recognizers--;
+    self.pan = nil;
+    [[NSNotificationCenter defaultCenter] removeObserver:self];
+    self.shouldBegin = nil; self.onEvent = nil;
+}
+@end

package/platforms/ios/src/module.modulemap

@@ -7,6 +7,7 @@ module JoltMotion {
     header "JoltPhotoZoom.h"
     header "JoltInteractiveAnimation.h"
     header "JoltInteractiveNavigation.h"
+    header "JoltInteractiveModal.h"
     header "JoltLiveSpring.h"
     header "JoltGestureSession.h"
     header "JoltReorderSession.h"

package/src/android-plugin.d.ts

@@ -1,4 +1,13 @@
 declare namespace org.rafaelaugusto.jolt {
+  class KeyframeFactory {
+    static create(
+      view: android.view.View,
+      property: android.util.Property<android.view.View, java.lang.Float>,
+      times: readonly number[],
+      values: readonly number[],
+      unit: number,
+    ): android.animation.ObjectAnimator
+  }
   class ShapeLayer extends android.graphics.drawable.Drawable {
     constructor(options: string)
     static liveCount(): number

package/src/animate.ts

@@ -308,12 +308,30 @@ export function group(animations: readonly Animation[]): Animation {
 }
 
 export function toView(target: Target): View {
-  if (target instanceof View) return target
-  const view =
-    (target as { nativeView?: unknown } | null)?.nativeView ??
-    (target as { nativeElement?: unknown } | null)?.nativeElement
+  const view = unwrap(target)
   if (view instanceof View) return view
-  throw new TypeError(`Expected a NativeScript view, got ${String(target)}.`)
+  throw new TypeError(`Expected a NativeScript view, got ${describe(target)}.`)
+}
+
+function unwrap(target: unknown, nested = false): unknown {
+  if (target instanceof View || target === null || typeof target !== 'object')
+    return target
+  const holder = target as {
+    nativeView?: unknown
+    nativeElement?: unknown
+    $el?: unknown
+  }
+  if (!nested && '$el' in holder) return unwrap(holder.$el, true)
+  return holder.nativeView ?? holder.nativeElement
+}
+
+function describe(target: unknown) {
+  if (target === null || typeof target !== 'object')
+    return typeof target === 'function' ? 'a function' : String(target)
+  if (Array.isArray(target)) return 'an array'
+  if ('$el' in target) return 'a component instance without a root view'
+  const name = Object.getPrototypeOf(target)?.constructor?.name
+  return name && name !== 'Object' ? `a ${name}` : 'an object without a view'
 }
 
 export function toViews(target: Target | readonly Target[]): View[] {

package/src/driver/android.ts

@@ -130,20 +130,37 @@ export function createAndroidDriver(): Driver {
         )
       }
 
-      const keyframes = Array.create(android.animation.Keyframe, track.values.length)
-      track.values.forEach((value, i) => {
-        keyframes[i] = android.animation.Keyframe.ofFloat(track.times[i]!, value * scale)
-      })
-      const holders = Array.create(android.animation.PropertyValuesHolder, 1)
-      holders[0] = android.animation.PropertyValuesHolder.ofKeyframe(
-        nativeProperties[track.property],
-        keyframes,
-      )
-
-      const animator = android.animation.ObjectAnimator.ofPropertyValuesHolder(
-        nativeView,
-        holders,
-      )
+      let animator: android.animation.ObjectAnimator
+      if (
+        typeof org !== 'undefined' &&
+        typeof org.rafaelaugusto?.jolt?.KeyframeFactory === 'function'
+      ) {
+        animator = org.rafaelaugusto.jolt.KeyframeFactory.create(
+          nativeView,
+          nativeProperties[track.property],
+          track.times,
+          track.values,
+          scale,
+        )
+      } else {
+        // Keep JS-only updates working with an app binary built before the factory.
+        const keyframes = Array.create(android.animation.Keyframe, track.values.length)
+        track.values.forEach((value, i) => {
+          keyframes[i] = android.animation.Keyframe.ofFloat(
+            track.times[i]!,
+            value * scale,
+          )
+        })
+        const holders = Array.create(android.animation.PropertyValuesHolder, 1)
+        holders[0] = android.animation.PropertyValuesHolder.ofKeyframe(
+          nativeProperties[track.property],
+          keyframes,
+        )
+        animator = android.animation.ObjectAnimator.ofPropertyValuesHolder(
+          nativeView,
+          holders,
+        )
+      }
       let restoreLayer: (() => void) | undefined
       const releaseLayer = () => {
         restoreLayer?.()

package/src/index.ts

@@ -1,7 +1,7 @@
 export { timeline } from './sequence.js'
 export type { TimelineAnimation, TimelineStep, PlayableAnimation } from './sequence.js'
 export { playbackProgress } from './motion-value.js'
-export { animate, decay, set, stop } from './animate.js'
+export { animate, decay, set, stop, toView } from './animate.js'
 export { bind, motionValue, scrollValue, springValue } from './motion-value.js'
 export type {
   Bindings,

package/src/interactive-navigation/index.ts

@@ -1,4 +1,11 @@
 import { ReturnScope } from '../shared-navigation/return-signal.js'
+export { interactiveModal } from './modal.js'
+export type {
+  InteractiveModal,
+  InteractiveModalEvent,
+  InteractiveModalOptions,
+  InteractiveModalState,
+} from './modal.js'
 import {
   Application,
   Image,