basalt-core 0.0.0-rc5 → 0.1.0

package/native/core/CoreModules.cpp

@@ -1,9 +1,15 @@
 #include "CoreModules.h"
 
+#include "DeviceMetrics.h"
+#include "SystemLocale.h"
+
 #include "ShareFallback.h"
 #include "TestDialog.h"
+#include "UIManagerAccess.h"
 
+#include <jsi/JSIDynamic.h>
 #include <react/bridging/Promise.h>
+#include <react/renderer/core/LayoutableShadowNode.h>
 
 #include <glog/logging.h>
 
@@ -236,25 +242,36 @@ I18nState &i18n() {
 
 Object DesktopI18nManagerModule::getConstants(Runtime &rt) {
   I18nState &state = i18n();
-  const std::lock_guard<std::mutex> lock(state.mutex);
+  const SystemLocale locale = lastKnownSystemLocale();
 
   Object constants(rt);
-  // `isRTL` is what the layout actually is. Only `forceRTL` can make it true
-  // here: deciding it from the system locale would need a locale database this
-  // does not have, and guessing wrong flips an app's entire layout.
-  constants.setProperty(rt, "isRTL", state.forceRTL);
-  constants.setProperty(rt, "doLeftAndRightSwapInRTL", state.swapLeftAndRight);
-  // Empty rather than a guess. React Native's JavaScript treats it as opaque
-  // and only apps read it.
-  constants.setProperty(rt, "localeIdentifier", String::createFromUtf8(rt, ""));
+  // `isRTL` is what the layout actually is, and since 2026-10-10 that includes
+  // the desktop's own language: every platform publishes a reading direction,
+  // which is a different question from parsing a locale name. See
+  // core/SystemLocale.h, which also decides the precedence between this and
+  // the two calls below.
+  constants.setProperty(rt, "isRTL", layoutIsRightToLeft());
+  {
+    const std::lock_guard<std::mutex> lock(state.mutex);
+    constants.setProperty(rt, "doLeftAndRightSwapInRTL", state.swapLeftAndRight);
+  }
+  constants.setProperty(rt,
+                        "localeIdentifier",
+                        String::createFromUtf8(rt, locale.identifier));
   return constants;
 }
 
 void DesktopI18nManagerModule::allowRTL(Runtime &rt, bool allow) {
   (void)rt;
   I18nState &state = i18n();
-  const std::lock_guard<std::mutex> lock(state.mutex);
-  state.allowRTL = allow;
+  {
+    const std::lock_guard<std::mutex> lock(state.mutex);
+    state.allowRTL = allow;
+  }
+  // And the copy the layout reads, which is core's: a host building layout
+  // constraints cannot lock this module's state, and the two must not be able
+  // to disagree about which way the app reads.
+  setAllowRTL(allow);
 }
 
 void DesktopI18nManagerModule::forceRTL(Runtime &rt, bool force) {
@@ -262,6 +279,7 @@ void DesktopI18nManagerModule::forceRTL(Runtime &rt, bool force) {
   I18nState &state = i18n();
   const std::lock_guard<std::mutex> lock(state.mutex);
   state.forceRTL = force;
+  setForceRTL(force);
   // Deliberately not restarting or relaying out. On iOS and Android this takes
   // effect after a reload, and React Native's own documentation says so -- an
   // app that flipped direction mid-session would be a surprise rather than a
@@ -589,4 +607,355 @@ Value DesktopShareModule::share(Runtime &rt, Object content, std::optional<Strin
   return Value(rt, facebook::react::bridging::toJs(rt, *promise, jsInvoker_));
 }
 
+// ---------------------------------------------------------------------------
+// AppState
+// ---------------------------------------------------------------------------
+
+DesktopAppStateModule::DesktopAppStateModule(
+    std::shared_ptr<facebook::react::CallInvoker> jsInvoker)
+    : facebook::react::NativeAppStateCxxSpec<DesktopAppStateModule>(std::move(jsInvoker)) {
+  setAppStateListener([this](AppStateKind state) {
+    const std::string name = appStateName(state);
+    emitDeviceEvent("appStateDidChange",
+                    [name](Runtime &runtime, std::vector<Value> &args) {
+                      Object payload(runtime);
+                      payload.setProperty(runtime, "app_state",
+                                          String::createFromUtf8(runtime, name));
+                      args.emplace_back(std::move(payload));
+                    });
+  });
+}
+
+DesktopAppStateModule::~DesktopAppStateModule() {
+  // The listener captured `this`; a surface torn down and started again builds
+  // a new module.
+  setAppStateListener(nullptr);
+}
+
+facebook::react::AppStateConstants DesktopAppStateModule::getConstants(Runtime & /*rt*/) {
+  facebook::react::AppStateConstants constants;
+  constants.initialAppState = appStateName(currentAppState());
+  return constants;
+}
+
+void DesktopAppStateModule::getCurrentAppState(
+    Runtime & /*rt*/,
+    const facebook::react::AsyncCallback<facebook::react::AppState> &success,
+    facebook::jsi::Function /*error*/) {
+  // Answered rather than dropped, which is the whole of what upstream's does:
+  // `AppState.js` calls this once at startup to populate `currentState`, and a
+  // callback that is never called leaves it as whatever `getConstants` said.
+  facebook::react::AppState state;
+  state.app_state = appStateName(currentAppState());
+  success(std::move(state));
+}
+
+void DesktopAppStateModule::addListener(Runtime & /*rt*/, const std::string & /*eventName*/) {}
+
+void DesktopAppStateModule::removeListeners(Runtime & /*rt*/, double /*count*/) {}
+
+// ---------------------------------------------------------------------------
+// Dimensions and PixelRatio
+// ---------------------------------------------------------------------------
+
+DesktopDeviceInfoModule::DesktopDeviceInfoModule(
+    std::shared_ptr<facebook::react::CallInvoker> jsInvoker)
+    : facebook::react::NativeDeviceInfoCxxSpec<DesktopDeviceInfoModule>(std::move(jsInvoker)) {
+  // `didUpdateDimensions`, which `Dimensions.js` subscribes to before it ever
+  // asks for the constants. The listener is core's second slot on the window
+  // bounds signal; see WindowControl.h for why there are two.
+  setDimensionsListener([this]() {
+    const basalt::DeviceMetrics metrics = currentDeviceMetrics();
+    if (metrics == lastSent_) {
+      return;
+    }
+    lastSent_ = metrics;
+    emitDeviceEvent("didUpdateDimensions",
+                    [metrics](Runtime &runtime, std::vector<Value> &args) {
+                      Object payload(runtime);
+                      const auto describe = [&runtime](const basalt::DisplayMetrics &one) {
+                        Object out(runtime);
+                        out.setProperty(runtime, "width", one.width);
+                        out.setProperty(runtime, "height", one.height);
+                        out.setProperty(runtime, "scale", one.scale);
+                        out.setProperty(runtime, "fontScale", one.fontScale);
+                        return out;
+                      };
+                      payload.setProperty(runtime, "window", describe(metrics.window));
+                      payload.setProperty(runtime, "screen", describe(metrics.screen));
+                      args.emplace_back(std::move(payload));
+                    });
+  });
+}
+
+DesktopDeviceInfoModule::~DesktopDeviceInfoModule() {
+  // The listener captured `this`. A surface torn down and started again builds
+  // a new module, and the old one must stop being called first.
+  setDimensionsListener(nullptr);
+}
+
+facebook::react::DeviceInfoConstants DesktopDeviceInfoModule::getConstants(Runtime & /*rt*/) {
+  const basalt::DeviceMetrics metrics = currentDeviceMetrics();
+  // What JavaScript now has, so the first resize after this does not re-send
+  // the same numbers.
+  lastSent_ = metrics;
+  // Every field, by assignment rather than by designated initialiser.
+  //
+  // Two of each struct's fields are Android's physical-pixel payloads and
+  // iOS's notch flag, which this platform has nothing to say about -- and
+  // naming only the fields that matter is what `-Wmissing-field-initializers`
+  // is for. Which is not a style point: the *generated* `DisplayMetrics`
+  // declares `fontScale` with no default member initialiser, so a partial
+  // initialisation leaves it as whatever was on the stack, which is the bug
+  // upstream's own module has. All four are filled here.
+  const auto describe = [](const basalt::DisplayMetrics &one) {
+    return facebook::react::DisplayMetrics{one.width, one.height, one.scale, one.fontScale};
+  };
+
+  facebook::react::DeviceInfoConstants constants;
+  constants.Dimensions.window = describe(metrics.window);
+  constants.Dimensions.screen = describe(metrics.screen);
+  return constants;
+}
+
+// ---------------------------------------------------------------------------
+// Settings
+// ---------------------------------------------------------------------------
+
+DesktopSettingsManagerModule::DesktopSettingsManagerModule(
+    std::shared_ptr<facebook::react::CallInvoker> jsInvoker)
+    : NativeSettingsManagerCxxSpec(std::move(jsInvoker)), store_(settingsFilePath()) {}
+
+Object DesktopSettingsManagerModule::getConstants(Runtime &rt) {
+  // `Settings._settings` is this object, once, at import. Everything
+  // `Settings.get` answers afterwards is read out of it in JavaScript, so a
+  // run that reads a setting never calls this module again -- which is why
+  // reading is as cheap here as it is on iOS.
+  Object constants(rt);
+  constants.setProperty(rt, "settings", facebook::jsi::valueFromDynamic(rt, store_.values()));
+  return constants;
+}
+
+void DesktopSettingsManagerModule::setValues(Runtime &rt, Object values) {
+  store_.merge(facebook::jsi::dynamicFromValue(rt, Value(rt, values)));
+}
+
+void DesktopSettingsManagerModule::deleteValues(Runtime &rt, Array values) {
+  const size_t count = values.size(rt);
+  std::vector<std::string> keys;
+  keys.reserve(count);
+  for (size_t index = 0; index < count; ++index) {
+    const Value element = values.getValueAtIndex(rt, index);
+    // `Settings` has no deleteValues of its own: this is reached by an app
+    // calling the module directly, so what arrives is whatever it passed.
+    if (element.isString()) {
+      keys.push_back(element.getString(rt).utf8(rt));
+    }
+  }
+  store_.erase(keys);
+}
+
+// ---------------------------------------------------------------------------
+// Action sheets
+// ---------------------------------------------------------------------------
+
+namespace {
+
+// `anchor`, which iOS uses to hang the popover off a view and a desktop uses to
+// put the menu under the control that opened it. A react tag, resolved through
+// the shadow tree, so all three hosts answer it with no code of their own.
+//
+// Nothing when there is no UIManager, when the tag names no view, or when that
+// view has no layout yet -- and the caller then shows the menu at the pointer,
+// which is where a menu with no anchor goes.
+std::optional<std::pair<double, double>> anchorPoint(int tag) {
+  const std::shared_ptr<facebook::react::UIManager> uiManager = sharedUIManager();
+  if (uiManager == nullptr) {
+    return std::nullopt;
+  }
+  // Deprecated upstream and the only way to get from a tag to a node: every
+  // other entry point takes a shadow node, and what JavaScript has is a tag.
+  const std::shared_ptr<const facebook::react::ShadowNode> node =
+      uiManager->findShadowNodeByTag_DEPRECATED(tag);
+  if (node == nullptr) {
+    return std::nullopt;
+  }
+
+  // Relative to the root, which is the window's own coordinates -- the same
+  // space `showContextMenu` is passed from JavaScript.
+  const facebook::react::LayoutableShadowNode::LayoutInspectingPolicy policy;
+  const facebook::react::LayoutMetrics metrics =
+      uiManager->getRelativeLayoutMetrics(*node, nullptr, policy);
+  if (metrics == facebook::react::EmptyLayoutMetrics) {
+    return std::nullopt;
+  }
+
+  // Under the anchor rather than over it, which is where a desktop puts the
+  // menu a button opens. iOS points a popover at the view from whichever side
+  // has room, which is an iPad's problem and not one a window has.
+  return std::make_pair(static_cast<double>(metrics.frame.origin.x),
+                        static_cast<double>(metrics.frame.origin.y + metrics.frame.size.height));
+}
+
+std::vector<int> indexList(Runtime &rt, const Object &options, const char *key) {
+  std::vector<int> indices;
+  const Value value = options.getProperty(rt, key);
+  if (!value.isObject() || !value.asObject(rt).isArray(rt)) {
+    return indices;
+  }
+  Array list = value.asObject(rt).asArray(rt);
+  const size_t count = list.size(rt);
+  for (size_t index = 0; index < count; ++index) {
+    const Value element = list.getValueAtIndex(rt, index);
+    if (element.isNumber()) {
+      indices.push_back(static_cast<int>(element.asNumber()));
+    }
+  }
+  return indices;
+}
+
+} // namespace
+
+Object DesktopActionSheetModule::getConstants(Runtime &rt) {
+  return Object(rt);
+}
+
+void DesktopActionSheetModule::showActionSheetWithOptions(Runtime &rt,
+                                                          Object options,
+                                                          Function callback) {
+  ActionSheetRequest request;
+  request.title = optionalString(rt, options, "title");
+  request.message = optionalString(rt, options, "message");
+
+  const Value titles = options.getProperty(rt, "options");
+  if (titles.isObject() && titles.asObject(rt).isArray(rt)) {
+    Array list = titles.asObject(rt).asArray(rt);
+    const size_t count = list.size(rt);
+    for (size_t index = 0; index < count; ++index) {
+      const Value element = list.getValueAtIndex(rt, index);
+      if (element.isString()) {
+        request.options.push_back(element.getString(rt).utf8(rt));
+      }
+    }
+  }
+  if (request.options.empty()) {
+    // `options` is required and React Native does not check it. Nothing to show
+    // and no index to report, so the callback is not called -- which is what
+    // iOS does with a sheet nobody pressed anything on.
+    LOG(WARNING) << "ActionSheetIOS.showActionSheetWithOptions was given no options";
+    return;
+  }
+
+  request.disabledIndices = indexList(rt, options, "disabledButtonIndices");
+  const Value cancel = options.getProperty(rt, "cancelButtonIndex");
+  if (cancel.isNumber()) {
+    request.cancelIndex = static_cast<int>(cancel.asNumber());
+  }
+
+  const Value anchor = options.getProperty(rt, "anchor");
+  if (anchor.isNumber()) {
+    const std::optional<std::pair<double, double>> point =
+        anchorPoint(static_cast<int>(anchor.asNumber()));
+    if (point.has_value()) {
+      request.x = point->first;
+      request.y = point->second;
+    }
+  }
+
+  const ActionSheetMenu menu = actionSheetMenu(request);
+  // What it is about to show, because the presentation is the one part an
+  // automated run skips: with BASALT_TEST_MENU set no menu appears, and this
+  // line is where the anchor having been resolved is visible at all.
+  LOG(INFO) << "action sheet: " << request.options.size() << " options at (" << menu.menu.x << ", "
+            << menu.menu.y << ")";
+
+  // The callback has to outlive the menu, which is up until somebody chooses.
+  auto shared = std::make_shared<Function>(std::move(callback));
+  auto invoker = jsInvoker_;
+
+  presentMenu(menu.menu, [shared, invoker, request, menu](int chosen) {
+    const std::optional<int> option = actionSheetChoice(request, menu, chosen);
+    if (!option.has_value() || invoker == nullptr) {
+      return;
+    }
+    // Back onto the JavaScript thread: a menu answers from the thread that drew
+    // it, and a jsi::Function may only be called on the runtime's.
+    invoker->invokeAsync(
+        [shared, index = *option](Runtime &runtime) { shared->call(runtime, Value(index)); });
+  });
+}
+
+void DesktopActionSheetModule::showShareActionSheetWithOptions(Runtime &rt,
+                                                               Object options,
+                                                               Function failureCallback,
+                                                               Function successCallback) {
+  ShareRequest request;
+  request.message = optionalString(rt, options, "message");
+  request.url = optionalString(rt, options, "url");
+  request.title = optionalString(rt, options, "subject");
+
+  if (request.message.empty() && request.url.empty()) {
+    // What iOS does: an error in the log and neither callback called. Worth
+    // keeping rather than improving, because an app that handled "no url or
+    // message" by waiting forever is already written that way.
+    LOG(ERROR) << "ActionSheetIOS.showShareActionSheetWithOptions had no `url` or `message`";
+    return;
+  }
+
+  auto failure = std::make_shared<Function>(std::move(failureCallback));
+  auto success = std::make_shared<Function>(std::move(successCallback));
+  auto invoker = jsInvoker_;
+
+  shareContent(request, [failure, success, invoker](ShareOutcome outcome,
+                                                    const std::string &message) {
+    if (invoker == nullptr) {
+      return;
+    }
+    if (outcome == ShareOutcome::Failed) {
+      invoker->invokeAsync([failure, message](Runtime &runtime) {
+        // The shape `ShareActionSheetError` declares, which is what
+        // RCTJSErrorFromNSError produces on iOS: a domain, a code and a
+        // message. There is no NSError here, so the domain says where it came
+        // from and the code says what happened.
+        Object error(runtime);
+        error.setProperty(runtime, "domain", String::createFromUtf8(runtime, "basalt.share"));
+        error.setProperty(runtime, "code", String::createFromUtf8(runtime, "share-failed"));
+        error.setProperty(
+            runtime,
+            "message",
+            String::createFromUtf8(runtime, message.empty() ? "sharing failed" : message));
+        failure->call(runtime, error);
+      });
+      return;
+    }
+    // `(completed, method)`. iOS reports the activity type as the method and
+    // null when the sheet was dismissed; a desktop picker has no activity type
+    // to report, which is the same null `Share.share()` resolves with here.
+    const bool completed = outcome == ShareOutcome::Shared;
+    invoker->invokeAsync([success, completed](Runtime &runtime) {
+      success->call(runtime, Value(completed), Value::null());
+    });
+  });
+}
+
+void DesktopActionSheetModule::dismissActionSheet(Runtime &rt) {
+  (void)rt;
+  // Nothing to dismiss, and not for want of trying. A popup menu on these three
+  // runs its own tracking loop -- `TrackPopupMenu` on Win32 and
+  // `popUpMenuPositioningItem` on AppKit both block the thread that opened it
+  // until the menu goes away -- so this call, which arrives on the JavaScript
+  // thread, cannot reach the menu while it is up: the UI thread is inside the
+  // menu and the work this would post runs after it has closed. Taking it down
+  // needs each toolkit's cancel called from inside its own loop
+  // (`[NSMenu cancelTracking]`, `EndMenu()`, `gtk_popover_popdown`), which is a
+  // per-host piece of work; see docs/backlog/modules.md.
+  //
+  // React Native's own JavaScript guards this one -- `typeof
+  // RCTActionSheetManager.dismissActionSheet === 'function'` -- so iOS treats it
+  // as optional too. It is here because the generated spec declares it, and it
+  // says what it did rather than pretending.
+  LOG(WARNING) << "ActionSheetIOS.dismissActionSheet: a popup menu here closes on Escape or on a "
+                  "choice and cannot be taken down from JavaScript";
+}
+
 } // namespace basalt

package/native/core/CoreModules.h

@@ -1,9 +1,13 @@
 // The core React Native modules ReactCxxPlatform does not provide.
 //
-// Upstream supplies fifteen -- Animated, AppState, DeviceInfo, DevSettings,
-// ImageLoader, LogBox, ExceptionsManager, the observers, Networking,
-// PlatformConstants, SourceCode, WebSocket. What is here is the set a real app
-// reaches for and finds missing, and it splits in two ways that matter.
+// Upstream supplies nineteen, from two providers rather than one:
+// ReactCxxTurboModuleProvider has AppState, DeviceInfo, DevLoadingView,
+// ExceptionsManager, ImageLoader, LogBox, NativeAnimatedModule, Networking,
+// PlatformConstants and WebSocketModule, and DefaultTurboModules -- which it
+// falls through to -- has the web APIs. `scripts/audit_modules.py` prints the
+// list per module and per host; this comment said fifteen from one provider
+// until that audit read both chains. What is here is the set a real app reaches
+// for and finds missing, and it splits in two ways that matter.
 //
 // **How they fail.** `Clipboard` and `Vibration` are looked up with
 // `getEnforcing`, so their absence *throws at import* -- an app that so much as
@@ -24,9 +28,15 @@
 
 #pragma once
 
+#include "ActionSheet.h"
+#include "AppStateHost.h"
+#include "DeviceMetrics.h"
 #include "PlatformServices.h"
+#include "SettingsStore.h"
 
 #include <FBReactNativeSpec/FBReactNativeSpecJSI.h>
+#include <react/coremodules/AppStateModule.h>
+#include <react/coremodules/DeviceInfoModule.h>
 
 #include <optional>
 #include <string>
@@ -144,6 +154,132 @@ class DesktopShareModule : public facebook::react::NativeShareModuleCxxSpec<Desk
                              std::optional<facebook::jsi::String> dialogTitle);
 };
 
+// `Settings`, which an app reaches through `Settings.get` and `Settings.set`.
+//
+// The second module whose JavaScript had to be replaced as well, and found the
+// same way: `Settings.js` branches on `Platform.OS === 'ios'` and hands
+// everything else `SettingsFallback`, which warns and answers null. So the
+// module was never reached, and the audit's claim that this one *throws* was
+// wrong in the app's favour -- see src/overrides/Settings.ts and
+// docs/backlog/modules.md.
+//
+// A file rather than each desktop's own settings store, for the reasons
+// core/SettingsStore.h argues. The store is a member rather than a global: it
+// is read in the constructor and written on every change, and a reload builds a
+// new module, which re-reads the file -- which is the state.
+//
+// No `settingsUpdated` event, deliberately. iOS sets `_ignoringUpdates` around
+// its own `setValues` for the reason this has nothing to emit: `Settings.set`
+// has already merged into JavaScript's copy by the time the module is called,
+// so `_sendObservations` would see no change and call no watcher. What does
+// fire a watcher is a change from outside the process, which means watching the
+// file; that is recorded rather than written.
+class DesktopSettingsManagerModule
+    : public facebook::react::NativeSettingsManagerCxxSpec<DesktopSettingsManagerModule> {
+ public:
+  explicit DesktopSettingsManagerModule(std::shared_ptr<facebook::react::CallInvoker> jsInvoker);
+
+  static constexpr const char *kModuleName = "SettingsManager";
+
+  facebook::jsi::Object getConstants(facebook::jsi::Runtime &rt);
+  void setValues(facebook::jsi::Runtime &rt, facebook::jsi::Object values);
+  void deleteValues(facebook::jsi::Runtime &rt, facebook::jsi::Array values);
+
+ private:
+  SettingsStore store_;
+};
+
+// `ActionSheetIOS`, which is a popup menu here. See core/ActionSheet.h for why
+// a menu rather than a dialog, and for what a desktop cannot do with one.
+//
+// The third module with a share sheet in it, and they are not duplicates: iOS
+// splits sharing between `Share.share()` -- a promise, Android-shaped, which is
+// `ShareModule` above -- and `ActionSheetIOS.showShareActionSheetWithOptions`,
+// a callback pair on this module. Both end up in `shareContent`, so the picker
+// an app sees is the same one either way.
+//
+// No JavaScript override, unlike `Settings`, `Share` and `Alert`:
+// `ActionSheetIOS.js` has no `Platform.OS` branch and calls the module
+// directly, so the module alone is enough. An iOS-named API is not
+// automatically one whose JavaScript refuses to run off iOS, and the only way
+// to know which kind it is, is to read it.
+// `Dimensions` and `PixelRatio`, which every app reads and which answered with
+// a fiction until 2026-10-10.
+//
+// ReactCxxPlatform *does* provide a `DeviceInfo` module -- the module audit
+// records it as answered -- and what it answers is a hardcoded 1280x720 with a
+// `// TODO: Wire this to come from the actual app size` beside it and no seam
+// to wire. `scale` came back zero and `fontScale` was never initialised, so
+// `PixelRatio.get()` was 0 and `PixelRatio.roundToNearestPixel(x)` was NaN in
+// every app on every desktop. "The module answers" and "the module answers
+// correctly" are different claims, and only the first was ever checked.
+//
+// The numbers are core's: see core/DeviceMetrics.h. What is here is the module
+// and the event -- `didUpdateDimensions`, which is how `Dimensions.js` learns
+// that a window was resized, and without which every layout computed from
+// `Dimensions.get('window')` is stale the moment somebody drags a corner.
+// `AppState`, whose every method ReactCxxPlatform leaves empty: `getConstants`
+// answers `initialAppState: ""`, `getCurrentAppState` calls neither of its
+// callbacks, and nothing ever emits a change. An app pausing a poll while it is
+// not in front, or refetching when it comes back, was told nothing at all. See
+// core/AppStateHost.h for what the three states mean on a desktop.
+class DesktopAppStateModule
+    : public facebook::react::NativeAppStateCxxSpec<DesktopAppStateModule> {
+ public:
+  explicit DesktopAppStateModule(std::shared_ptr<facebook::react::CallInvoker> jsInvoker);
+  ~DesktopAppStateModule() override;
+
+  static constexpr const char *kModuleName = "AppState";
+
+  facebook::react::AppStateConstants getConstants(facebook::jsi::Runtime &rt);
+  void getCurrentAppState(
+      facebook::jsi::Runtime &rt,
+      const facebook::react::AsyncCallback<facebook::react::AppState> &success,
+      facebook::jsi::Function error);
+  // React Native's `NativeEventEmitter` calls both, and this platform's events
+  // go through `RCTDeviceEventEmitter` rather than through the module -- see
+  // AppState.js, which passes null for anything that is not iOS. Nothing to
+  // count, so nothing to do.
+  void addListener(facebook::jsi::Runtime &rt, const std::string &eventName);
+  void removeListeners(facebook::jsi::Runtime &rt, double count);
+};
+
+class DesktopDeviceInfoModule
+    : public facebook::react::NativeDeviceInfoCxxSpec<DesktopDeviceInfoModule> {
+ public:
+  explicit DesktopDeviceInfoModule(std::shared_ptr<facebook::react::CallInvoker> jsInvoker);
+  ~DesktopDeviceInfoModule() override;
+
+  static constexpr const char *kModuleName = "DeviceInfo";
+
+  facebook::react::DeviceInfoConstants getConstants(facebook::jsi::Runtime &rt);
+
+ private:
+  // What was last sent, so that a window *moved* rather than resized says
+  // nothing: the bounds signal fires for both, and `Dimensions.set` re-emits
+  // its `change` event for every call whether or not anything differs.
+  DeviceMetrics lastSent_;
+};
+
+class DesktopActionSheetModule
+    : public facebook::react::NativeActionSheetManagerCxxSpec<DesktopActionSheetModule> {
+ public:
+  explicit DesktopActionSheetModule(std::shared_ptr<facebook::react::CallInvoker> jsInvoker)
+      : NativeActionSheetManagerCxxSpec(std::move(jsInvoker)) {}
+
+  static constexpr const char *kModuleName = "ActionSheetManager";
+
+  facebook::jsi::Object getConstants(facebook::jsi::Runtime &rt);
+  void showActionSheetWithOptions(facebook::jsi::Runtime &rt,
+                                  facebook::jsi::Object options,
+                                  facebook::jsi::Function callback);
+  void showShareActionSheetWithOptions(facebook::jsi::Runtime &rt,
+                                       facebook::jsi::Object options,
+                                       facebook::jsi::Function failureCallback,
+                                       facebook::jsi::Function successCallback);
+  void dismissActionSheet(facebook::jsi::Runtime &rt);
+};
+
 // Right-to-left layout. Portable in full: Yoga already does the work, and this
 // is the switch that turns it on.
 class DesktopI18nManagerModule