basalt-core 0.0.0-rc5

package/native/core/ScrollMomentum.h

@@ -0,0 +1,73 @@
+// A fling, after the fingers have gone.
+//
+// The two desktops divide this differently, and the split is the whole reason
+// this file exists rather than one platform's private helper.
+//
+// macOS does the deceleration itself. An `NSEvent` carries a `momentumPhase`
+// alongside its ordinary phase, and the system keeps delivering scroll deltas
+// after the fingers lift, tapering off on its own. So the AppKit host models
+// nothing: it reports what it is handed, and `onMomentumScrollBegin` and
+// `onMomentumScrollEnd` are that report.
+//
+// GTK does not. `GtkEventControllerScroll` with the kinetic flag emits one
+// `decelerate` signal carrying the velocity the gesture ended at, and then
+// stops -- the coasting is the application's to run. So there has to be a
+// model, and this is it.
+//
+// ## The model
+//
+// Exponential friction, which is what UIScrollView, Android's OverScroller and
+// every browser use: velocity is multiplied by a constant per millisecond, so
+// distance falls off smoothly and the fling has no fixed duration. React Native
+// already names the constant -- `decelerationRate`, 0.998 for `'normal'` and
+// 0.99 for `'fast'` -- and it is a per-millisecond factor, so the two
+// implementations agree on what a fling feels like without either quoting a
+// number the other does not have.
+//
+// It is deliberately not a spring or a fixed-duration curve. Both would need a
+// target offset up front, and a fling does not have one: where it lands is a
+// consequence of how hard it was thrown.
+
+#pragma once
+
+namespace basalt {
+
+class ScrollMomentum {
+ public:
+  // React Native's own two, as its `decelerationRate` prop resolves them. The
+  // prop is a float, so an app can pass anything between; these are the values
+  // `'normal'` and `'fast'` mean.
+  static constexpr double kNormalDeceleration = 0.998;
+  static constexpr double kFastDeceleration = 0.99;
+
+  // Begins a fling at a velocity in pixels per second, with the same sign
+  // convention as a scroll offset: positive moves the content offset up.
+  //
+  // Returns false, and starts nothing, for a fling too slow to be worth
+  // animating. That check is here rather than in a caller because the threshold
+  // and the stopping condition are the same number, and a fling that stops on
+  // its first frame is worse than one that never started -- it would report a
+  // momentum scroll beginning and ending with nothing in between.
+  bool start(double velocityX, double velocityY, double decelerationRate);
+
+  // Advances the fling by `seconds` and reports how far the offset should move.
+  // Returns false once it has stopped, in which case the deltas are the last
+  // step and the caller should apply them and finish.
+  bool advance(double seconds, double &dx, double &dy);
+
+  // Stops without reporting a final step. For a fling interrupted by a new
+  // gesture, or by the view going away.
+  void stop();
+
+  bool isRunning() const {
+    return running_;
+  }
+
+ private:
+  bool running_{false};
+  double velocityX_{0};
+  double velocityY_{0};
+  double decelerationRate_{kNormalDeceleration};
+};
+
+} // namespace basalt

package/native/core/ScrollSnap.cpp

@@ -0,0 +1,123 @@
+#include "ScrollSnap.h"
+
+#include <algorithm>
+#include <cmath>
+
+namespace basalt {
+
+namespace {
+
+// What the alignment shifts by: a centred snap lines the middle of the
+// container up with a point, an end-aligned one lines up its trailing edge.
+double alignmentShift(ScrollSnapAlignment alignment, double containerLength) {
+  switch (alignment) {
+    case ScrollSnapAlignment::Start:
+      return 0.0;
+    case ScrollSnapAlignment::Center:
+      return containerLength / 2.0;
+    case ScrollSnapAlignment::End:
+      return containerLength;
+  }
+  return 0.0;
+}
+
+double clampToContent(double offset, double containerLength, double contentLength) {
+  const double furthest = std::max(0.0, contentLength - containerLength);
+  return std::clamp(offset, 0.0, furthest);
+}
+
+// The nearest of an explicit list, with a flick moving at least one entry.
+std::optional<double> nearestOffset(const std::vector<double> &offsets,
+                                    double offset,
+                                    double velocity) {
+  if (offsets.empty()) {
+    return std::nullopt;
+  }
+  std::vector<double> sorted = offsets;
+  std::sort(sorted.begin(), sorted.end());
+
+  auto nearest = sorted.begin();
+  double best = std::abs(sorted.front() - offset);
+  for (auto it = sorted.begin(); it != sorted.end(); ++it) {
+    const double distance = std::abs(*it - offset);
+    if (distance < best) {
+      best = distance;
+      nearest = it;
+    }
+  }
+
+  if (velocity > kScrollSnapFlickVelocity) {
+    // The first entry strictly past where we are. A flick forwards must not
+    // settle back on the point it started from.
+    for (auto it = sorted.begin(); it != sorted.end(); ++it) {
+      if (*it > offset) {
+        return *it;
+      }
+    }
+    return sorted.back();
+  }
+  if (velocity < -kScrollSnapFlickVelocity) {
+    for (auto it = sorted.rbegin(); it != sorted.rend(); ++it) {
+      if (*it < offset) {
+        return *it;
+      }
+    }
+    return sorted.front();
+  }
+  return *nearest;
+}
+
+} // namespace
+
+std::optional<double> scrollSnapTarget(const ScrollSnapConfig &config,
+                                       double offset,
+                                       double velocity,
+                                       double containerLength,
+                                       double contentLength) {
+  if (!config.enabled()) {
+    return std::nullopt;
+  }
+
+  // An explicit list wins over a spacing, and a spacing over paging only when
+  // paging is off: `pagingEnabled` is the coarsest statement and iOS lets it
+  // take precedence.
+  if (!config.paging && !config.offsets.empty()) {
+    const auto target = nearestOffset(config.offsets, offset, velocity);
+    if (!target) {
+      return std::nullopt;
+    }
+    return clampToContent(*target, containerLength, contentLength);
+  }
+
+  const double interval = config.paging ? containerLength : config.interval;
+  if (interval <= 0.0) {
+    return std::nullopt;
+  }
+
+  // Aligned snapping is the same arithmetic about a shifted point: what lines
+  // up with a multiple is the container's leading edge, its middle, or its
+  // trailing edge.
+  const double shift = alignmentShift(config.alignment, containerLength);
+  const double aligned = offset + shift;
+
+  double index = std::floor(aligned / interval);
+  const double within = aligned - index * interval;
+
+  if (velocity > kScrollSnapFlickVelocity) {
+    index += 1.0;
+  } else if (velocity < -kScrollSnapFlickVelocity) {
+    // Already past a boundary by less than half means the flick backwards is
+    // to the boundary itself rather than the one before it.
+    if (within > 0.0) {
+      // index already floors to the boundary behind us.
+    } else {
+      index -= 1.0;
+    }
+  } else if (within > interval / 2.0) {
+    index += 1.0;
+  }
+
+  return clampToContent(index * interval - shift, containerLength, contentLength);
+}
+
+} // namespace basalt

package/native/core/ScrollSnap.h

@@ -0,0 +1,80 @@
+// Where a scroll should come to rest.
+//
+// `pagingEnabled`, `snapToInterval` and `snapToOffsets` are how a carousel, a
+// paged list and a stop-at-each-card list are written in React Native, and none
+// of them did anything here: a drag ended wherever the fingers left it.
+//
+// ## Why this is arithmetic and not a host's business
+//
+// Choosing the resting point needs the offset, the velocity, the container, the
+// content and the props -- and nothing from a toolkit. So it is decided here,
+// once, and each host does the same two things with the answer: stop the fling
+// and animate to it, which is what `core/ScrollAnimation.h` is for.
+//
+// That also makes it testable. Almost nothing about a scroll view on these
+// hosts can be asserted without a display; this can.
+//
+// ## The rules
+//
+// A flick settles on the next point in the direction it was flicked, even when
+// the finger left nearer the point behind. That is what makes a carousel feel
+// like a carousel rather than a list that sometimes changes page -- and it is
+// why velocity is a parameter rather than the caller simply passing the offset
+// it landed on.
+//
+// "Next in that direction" rather than "a whole page on": twenty pixels into a
+// page, flicked back, the answer is that page's start and not the one before
+// it. The rule is symmetric -- forwards from the same place is the page ahead --
+// and a small flick must not be able to travel further than a large one.
+//
+// Below that threshold the nearest point wins, which is the behaviour of
+// letting go without meaning anything by it.
+
+#pragma once
+
+#include <optional>
+#include <vector>
+
+namespace basalt {
+
+// Where in the container a snap point should line up, as React Native's
+// `snapToAlignment` names it.
+enum class ScrollSnapAlignment {
+  Start,
+  Center,
+  End,
+};
+
+struct ScrollSnapConfig {
+  // `pagingEnabled`: the interval is the container's own length, so a page is a
+  // screenful. Takes precedence over the two below, as it does on iOS.
+  bool paging{false};
+  // `snapToInterval`, in points. Zero means unused.
+  double interval{0.0};
+  // `snapToOffsets`. Empty means unused; when set it wins over `interval`,
+  // because a list of explicit points is a more specific statement than a
+  // spacing.
+  std::vector<double> offsets;
+  ScrollSnapAlignment alignment{ScrollSnapAlignment::Start};
+
+  bool enabled() const {
+    return paging || interval > 0.0 || !offsets.empty();
+  }
+};
+
+// Pixels per second past which a gesture counts as a flick rather than a
+// release. Low enough that a deliberate flick always carries, high enough that
+// the wobble of letting go does not.
+inline constexpr double kScrollSnapFlickVelocity = 250.0;
+
+// The offset to settle at, or nothing when no snapping is configured.
+//
+// `velocity` is in pixels per second, positive meaning the content offset is
+// growing -- the same sign convention as everything else here.
+std::optional<double> scrollSnapTarget(const ScrollSnapConfig &config,
+                                       double offset,
+                                       double velocity,
+                                       double containerLength,
+                                       double contentLength);
+
+} // namespace basalt

package/native/core/ShareFallback.cpp

@@ -0,0 +1,101 @@
+#include "ShareFallback.h"
+
+#include "TestDialog.h"
+
+#include <array>
+#include <string>
+
+namespace basalt {
+
+namespace {
+
+// RFC 3986's unreserved set, plus nothing. A `mailto:` is built by
+// concatenation, so anything else has to be encoded or it changes the meaning
+// of the URL rather than appearing in it -- an `&` in a message being the case
+// that actually bites, because it ends the body and starts a header.
+bool isUnreserved(unsigned char c) {
+  return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') || c == '-' ||
+      c == '_' || c == '.' || c == '~';
+}
+
+std::string percentEncode(const std::string &text) {
+  static constexpr std::array<char, 16> kHex{
+      '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
+  std::string out;
+  out.reserve(text.size());
+  for (const char raw : text) {
+    const auto c = static_cast<unsigned char>(raw);
+    if (isUnreserved(c)) {
+      out.push_back(raw);
+      continue;
+    }
+    out.push_back('%');
+    out.push_back(kHex[c >> 4U]);
+    out.push_back(kHex[c & 0x0FU]);
+  }
+  return out;
+}
+
+// The two buttons and the way out, in the order the alert shows them. React
+// Native's alerts put the cancelling one last on both desktops, so this does
+// too.
+constexpr int kCopyButton = 0;
+constexpr int kEmailButton = 1;
+
+} // namespace
+
+std::string shareClipboardText(const ShareRequest &request) {
+  // Both, when an app gave both: a link with a sentence explaining it is what
+  // most calls to Share are, and dropping either would be dropping half of what
+  // was asked for.
+  if (request.message.empty()) {
+    return request.url;
+  }
+  if (request.url.empty()) {
+    return request.message;
+  }
+  return request.message + "\n" + request.url;
+}
+
+std::string shareMailtoUrl(const ShareRequest &request) {
+  std::string url = "mailto:?body=" + percentEncode(shareClipboardText(request));
+  if (!request.title.empty()) {
+    url += "&subject=" + percentEncode(request.title);
+  }
+  return url;
+}
+
+void shareThroughFallbackPicker(const ShareRequest &request, ShareCallback onDone) {
+  AlertRequest alert;
+  // The app's own words for the picker when it gave any, which is what
+  // `options.dialogTitle` is for.
+  alert.title = request.dialogTitle.empty() ? "Share" : request.dialogTitle;
+  // The content, so a person can see what they are about to send. A share sheet
+  // shows a preview and this is the plainest form of one.
+  alert.message = shareClipboardText(request);
+  alert.buttons = {"Copy", "Email", "Cancel"};
+
+  presentAlert(alert, [request, onDone = std::move(onDone)](int button, const std::string &) {
+    switch (button) {
+      case kCopyButton:
+        setClipboardText(shareClipboardText(request));
+        onDone(ShareOutcome::Shared, "");
+        return;
+      case kEmailButton:
+        if (openUrl(shareMailtoUrl(request))) {
+          onDone(ShareOutcome::Shared, "");
+        } else {
+          // No mail client, or nothing registered for `mailto:`. A failure
+          // rather than a dismissal: the person chose to send it and it did not
+          // go, which is not the same as changing their mind.
+          onDone(ShareOutcome::Failed, "no application is registered for mailto:");
+        }
+        return;
+      default:
+        onDone(ShareOutcome::Dismissed, "");
+        return;
+    }
+  });
+}
+
+} // namespace basalt

package/native/core/ShareFallback.h

@@ -0,0 +1,45 @@
+// A share sheet for the desktops that do not have one.
+//
+// `Share.share()` promises a picker. macOS has `NSSharingServicePicker` and
+// means it. Windows has the `DataTransferManager` share UI, reachable through
+// WinRT interop. Linux has neither: there is no share portal, GNOME and KDE
+// expose no such API, and the nearest thing in the freedesktop specifications
+// is `xdg-email`, which is one destination rather than a choice of them.
+//
+// So the options were to reject on the desktops with no service, or to build
+// the smallest honest picker out of what every desktop does have. This is the
+// second. A share sheet is a list of places to send something, and the two
+// entries on it that every desktop can actually perform are *the clipboard* and
+// *an email*. Both already have seams here -- `setClipboardText` and `openUrl`
+// -- so this file is a dialog and a `mailto:` and nothing platform-specific at
+// all.
+//
+// It is deliberately not dressed up as a native share sheet. A person sees a
+// dialog with the message in it and two things they can do with it, which is
+// what is true; pretending to be a service picker that does not exist would be
+// worse than being a plain one that does.
+//
+// An implementation that wants the real thing on Windows should replace its
+// `shareContent` and leave this alone; see docs/BACKLOG.md.
+
+#pragma once
+
+#include "PlatformServices.h"
+
+namespace basalt {
+
+// The text a share puts on the clipboard: the message and the URL, whichever of
+// them the app supplied, one per line. Exposed for the tests, because it is the
+// only part of this with an answer that can be wrong.
+std::string shareClipboardText(const ShareRequest &request);
+
+// `mailto:` for the same content, with the title as the subject. Percent-encoded
+// as RFC 6068 requires, which matters more than it looks: a message with an
+// ampersand in it silently truncates the body of the draft otherwise.
+std::string shareMailtoUrl(const ShareRequest &request);
+
+// Shows the picker and reports what was chosen. The implementation of
+// `shareContent` on every desktop that has no service of its own.
+void shareThroughFallbackPicker(const ShareRequest &request, ShareCallback onDone);
+
+} // namespace basalt

package/native/core/SkiaPictureViewComponent.cpp

@@ -0,0 +1,11 @@
+#include "SkiaPictureViewComponent.h"
+
+namespace facebook::react {
+
+// The name the package's JavaScript registers, from
+// `codegenNativeComponent<NativeProps>("SkiaPictureView")`. No adapter prefix:
+// this is a codegen component rather than an Expo view manager, so the name is
+// the name.
+extern const char SkiaPictureViewComponentName[] = "SkiaPictureView";
+
+} // namespace facebook::react

package/native/core/SkiaPictureViewComponent.h

@@ -0,0 +1,47 @@
+// `SkiaPictureView`, which is what a `<Canvas>` from @shopify/react-native-skia
+// mounts.
+//
+// Plain `ViewProps`, unlike core/ExpoImageComponent.h which needed its own props
+// class -- and for a reason worth stating, because it looks like a shortcut and
+// is not. A `<Canvas>` does not carry its content in props. It renders a
+// `SkPicture` in JavaScript and pushes it through the Skia JSI API keyed by an
+// id, and the only thing the native side needs from props is which id it is:
+//
+//     <SkiaPictureViewNativeComponent nativeID={`${nativeId}`} ... />
+//
+// `nativeID` is an ordinary `ViewProps` field, so it arrives on any component
+// whatever its view config says. That sidesteps the trap ExpoImageComponent.h
+// spends a paragraph on: a prop absent from the JavaScript view config is
+// dropped before it is ever diffed, silently. Here there is nothing to drop.
+//
+// What *is* dropped: `debug`, `opaque`, `colorSpace` and `highBitDepth`, the four
+// props the package's spec declares. They are decoration -- an FPS overlay, an
+// opaque backing, P3, ten bits a channel -- and a canvas without them draws the
+// same picture. The same call ExpoImage makes about placeholders and blurhash.
+// When one is wanted, it belongs in a props class here and in the peer.
+//
+// Registered unconditionally, like ExpoImage and for the same reason: it costs a
+// name in a registry, and the alternative is a host that has to be rebuilt to
+// run an app that draws. Without Skia in the build the view mounts and stays
+// empty -- but an app that draws will already have failed at
+// `getEnforcing('RNSkiaModule')` long before, which is the error that says what
+// is actually missing.
+
+#pragma once
+
+#include <react/renderer/components/view/ConcreteViewShadowNode.h>
+#include <react/renderer/components/view/ViewEventEmitter.h>
+#include <react/renderer/components/view/ViewProps.h>
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+
+namespace facebook::react {
+
+extern const char SkiaPictureViewComponentName[];
+
+using SkiaPictureViewShadowNode =
+    ConcreteViewShadowNode<SkiaPictureViewComponentName, ViewProps, ViewEventEmitter>;
+
+using SkiaPictureViewComponentDescriptor =
+    ConcreteComponentDescriptor<SkiaPictureViewShadowNode>;
+
+} // namespace facebook::react

package/native/core/SourceCodeModule.cpp

@@ -0,0 +1,55 @@
+#include "SourceCodeModule.h"
+
+#include <filesystem>
+
+namespace basalt {
+
+facebook::jsi::Object DesktopSourceCodeModule::getConstants(facebook::jsi::Runtime &rt) {
+  facebook::jsi::Object constants(rt);
+  constants.setProperty(rt, "scriptURL", facebook::jsi::String::createFromUtf8(rt, scriptURL_));
+  return constants;
+}
+
+std::string scriptURLFor(const std::string &bundlePath,
+                         bool devMode,
+                         const std::string &devHost,
+                         unsigned int devPort,
+                         const std::string &devEntry,
+                         const std::string &platform) {
+  if (devMode) {
+    // Shaped like the URL the dev server actually served, because React Native
+    // recovers the server's address by stripping the path off this. Assets then
+    // resolve to that server, which is what makes them work in development
+    // without anything being copied anywhere. And the platform is the host's
+    // own, because HMRClient registers this URL for Fast Refresh; see the
+    // header.
+    return "http://" + devHost + ":" + std::to_string(devPort) + "/" + devEntry +
+        ".bundle?platform=" + platform + "&dev=true";
+  }
+
+  // Absolute and fully formed: React Native tests this with
+  // startsWith('file://') and then takes the directory beside it, so a relative
+  // path silently produces an asset URL that resolves nowhere.
+  std::error_code ignored;
+  const std::filesystem::path absolute = std::filesystem::absolute(bundlePath, ignored);
+
+  // `generic_string`, not `string`: on Windows the native form is
+  // `D:\build\x.js`, and `resolveAssetSource` finds the bundle's directory
+  // with `scriptURL.lastIndexOf('/')`. With no forward slash in it that is -1,
+  // the directory comes out empty, and every `require()`d image resolves to
+  // `file://assets/...` -- a URI with an authority and no path, which opens
+  // nothing. It cost a green Linux run and a red Windows one to find, and it
+  // was never about LogBox: it is every asset on that platform.
+  std::string path = absolute.lexically_normal().generic_string();
+
+  // And the third slash. A POSIX path already starts with one, so `file://` and
+  // `/Users/x` make `file:///Users/x`; a Windows path starts at the drive
+  // letter and has to be given one, which is what every browser and URI library
+  // does with `file:///C:/x`.
+  if (path.empty() || path.front() != '/') {
+    path.insert(path.begin(), '/');
+  }
+  return "file://" + path;
+}
+
+} // namespace basalt

package/native/core/SourceCodeModule.h

@@ -0,0 +1,53 @@
+// `SourceCode`, which is how JavaScript learns where the bundle came from.
+//
+// It sounds like diagnostics and is not: React Native's asset resolution is
+// built on it. `AssetSourceResolver` asks whether the script came from a server
+// or from a file, and answers `require('./logo.png')` with either a URL on that
+// server or a path beside that file. With no script URL, every asset resolves
+// to nonsense -- `file://assets/assets/logo.png`, in the case that led here.
+//
+// ReactCxxPlatform ships a SourceCode module, and on React Native 0.86 it is
+// always handed an empty string: `ReactHost` has no `sourceURL_` at all, and
+// 0.87 added one. Rather than support this on the versions that happen to fill
+// it in, the host reports the URL itself, which it has known all along.
+
+#pragma once
+
+#include <FBReactNativeSpec/FBReactNativeSpecJSI.h>
+
+#include <string>
+
+namespace basalt {
+
+class DesktopSourceCodeModule
+    : public facebook::react::NativeSourceCodeCxxSpec<DesktopSourceCodeModule> {
+ public:
+  DesktopSourceCodeModule(std::shared_ptr<facebook::react::CallInvoker> jsInvoker, std::string scriptURL)
+      : NativeSourceCodeCxxSpec(std::move(jsInvoker)), scriptURL_(std::move(scriptURL)) {}
+
+  facebook::jsi::Object getConstants(facebook::jsi::Runtime &rt);
+
+ private:
+  std::string scriptURL_;
+};
+
+// The URL to report for a bundle loaded from `bundlePath`, or from a dev server
+// when one is in use.
+//
+// A file URL has to be absolute and fully formed: React Native tests it with
+// `startsWith('file://')` and then takes the directory beside it, so a relative
+// path silently produces an asset URL that resolves nowhere.
+//
+// A dev server URL has to name the host's platform. React Native's HMRClient
+// registers exactly this URL with Metro, and Metro keys the module graph it
+// sends updates for by the platform in it. This used to say `linux` on every
+// host, so on Windows Metro dutifully sent Fast Refresh updates for a Linux
+// graph that the running app did not have, and no edit ever appeared.
+std::string scriptURLFor(const std::string &bundlePath,
+                         bool devMode,
+                         const std::string &devHost,
+                         unsigned int devPort,
+                         const std::string &devEntry,
+                         const std::string &platform);
+
+} // namespace basalt

package/native/core/StatusBarModule.cpp

@@ -0,0 +1,23 @@
+#include "StatusBarModule.h"
+
+namespace basalt {
+
+using facebook::jsi::Object;
+using facebook::jsi::Runtime;
+
+Object DesktopStatusBarModule::getConstants(Runtime &rt) {
+  Object constants(rt);
+  // Zero, and meant literally. React Native's own JavaScript lays out around
+  // this value, so reporting a plausible-looking phone height would push every
+  // app's content down by a status bar that is not there.
+  constants.setProperty(rt, "HEIGHT", 0.0);
+  constants.setProperty(rt, "DEFAULT_BACKGROUND_COLOR", 0.0);
+  return constants;
+}
+
+void DesktopStatusBarModule::setColor(Runtime & /*rt*/, double /*color*/, bool /*animated*/) {}
+void DesktopStatusBarModule::setTranslucent(Runtime & /*rt*/, bool /*translucent*/) {}
+void DesktopStatusBarModule::setStyle(Runtime & /*rt*/, std::optional<std::string> /*style*/) {}
+void DesktopStatusBarModule::setHidden(Runtime & /*rt*/, bool /*hidden*/) {}
+
+} // namespace basalt

package/native/core/StatusBarModule.h

@@ -0,0 +1,42 @@
+// `StatusBarManager`, which a desktop does not have.
+//
+// React Native's <StatusBar> resolves to this module, and `expo-status-bar`
+// wraps it, so the component that a blank Expo app puts on screen by default
+// reaches for it before rendering. It is looked up with getEnforcing, so its
+// absence is not a quiet no-op -- it throws, and takes the app's first render
+// with it.
+//
+// So the module exists and does nothing, which is the truthful implementation
+// rather than a placeholder. There is no status bar on a desktop: its height is
+// zero, and hiding or styling something with no pixels is a no-op in the
+// strongest sense, not a stub waiting to be filled in.
+//
+// The Android spec is the one implemented, for the same reason the platform
+// constants module answers the Android shape: this platform reports Android
+// constants and shares Android's JavaScript. The iOS spec carries methods about
+// network activity indicators that mean even less here.
+
+#pragma once
+
+#include <FBReactNativeSpec/FBReactNativeSpecJSI.h>
+
+#include <optional>
+#include <string>
+
+namespace basalt {
+
+class DesktopStatusBarModule
+    : public facebook::react::NativeStatusBarManagerAndroidCxxSpec<DesktopStatusBarModule> {
+ public:
+  explicit DesktopStatusBarModule(std::shared_ptr<facebook::react::CallInvoker> jsInvoker)
+      : NativeStatusBarManagerAndroidCxxSpec(std::move(jsInvoker)) {}
+
+  facebook::jsi::Object getConstants(facebook::jsi::Runtime &rt);
+
+  void setColor(facebook::jsi::Runtime &rt, double color, bool animated);
+  void setTranslucent(facebook::jsi::Runtime &rt, bool translucent);
+  void setStyle(facebook::jsi::Runtime &rt, std::optional<std::string> statusBarStyle);
+  void setHidden(facebook::jsi::Runtime &rt, bool hidden);
+};
+
+} // namespace basalt