basalt-core 0.0.0-rc5

package/native/core/ReanimatedModule.cpp

@@ -0,0 +1,203 @@
+#include "ReanimatedModule.h"
+
+#include "Gestures.h"
+#include "PlatformServices.h"
+#include "UIManagerAccess.h"
+
+#include <glog/logging.h>
+
+#ifdef BASALT_HAS_REANIMATED
+#include <reanimated/NativeModules/ReanimatedModuleProxy.h>
+#include <reanimated/RuntimeDecorators/RNRuntimeDecorator.h>
+#include <reanimated/Tools/PlatformDepMethodsHolder.h>
+#include <worklets/Compat/StableApi.h>
+#endif
+
+namespace basalt {
+
+bool hasReanimated() {
+#ifdef BASALT_HAS_REANIMATED
+  return true;
+#else
+  return false;
+#endif
+}
+
+#ifdef BASALT_HAS_REANIMATED
+
+namespace {
+
+using facebook::jsi::Runtime;
+using facebook::jsi::Value;
+using facebook::react::TurboModule;
+
+std::shared_ptr<reanimated::ReanimatedModuleProxy> &heldProxy() {
+  static std::shared_ptr<reanimated::ReanimatedModuleProxy> proxy;
+  return proxy;
+}
+
+// Reanimated's operations are flushed once a frame, forever, from the moment it
+// is installed. The frame is a timer for the same reason worklets' is: the
+// display link on each platform belongs to React Native's own choreographer,
+// which pauses whenever React Native has no animation of its own -- which is
+// exactly when a Reanimated one might be running.
+constexpr double kFrameMilliseconds = 16;
+
+void scheduleFlush() {
+  postDelayed(kFrameMilliseconds, []() {
+    if (auto proxy = heldProxy()) {
+      proxy->performOperations();
+      scheduleFlush();
+    }
+  });
+}
+
+reanimated::PlatformDepMethodsHolder makePlatformDepMethodsHolder() {
+  reanimated::PlatformDepMethodsHolder holder{};
+
+  holder.requestRender = [](std::function<void(const double)> callback) {
+    postDelayed(kFrameMilliseconds, [callback = std::move(callback)]() {
+      callback(monotonicMilliseconds());
+    });
+  };
+
+#ifdef __APPLE__
+  // iOS takes a snapshot of a view before a shared-element transition. Nothing
+  // here does shared-element transitions, and the field exists on Apple builds
+  // whether or not it is used.
+  holder.forceScreenSnapshotFunction = [](facebook::react::Tag) {};
+#endif
+
+  // The direct-to-view path, which skips the shadow tree for props that can be
+  // applied to a mounted view immediately. Not wired: this platform's mounting
+  // managers only accept mutations from a Fabric transaction, which is what
+  // makes their thread rule assertable. Reanimated's other path -- committing
+  // to the shadow tree -- is the one used here, and it is the one that works on
+  // every platform.
+  holder.synchronouslyUpdateUIPropsFunction = [](const int, const folly::dynamic &) {};
+
+  holder.getAnimationTimestamp = []() { return monotonicMilliseconds(); };
+
+  // useAnimatedSensor. A desktop has no accelerometer, gyroscope or
+  // magnetometer; -1 is Reanimated's own "could not register".
+  holder.registerSensor = [](int, int, int, std::function<void(double[], int)>) { return -1; };
+  holder.unregisterSensor = [](int) {};
+
+  // A worklet telling a gesture handler what to do, which is how
+  // GestureStateManager.activate() and friends work. The registry is
+  // core/Gestures.h's, so this is the two halves of phase 37 and phase 38
+  // meeting.
+  holder.setGestureStateFunction = [](int handlerTag, int newState) {
+    postToUiThread([handlerTag, newState]() { gestures().setStateFromWorklet(handlerTag, newState); });
+  };
+
+  // A desktop has no soft keyboard to move out of the way of.
+  holder.subscribeForKeyboardEvents = [](std::function<void(int, int)>, bool, bool) { return 0; };
+  holder.unsubscribeFromKeyboardEvents = [](int) {};
+
+  holder.maybeFlushUIUpdatesQueueFunction = []() {};
+
+  // CSS transitions driven by the platform rather than by Reanimated's own
+  // clock -- an optimisation Apple has and this does not. Declining every
+  // property means Reanimated animates them itself.
+  holder.cssCanRouteProperty = [](const std::string &,
+                                  const reanimated::css::EasingConfig &) { return false; };
+  holder.cssRemoveTransition = [](facebook::react::Tag, const std::string &) {};
+
+  // Hover and press pseudo-selectors, which need the view layer to report
+  // pointer state per view. Not wired yet.
+  holder.attachPseudoSelector = [](facebook::react::Tag,
+                                   reanimated::PseudoSelector,
+                                   std::function<void(bool)>) {};
+  holder.detachPseudoSelector = [](facebook::react::Tag, reanimated::PseudoSelector) {};
+
+  return holder;
+}
+
+} // namespace
+
+DesktopReanimatedModule::DesktopReanimatedModule(
+    std::shared_ptr<facebook::react::CallInvoker> jsInvoker)
+    : TurboModule(kModuleName, std::move(jsInvoker)) {
+  methodMap_["installTurboModule"] = MethodMetadata{0, installTurboModule};
+}
+
+DesktopReanimatedModule::~DesktopReanimatedModule() {
+  heldProxy().reset();
+}
+
+Value DesktopReanimatedModule::installTurboModule(Runtime &runtime,
+                                                  TurboModule &module,
+                                                  const Value * /*args*/,
+                                                  size_t /*count*/) {
+  auto &self = static_cast<DesktopReanimatedModule &>(module);
+
+  // Worklets put both of these on the JavaScript global when its own module
+  // installed. Reading them back is Reanimated's own arrangement for finding
+  // the runtime it shares with worklets rather than making a second one.
+  auto global = runtime.global();
+  auto uiWorkletRuntime = worklets::getWorkletRuntimeFromHolder(
+      runtime, global.getPropertyAsObject(runtime, "__UI_WORKLET_RUNTIME_HOLDER"));
+  auto uiScheduler = worklets::getUISchedulerFromHolder(
+      runtime, global.getPropertyAsObject(runtime, "__UI_SCHEDULER_HOLDER"));
+
+  if (uiWorkletRuntime == nullptr || uiScheduler == nullptr) {
+    LOG(ERROR) << "reanimated: the worklets runtime is not installed; is "
+                  "react-native-worklets compiled into this host?";
+    return Value(false);
+  }
+
+  const auto platformDepMethodsHolder = makePlatformDepMethodsHolder();
+  auto proxy = std::make_shared<reanimated::ReanimatedModuleProxy>(uiWorkletRuntime,
+                                                                   uiScheduler,
+                                                                   runtime,
+                                                                   self.jsInvoker_,
+                                                                   platformDepMethodsHolder,
+                                                                   /*isReducedMotion=*/false);
+  proxy->init(platformDepMethodsHolder);
+
+  auto &uiRuntime = worklets::getJSIRuntimeFromWorkletRuntime(uiWorkletRuntime);
+  reanimated::RNRuntimeDecorator::decorate(runtime, uiRuntime, proxy);
+
+  // The shadow-tree half. Without a UIManager Reanimated still runs -- shared
+  // values update and callbacks fire -- and nothing it animates reaches the
+  // screen, which is the confusing failure, so it is worth a loud line.
+  if (auto uiManager = sharedUIManager()) {
+    proxy->initializeFabric(uiManager);
+  } else {
+    LOG(ERROR) << "reanimated: no UIManager, so animated styles will not be applied";
+  }
+
+  // Every event Fabric dispatches, offered to Reanimated before the components
+  // see it. That is how a scroll handler or a gesture callback written as a
+  // worklet runs at all: without it they are declared, attached and never
+  // called.
+  //
+  // Only events raised on the UI thread, which is what iOS does and for the
+  // same reason -- a worklet runtime may only be touched from the thread that
+  // owns it, and an event from the JavaScript thread (a layout, a state update)
+  // arrives on the wrong one.
+  std::weak_ptr<reanimated::ReanimatedModuleProxy> weakProxy = proxy;
+  const bool listening = installEventListener(std::make_shared<facebook::react::EventListener>(
+      [weakProxy](const facebook::react::RawEvent &rawEvent) {
+        if (!isUiThread()) {
+          return false;
+        }
+        if (auto proxy = weakProxy.lock()) {
+          return proxy->handleRawEvent(rawEvent, monotonicMilliseconds());
+        }
+        return false;
+      }));
+  if (!listening) {
+    LOG(WARNING) << "reanimated: no event listener, so scroll and gesture "
+                    "worklets will not run";
+  }
+
+  heldProxy() = proxy;
+  scheduleFlush();
+  return Value(true);
+}
+
+#endif
+
+} // namespace basalt

package/native/core/ReanimatedModule.h

@@ -0,0 +1,55 @@
+// react-native-reanimated, on top of core/WorkletsModule.h.
+//
+// The same arrangement again, and by now the pattern is the point: the package
+// ships a large body of portable C++ -- the animation clock, the shadow-tree
+// cloning that applies an animated style without a React re-render, the CSS
+// engine, the registries -- and a small per-platform half that wires it to a
+// host. This is that half.
+//
+// It is a thicker seam than worklets' because Reanimated reaches further into
+// the renderer. Three things have to be found for it:
+//
+//   - The **UI worklet runtime** and its scheduler, which worklets installed on
+//     the JavaScript global and which Reanimated reads back from there. That is
+//     Reanimated's own arrangement, not something invented here.
+//   - The **UIManager**, because Reanimated commits to the shadow tree itself.
+//     ReactCxxPlatform hands one to the mounting manager, which is where this
+//     gets it; see core/UIManagerAccess.h.
+//   - A **frame**, on which its operations are flushed.
+//
+// What is deliberately not here is `PlatformDepMethodsHolder`'s long tail:
+// sensors, keyboard events, screen snapshots and pseudo-selector observers are
+// no-ops, because a desktop has no accelerometer and no soft keyboard, and the
+// other two are iOS's answers to iOS problems. Each one is a field in a struct
+// rather than a silent omission, which is the useful thing about that struct.
+
+#pragma once
+
+#include <ReactCommon/TurboModule.h>
+
+#include <memory>
+
+namespace basalt {
+
+// Whether this build has react-native-reanimated compiled into it.
+bool hasReanimated();
+
+#ifdef BASALT_HAS_REANIMATED
+
+class DesktopReanimatedModule : public facebook::react::TurboModule {
+ public:
+  static constexpr const char *kModuleName = "ReanimatedModule";
+
+  explicit DesktopReanimatedModule(std::shared_ptr<facebook::react::CallInvoker> jsInvoker);
+  ~DesktopReanimatedModule() override;
+
+ private:
+  static facebook::jsi::Value installTurboModule(facebook::jsi::Runtime &runtime,
+                                                 facebook::react::TurboModule &module,
+                                                 const facebook::jsi::Value *args,
+                                                 size_t count);
+};
+
+#endif
+
+} // namespace basalt

package/native/core/ScrollAnimation.cpp

@@ -0,0 +1,59 @@
+#include "ScrollAnimation.h"
+
+namespace basalt {
+
+namespace {
+
+// Cubic ease-in-out on [0, 1]. See the header for why this curve.
+double eased(double t) {
+  if (t < 0.5) {
+    return 4.0 * t * t * t;
+  }
+  const double shifted = -2.0 * t + 2.0;
+  return 1.0 - (shifted * shifted * shifted) / 2.0;
+}
+
+} // namespace
+
+bool ScrollAnimation::start(double fromX, double fromY, double toX, double toY) {
+  if (fromX == toX && fromY == toY) {
+    running_ = false;
+    return false;
+  }
+  running_ = true;
+  elapsed_ = 0.0;
+  fromX_ = fromX;
+  fromY_ = fromY;
+  toX_ = toX;
+  toY_ = toY;
+  return true;
+}
+
+bool ScrollAnimation::advance(double seconds, double &x, double &y) {
+  if (!running_) {
+    x = toX_;
+    y = toY_;
+    return false;
+  }
+
+  elapsed_ += seconds;
+  if (elapsed_ >= kDurationSeconds) {
+    // Exactly the target, not the curve evaluated near 1.0. An app that scrolls
+    // to a computed offset and then reads it back should get its own number.
+    x = toX_;
+    y = toY_;
+    running_ = false;
+    return false;
+  }
+
+  const double progress = eased(elapsed_ / kDurationSeconds);
+  x = fromX_ + (toX_ - fromX_) * progress;
+  y = fromY_ + (toY_ - fromY_) * progress;
+  return true;
+}
+
+void ScrollAnimation::stop() {
+  running_ = false;
+}
+
+} // namespace basalt

package/native/core/ScrollAnimation.h

@@ -0,0 +1,70 @@
+// A programmatic scroll that moves rather than jumps.
+//
+// `scrollTo({x, y, animated: true})` is one of the most-used things a list does
+// -- scroll to top, scroll to the newest message -- and until now the `animated`
+// flag was parsed and dropped, so every one of them arrived instantly.
+//
+// ## Why this is not ScrollMomentum
+//
+// The file next door is deliberate about it: a fling is velocity with friction
+// and *no target*, because where it lands is a consequence of how hard it was
+// thrown. This is the opposite -- a target is the only thing given, and what has
+// to be invented is the path to it. Exponential friction cannot be used here at
+// all: it approaches its destination asymptotically and never arrives.
+//
+// So: a fixed duration and an easing curve, which is what UIScrollView and
+// Android's smooth scroller both do, and what makes two of these in a row look
+// deliberate rather than elastic.
+//
+// ## The curve
+//
+// Cubic ease-in-out. It starts slow, accelerates, and settles -- and, more
+// usefully, its derivative is zero at both ends, so a scroll that begins where
+// the last one ended has no visible seam. A linear ramp is the obvious
+// alternative and looks mechanical precisely because it starts and stops at full
+// speed.
+//
+// Absolute positions rather than deltas, unlike ScrollMomentum. A fling asks
+// "how far since last frame", because it has no idea where it will end; an
+// animation knows exactly where it must be at time t, and computing that from
+// the start point avoids the drift that accumulating deltas would give over
+// ninety frames.
+
+#pragma once
+
+namespace basalt {
+
+class ScrollAnimation {
+ public:
+  // Long enough to read as movement, short enough not to feel slow. iOS uses
+  // about this for `setContentOffset:animated:`; Android's default smooth
+  // scroll is a little longer and feels it.
+  static constexpr double kDurationSeconds = 0.3;
+
+  // Begins a scroll from one offset to another. A target equal to the start is
+  // not an animation and returns false, so a caller can apply the offset and be
+  // done rather than running a curve that goes nowhere.
+  bool start(double fromX, double fromY, double toX, double toY);
+
+  // Advances by `seconds` and reports where the offset should now be. Returns
+  // false on the final step, whose position is exactly the target -- the curve
+  // is evaluated at 1.0 rather than approached, so an animated scroll always
+  // arrives at the number it was asked for.
+  bool advance(double seconds, double &x, double &y);
+
+  void stop();
+
+  bool isRunning() const {
+    return running_;
+  }
+
+ private:
+  bool running_{false};
+  double elapsed_{0.0};
+  double fromX_{0.0};
+  double fromY_{0.0};
+  double toX_{0.0};
+  double toY_{0.0};
+};
+
+} // namespace basalt

package/native/core/ScrollBounds.cpp

@@ -0,0 +1,26 @@
+#include "ScrollBounds.h"
+
+#include <algorithm>
+
+namespace basalt {
+
+ScrollRange scrollRangeFor(double containerLength,
+                           double contentLength,
+                           ScrollAxisInsets insets) {
+  ScrollRange range;
+  // Pulling *before* the content is what a leading inset buys, so the range
+  // starts below zero rather than at it.
+  range.minimum = -insets.leading;
+  range.maximum = std::max(range.minimum, contentLength - containerLength + insets.trailing);
+  return range;
+}
+
+double clampScrollOffset(double offset,
+                         double containerLength,
+                         double contentLength,
+                         ScrollAxisInsets insets) {
+  const ScrollRange range = scrollRangeFor(containerLength, contentLength, insets);
+  return std::clamp(offset, range.minimum, range.maximum);
+}
+
+} // namespace basalt

package/native/core/ScrollBounds.h

@@ -0,0 +1,68 @@
+// How far a scroll view may be scrolled, once `contentInset` has had its say.
+//
+// Three hosts had the same four lines of arithmetic -- clamp between zero and
+// `content - container` -- and none of them read `contentInset`, which was
+// parsed, stored, echoed back in the scroll event, and otherwise ignored. A
+// list that asked to be inset from the top scrolled as though it had not.
+//
+// ## What an inset does
+//
+// It is not padding. Padding makes the content bigger; an inset makes the
+// *scrollable range* bigger while leaving the content the size it is. With a
+// top inset of 50 the list may be pulled 50 points further down than its first
+// row, exposing empty space above it -- which is what a header that overlays
+// the list needs, and the reason iOS has the prop at all.
+//
+// So the range runs from `-leading` to `content - container + trailing`,
+// instead of from zero to `content - container`. With no insets those are the
+// same numbers, which is why nothing changed for anybody who never set one.
+//
+// ## Two insets, not one
+//
+// `contentInset` moves the content and `scrollIndicatorInsets` moves the
+// scrollbar, and an app may set either without the other: a header that covers
+// the top of the list usually wants both, and a window with a rounded corner
+// wants only the second. They are separate parameters here for the same reason
+// React Native keeps them separate props.
+
+#pragma once
+
+namespace basalt {
+
+// One axis of an `EdgeInsets`: the inset before the content and the one after
+// it. Vertically that is top and bottom; horizontally, left and right.
+struct ScrollAxisInsets {
+  double leading{0.0};
+  double trailing{0.0};
+};
+
+// The offsets a scroll view may rest at, on one axis. `minimum` is zero or
+// negative, `maximum` is at least `minimum`.
+struct ScrollRange {
+  double minimum{0.0};
+  double maximum{0.0};
+
+  double length() const { return maximum - minimum; }
+};
+
+// The range for one axis.
+//
+// `maximum` is never below `minimum`: content shorter than its container with a
+// leading inset can still be pulled, and the two ends must not cross, or a
+// clamp between them would answer with whichever was written last.
+ScrollRange scrollRangeFor(double containerLength,
+                           double contentLength,
+                           ScrollAxisInsets insets = {});
+
+// An offset brought inside that range.
+//
+// The one place the three hosts agreed already, and now the one place it is
+// written: an offset outside the range is a momentum frame, a `scrollTo` past
+// the end, or content that shrank under a scrolled view, and all three want the
+// nearest reachable position rather than a refusal.
+double clampScrollOffset(double offset,
+                         double containerLength,
+                         double contentLength,
+                         ScrollAxisInsets insets = {});
+
+} // namespace basalt

package/native/core/ScrollIndicator.cpp

@@ -0,0 +1,50 @@
+#include "ScrollIndicator.h"
+
+#include <algorithm>
+
+namespace basalt {
+
+ScrollIndicator scrollIndicatorFor(double containerLength,
+                                   double contentLength,
+                                   double scrollOffset,
+                                   ScrollAxisInsets content,
+                                   ScrollAxisInsets indicator) {
+  ScrollIndicator result;
+  if (containerLength <= 0.0) {
+    return result;
+  }
+
+  // Nothing to indicate when there is nowhere to go. Asked of the range rather
+  // than of the content, because a `contentInset` is somewhere to go: a list
+  // that fits exactly but can be pulled down past its top does scroll, and a
+  // bar is how you know that.
+  const ScrollRange range = scrollRangeFor(containerLength, contentLength, content);
+  if (range.length() <= 0.0) {
+    return result;
+  }
+
+  // The track: the view, less the standard inset at each end, less whatever
+  // `scrollIndicatorInsets` asks for on top of that.
+  const double start = kScrollIndicatorInset + indicator.leading;
+  const double end = containerLength - kScrollIndicatorInset - indicator.trailing;
+  const double track = end - start;
+  if (track <= 0.0) {
+    return result;
+  }
+
+  // The thumb is as long as the visible fraction of everything there is to
+  // scroll through, with a floor. A very long list would otherwise end up with
+  // a one-pixel thumb.
+  const double scrollable = range.length() + containerLength;
+  const double fraction = containerLength / scrollable;
+  const double length = std::min(track, std::max(kScrollIndicatorMinimumLength, track * fraction));
+
+  const double progress = std::clamp((scrollOffset - range.minimum) / range.length(), 0.0, 1.0);
+
+  result.visible = true;
+  result.length = length;
+  result.offset = start + progress * (track - length);
+  return result;
+}
+
+} // namespace basalt

package/native/core/ScrollIndicator.h

@@ -0,0 +1,69 @@
+// The scrollbar a scroll view draws over itself.
+//
+// None of the three hosts drew one, so a long list gave no sign of how long it
+// was or where you were in it -- which on a desktop reads as a bug rather than
+// a style.
+//
+// ## Drawn rather than borrowed
+//
+// Each toolkit has a scrollbar and none of them is available here. GTK's comes
+// with `GtkScrolledWindow`, AppKit's `NSScroller` comes with `NSScrollView`,
+// and this platform's scroll view is neither -- it is a `<View>` that moves its
+// children, because that is what Fabric hands it. Adopting a toolkit scroll
+// container would mean giving it the scrolling too, and then React Native and
+// the toolkit would both believe they own the offset.
+//
+// So it is drawn, and the geometry is decided here so that all three draw the
+// same thing. That also makes it testable, which is worth more than usual: a
+// scrollbar is pure paint, and paint is what these hosts cannot assert.
+//
+// ## The shape
+//
+// An overlay indicator, like every modern desktop: a rounded bar inset from the
+// trailing edge, sized to the fraction of the content on screen, positioned by
+// how far through it you are. Not a classic scrollbar with arrows and a
+// trough -- nothing here is a drag target yet, which `docs/backlog` records.
+
+#pragma once
+
+#include "ScrollBounds.h"
+
+namespace basalt {
+
+// Drawing constants, here rather than in three hosts so they cannot drift.
+// Thin, because it sits over content rather than beside it.
+inline constexpr double kScrollIndicatorThickness = 6.0;
+// From the trailing edge, and from each end of the track.
+inline constexpr double kScrollIndicatorInset = 2.0;
+// Below this a thumb stops reading as a position and starts reading as a dot.
+inline constexpr double kScrollIndicatorMinimumLength = 24.0;
+
+struct ScrollIndicator {
+  // False when everything fits: a scrollbar for content that cannot scroll is
+  // noise, and every list shorter than its container would grow one.
+  bool visible{false};
+  // Along the track, from its start, in points.
+  double offset{0.0};
+  double length{0.0};
+};
+
+// Where the thumb goes for one axis.
+//
+// `scrollOffset` may be outside the range -- an elastic overscroll goes
+// negative at the top -- and the result is clamped rather than refused, because
+// a thumb that vanished at the limits would flicker at exactly the moment
+// somebody is looking at it.
+//
+// Two sets of insets, and they do different jobs. `content` is the app's
+// `contentInset`: it changes how far the view scrolls, so it changes what
+// fraction of the way through any given offset is. `indicator` is
+// `scrollIndicatorInsets`: it shortens the track the thumb runs in and nothing
+// else, which is what a header overlaying the top of a list wants -- the bar
+// should start below it.
+ScrollIndicator scrollIndicatorFor(double containerLength,
+                                   double contentLength,
+                                   double scrollOffset,
+                                   ScrollAxisInsets content = {},
+                                   ScrollAxisInsets indicator = {});
+
+} // namespace basalt

package/native/core/ScrollMomentum.cpp

@@ -0,0 +1,71 @@
+#include "ScrollMomentum.h"
+
+#include <algorithm>
+#include <cmath>
+
+namespace basalt {
+
+namespace {
+
+// Pixels per second below which a fling is over. Roughly a pixel every two
+// frames, which is slower than a screen can show moving.
+constexpr double kStopSpeed = 30.0;
+
+// A fling is not allowed to take longer than this per step. A frame clock that
+// stalls -- a window dragged between monitors, a machine that swapped -- would
+// otherwise hand `advance` a whole second and teleport the list.
+constexpr double kMaxStepSeconds = 0.1;
+
+double speed(double x, double y) {
+  return std::sqrt(x * x + y * y);
+}
+
+} // namespace
+
+bool ScrollMomentum::start(double velocityX, double velocityY, double decelerationRate) {
+  if (speed(velocityX, velocityY) < kStopSpeed) {
+    running_ = false;
+    return false;
+  }
+  velocityX_ = velocityX;
+  velocityY_ = velocityY;
+  // Clamped rather than trusted: the prop is a float an app can set to
+  // anything, and a rate of 1 or more is a fling that never stops.
+  decelerationRate_ = std::clamp(decelerationRate, 0.5, 0.9999);
+  running_ = true;
+  return true;
+}
+
+bool ScrollMomentum::advance(double seconds, double &dx, double &dy) {
+  dx = 0;
+  dy = 0;
+  if (!running_) {
+    return false;
+  }
+  const double step = std::clamp(seconds, 0.0, kMaxStepSeconds);
+
+  // The distance covered during the step, at the velocity it started with. A
+  // closed-form integral of the decay would be more exact; at sixty steps a
+  // second the difference is under a pixel over a whole fling, and this stays
+  // readable.
+  dx = velocityX_ * step;
+  dy = velocityY_ * step;
+
+  const double decay = std::pow(decelerationRate_, step * 1000.0);
+  velocityX_ *= decay;
+  velocityY_ *= decay;
+
+  if (speed(velocityX_, velocityY_) < kStopSpeed) {
+    running_ = false;
+    return false;
+  }
+  return true;
+}
+
+void ScrollMomentum::stop() {
+  running_ = false;
+  velocityX_ = 0;
+  velocityY_ = 0;
+}
+
+} // namespace basalt