basalt-core 0.0.0-rc5

package/native/core/WindowControl.h

@@ -0,0 +1,235 @@
+// The window's geometry: how big it is, where it is, and whether it fills the
+// screen.
+//
+// React Native has no API for any of this, for the same reason it has no file
+// dialog: on a phone there is one window, it is the screen, and nothing an app
+// can say would change it. On a desktop it is the first thing an app wants
+// after it has drawn something.
+//
+// A seam rather than three modules. The title bar next door is per-host because
+// what it does differs per host -- GTK installs a header bar to have something
+// to style, Windows draws its own caption buttons -- but a window's size is the
+// same idea everywhere and only the call differs. So the JavaScript boundary is
+// written once, in core/WindowMethods.h, and this is the four lines under it
+// each platform answers.
+//
+// One window, which is the honest limit. Every function here means "the
+// window", because the host makes exactly one; multiple windows are their own
+// piece of work and are in docs/BACKLOG.md. When they arrive these grow a
+// window argument and the module grows a handle, and nothing above changes
+// shape.
+
+#pragma once
+
+#include <functional>
+#include <vector>
+
+namespace basalt {
+
+struct WindowBounds {
+  // In logical pixels, in the desktop's coordinates -- which is what an app can
+  // pass straight back to `setWindowPosition`. Not physical pixels: an app
+  // reasoning about its own layout is reasoning in the same units React Native
+  // lays out in.
+  double x{0.0};
+  double y{0.0};
+  double width{0.0};
+  double height{0.0};
+
+  // Distinct states, not one enum: a window can be maximised *and* full screen
+  // on every one of these desktops, and an app that restores a remembered
+  // layout needs to know which it was.
+  bool fullScreen{false};
+  bool maximized{false};
+};
+
+// Where the window is now.
+//
+// **Called on the UI thread only.** Every one of these touches a GtkWindow, an
+// NSWindow or an HWND, and none of those may be touched from the JavaScript
+// thread -- which is where a TurboModule method arrives. `core/WindowMethods.h`
+// is what marshals, so a platform implementation may assume it is already in
+// the right place. Getting this wrong is quiet rather than loud: the AppKit
+// resize simply did not happen, with no warning anywhere.
+WindowBounds windowBounds();
+
+void setWindowSize(double width, double height);
+void setWindowPosition(double x, double y);
+
+// Centred on the display the window is already on, which is not always the
+// primary one.
+void centerWindow();
+
+void setWindowFullScreen(bool fullScreen);
+
+// Called by the host whenever the window is resized, moved, or changes state.
+//
+// The module installs one of these and turns it into a device event, so that
+// `useWindow()` can hand an app live bounds rather than a snapshot it has to
+// remember to refresh. Replacing a listener drops the previous one; passing
+// nothing removes it.
+void setWindowBoundsListener(std::function<void(const WindowBounds &)> listener);
+
+// The host's half of that: called from wherever it already learns the window
+// moved or resized, on the UI thread. Also updates the cache below, so it is
+// worth calling once when the window is first shown even if nothing is
+// listening yet.
+void notifyWindowBoundsChanged();
+
+// How big the window is allowed to be, in logical pixels.
+//
+// Zero means "no limit" in either direction, which is the default and is also
+// how an app clears one. Not part of `WindowBounds`: bounds are what the window
+// *is* and these are what it may become, and an app restoring a remembered
+// layout wants the first without being told the second.
+struct WindowSizeLimits {
+  double minWidth{0.0};
+  double minHeight{0.0};
+  double maxWidth{0.0};
+  double maxHeight{0.0};
+};
+
+// Set the limits and apply them. Portable: the storing is identical everywhere
+// and only `applyWindowSizeLimits` differs.
+void setWindowMinimumSize(double width, double height);
+void setWindowMaximumSize(double width, double height);
+
+// What is in force, readable from any thread. Windows answers WM_GETMINMAXINFO
+// from this, which is a message rather than a call and so cannot be given them.
+WindowSizeLimits windowSizeLimits();
+
+// Clamp a requested size to the limits this platform says it enforces.
+//
+// Portable, and applied before every `setWindowSize`, because the toolkits do
+// not agree on whether a programmatic resize is subject to the same limits a
+// dragged corner is. AppKit's `setFrame:` clamps down to the maximum and not up
+// to the minimum, which is a resize that lands outside a limit an app set and
+// the window manager would have refused -- found by the test for exactly that.
+//
+// Filtered by `windowCapabilities()` rather than applied unconditionally, so
+// that what an app is told and what it gets stay the same thing: a desktop that
+// reports `maximumSize: false` does not quietly enforce one here.
+void constrainToWindowSizeLimits(double &width, double &height);
+
+// Tell the window manager about the limits above. Called on the UI thread, with
+// the new values already stored.
+void applyWindowSizeLimits();
+
+// Whether the person may resize the window at all.
+void setWindowResizable(bool resizable);
+
+// Whether it floats above other applications' windows. Not "above everything":
+// no desktop lets an ordinary application outrank a screen lock or a system
+// alert, and none of these ask it to.
+void setWindowAlwaysOnTop(bool alwaysOnTop);
+
+// Which of the above this desktop actually does.
+//
+// Answered rather than documented, because two of these are not gaps and will
+// not be filled. GTK4 removed `gtk_window_set_geometry_hints` and
+// `gtk_window_set_keep_above`, and Wayland has no protocol for either: a client
+// there does not know where it is, does not place itself, and does not outrank
+// its neighbours. An app that asks can put its "always on top" switch away on
+// the platform that has no such thing, which is better than a switch that lies.
+struct WindowCapabilities {
+  bool position{false};
+  bool minimumSize{false};
+  bool maximumSize{false};
+  bool resizable{false};
+  bool alwaysOnTop{false};
+};
+
+WindowCapabilities windowCapabilities();
+
+// The last bounds the host reported, readable from any thread.
+//
+// `windowBounds()` cannot be: it asks the toolkit, and a TurboModule method
+// runs on the JavaScript thread. So `getBounds()` answers from here, which is
+// exact rather than approximate -- the host reports every change -- and needs
+// no hop, which matters because it is read during render.
+//
+// All zeroes before the host has reported anything, which is what an app
+// reading bounds during its first render sees.
+WindowBounds lastKnownWindowBounds();
+
+// --- The displays the desktop has -------------------------------------------
+//
+// React Native's `Dimensions` reports the window, which is the right answer to
+// a different question: an app placing a window, or deciding how much it can
+// show, is asking about the screen it is on and the ones beside it.
+//
+// The lookups already existed -- `NSScreen`, `GdkMonitor` and
+// `MonitorFromWindow` are how `center()` and full screen work -- and were
+// simply not passed on.
+
+struct DisplayInfo {
+  // In the same logical pixels and the same desktop coordinates WindowBounds
+  // uses, so a bound and a display can be compared without converting either.
+  // Top-left origin on every host, which costs AppKit a flip: its own
+  // coordinates grow upwards from the primary screen.
+  double x{0.0};
+  double y{0.0};
+  double width{0.0};
+  double height{0.0};
+
+  // What is left after the desktop's own furniture -- a menu bar, a taskbar, a
+  // dock, a panel. Where a window should go; `bounds` is where the glass is.
+  // Equal to bounds on a desktop that reserves nothing.
+  double workX{0.0};
+  double workY{0.0};
+  double workWidth{0.0};
+  double workHeight{0.0};
+
+  // Physical pixels per logical pixel: 2 on a Retina display, 1 on an
+  // ordinary one, and fractional under Wayland or a Windows display set to
+  // 150%. Never zero -- a host that cannot answer reports 1, because a caller
+  // dividing by this should not have to check.
+  double scaleFactor{1.0};
+
+  // Exactly one display is primary, and it is the one the desktop's
+  // coordinates are anchored to.
+  bool primary{false};
+};
+
+// Every display, primary first.
+//
+// **Called on the UI thread only**, like everything above it: each host asks
+// its toolkit.
+std::vector<DisplayInfo> displays();
+
+// The last list the host reported, readable from any thread.
+//
+// The same arrangement `lastKnownWindowBounds` has, and for the same reason:
+// `displays()` asks the toolkit and a TurboModule method runs on the
+// JavaScript thread. Exact rather than approximate, because the host reports
+// every change -- and empty before the host has reported anything, which is
+// what an app asking during its first render sees.
+std::vector<DisplayInfo> lastKnownDisplays();
+
+// Where the pointer is, in the same coordinates the bounds above use.
+//
+// A display question rather than a window one: it may be over a different
+// display than the app's window, or over no window at all. All zeroes on a
+// host that cannot answer -- Wayland does not tell a client where the pointer
+// is unless it is over one of its own surfaces.
+struct PointerPosition {
+  double x{0.0};
+  double y{0.0};
+  // False where the desktop will not say, so that an app can tell "at the
+  // origin" from "not answered".
+  bool known{false};
+};
+
+PointerPosition pointerPosition();
+
+// A monitor plugged in, unplugged, or rearranged.
+//
+// No argument: an app that cares re-reads the list, which is the only way to
+// be right about several changes arriving together. Same shape as the window
+// bounds listener above, and set by the module for the same reason.
+void setDisplaysListener(std::function<void()> listener);
+
+// The host's half: called on the UI thread when the arrangement changes.
+void notifyDisplaysChanged();
+
+} // namespace basalt

package/native/core/WindowHost.h

@@ -0,0 +1,158 @@
+// Opening a second window.
+//
+// Fabric has supported more than one surface all along -- `startSurface` takes
+// a surface id, the mounting managers keep a root per id, and the error
+// inspector has been a second surface since it was written. What has been
+// missing is a second *window* to put one in: every host made exactly one, at
+// startup, and everything in it reached for `the` window and `the` root.
+//
+// So this is the seam for the part that is genuinely per-toolkit -- making a
+// window and wiring a surface into it -- and `core/WindowsModule.h` is the
+// JavaScript boundary above it. The implementation lives in each host's
+// `main_*.cpp` rather than beside the other platform services, because that is
+// where a window is made and where the ReactHost that starts a surface lives.
+//
+// ## A window is a surface
+//
+// One window, one surface, one React root. That is Fabric's grain rather than a
+// simplification: a surface is what has a size, a layout context and a root
+// shadow node, and two windows sharing one would be two windows sharing a
+// layout. It is also why the id a window is identified by *is* its surface id
+// -- there is no second numbering to keep in step.
+//
+// The cost is that a second window is a second React tree: it does not share
+// context, state or a render pass with the first. `<Window>` in JavaScript
+// papers over enough of that to be useful and says where it cannot; see
+// src/Window.js.
+
+#pragma once
+
+#include <folly/dynamic.h>
+
+#include <functional>
+#include <react/renderer/core/ReactPrimitives.h>
+
+#include <string>
+#include <vector>
+
+namespace basalt {
+
+struct NewWindowOptions {
+  // The component to run, as registered with `AppRegistry.registerComponent`.
+  // A window with no component is a window with nothing in it, which is not
+  // something to open by accident: an empty one is refused.
+  std::string component;
+  std::string title;
+  double width{900.0};
+  double height{700.0};
+  // `initialProps`, which is how the second React root is told which window it
+  // is. See src/Window.js.
+  folly::dynamic props{folly::dynamic::object()};
+};
+
+// Opens a window and starts `component` in it. Returns the new surface id,
+// which is also the window's, or 0 if it could not.
+//
+// Called on the UI thread.
+facebook::react::SurfaceId openHostWindow(const NewWindowOptions &options);
+
+// Closes a window opened by `openHostWindow` and stops its surface. Ignores the
+// main window: an app closing the window it is running in should say so through
+// `close()` on the window itself, which is a different thing from destroying a
+// surface out from under a React tree.
+//
+// Called on the UI thread.
+void closeHostWindow(facebook::react::SurfaceId surfaceId);
+
+// Ends the application: `[NSApp terminate:]`, `g_application_quit`,
+// `PostQuitMessage`. What `quit()` reaches, and what a quit handler calls
+// when its answer is "go ahead" -- an app that intercepted the quit refused
+// the one the system asked for, so somebody has to ask again.
+//
+// Called on the UI thread.
+void quitHost();
+
+// Every window this host has open, main window first. For the tree dump, and
+// for an app asking what it has.
+std::vector<facebook::react::SurfaceId> hostWindows();
+
+// A window was closed by the person rather than by the app -- its own close
+// button, or the window manager.
+//
+// This is not a nicety. Without it the host is left holding a record whose
+// window is gone, which is a dangling pointer rather than a stale flag, and the
+// `<Window>` that opened it goes on believing it is open: the app's state says
+// one thing and the screen says another, and the next render tries to close a
+// window that has already closed itself.
+//
+// So the host calls `hostWindowClosed` on the way out, and the module turns it
+// into a device event that `<Window>` unmounts on.
+void setHostWindowClosedListener(std::function<void(facebook::react::SurfaceId)> listener);
+
+// The host's half: called on the UI thread, before the record is dropped.
+void hostWindowClosed(facebook::react::SurfaceId surfaceId);
+
+// ## Refusing to close
+//
+// The above is a window that *has* closed. This is a window somebody is trying
+// to close, which is a different question with a different answer: an app with
+// unsaved work wants to ask before it goes, and by the time `hostWindowClosed`
+// runs there is nothing left to ask about.
+//
+// Electron spells this `event.preventDefault()` in a `close` handler, and can,
+// because its handler runs in the main process and the answer is available the
+// moment the event is raised. Here the answer lives in JavaScript, on another
+// thread, and the window manager wants a synchronous yes or no -- so the
+// decision has to be made *before* the attempt rather than during it.
+//
+// Hence a flag rather than a callback. An app that registers a close handler
+// marks its window intercepted; the host then refuses every close the window
+// manager asks for and reports the attempt instead, and the app closes the
+// window itself when it is ready. A window with no handler is not marked and
+// closes exactly as it did before -- which matters, because that is every
+// window, and a close path that waits on JavaScript to say "go ahead" would be
+// a window that does not close when the runtime is busy.
+void setHostWindowCloseIntercepted(facebook::react::SurfaceId surfaceId, bool intercepted);
+
+// Whether this window refuses the window manager. Called on the UI thread from
+// inside a close handler, which is why it may not hop to ask anybody.
+bool hostWindowCloseIntercepted(facebook::react::SurfaceId surfaceId);
+
+// Somebody tried to close a window that is intercepted, and it did not close.
+// The module turns this into a device event; the app decides what to do and
+// calls `close()` if that is "go ahead".
+void setHostWindowCloseRequestListener(std::function<void(facebook::react::SurfaceId)> listener);
+
+// The host's half: called on the UI thread, instead of closing.
+void hostWindowCloseRequested(facebook::react::SurfaceId surfaceId);
+
+// ## Refusing to quit
+//
+// The same question about the application rather than about one window, and
+// not answerable by the above: an app can guard every window it owns and
+// still lose the person's work to Cmd-Q. macOS routes quitting through
+// `applicationShouldTerminate:` and asks no window whether it minds; the
+// Windows and GNOME session-end signals do the same.
+//
+// A flag rather than a callback, for exactly the reason the close case is:
+// the system wants a synchronous yes or no and the answer lives in
+// JavaScript on another thread. An app that registers a quit handler marks
+// the application intercepted; the host then refuses the quit and reports
+// the attempt, and the app quits itself when it is ready.
+//
+// One flag rather than one per window, because quitting is one event no
+// matter how many windows are open -- and because the last window closing is
+// already a different thing that already works.
+void setHostQuitIntercepted(bool intercepted);
+
+// Whether the application refuses to quit. Called on the UI thread from
+// inside a terminate handler, which is why it may not hop to ask anybody.
+bool hostQuitIntercepted();
+
+// Somebody tried to quit an intercepted application, and it did not quit.
+void setHostQuitRequestListener(std::function<void()> listener);
+
+// The host's half: called on the UI thread, instead of quitting.
+void hostQuitRequested();
+
+} // namespace basalt

package/native/core/WindowMethods.cpp

@@ -0,0 +1,167 @@
+#include "WindowMethods.h"
+
+#include "PlatformServices.h"
+#include "WindowControl.h"
+
+#include <mutex>
+
+namespace basalt {
+
+namespace {
+
+using facebook::jsi::Object;
+using facebook::jsi::Runtime;
+using facebook::jsi::Value;
+using facebook::react::TurboModule;
+
+bool twoNumbers(const Value *args, size_t count) {
+  return count >= 2 && args[0].isNumber() && args[1].isNumber();
+}
+
+// Everything that changes a window happens on the UI thread.
+//
+// A TurboModule method runs on the JavaScript thread, and none of the three
+// toolkits may be touched from it. This was found the loud way and reported the
+// quiet way: `setSize` from JavaScript did nothing at all on macOS, with no
+// warning and no crash.
+void onUiThread(std::function<void()> work) {
+  postToUiThread(std::move(work));
+}
+
+} // namespace
+
+Value windowSetSize(Runtime & /*runtime*/,
+                    TurboModule & /*module*/,
+                    const Value *args,
+                    size_t count) {
+  if (twoNumbers(args, count)) {
+    const double first = args[0].asNumber();
+    const double second = args[1].asNumber();
+    onUiThread([first, second] {
+      // Clamped here rather than left to the toolkit, which is the only way the
+      // three agree. See core/WindowControl.h.
+      double width = first;
+      double height = second;
+      constrainToWindowSizeLimits(width, height);
+      setWindowSize(width, height);
+    });
+  }
+  return Value::undefined();
+}
+
+Value windowSetPosition(Runtime & /*runtime*/,
+                        TurboModule & /*module*/,
+                        const Value *args,
+                        size_t count) {
+  if (twoNumbers(args, count)) {
+    const double first = args[0].asNumber();
+    const double second = args[1].asNumber();
+    onUiThread([first, second] { setWindowPosition(first, second); });
+  }
+  return Value::undefined();
+}
+
+Value windowCenter(Runtime & /*runtime*/,
+                   TurboModule & /*module*/,
+                   const Value * /*args*/,
+                   size_t /*count*/) {
+  onUiThread([] { centerWindow(); });
+  return Value::undefined();
+}
+
+Value windowSetFullScreen(Runtime & /*runtime*/,
+                          TurboModule & /*module*/,
+                          const Value *args,
+                          size_t count) {
+  // Anything but a boolean is ignored rather than coerced: `setFullScreen()`
+  // with no argument reads as "make it full screen" to a JavaScript truthiness
+  // check and as a mistake to everyone else.
+  if (count >= 1 && args[0].isBool()) {
+    const bool fullScreen = args[0].asBool();
+    onUiThread([fullScreen] { setWindowFullScreen(fullScreen); });
+  }
+  return Value::undefined();
+}
+
+Value windowSetMinimumSize(Runtime & /*runtime*/,
+                           TurboModule & /*module*/,
+                           const Value *args,
+                           size_t count) {
+  if (twoNumbers(args, count)) {
+    const double width = args[0].asNumber();
+    const double height = args[1].asNumber();
+    // The store is portable and thread-safe; what needs the UI thread is the
+    // applying, which is why the hop wraps the whole call rather than half of
+    // it. See core/WindowControl.h.
+    onUiThread([width, height] { setWindowMinimumSize(width, height); });
+  }
+  return Value::undefined();
+}
+
+Value windowSetMaximumSize(Runtime & /*runtime*/,
+                           TurboModule & /*module*/,
+                           const Value *args,
+                           size_t count) {
+  if (twoNumbers(args, count)) {
+    const double width = args[0].asNumber();
+    const double height = args[1].asNumber();
+    onUiThread([width, height] { setWindowMaximumSize(width, height); });
+  }
+  return Value::undefined();
+}
+
+Value windowSetResizable(Runtime & /*runtime*/,
+                         TurboModule & /*module*/,
+                         const Value *args,
+                         size_t count) {
+  if (count >= 1 && args[0].isBool()) {
+    const bool resizable = args[0].asBool();
+    onUiThread([resizable] { setWindowResizable(resizable); });
+  }
+  return Value::undefined();
+}
+
+Value windowSetAlwaysOnTop(Runtime & /*runtime*/,
+                           TurboModule & /*module*/,
+                           const Value *args,
+                           size_t count) {
+  if (count >= 1 && args[0].isBool()) {
+    const bool onTop = args[0].asBool();
+    onUiThread([onTop] { setWindowAlwaysOnTop(onTop); });
+  }
+  return Value::undefined();
+}
+
+Value windowGetCapabilities(Runtime &runtime,
+                            TurboModule & /*module*/,
+                            const Value * /*args*/,
+                            size_t /*count*/) {
+  const WindowCapabilities capabilities = windowCapabilities();
+  Object result(runtime);
+  result.setProperty(runtime, "position", capabilities.position);
+  result.setProperty(runtime, "minimumSize", capabilities.minimumSize);
+  result.setProperty(runtime, "maximumSize", capabilities.maximumSize);
+  result.setProperty(runtime, "resizable", capabilities.resizable);
+  result.setProperty(runtime, "alwaysOnTop", capabilities.alwaysOnTop);
+  return Value(runtime, result);
+}
+
+Value windowGetBounds(Runtime &runtime,
+                      TurboModule & /*module*/,
+                      const Value * /*args*/,
+                      size_t /*count*/) {
+  // From the cache rather than from the toolkit: this runs on the JavaScript
+  // thread, and it is read during render, so it can neither ask AppKit nor wait
+  // for a hop. The host reports every change, so the cache is exact.
+  const WindowBounds bounds = lastKnownWindowBounds();
+  Object object(runtime);
+  object.setProperty(runtime, "x", bounds.x);
+  object.setProperty(runtime, "y", bounds.y);
+  object.setProperty(runtime, "width", bounds.width);
+  object.setProperty(runtime, "height", bounds.height);
+  object.setProperty(runtime, "fullScreen", bounds.fullScreen);
+  object.setProperty(runtime, "maximized", bounds.maximized);
+  return Value(runtime, object);
+}
+
+} // namespace basalt

package/native/core/WindowMethods.h

@@ -0,0 +1,84 @@
+// The JavaScript boundary for a window's geometry, written once.
+//
+// Each host's `BasaltWindow` module registers these beside its own title-bar
+// methods. They are free functions with the signature a TurboModule method has,
+// so a host installs one with a line:
+//
+//     methodMap_["setSize"] = MethodMetadata{2, basalt::windowSetSize};
+//
+// Everything they do is in core/WindowControl.h, which is the part that differs
+// per platform. Nothing here is per-platform at all, which is why it is not
+// written three times -- the reading of arguments and the shape of the answer
+// are exactly the things three copies would drift on.
+
+#pragma once
+
+#include <ReactCommon/TurboModule.h>
+
+namespace basalt {
+
+// `setSize(width, height)`. Ignores a call with anything but two numbers, which
+// is what a JavaScript caller passing undefined looks like.
+facebook::jsi::Value windowSetSize(facebook::jsi::Runtime &runtime,
+                                   facebook::react::TurboModule &module,
+                                   const facebook::jsi::Value *args,
+                                   size_t count);
+
+// `setPosition(x, y)`, in the desktop's coordinates.
+facebook::jsi::Value windowSetPosition(facebook::jsi::Runtime &runtime,
+                                       facebook::react::TurboModule &module,
+                                       const facebook::jsi::Value *args,
+                                       size_t count);
+
+// `center()`, on whichever display the window is already on.
+facebook::jsi::Value windowCenter(facebook::jsi::Runtime &runtime,
+                                  facebook::react::TurboModule &module,
+                                  const facebook::jsi::Value *args,
+                                  size_t count);
+
+// `setFullScreen(boolean)`.
+facebook::jsi::Value windowSetFullScreen(facebook::jsi::Runtime &runtime,
+                                         facebook::react::TurboModule &module,
+                                         const facebook::jsi::Value *args,
+                                         size_t count);
+
+// `setMinimumSize(width, height)` and `setMaximumSize(width, height)`. Zero in
+// either direction clears that limit.
+facebook::jsi::Value windowSetMinimumSize(facebook::jsi::Runtime &runtime,
+                                          facebook::react::TurboModule &module,
+                                          const facebook::jsi::Value *args,
+                                          size_t count);
+facebook::jsi::Value windowSetMaximumSize(facebook::jsi::Runtime &runtime,
+                                          facebook::react::TurboModule &module,
+                                          const facebook::jsi::Value *args,
+                                          size_t count);
+
+// `setResizable(boolean)` and `setAlwaysOnTop(boolean)`.
+facebook::jsi::Value windowSetResizable(facebook::jsi::Runtime &runtime,
+                                        facebook::react::TurboModule &module,
+                                        const facebook::jsi::Value *args,
+                                        size_t count);
+facebook::jsi::Value windowSetAlwaysOnTop(facebook::jsi::Runtime &runtime,
+                                          facebook::react::TurboModule &module,
+                                          const facebook::jsi::Value *args,
+                                          size_t count);
+
+// `getCapabilities()` -> which of the above this desktop does. Read during
+// render, so it answers without a thread hop -- it is five booleans a platform
+// knows at compile time, not a question for the window manager.
+facebook::jsi::Value windowGetCapabilities(facebook::jsi::Runtime &runtime,
+                                           facebook::react::TurboModule &module,
+                                           const facebook::jsi::Value *args,
+                                           size_t count);
+
+// `getBounds()` -> `{x, y, width, height, fullScreen, maximized}`.
+facebook::jsi::Value windowGetBounds(facebook::jsi::Runtime &runtime,
+                                     facebook::react::TurboModule &module,
+                                     const facebook::jsi::Value *args,
+                                     size_t count);
+
+// The device event `useWindow()` listens for. Named here so the two sides
+// cannot drift.
+inline constexpr const char *kWindowBoundsEvent = "basaltWindowBoundsChanged";
+
+} // namespace basalt