basalt-core 0.0.0-rc5

package/native/core/ExpoRuntime.cpp

@@ -0,0 +1,366 @@
+#include "ExpoRuntime.h"
+
+#include "ExpoModules.h"
+#include "FontRegistry.h"
+
+#include <filesystem>
+#include <random>
+#include <string>
+#include <string_view>
+
+#ifdef BASALT_HAS_EXPO
+#include <EventEmitter.h>
+#include <JSI/JSIUtils.h>
+#include <NativeModule.h>
+#include <SharedObject.h>
+#include <SharedRef.h>
+#endif
+
+namespace basalt {
+
+bool hasExpoRuntime() {
+#ifdef BASALT_HAS_EXPO
+  return true;
+#else
+  return false;
+#endif
+}
+
+#ifdef BASALT_HAS_EXPO
+
+namespace {
+
+// A version 4 UUID: 122 random bits, with the version and variant fields set as
+// RFC 4122 requires. `std::random_device` rather than a seeded generator --
+// this names things that may outlive the process and must not repeat between
+// two runs started in the same millisecond.
+std::string randomUuidV4() {
+  std::random_device entropy;
+  std::uniform_int_distribution<unsigned> nibble(0, 15);
+
+  static constexpr char kHex[] = "0123456789abcdef";
+  std::string uuid = "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx";
+  for (char &c : uuid) {
+    if (c == 'x') {
+      c = kHex[nibble(entropy)];
+    } else if (c == 'y') {
+      // The variant: one of 8, 9, a or b.
+      c = kHex[(nibble(entropy) & 0x3U) | 0x8U];
+    }
+  }
+  return uuid;
+}
+
+using facebook::jsi::Function;
+using facebook::jsi::Object;
+using facebook::jsi::PropNameID;
+using facebook::jsi::Runtime;
+using facebook::jsi::String;
+using facebook::jsi::Value;
+
+// An already-settled promise, which is all this module needs: registering a
+// font is synchronous, and the JavaScript signature is async only because it is
+// asynchronous everywhere else.
+Value resolvedPromise(Runtime &rt) {
+  return rt.global()
+      .getPropertyAsObject(rt, "Promise")
+      .getPropertyAsFunction(rt, "resolve")
+      .call(rt);
+}
+
+Value rejectedPromise(Runtime &rt, const std::string &message) {
+  Function error = rt.global().getPropertyAsFunction(rt, "Error");
+  Value reason = error.callAsConstructor(rt, String::createFromUtf8(rt, message));
+  return rt.global()
+      .getPropertyAsObject(rt, "Promise")
+      .getPropertyAsFunction(rt, "reject")
+      .call(rt, reason);
+}
+
+// expo-font hands over whatever `expo-asset` resolved: a string, or an object
+// with a localUri or uri. Both shapes appear depending on how the asset was
+// bundled, so both are read rather than one being assumed.
+std::string localPathFrom(Runtime &rt, const Value &resource) {
+  std::string uri;
+  if (resource.isString()) {
+    uri = resource.asString(rt).utf8(rt);
+  } else if (resource.isObject()) {
+    Object object = resource.asObject(rt);
+    for (const char *key : {"localUri", "uri"}) {
+      Value value = object.getProperty(rt, key);
+      if (value.isString()) {
+        uri = value.asString(rt).utf8(rt);
+        break;
+      }
+    }
+  }
+
+  if (uri.rfind("file://", 0) == 0) {
+    uri.erase(0, std::string_view{"file://"}.size());
+  }
+  return uri;
+}
+
+// ExpoAsset, which is how expo-asset turns an asset's URL into a local file.
+//
+// For a `file://` URL there is nothing to download: React Native resolved it
+// beside the bundle and it is already on disk, so the work is confirming that
+// and handing the same URL back. The existence check is the point -- without it
+// a missing asset succeeds here and fails much later, somewhere that has no
+// idea which file was meant.
+//
+// An http URL is what a dev server produces, and fetching one is not
+// implemented. It rejects saying so rather than pretending.
+Object makeAssetModule(Runtime &runtime) {
+  Object module(runtime);
+
+  module.setProperty(
+      runtime,
+      "downloadAsync",
+      Function::createFromHostFunction(
+          runtime,
+          PropNameID::forAscii(runtime, "downloadAsync"),
+          3,
+          [](Runtime &rt, const Value &, const Value *args, size_t count) -> Value {
+            if (count < 1 || !args[0].isString()) {
+              return rejectedPromise(rt, "downloadAsync expects a url");
+            }
+            const std::string url = args[0].asString(rt).utf8(rt);
+
+            if (url.rfind("file://", 0) != 0) {
+              return rejectedPromise(
+                  rt,
+                  "basalt-core cannot fetch assets over the network yet; "
+                  "got " + url);
+            }
+
+            const std::string path = url.substr(std::string_view{"file://"}.size());
+            std::error_code ignored;
+            if (!std::filesystem::is_regular_file(path, ignored)) {
+              return rejectedPromise(
+                  rt,
+                  "no asset at " + path +
+                      ". Assets are not copied beside the bundle yet.");
+            }
+
+            return rt.global()
+                .getPropertyAsObject(rt, "Promise")
+                .getPropertyAsFunction(rt, "resolve")
+                .call(rt, String::createFromUtf8(rt, url));
+          }));
+
+  return module;
+}
+
+// ExpoFontLoader, as far as a non-web platform is concerned. expo-font's own
+// type declaration marks everything but these two as web-only.
+Object makeFontLoader(Runtime &runtime) {
+  Object loader(runtime);
+
+  loader.setProperty(
+      runtime,
+      "loadAsync",
+      Function::createFromHostFunction(
+          runtime,
+          PropNameID::forAscii(runtime, "loadAsync"),
+          2,
+          [](Runtime &rt, const Value &, const Value *args, size_t count) -> Value {
+            if (count < 2 || !args[0].isString()) {
+              return rejectedPromise(rt, "loadAsync expects a family name and a font");
+            }
+            const std::string name = args[0].asString(rt).utf8(rt);
+            const std::string path = localPathFrom(rt, args[1]);
+            if (path.empty()) {
+              return rejectedPromise(
+                  rt, "could not find a local file for font '" + name + "'");
+            }
+            if (!registerFont(name, path)) {
+              return rejectedPromise(rt, "could not load font '" + name + "' from " + path);
+            }
+            return resolvedPromise(rt);
+          }));
+
+  loader.setProperty(
+      runtime,
+      "isLoaded",
+      Function::createFromHostFunction(
+          runtime,
+          PropNameID::forAscii(runtime, "isLoaded"),
+          1,
+          [](Runtime &rt, const Value &, const Value *args, size_t count) -> Value {
+            if (count < 1 || !args[0].isString()) {
+              return Value(false);
+            }
+            return Value(isFontRegistered(args[0].asString(rt).utf8(rt)));
+          }));
+
+  loader.setProperty(
+      runtime,
+      "getLoadedFonts",
+      Function::createFromHostFunction(
+          runtime,
+          PropNameID::forAscii(runtime, "getLoadedFonts"),
+          0,
+          [](Runtime &rt, const Value &, const Value *, size_t) -> Value {
+            Object array = rt.global()
+                               .getPropertyAsFunction(rt, "Array")
+                               .callAsConstructor(rt)
+                               .asObject(rt);
+            Function push = array.getPropertyAsFunction(rt, "push");
+
+            const std::string joined = registeredFontNamesJoined('\n');
+            std::size_t start = 0;
+            while (start < joined.size()) {
+              const std::size_t end = joined.find('\n', start);
+              const std::string one =
+                  joined.substr(start, end == std::string::npos ? std::string::npos : end - start);
+              push.callWithThis(rt, array, String::createFromUtf8(rt, one));
+              if (end == std::string::npos) {
+                break;
+              }
+              start = end + 1;
+            }
+            return Value(rt, array);
+          }));
+
+  return loader;
+}
+
+// `expo/fetch`, which this platform does not have, routed back to the one it
+// does.
+//
+// Expo replaces `globalThis.fetch` with its own WinterCG implementation, built
+// on a native module called `ExpoFetchModule` -- a pair of SharedObject classes
+// with a streaming body between them. There is no port of it here, so the
+// replacement is a lazy getter that throws `Cannot find native module
+// 'ExpoFetchModule'` the first time anything in the app calls `fetch`. That is
+// most apps, immediately, and it is not a failure an app can catch: it happens
+// inside the global it was calling.
+//
+// Expo's own way out is `EXPO_PUBLIC_USE_RN_FETCH`, which leaves React Native's
+// fetch in place -- and React Native's fetch works here, over the same curl
+// client core/HttpClient.cpp gives the rest of the networking stack. So the
+// default is set here rather than asked of every app, because "install basalt
+// and the desktop works" stops being true if each app has to discover this
+// variable from a crash inside `fetch`.
+//
+// **Before the bundle, so that everything downstream agrees.** Metro's prelude
+// opens with `process = globalThis.process || {}` and React Native's
+// setUpGlobals with `global.process = global.process || {}`, both of which keep
+// what is already there. Expo's CLI then defines the app's own `EXPO_PUBLIC_`
+// variables over the top in development, which is the right precedence: a
+// developer who sets this explicitly beats the default. Plain assignment rather
+// than defineProperty for that reason -- a non-configurable property here would
+// make their `Object.defineProperties` throw.
+//
+// What is lost is what `expo/fetch` adds: a streamed response body. React
+// Native's fetch buffers, and an app importing `expo/fetch` directly still gets
+// the error naming the module, which is the honest answer until someone ports
+// it.
+void useReactNativeFetch(facebook::jsi::Runtime &runtime) {
+  namespace jsi = facebook::jsi;
+  static constexpr const char *kVariable = "EXPO_PUBLIC_USE_RN_FETCH";
+
+  jsi::Object global = runtime.global();
+  const jsi::Value processValue = global.getProperty(runtime, "process");
+  jsi::Object process =
+      processValue.isObject() ? processValue.asObject(runtime) : jsi::Object(runtime);
+
+  const jsi::Value envValue = process.getProperty(runtime, "env");
+  jsi::Object env = envValue.isObject() ? envValue.asObject(runtime) : jsi::Object(runtime);
+
+  // Only as a default. Nothing sets this before the bundle today, but something
+  // that did would have meant it.
+  if (env.getProperty(runtime, kVariable).isUndefined()) {
+    env.setProperty(runtime, kVariable, jsi::String::createFromAscii(runtime, "1"));
+  }
+
+  process.setProperty(runtime, "env", std::move(env));
+  global.setProperty(runtime, "process", std::move(process));
+}
+
+} // namespace
+
+void installExpoRuntime(facebook::jsi::Runtime &runtime) {
+  namespace jsi = facebook::jsi;
+
+  // `expo` has to exist before the classes go in: each of them reaches for
+  // `global.expo` through expo::common::getCoreObject and hangs itself off it.
+  // Installing them first throws on a property that is not there yet.
+  runtime.global().setProperty(runtime, "expo", jsi::Object(runtime));
+
+  expo::EventEmitter::installClass(runtime);
+
+  // The releaser is how Expo hands a shared object's native half back to be
+  // freed. On Android it reaches through JNI to the owning context. Nothing
+  // here owns any native Expo object -- no Expo module is ported yet -- so
+  // there is nothing to free, and the honest implementation of "free nothing"
+  // is to do nothing.
+  expo::SharedObject::installBaseClass(runtime, [](expo::SharedObject::ObjectId) {});
+  expo::SharedRef::installBaseClass(runtime);
+  expo::NativeModule::installClass(runtime);
+
+  // The module registry.
+  //
+  // ExpoAsset is here rather than in ExpoModules.cpp because it is older than
+  // the module host and because it is half a stub: it confirms a `file://`
+  // asset exists and rejects an http one, which is enough for Expo's own
+  // start-up and no more. ExponentConstants used to sit beside it as an empty
+  // object for the same reason, and is a real module now.
+  jsi::Object modules(runtime);
+  modules.setProperty(runtime, "ExpoAsset", makeAssetModule(runtime));
+
+  // The first Expo module here that is not a stub. It loads a real font file
+  // into fontconfig, which is where Pango looks, so `fontFamily` works
+  // afterwards for text this platform renders. See src/LinuxFonts.cpp.
+  modules.setProperty(runtime, "ExpoFontLoader", makeFontLoader(runtime));
+
+  // This platform's own Expo modules. See core/ExpoModules.h; they are separate
+  // from the stubs above because they are not stubs.
+  installExpoModules(runtime, modules);
+
+  // expo-modules-core builds its NativeModulesProxy by iterating this, falling
+  // back to the legacy proxy when it is absent, so its presence matters even
+  // when it is empty.
+  jsi::Object proxy(runtime);
+  proxy.setProperty(runtime, "exportedMethods", jsi::Object(runtime));
+  proxy.setProperty(runtime, "viewManagersMetadata", jsi::Object(runtime));
+  modules.setProperty(runtime, "NativeModulesProxy", std::move(proxy));
+
+  jsi::Object core = runtime.global().getPropertyAsObject(runtime, "expo");
+  core.setProperty(runtime, "modules", std::move(modules));
+  installExpoViewConfigs(runtime, core);
+
+  // Before the bundle evaluates, which is the only moment early enough; see the
+  // function.
+  useReactNativeFetch(runtime);
+
+  // `expo.uuidv4`, which expo-modules-core's own `uuid.v4()` calls and throws
+  // without: "Native UUID version 4 generator implementation wasn't found in
+  // `expo-modules-core`". It is not a notifications concern, though that is
+  // where it was found -- `scheduleNotificationAsync` names a notification with
+  // one when an app does not, and so does every other Expo package that
+  // generates an identifier.
+  //
+  // `uuidv5` is deliberately absent: it is a SHA-1 of a namespace and a name,
+  // which is a hash implementation rather than a random number, and expo
+  // reports a missing one by name the way it reports a missing method.
+  core.setProperty(
+      runtime,
+      "uuidv4",
+      jsi::Function::createFromHostFunction(
+          runtime,
+          jsi::PropNameID::forAscii(runtime, "uuidv4"),
+          0,
+          [](jsi::Runtime &rt, const jsi::Value &, const jsi::Value *, size_t) -> jsi::Value {
+            return jsi::String::createFromUtf8(rt, randomUuidV4());
+          }));
+}
+
+#else
+
+void installExpoRuntime(facebook::jsi::Runtime & /*runtime*/) {}
+
+#endif
+
+} // namespace basalt

package/native/core/ExpoRuntime.h

@@ -0,0 +1,42 @@
+// Expo's runtime, installed into the JavaScript runtime before the bundle runs.
+//
+// An Expo app's very first import reaches `globalThis.expo.EventEmitter`, and
+// without it the app dies before React renders. That object is normally
+// installed from native code, which is why an Expo app cannot start on a
+// platform nobody has ported Expo to.
+//
+// The port is smaller than it sounds, because expo-modules-core ships the
+// portable half in its npm package: `common/cpp` holds EventEmitter,
+// SharedObject, SharedRef, NativeModule and their JSI helpers, and depends on
+// nothing but JSI and a call invoker. So there is nothing to vendor and nothing
+// to fetch -- this compiles the app's own copy, at the app's own version, the
+// same arrangement that keeps React Native's C++ and JavaScript in step.
+//
+// react-native-windows and react-native-macos reach the same place by way of
+// shirakaba/expo-desktop, which vendors that directory at a pinned Expo SDK.
+// Compiling the app's copy avoids the pin.
+//
+// What this installs is deliberately the floor rather than the ceiling: the
+// four classes and an empty module registry, which is what an Expo app needs to
+// *start*. Any actual Expo module -- expo-font, expo-image, a config plugin's
+// native half -- needs its own port, and this does not pretend otherwise.
+
+#pragma once
+
+#include <jsi/jsi.h>
+
+namespace basalt {
+
+// Installs `globalThis.expo`. Call before the bundle is evaluated; ReactHost's
+// bindingsInstallFunc is that moment.
+//
+// Compiled only when the build was pointed at an expo-modules-core; without one
+// this is a no-op, so a plain React Native app pays nothing and an Expo app
+// fails the way it did before rather than differently.
+void installExpoRuntime(facebook::jsi::Runtime &runtime);
+
+// Whether the above will do anything, for the log line that tells a developer
+// which of the two situations they are in.
+bool hasExpoRuntime();
+
+} // namespace basalt

package/native/core/FocusRing.h

@@ -0,0 +1,36 @@
+// What keyboard focus looks like.
+//
+// Two numbers and a colour, in one place, for the same reason
+// `kWheelStepPixels` is: a ring that is two pixels of blue on one desktop and
+// three of grey on another is a difference an app did not ask for and cannot
+// control. Matching the other platform matters more here than matching either
+// toolkit's own default, which is the argument of this project in one constant.
+//
+// Not the system accent colour, on either desktop, and that is a real choice
+// rather than an omission. macOS has `NSColor.keyboardFocusIndicatorColor` and
+// GTK has a theme; using each would make the ring native and make the two
+// desktops disagree, and an app that draws its own buttons in its own colours
+// has already said it is not trying to look native. The same reasoning kept
+// `<TextInput>`'s peers looking like the app rather than like the toolkit.
+//
+// Drawn rather than delegated for a second reason too: these widgets have no
+// theme to delegate to. React Native decided every colour in the tree, and GTK's
+// focus rendering is a CSS outline on a themed widget.
+
+#pragma once
+
+namespace basalt {
+
+// Pixels, outside the view's own bounds, so the ring does not cover content at
+// the edge of a button.
+constexpr float kFocusRingWidth = 2.0F;
+
+// A blue that reads as "focused" on a light background and on a dark one, which
+// is what an app-coloured tree offers no guarantees about. sRGB, 0..1 per
+// channel, in the order every host's colour type takes.
+constexpr float kFocusRingRed = 0.259F;
+constexpr float kFocusRingGreen = 0.522F;
+constexpr float kFocusRingBlue = 0.957F;
+constexpr float kFocusRingAlpha = 1.0F;
+
+} // namespace basalt

package/native/core/FontRegistry.h

@@ -0,0 +1,51 @@
+// Fonts an app loads at runtime, and the name it knows them by.
+//
+// Declared here and implemented per platform, because this is one of the places
+// a desktop platform genuinely differs: fontconfig on Linux, and something else
+// on macOS or Windows. Core calls it -- `expo-font` arrives here -- and links
+// against whichever implementation the platform half provides. Linux's is
+// src/FontRegistryFontconfig.cpp.
+//
+// `expo-font` hands over a file and a name of the app's choosing -- "Inter",
+// say -- and expects `fontFamily: 'Inter'` to work afterwards. A font file
+// carries its own family name inside it, which is usually something else
+// entirely, and fontconfig indexes by that. So loading the file is only half
+// the job; the other half is remembering that this app calls it "Inter".
+//
+// Kept here rather than in the Expo layer because the Pango side has to consult
+// it on every text measurement, and because nothing about it is Expo-specific:
+// any future API that loads a font at runtime wants exactly this.
+
+#pragma once
+
+#include <string>
+
+namespace basalt {
+
+// Makes a font file available to Pango, under `name`.
+//
+// Returns false if the file cannot be read or fontconfig will not take it, in
+// which case nothing is registered. Safe to call twice with the same name.
+bool registerFont(const std::string &name, const std::string &path);
+
+// The family Pango should be asked for, given what the app called it. Returns
+// `name` unchanged when it was never registered, so ordinary system families
+// pass straight through.
+std::string resolveFontFamily(const std::string &name);
+
+// Bumped every time a font is registered. Text measured before a font arrived
+// was measured against a different set of fonts, and a cache that does not know
+// that will keep handing back the old size -- which is what makes a font loaded
+// after first render appear to do nothing.
+unsigned long fontGeneration();
+
+// Whether `name` has been registered. expo-font insists this exists and is a
+// function, and throws when it is not, so it is not optional however web-only
+// its type declaration claims to be.
+bool isFontRegistered(const std::string &name);
+
+// The names registered so far, in registration order, for
+// ExpoFontLoader.getLoadedFonts.
+std::string registeredFontNamesJoined(char separator);
+
+} // namespace basalt

package/native/core/GestureHandlerModule.cpp

@@ -0,0 +1,136 @@
+#include "GestureHandlerModule.h"
+
+#include "Gestures.h"
+#include "PlatformServices.h"
+
+#include <jsi/JSIDynamic.h>
+
+namespace basalt {
+
+using facebook::jsi::Runtime;
+using facebook::jsi::Value;
+using facebook::react::TurboModule;
+
+namespace {
+
+double numberArg(const Value *args, size_t count, size_t index) {
+  return index < count && args[index].isNumber() ? args[index].asNumber() : 0;
+}
+
+folly::dynamic objectArg(Runtime &runtime, const Value *args, size_t count, size_t index) {
+  if (index >= count || !args[index].isObject()) {
+    return folly::dynamic::object();
+  }
+  return facebook::jsi::dynamicFromValue(runtime, args[index]);
+}
+
+} // namespace
+
+DesktopGestureHandlerModule::DesktopGestureHandlerModule(
+    std::shared_ptr<facebook::react::CallInvoker> jsInvoker)
+    : TurboModule(kModuleName, std::move(jsInvoker)) {
+  methodMap_["createGestureHandler"] = MethodMetadata{3, createGestureHandler};
+  methodMap_["attachGestureHandler"] = MethodMetadata{3, attachGestureHandler};
+  methodMap_["updateGestureHandler"] = MethodMetadata{2, updateGestureHandler};
+  methodMap_["dropGestureHandler"] = MethodMetadata{1, dropGestureHandler};
+  methodMap_["install"] = MethodMetadata{0, install};
+  // Nothing here batches, so there is nothing to flush; and there is no
+  // responder to hand over, because this platform's gesture recognisers and
+  // React Native's touches are fed from the same place rather than competing
+  // for a responder. See core/Gestures.h.
+  methodMap_["flushOperations"] = MethodMetadata{0, noop};
+  methodMap_["handleSetJSResponder"] = MethodMetadata{2, noop};
+  methodMap_["handleClearJSResponder"] = MethodMetadata{0, noop};
+
+  // The registry outlives any one instance of this module -- it is UI-thread
+  // state and the module is recreated whenever the runtime is -- so the
+  // emitter is installed here and taken away in the destructor rather than
+  // left pointing at a module that has gone.
+  gestures().setEmitter([this](const std::string &eventName, folly::dynamic payload) {
+    emitGestureEvent(eventName, std::move(payload));
+  });
+}
+
+DesktopGestureHandlerModule::~DesktopGestureHandlerModule() {
+  gestures().setEmitter(nullptr);
+}
+
+void DesktopGestureHandlerModule::emitGestureEvent(const std::string &eventName,
+                                                   folly::dynamic payload) {
+  emitDeviceEvent(eventName,
+                  [payload = std::move(payload)](Runtime &runtime, std::vector<Value> &args) {
+                    args.emplace_back(facebook::jsi::valueFromDynamic(runtime, payload));
+                  });
+}
+
+Value DesktopGestureHandlerModule::createGestureHandler(Runtime &runtime,
+                                                        TurboModule & /*module*/,
+                                                        const Value *args,
+                                                        size_t count) {
+  if (count < 2 || !args[0].isString()) {
+    return Value::undefined();
+  }
+  std::string name = args[0].asString(runtime).utf8(runtime);
+  const int tag = static_cast<int>(numberArg(args, count, 1));
+  folly::dynamic config = objectArg(runtime, args, count, 2);
+
+  postToUiThread([name = std::move(name), tag, config = std::move(config)]() mutable {
+    gestures().create(name, tag, std::move(config));
+  });
+  return Value::undefined();
+}
+
+Value DesktopGestureHandlerModule::attachGestureHandler(Runtime & /*runtime*/,
+                                                        TurboModule & /*module*/,
+                                                        const Value *args,
+                                                        size_t count) {
+  const int handlerTag = static_cast<int>(numberArg(args, count, 0));
+  const int viewTag = static_cast<int>(numberArg(args, count, 1));
+  // The third argument is RNGH's ActionType. 1 is REANIMATED_WORKLET, which
+  // means the callbacks are worklets and the events are meant for a worklet
+  // runtime rather than for DeviceEventEmitter. Attaching it anyway is right:
+  // the handler still runs, and its events are still emitted; what a worklet
+  // gesture loses is being handled off the JS thread.
+  postToUiThread([handlerTag, viewTag]() { gestures().attach(handlerTag, viewTag); });
+  return Value::undefined();
+}
+
+Value DesktopGestureHandlerModule::updateGestureHandler(Runtime &runtime,
+                                                        TurboModule & /*module*/,
+                                                        const Value *args,
+                                                        size_t count) {
+  const int handlerTag = static_cast<int>(numberArg(args, count, 0));
+  folly::dynamic config = objectArg(runtime, args, count, 1);
+  postToUiThread([handlerTag, config = std::move(config)]() mutable {
+    gestures().update(handlerTag, std::move(config));
+  });
+  return Value::undefined();
+}
+
+Value DesktopGestureHandlerModule::dropGestureHandler(Runtime & /*runtime*/,
+                                                      TurboModule & /*module*/,
+                                                      const Value *args,
+                                                      size_t count) {
+  const int handlerTag = static_cast<int>(numberArg(args, count, 0));
+  postToUiThread([handlerTag]() { gestures().drop(handlerTag); });
+  return Value::undefined();
+}
+
+// True means "the JSI bindings are in place". RNGH calls this once, on the
+// first render of a GestureHandlerRootView under Fabric, and uses the answer
+// only to avoid calling it again.
+Value DesktopGestureHandlerModule::install(Runtime & /*runtime*/,
+                                           TurboModule & /*module*/,
+                                           const Value * /*args*/,
+                                           size_t /*count*/) {
+  return Value(true);
+}
+
+Value DesktopGestureHandlerModule::noop(Runtime & /*runtime*/,
+                                        TurboModule & /*module*/,
+                                        const Value * /*args*/,
+                                        size_t /*count*/) {
+  return Value::undefined();
+}
+
+} // namespace basalt