basalt-appkit 0.0.0-rc5

package/native/appkit/AppKitWindowControl.mm

@@ -0,0 +1,222 @@
+// The macOS half of core/WindowControl.h.
+//
+// The one place this differs from the other two in more than spelling is the
+// coordinate system. AppKit's origin is the bottom left of the *primary*
+// display and y grows upwards; every other desktop, and React Native, put the
+// origin at the top left and grow downwards. So `windowBounds` and
+// `setWindowPosition` flip, against the primary screen's height, and an app
+// that remembers a position and restores it gets the same window back.
+//
+// Not flipping would be the subtler bug: a window would be restored the same
+// distance from the wrong edge, which looks almost right on a large display and
+// entirely wrong on a small one.
+
+#include <vector>
+#include "WindowControl.h"
+
+#import <Cocoa/Cocoa.h>
+
+namespace basalt {
+
+namespace {
+
+
+NSWindow *window() {
+  return NSApp.keyWindow != nil ? NSApp.keyWindow : NSApp.mainWindow;
+}
+
+// The height AppKit measures y from. `NSScreen.screens.firstObject` is the
+// primary display, which is the one AppKit's global coordinates are anchored
+// to -- not `mainScreen`, which is wherever the key window happens to be.
+CGFloat primaryHeight() {
+  NSScreen *primary = NSScreen.screens.firstObject;
+  return primary != nil ? NSMaxY(primary.frame) : 0.0;
+}
+
+} // namespace
+
+std::vector<DisplayInfo> displays() {
+  std::vector<DisplayInfo> found;
+  @autoreleasepool {
+    const CGFloat anchor = primaryHeight();
+    for (NSScreen *screen in NSScreen.screens) {
+      DisplayInfo info;
+      const NSRect frame = screen.frame;
+      const NSRect visible = screen.visibleFrame;
+
+      info.x = frame.origin.x;
+      // The same flip windowBounds does, and it has to be the same one: a
+      // display and a window are compared by apps that place windows, and two
+      // conventions in one API would be a bug nobody could see until a second
+      // monitor was above the first.
+      info.y = anchor - NSMaxY(frame);
+      info.width = frame.size.width;
+      info.height = frame.size.height;
+
+      // `visibleFrame` is what is left after the menu bar and the Dock, which
+      // is exactly what the work area means.
+      info.workX = visible.origin.x;
+      info.workY = anchor - NSMaxY(visible);
+      info.workWidth = visible.size.width;
+      info.workHeight = visible.size.height;
+
+      info.scaleFactor = screen.backingScaleFactor > 0.0 ? screen.backingScaleFactor : 1.0;
+      // `NSScreen.screens` is documented to put the primary first, and that is
+      // also the screen the coordinates above are anchored to -- so this is
+      // the same answer primaryHeight() relies on rather than a second one.
+      info.primary = found.empty();
+      found.push_back(info);
+    }
+  }
+  return found;
+}
+
+PointerPosition pointerPosition() {
+  PointerPosition where;
+  @autoreleasepool {
+    // Global, and available whether or not the pointer is over this app --
+    // which is the whole point of asking, and is not true on every desktop.
+    const NSPoint mouse = NSEvent.mouseLocation;
+    where.x = mouse.x;
+    where.y = primaryHeight() - mouse.y;
+    where.known = true;
+  }
+  return where;
+}
+
+WindowBounds windowBounds() {
+  WindowBounds bounds;
+  @autoreleasepool {
+    NSWindow *target = window();
+    if (target == nil) {
+      return bounds;
+    }
+    const NSRect frame = target.frame;
+    bounds.x = frame.origin.x;
+    // Top-left origin, growing downwards. See the header.
+    bounds.y = primaryHeight() - NSMaxY(frame);
+    bounds.width = frame.size.width;
+    bounds.height = frame.size.height;
+    bounds.fullScreen = (target.styleMask & NSWindowStyleMaskFullScreen) != 0;
+    bounds.maximized = target.isZoomed;
+  }
+  return bounds;
+}
+
+void setWindowSize(double width, double height) {
+  if (width <= 0.0 || height <= 0.0) {
+    return;
+  }
+  @autoreleasepool {
+    NSWindow *target = window();
+    if (target == nil) {
+      return;
+    }
+    NSRect frame = target.frame;
+    // The top edge stays where it is. Resizing a window from its bottom-left
+    // origin -- which is what setting the size alone would do -- moves its
+    // title bar, and every other desktop grows a window downwards.
+    frame.origin.y = NSMaxY(frame) - height;
+    frame.size = NSMakeSize(width, height);
+    [target setFrame:frame display:YES animate:NO];
+  }
+}
+
+void setWindowPosition(double x, double y) {
+  @autoreleasepool {
+    NSWindow *target = window();
+    if (target == nil) {
+      return;
+    }
+    // `setFrameTopLeftPoint` takes AppKit coordinates, so the y this was given
+    // -- measured down from the top -- is measured back up from the bottom.
+    [target setFrameTopLeftPoint:NSMakePoint(x, primaryHeight() - y)];
+  }
+}
+
+void centerWindow() {
+  @autoreleasepool {
+    // AppKit's own, which puts the window slightly above centre: that is where
+    // Apple's guidelines say a window goes, and an app asking to be centred on
+    // a Mac is asking for that rather than for arithmetic.
+    [window() center];
+  }
+}
+
+void setWindowFullScreen(bool fullScreen) {
+  @autoreleasepool {
+    NSWindow *target = window();
+    if (target == nil) {
+      return;
+    }
+    const bool already = (target.styleMask & NSWindowStyleMaskFullScreen) != 0;
+    // `toggleFullScreen:` is the only way in, and it toggles -- so asking for
+    // the state it is already in has to do nothing rather than reverse it.
+    if (already != fullScreen) {
+      [target toggleFullScreen:nil];
+    }
+  }
+}
+
+void applyWindowSizeLimits() {
+  @autoreleasepool {
+    NSWindow *target = window();
+    if (target == nil) {
+      return;
+    }
+    const WindowSizeLimits limits = windowSizeLimits();
+    // `contentMinSize` and `contentMaxSize` rather than `minSize`/`maxSize`:
+    // those are the frame, which includes the title bar, and an app asking for
+    // a minimum of 400x300 means 400x300 of its own content -- the same
+    // distinction `setWindowSize` already makes.
+    target.contentMinSize = NSMakeSize(limits.minWidth > 0.0 ? limits.minWidth : 0.0,
+                                       limits.minHeight > 0.0 ? limits.minHeight : 0.0);
+    // No maximum is CGFLOAT_MAX rather than zero, which would be a window that
+    // cannot be any size at all.
+    target.contentMaxSize = NSMakeSize(limits.maxWidth > 0.0 ? limits.maxWidth : CGFLOAT_MAX,
+                                       limits.maxHeight > 0.0 ? limits.maxHeight : CGFLOAT_MAX);
+  }
+}
+
+void setWindowResizable(bool resizable) {
+  @autoreleasepool {
+    NSWindow *target = window();
+    if (target == nil) {
+      return;
+    }
+    // A bit in the style mask, which is also what draws the zoom button: a
+    // window that cannot be resized should not offer to be.
+    if (resizable) {
+      target.styleMask |= NSWindowStyleMaskResizable;
+    } else {
+      target.styleMask &= ~NSWindowStyleMaskResizable;
+    }
+  }
+}
+
+void setWindowAlwaysOnTop(bool alwaysOnTop) {
+  @autoreleasepool {
+    NSWindow *target = window();
+    if (target == nil) {
+      return;
+    }
+    // Floating, not one of the higher levels. `NSFloatingWindowLevel` puts a
+    // window above other applications and still below the things that are
+    // supposed to outrank an application -- a screen lock, a system alert -- and
+    // asking for more than that is asking to be the bug report.
+    target.level = alwaysOnTop ? NSFloatingWindowLevel : NSNormalWindowLevel;
+  }
+}
+
+WindowCapabilities windowCapabilities() {
+  // The one desktop where every one of these is real.
+  WindowCapabilities capabilities;
+  capabilities.position = true;
+  capabilities.minimumSize = true;
+  capabilities.maximumSize = true;
+  capabilities.resizable = true;
+  capabilities.alwaysOnTop = true;
+  return capabilities;
+}
+
+} // namespace basalt

package/native/appkit/AppKitWindowModule.h

@@ -0,0 +1,62 @@
+// `BasaltWindow` on macOS: the module src/TitleBar.js talks to.
+//
+// The same four methods Win32WindowModule has, because the JavaScript is
+// shared and does not know which desktop it is on. What differs is underneath,
+// in AppKitTitleBar.h.
+
+#pragma once
+
+#include <ReactCommon/TurboModule.h>
+
+#include <memory>
+
+namespace basalt {
+
+class AppKitWindowModule : public facebook::react::TurboModule {
+ public:
+  static constexpr const char *kModuleName = "BasaltWindow";
+
+  explicit AppKitWindowModule(std::shared_ptr<facebook::react::CallInvoker> jsInvoker);
+  ~AppKitWindowModule() override;
+
+ private:
+  static facebook::jsi::Value setTitle(facebook::jsi::Runtime &runtime,
+                                       facebook::react::TurboModule &module,
+                                       const facebook::jsi::Value *args,
+                                       size_t count);
+  static facebook::jsi::Value setTitleBarColors(facebook::jsi::Runtime &runtime,
+                                                facebook::react::TurboModule &module,
+                                                const facebook::jsi::Value *args,
+                                                size_t count);
+  static facebook::jsi::Value setTitleBarStyle(facebook::jsi::Runtime &runtime,
+                                               facebook::react::TurboModule &module,
+                                               const facebook::jsi::Value *args,
+                                               size_t count);
+  static facebook::jsi::Value getTitleBarMetrics(facebook::jsi::Runtime &runtime,
+                                                 facebook::react::TurboModule &module,
+                                                 const facebook::jsi::Value *args,
+                                                 size_t count);
+  // The caption buttons' functions, for an app drawing its own header.
+  static facebook::jsi::Value minimize(facebook::jsi::Runtime &runtime,
+                                       facebook::react::TurboModule &module,
+                                       const facebook::jsi::Value *args,
+                                       size_t count);
+  static facebook::jsi::Value toggleMaximize(facebook::jsi::Runtime &runtime,
+                                             facebook::react::TurboModule &module,
+                                             const facebook::jsi::Value *args,
+                                             size_t count);
+  static facebook::jsi::Value closeWindow(facebook::jsi::Runtime &runtime,
+                                          facebook::react::TurboModule &module,
+                                          const facebook::jsi::Value *args,
+                                          size_t count);
+  static facebook::jsi::Value startWindowDrag(facebook::jsi::Runtime &runtime,
+                                              facebook::react::TurboModule &module,
+                                              const facebook::jsi::Value *args,
+                                              size_t count);
+  static facebook::jsi::Value noop(facebook::jsi::Runtime &runtime,
+                                   facebook::react::TurboModule &module,
+                                   const facebook::jsi::Value *args,
+                                   size_t count);
+};
+
+} // namespace basalt

package/native/appkit/AppKitWindowModule.mm

@@ -0,0 +1,194 @@
+#import "AppKitWindowModule.h"
+
+#import "AppKitTitleBar.h"
+#include "PlatformServices.h"
+
+#include "WindowControl.h"
+#include "WindowMethods.h"
+#include <cstdint>
+#include <optional>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace basalt {
+
+namespace {
+
+using facebook::jsi::Object;
+using facebook::jsi::Runtime;
+using facebook::jsi::String;
+using facebook::jsi::Value;
+using facebook::react::TurboModule;
+
+constexpr const char *kMetricsChangedEvent = "basaltTitleBarMetricsChanged";
+
+// processColor's 0xAARRGGBB, or nullopt for anything that is not a number --
+// which is how JavaScript asks for the system's colour back.
+std::optional<uint32_t> colorArgument(const Value *args, size_t count, size_t index) {
+  if (index >= count || !args[index].isNumber()) {
+    return std::nullopt;
+  }
+  return static_cast<uint32_t>(static_cast<int64_t>(args[index].asNumber()));
+}
+
+Value metricsValue(Runtime &runtime, const TitleBarMetrics &metrics) {
+  Object object(runtime);
+  object.setProperty(runtime, "height", metrics.height);
+  object.setProperty(runtime, "buttonsWidth", metrics.buttonsWidth);
+  object.setProperty(runtime,
+                     "style",
+                     String::createFromAscii(
+                         runtime, metrics.style == TitleBarStyle::Hidden ? "hidden" : "native"));
+  return Value(runtime, object);
+}
+
+} // namespace
+
+AppKitWindowModule::AppKitWindowModule(std::shared_ptr<facebook::react::CallInvoker> jsInvoker)
+    : TurboModule(kModuleName, std::move(jsInvoker)) {
+  methodMap_["setTitle"] = MethodMetadata{1, setTitle};
+  methodMap_["setTitleBarColors"] = MethodMetadata{3, setTitleBarColors};
+  methodMap_["setTitleBarStyle"] = MethodMetadata{1, setTitleBarStyle};
+  methodMap_["getTitleBarMetrics"] = MethodMetadata{0, getTitleBarMetrics};
+  methodMap_["minimize"] = MethodMetadata{0, minimize};
+  methodMap_["toggleMaximize"] = MethodMetadata{0, toggleMaximize};
+  methodMap_["close"] = MethodMetadata{0, closeWindow};
+  methodMap_["startWindowDrag"] = MethodMetadata{0, startWindowDrag};
+  // A window's geometry. The bodies are in core/WindowMethods.h, written once:
+  // nothing about reading two numbers or shaping the answer differs per
+  // desktop, and three copies would be three chances to drift.
+  methodMap_["setSize"] = MethodMetadata{2, windowSetSize};
+  methodMap_["setPosition"] = MethodMetadata{2, windowSetPosition};
+  methodMap_["center"] = MethodMetadata{0, windowCenter};
+  methodMap_["setFullScreen"] = MethodMetadata{1, windowSetFullScreen};
+  // How big it may be, whether it may be resized at all, and whether it floats.
+  // Not every desktop does every one of these; `getCapabilities` is how an app
+  // finds out rather than guessing. See core/WindowControl.h.
+  methodMap_["setMinimumSize"] = MethodMetadata{2, windowSetMinimumSize};
+  methodMap_["setMaximumSize"] = MethodMetadata{2, windowSetMaximumSize};
+  methodMap_["setResizable"] = MethodMetadata{1, windowSetResizable};
+  methodMap_["setAlwaysOnTop"] = MethodMetadata{1, windowSetAlwaysOnTop};
+  methodMap_["getCapabilities"] = MethodMetadata{0, windowGetCapabilities};
+  methodMap_["getBounds"] = MethodMetadata{0, windowGetBounds};
+  // What a NativeEventEmitter over this module calls; the events go out as
+  // device events either way.
+  methodMap_["addListener"] = MethodMetadata{1, noop};
+  methodMap_["removeListeners"] = MethodMetadata{1, noop};
+
+  titleBar().setMetricsListener([this](const TitleBarMetrics &metrics) {
+    emitDeviceEvent(kMetricsChangedEvent, [metrics](Runtime &runtime, std::vector<Value> &args) {
+      args.emplace_back(metricsValue(runtime, metrics));
+    });
+  });
+
+  // The window's geometry, the same way the title bar's metrics go out: a
+  // device event, so `useWindow()` can hand an app live bounds rather than a
+  // snapshot it has to remember to refresh.
+  setWindowBoundsListener([this](const WindowBounds &bounds) {
+    emitDeviceEvent(kWindowBoundsEvent, [bounds](Runtime &runtime, std::vector<Value> &args) {
+      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);
+      args.emplace_back(Value(runtime, object));
+    });
+  });
+
+  // And ask for the bounds once, now that something is listening. The host
+  // primes the cache when its window appears, but this module is built lazily
+  // -- the first time JavaScript asks for it -- so an app that mounts before
+  // then would read a window of no size and never be told otherwise.
+  postToUiThread([] { notifyWindowBoundsChanged(); });
+}
+
+AppKitWindowModule::~AppKitWindowModule() {
+  titleBar().setMetricsListener(nullptr);
+  setWindowBoundsListener(nullptr);
+}
+
+Value AppKitWindowModule::setTitle(Runtime &runtime,
+                                   TurboModule & /*module*/,
+                                   const Value *args,
+                                   size_t count) {
+  std::optional<std::string> title;
+  if (count > 0 && args[0].isString()) {
+    title = args[0].getString(runtime).utf8(runtime);
+  }
+  postToUiThread([title = std::move(title)]() mutable { titleBar().setTitle(std::move(title)); });
+  return Value::undefined();
+}
+
+Value AppKitWindowModule::setTitleBarColors(Runtime & /*runtime*/,
+                                            TurboModule & /*module*/,
+                                            const Value *args,
+                                            size_t count) {
+  const auto background = colorArgument(args, count, 0);
+  const auto text = colorArgument(args, count, 1);
+  const auto border = colorArgument(args, count, 2);
+  postToUiThread([background, text, border] { titleBar().setColors(background, text, border); });
+  return Value::undefined();
+}
+
+Value AppKitWindowModule::setTitleBarStyle(Runtime &runtime,
+                                           TurboModule & /*module*/,
+                                           const Value *args,
+                                           size_t count) {
+  const bool hidden =
+      count > 0 && args[0].isString() && args[0].getString(runtime).utf8(runtime) == "hidden";
+  postToUiThread([hidden] {
+    titleBar().setStyle(hidden ? TitleBarStyle::Hidden : TitleBarStyle::Native);
+  });
+  return Value::undefined();
+}
+
+Value AppKitWindowModule::getTitleBarMetrics(Runtime &runtime,
+                                             TurboModule & /*module*/,
+                                             const Value * /*args*/,
+                                             size_t /*count*/) {
+  return metricsValue(runtime, titleBar().metrics());
+}
+
+Value AppKitWindowModule::minimize(Runtime & /*runtime*/,
+                      TurboModule & /*module*/,
+                      const Value * /*args*/,
+                      size_t /*count*/) {
+  postToUiThread([] { titleBar().minimize(); });
+  return Value::undefined();
+}
+
+Value AppKitWindowModule::toggleMaximize(Runtime & /*runtime*/,
+                            TurboModule & /*module*/,
+                            const Value * /*args*/,
+                            size_t /*count*/) {
+  postToUiThread([] { titleBar().toggleMaximize(); });
+  return Value::undefined();
+}
+
+Value AppKitWindowModule::closeWindow(Runtime & /*runtime*/,
+                         TurboModule & /*module*/,
+                         const Value * /*args*/,
+                         size_t /*count*/) {
+  postToUiThread([] { titleBar().close(); });
+  return Value::undefined();
+}
+
+Value AppKitWindowModule::startWindowDrag(Runtime & /*runtime*/,
+                             TurboModule & /*module*/,
+                             const Value * /*args*/,
+                             size_t /*count*/) {
+  postToUiThread([] { titleBar().startDrag(); });
+  return Value::undefined();
+}
+
+Value AppKitWindowModule::noop(Runtime & /*runtime*/,
+                               TurboModule & /*module*/,
+                               const Value * /*args*/,
+                               size_t /*count*/) {
+  return Value::undefined();
+}
+
+} // namespace basalt

package/native/appkit/ColorSchemeAppKit.mm

@@ -0,0 +1,71 @@
+// macOS's half of the colour-scheme seam.
+//
+// `NSApp.effectiveAppearance` is the authority: it accounts for the system
+// setting, any per-application override in defaults, and the accessibility
+// contrast variants, none of which reading `AppleInterfaceStyle` out of
+// NSUserDefaults would see.
+
+#include "ColorScheme.h"
+
+#import <Cocoa/Cocoa.h>
+
+// Key-value observing needs an object to deliver to, and the C++ half is not
+// one. Observing the *application's* effectiveAppearance rather than the
+// `AppleInterfaceThemeChangedNotification` distributed notification: that one
+// fires for the system setting only, so an app told to be dark on a light
+// system would never hear anything.
+@interface RnAppKitAppearanceObserver : NSObject
+@end
+
+@implementation RnAppKitAppearanceObserver
+
+- (void)observeValueForKeyPath:(NSString *)keyPath
+                      ofObject:(id)object
+                        change:(NSDictionary *)change
+                       context:(void *)context {
+  (void)keyPath;
+  (void)object;
+  (void)change;
+  (void)context;
+  basalt::notifyColorSchemeChanged();
+}
+
+@end
+
+namespace basalt {
+
+namespace {
+
+// Kept for the life of the process: it *is* the observer registration, and
+// letting it go would stop the notifications without saying so.
+RnAppKitAppearanceObserver *gObserver = nil;
+
+} // namespace
+
+ColorScheme systemColorScheme() {
+  @autoreleasepool {
+    NSAppearance *appearance = NSApp != nil ? NSApp.effectiveAppearance : nil;
+    if (appearance == nil) {
+      // Before NSApplication exists -- a unit test, or a very early read. Light
+      // is React Native's default when a platform has no answer.
+      return ColorScheme::Light;
+    }
+    NSAppearanceName best = [appearance
+        bestMatchFromAppearancesWithNames:@[ NSAppearanceNameAqua, NSAppearanceNameDarkAqua ]];
+    return [best isEqualToString:NSAppearanceNameDarkAqua] ? ColorScheme::Dark
+                                                           : ColorScheme::Light;
+  }
+}
+
+void startObservingColorScheme() {
+  if (gObserver != nil || NSApp == nil) {
+    return;
+  }
+  gObserver = [[RnAppKitAppearanceObserver alloc] init];
+  [NSApp addObserver:gObserver
+          forKeyPath:@"effectiveAppearance"
+             options:NSKeyValueObservingOptionNew
+             context:nullptr];
+}
+
+} // namespace basalt

package/native/appkit/ComponentRegistryAppKit.mm

@@ -0,0 +1,121 @@
+// The component registry for the macOS platform. See core/ComponentRegistry.h
+// for why this is per-platform rather than shared.
+//
+// `<View>`, `<Text>`, `<ScrollView>`, `<Image>` and `<TextInput>` -- the
+// components an ordinary app is built from, plus the root; and below them the
+// controls, which are the ones a view layer needs a real toolkit peer for.
+//
+// Paragraph arrived with CoreTextLayoutManager.mm, and could not have arrived
+// before it: registering it constructs a `TextLayoutManager`, whose stub this
+// build drops so a platform's own can be the only definition. That is the link
+// error phase 19 found, and it is what kept this list at one entry.
+//
+// Registering them early would cost nothing visible and be worse than the gap.
+// A registered descriptor with no mounting peer does not error -- Fabric builds
+// the shadow nodes, lays them out, and the app renders blank rectangles where
+// its text should be. Leaving them out means React Native substitutes
+// UnimplementedNativeView, which at least says so.
+
+#include "ComponentRegistry.h"
+#include "ExpoImageComponent.h"
+
+#include <react/renderer/componentregistry/ComponentDescriptorProviderRegistry.h>
+
+#include "SkiaPictureViewComponent.h"
+#include <react/renderer/components/FBReactNativeSpec/ComponentDescriptors.h>
+#include <react/renderer/components/image/ImageComponentDescriptor.h>
+#include <react/renderer/components/iostextinput/TextInputComponentDescriptor.h>
+#include <react/renderer/components/modal/ModalHostViewComponentDescriptor.h>
+#include <react/renderer/components/scrollview/ScrollViewComponentDescriptor.h>
+#include <react/renderer/components/switch/AppleSwitchComponentDescriptor.h>
+#include <react/renderer/components/text/ParagraphComponentDescriptor.h>
+#include <react/renderer/components/text/RawTextComponentDescriptor.h>
+#include <react/renderer/components/text/TextComponentDescriptor.h>
+#include <react/renderer/components/view/ViewComponentDescriptor.h>
+
+namespace facebook::react {
+
+ComponentRegistryFactory getDefaultComponentRegistryFactory() {
+  return [](const EventDispatcher::Weak &eventDispatcher,
+            const std::shared_ptr<const ContextContainer> &contextContainer) {
+    static auto providerRegistry = []() {
+      auto registry = std::make_shared<ComponentDescriptorProviderRegistry>();
+      registry->add(concreteComponentDescriptorProvider<ViewComponentDescriptor>());
+      // Text is three descriptors and only one of them mounts. <Text> becomes a
+      // Text node, its string a RawText node, and the outermost <Text> a
+      // Paragraph that folds the whole subtree into a single AttributedString.
+      registry->add(concreteComponentDescriptorProvider<ParagraphComponentDescriptor>());
+      registry->add(concreteComponentDescriptorProvider<TextComponentDescriptor>());
+      registry->add(concreteComponentDescriptorProvider<RawTextComponentDescriptor>());
+      // Unlike Image's, ScrollView's descriptor is a bare alias for
+      // ConcreteComponentDescriptor -- no manager, no ContextContainer entry.
+      // Leaving it out does not fail loudly: the registry silently substitutes
+      // UnimplementedNativeView, which has no ScrollViewState, and the symptom
+      // is a ScrollView that renders but never scrolls.
+      registry->add(concreteComponentDescriptorProvider<ScrollViewComponentDescriptor>());
+      // Image's descriptor pulls an ImageManager out of the ContextContainer,
+      // creating one if absent. React Native's cxx ImageManager is a stub, so
+      // it produces no pixels; AppKitImageLoader does that from the props.
+      registry->add(concreteComponentDescriptorProvider<ImageComponentDescriptor>());
+      // React Native's *iOS* TextInput, whose C++ is portable: it measures
+      // through a TextLayoutManager, which here is the Core Text one.
+      // Android's needs fbjni. Its component name is "TextInput".
+      registry->add(concreteComponentDescriptorProvider<TextInputComponentDescriptor>());
+      // @shopify/react-native-skia's <Canvas>. Registered whether or not the
+      // build has Skia in it, for the reason the Expo one below gives: it costs
+      // a name in a registry. Without Skia the view mounts and stays empty, and
+      // an app that draws has already failed at getEnforcing('RNSkiaModule').
+      registry->add(concreteComponentDescriptorProvider<SkiaPictureViewComponentDescriptor>());
+      // expo-image's view. Registered whether or not the build has Expo in it:
+      // the descriptor is ordinary Fabric C++, and an app that never renders
+      // one pays a registry entry. See core/ExpoImageComponent.h.
+      registry->add(concreteComponentDescriptorProvider<ExpoImageComponentDescriptor>());
+
+      // --- The controls -----------------------------------------------------
+      //
+      // Everything above is a box with something drawn in it. These are not:
+      // each one is a toolkit control, or a window, and each one needed the
+      // view layer to grow a peer before registering it here would have meant
+      // anything. Registering a descriptor with nothing to mount it does not
+      // error -- Fabric builds the shadow nodes, lays them out, and the app
+      // renders blank rectangles -- so this list and the mounting manager's
+      // `hasComponent` are two statements of the same fact and have to agree.
+
+      // <ActivityIndicator>. React Native's JavaScript writes the 20pt or 36pt
+      // box into the view's style, so the shadow node needs no measurement of
+      // its own; what the host draws inside it is a spinner.
+      registry->add(concreteComponentDescriptorProvider<ActivityIndicatorViewComponentDescriptor>());
+      // <Switch>. The descriptor is React Native's iOS one -- portable C++
+      // apart from a `measureContent` that instantiates a UISwitch, which
+      // core/DesktopControls.cpp replaces with a constant so a switch is the
+      // same size on all three desktops.
+      registry->add(concreteComponentDescriptorProvider<SwitchComponentDescriptor>());
+      // <Modal>. Not a second window: the shadow node is a root-kind node sized
+      // from its state and positioned absolutely, so a modal is an overlay
+      // filling the surface -- which is also what it is on the web. The host
+      // commits the window's size into that state; see
+      // core/DesktopControls.h's modalScreenSizeNeedsUpdate for why it must.
+      registry->add(concreteComponentDescriptorProvider<ModalHostViewComponentDescriptor>());
+      // <RefreshControl>. The spinner a scroll view shows while it refreshes.
+      // The gesture that starts it is in core/PullToRefresh.h, because a
+      // desktop has no rubber band to release.
+      registry->add(concreteComponentDescriptorProvider<PullToRefreshViewComponentDescriptor>());
+      // What React Native substitutes for a component no platform registered.
+      // Registering it is what turns "nothing happens" into a mounted view the
+      // tree dump can show, and it is what the comments above mean when they
+      // say the substitution is silent.
+      registry->add(concreteComponentDescriptorProvider<UnimplementedNativeViewComponentDescriptor>());
+      // React DevTools' element highlighter. It draws nothing here yet -- the
+      // highlight arrives as a command rather than as props -- but a DevTools
+      // session mounts one, and an unregistered component in the tree is a
+      // blank rectangle in the middle of the app.
+      registry->add(concreteComponentDescriptorProvider<DebuggingOverlayComponentDescriptor>());
+
+      return registry;
+    }();
+    return providerRegistry->createComponentDescriptorRegistry(
+        {eventDispatcher, contextContainer, nullptr});
+  };
+}
+
+} // namespace facebook::react