one 2.10.0 → 2.11.0

package/macos/host/OneMacosToggleComponentView.h

@@ -0,0 +1,4 @@
+#import "OneMacosComponentView.h"
+
+@interface OneMacosToggleComponentView : OneMacosViewComponentView
+@end

package/macos/host/OneMacosToggleComponentView.mm

@@ -0,0 +1,57 @@
+#import "OneMacosToggleComponentView.h"
+
+#import "OneMacosToggleHosting.h"
+
+#include <OneMacToggle/OneMacToggleEventEmitter.h>
+#include <OneMacToggle/OneMacToggleProps.h>
+
+using namespace facebook::react;
+
+// The controlled round trip lives in Swift (OneNativeControlled, shared with
+// iOS); this view forwards props in and the native event out.
+@implementation OneMacosToggleComponentView {
+  NSView<OneMacosToggleHosting> *_host;
+}
+
+- (instancetype)initWithFrame:(NSRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    Class hostClass = NSClassFromString(@"OneMacToggleHostView");
+    if (!hostClass) {
+      [NSException raise:NSInternalInconsistencyException
+                  format:@"OneMacToggleHostView is missing; add host/swift/OneMacToggle.swift to the app target"];
+    }
+    _host = [[hostClass alloc] initWithFrame:self.bounds];
+    _host.autoresizingMask = NSViewWidthSizable | NSViewHeightSizable;
+    __weak OneMacosToggleComponentView *weakSelf = self;
+    _host.onChange = ^(BOOL isOn, NSInteger eventCount, NSInteger revision) {
+      [weakSelf userDidChange:isOn eventCount:eventCount revision:revision];
+    };
+    [self addSubview:_host];
+  }
+  return self;
+}
+
+- (void)userDidChange:(BOOL)isOn eventCount:(NSInteger)eventCount revision:(NSInteger)revision
+{
+  auto emitter = std::static_pointer_cast<const OneMacToggleEventEmitter>(self.eventEmitter);
+  if (emitter) {
+    emitter->onIsOnChange({.isOn = (bool)isOn, .eventCount = (int)eventCount, .revision = (int)revision});
+  }
+}
+
+- (void)updateProps:(const Props::Shared &)props oldProps:(const Props::Shared &)oldProps
+{
+  [super updateProps:props oldProps:oldProps];
+  const auto &toggleProps = static_cast<const OneMacToggleProps &>(*props);
+  _host.label = [NSString stringWithUTF8String:toggleProps.label.c_str()];
+  [_host applyValue:toggleProps.isOn acknowledged:toggleProps.acknowledgedEvent revision:toggleProps.revision];
+}
+
+- (void)updateLayoutMetrics:(const LayoutMetrics &)layoutMetrics oldLayoutMetrics:(const LayoutMetrics &)oldLayoutMetrics
+{
+  [super updateLayoutMetrics:layoutMetrics oldLayoutMetrics:oldLayoutMetrics];
+  _host.frame = self.bounds;
+}
+
+@end

package/macos/host/OneMacosToggleHosting.h

@@ -0,0 +1,15 @@
+#import <AppKit/AppKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+// Implemented in Swift by OneMacToggleHostView (host/swift), which hosts the
+// SwiftUI Toggle in an NSHostingView. The Fabric component view in the core
+// library finds the class by name so the library itself carries no Swift.
+@protocol OneMacosToggleHosting <NSObject>
+@property (nonatomic, copy) NSString *label;
+// the controlled state lives in Swift (OneNativeControlled, shared with iOS)
+- (void)applyValue:(BOOL)isOn acknowledged:(NSInteger)acknowledged revision:(NSInteger)revision;
+@property (nonatomic, copy, nullable) void (^onChange)(BOOL isOn, NSInteger eventCount, NSInteger revision);
+@end
+
+NS_ASSUME_NONNULL_END

package/macos/host/OneMacosWebSocket.h

@@ -0,0 +1,22 @@
+#import <Foundation/Foundation.h>
+
+#include <folly/dynamic.h>
+
+#include <functional>
+
+NS_ASSUME_NONNULL_BEGIN
+
+// NSURLSessionWebSocketTask behind the event names RN's WebSocket.js expects.
+@interface OneMacosWebSocketManager : NSObject
+
+- (instancetype)initWithEmitter:(std::function<void(const std::string &, folly::dynamic)>)emitter;
+
+- (void)connect:(NSURL *)url protocols:(nullable NSArray<NSString *> *)protocols socketID:(NSInteger)socketID;
+- (void)sendText:(NSString *)text socketID:(NSInteger)socketID;
+- (void)sendBase64:(NSString *)base64 socketID:(NSInteger)socketID;
+- (void)ping:(NSInteger)socketID;
+- (void)close:(NSInteger)socketID code:(NSInteger)code reason:(nullable NSString *)reason;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/macos/host/OneMacosWebSocket.mm

@@ -0,0 +1,161 @@
+#import "OneMacosWebSocket.h"
+
+@interface OneMacosWebSocketManager () <NSURLSessionWebSocketDelegate>
+@end
+
+@implementation OneMacosWebSocketManager {
+  std::function<void(const std::string &, folly::dynamic)> _emit;
+  NSURLSession *_session;
+  NSMutableDictionary<NSNumber *, NSURLSessionWebSocketTask *> *_tasks;
+}
+
+- (instancetype)initWithEmitter:(std::function<void(const std::string &, folly::dynamic)>)emitter
+{
+  if (self = [super init]) {
+    _emit = std::move(emitter);
+    _tasks = [NSMutableDictionary new];
+    NSOperationQueue *queue = [NSOperationQueue new];
+    queue.maxConcurrentOperationCount = 1;
+    _session = [NSURLSession sessionWithConfiguration:NSURLSessionConfiguration.defaultSessionConfiguration
+                                             delegate:self
+                                        delegateQueue:queue];
+  }
+  return self;
+}
+
+- (NSNumber *)socketIDForTask:(NSURLSessionTask *)task
+{
+  @synchronized(self) {
+    for (NSNumber *key in _tasks) {
+      if (_tasks[key] == task) {
+        return key;
+      }
+    }
+  }
+  return nil;
+}
+
+- (void)connect:(NSURL *)url protocols:(NSArray<NSString *> *)protocols socketID:(NSInteger)socketID
+{
+  NSURLSessionWebSocketTask *task = protocols.count > 0 ? [_session webSocketTaskWithURL:url protocols:protocols]
+                                                         : [_session webSocketTaskWithURL:url];
+  @synchronized(self) {
+    _tasks[@(socketID)] = task;
+  }
+  [task resume];
+  [self receive:task socketID:socketID];
+}
+
+- (void)receive:(NSURLSessionWebSocketTask *)task socketID:(NSInteger)socketID
+{
+  __weak OneMacosWebSocketManager *weakSelf = self;
+  [task receiveMessageWithCompletionHandler:^(NSURLSessionWebSocketMessage *message, NSError *error) {
+    OneMacosWebSocketManager *strongSelf = weakSelf;
+    if (!strongSelf) {
+      return;
+    }
+    if (error) {
+      // closing already reported through the delegate
+      if (task.state == NSURLSessionTaskStateRunning) {
+        strongSelf->_emit(
+            "websocketFailed",
+            folly::dynamic::object("id", (int)socketID)("message", error.localizedDescription.UTF8String));
+      }
+      return;
+    }
+    if (message.type == NSURLSessionWebSocketMessageTypeString) {
+      strongSelf->_emit(
+          "websocketMessage",
+          folly::dynamic::object("id", (int)socketID)("type", "text")("data", message.string.UTF8String));
+    } else {
+      strongSelf->_emit(
+          "websocketMessage",
+          folly::dynamic::object("id", (int)socketID)("type", "binary")(
+              "data", [message.data base64EncodedStringWithOptions:0].UTF8String));
+    }
+    [strongSelf receive:task socketID:socketID];
+  }];
+}
+
+- (nullable NSURLSessionWebSocketTask *)task:(NSInteger)socketID
+{
+  @synchronized(self) {
+    return _tasks[@(socketID)];
+  }
+}
+
+- (void)sendText:(NSString *)text socketID:(NSInteger)socketID
+{
+  [[self task:socketID] sendMessage:[[NSURLSessionWebSocketMessage alloc] initWithString:text]
+                  completionHandler:^(NSError *error) {
+                    if (error) {
+                      self->_emit(
+                          "websocketFailed",
+                          folly::dynamic::object("id", (int)socketID)("message", error.localizedDescription.UTF8String));
+                    }
+                  }];
+}
+
+- (void)sendBase64:(NSString *)base64 socketID:(NSInteger)socketID
+{
+  NSData *data = [[NSData alloc] initWithBase64EncodedString:base64 options:0];
+  [[self task:socketID] sendMessage:[[NSURLSessionWebSocketMessage alloc] initWithData:data]
+                  completionHandler:^(NSError *error) {}];
+}
+
+- (void)ping:(NSInteger)socketID
+{
+  [[self task:socketID] sendPingWithPongReceiveHandler:^(NSError *error) {}];
+}
+
+- (void)close:(NSInteger)socketID code:(NSInteger)code reason:(NSString *)reason
+{
+  [[self task:socketID] cancelWithCloseCode:(NSURLSessionWebSocketCloseCode)code
+                                     reason:[reason dataUsingEncoding:NSUTF8StringEncoding]];
+}
+
+#pragma mark - NSURLSessionWebSocketDelegate
+
+- (void)URLSession:(NSURLSession *)session
+          webSocketTask:(NSURLSessionWebSocketTask *)task
+    didOpenWithProtocol:(NSString *)protocol
+{
+  NSNumber *socketID = [self socketIDForTask:task];
+  if (socketID) {
+    _emit(
+        "websocketOpen",
+        folly::dynamic::object("id", socketID.intValue)("protocol", protocol ? protocol.UTF8String : ""));
+  }
+}
+
+- (void)URLSession:(NSURLSession *)session
+       webSocketTask:(NSURLSessionWebSocketTask *)task
+    didCloseWithCode:(NSURLSessionWebSocketCloseCode)closeCode
+              reason:(NSData *)reason
+{
+  NSNumber *socketID = [self socketIDForTask:task];
+  if (socketID) {
+    NSString *reasonString = reason ? [[NSString alloc] initWithData:reason encoding:NSUTF8StringEncoding] : @"";
+    _emit(
+        "websocketClosed",
+        folly::dynamic::object("id", socketID.intValue)("code", (int)closeCode)("reason", reasonString.UTF8String));
+    @synchronized(self) {
+      [_tasks removeObjectForKey:socketID];
+    }
+  }
+}
+
+- (void)URLSession:(NSURLSession *)session task:(NSURLSessionTask *)task didCompleteWithError:(NSError *)error
+{
+  NSNumber *socketID = [self socketIDForTask:task];
+  if (socketID && error) {
+    _emit(
+        "websocketFailed",
+        folly::dynamic::object("id", socketID.intValue)("message", error.localizedDescription.UTF8String));
+    @synchronized(self) {
+      [_tasks removeObjectForKey:socketID];
+    }
+  }
+}
+
+@end

package/macos/host/OneMacosWorklets.cpp

@@ -0,0 +1,139 @@
+#include "OneMacosWorklets.h"
+
+#include <dispatch/dispatch.h>
+#include <pthread.h>
+
+#include <worklets/NativeModules/WorkletsModuleProxyInitializer.h>
+#include <worklets/Tools/JSScheduler.h>
+#include <worklets/Tools/RNRuntimeStatus.h>
+#include <worklets/Tools/UIScheduler.h>
+#include <worklets/WorkletRuntime/RuntimeBindings.h>
+
+#include <unordered_map>
+
+namespace facebook::react {
+
+namespace {
+
+// this file is plain c++, so queue work through dispatch_async_f instead of blocks
+void dispatchAsync(dispatch_queue_t queue, std::function<void()> job)
+{
+  dispatch_async_f(queue, new std::function<void()>(std::move(job)), [](void *context) {
+    std::unique_ptr<std::function<void()>> job(static_cast<std::function<void()> *>(context));
+    (*job)();
+  });
+}
+
+class MainQueueUIScheduler : public worklets::UIScheduler,
+                             public std::enable_shared_from_this<MainQueueUIScheduler> {
+ public:
+  void scheduleOnUI(std::function<void()> job) override
+  {
+    if (isOnUIThread()) {
+      job();
+      return;
+    }
+
+    UIScheduler::scheduleOnUI(job);
+
+    if (!scheduledOnUI_) {
+      dispatchAsync(dispatch_get_main_queue(), [weakThis = weak_from_this()] {
+        if (auto strongThis = weakThis.lock()) {
+          strongThis->triggerUI();
+        }
+      });
+    }
+  }
+
+ protected:
+  bool queryIsOnUIThread() const override
+  {
+    return pthread_main_np() != 0;
+  }
+};
+
+jsi::Value nativeLog(jsi::Runtime &rt, const jsi::Value &, const jsi::Value *args, size_t count)
+{
+  if (count != 2) {
+    throw std::invalid_argument("nativeLoggingHook takes 2 arguments");
+  }
+  auto message = args[0].asString(rt).utf8(rt);
+  fprintf(stderr, "[one-macos] worklets log(%u): %s\n", static_cast<unsigned>(args[1].asNumber()), message.c_str());
+  return jsi::Value::undefined();
+}
+
+class WorkletsModule : public TurboModule {
+ public:
+  WorkletsModule(jsi::Runtime &runtime, std::shared_ptr<CallInvoker> jsInvoker, std::function<bool()> isJavaScriptQueue)
+      : TurboModule("WorkletsModule", jsInvoker), runtime_(runtime)
+  {
+    auto jsScheduler = std::make_shared<worklets::JSScheduler>(runtime, jsInvoker, std::move(isJavaScriptQueue));
+    auto uiScheduler = std::make_shared<MainQueueUIScheduler>();
+    rnRuntimeStatus_ = std::make_shared<worklets::RNRuntimeStatus>();
+    auto bindings = std::make_shared<worklets::RuntimeBindings>(worklets::RuntimeBindings{
+        .requestAnimationFrame = [](std::function<void(const double)> callback) { OneMacosRequestAnimationFrame(std::move(callback)); },
+        .nativeLoggingHook = nativeLog,
+        .networkingBackend = OneMacosMakeWorkletsNetworkingBackend()});
+    initializer_ =
+        std::make_shared<worklets::WorkletsModuleProxyInitializer>(jsScheduler, uiScheduler, bindings, rnRuntimeStatus_);
+
+    auto initializer = initializer_;
+    dispatchAsync(dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0), [initializer] { initializer->prepareProxy(); });
+  }
+
+  ~WorkletsModule() override
+  {
+    OneMacosInvalidateAnimationFrames();
+    rnRuntimeStatus_->setDead();
+    initializer_->invalidate();
+  }
+
+  jsi::Value create(jsi::Runtime &rt, const jsi::PropNameID &propName) override
+  {
+    auto name = propName.utf8(rt);
+    if (name == "installTurboModule") {
+      return method(rt, propName, 1, [this](jsi::Runtime &, const jsi::Value *args, size_t count) {
+        bool bundleMode = count > 0 && args[0].isBool() && args[0].getBool();
+        proxy_ = initializer_->finalize(runtime_, bundleMode, [] { return worklets::BundleModeConfig{}; });
+        return jsi::Value(true);
+      });
+    }
+    if (name == "start") {
+      return method(rt, propName, 0, [this](jsi::Runtime &, const jsi::Value *, size_t) {
+        proxy_->start();
+        return jsi::Value(true);
+      });
+    }
+    if (name == "prepareBundleMode") {
+      return method(rt, propName, 0, [](jsi::Runtime &, const jsi::Value *, size_t) { return jsi::Value(true); });
+    }
+    return jsi::Value::undefined();
+  }
+
+ private:
+  template <typename Fn>
+  static jsi::Value method(jsi::Runtime &rt, const jsi::PropNameID &name, unsigned argCount, Fn fn)
+  {
+    return jsi::Function::createFromHostFunction(
+        rt, name, argCount, [fn](jsi::Runtime &r, const jsi::Value &, const jsi::Value *args, size_t count) {
+          return fn(r, args, count);
+        });
+  }
+
+  jsi::Runtime &runtime_;
+  std::shared_ptr<worklets::RNRuntimeStatus> rnRuntimeStatus_;
+  std::shared_ptr<worklets::WorkletsModuleProxyInitializer> initializer_;
+  std::shared_ptr<worklets::WorkletsModuleProxy> proxy_;
+};
+
+} // namespace
+
+std::shared_ptr<TurboModule> OneMacosCreateWorkletsModule(
+    jsi::Runtime &runtime,
+    std::shared_ptr<CallInvoker> jsInvoker,
+    std::function<bool()> isJavaScriptQueue)
+{
+  return std::make_shared<WorkletsModule>(runtime, std::move(jsInvoker), std::move(isJavaScriptQueue));
+}
+
+} // namespace facebook::react

package/macos/host/OneMacosWorklets.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <ReactCommon/CallInvoker.h>
+#include <ReactCommon/TurboModule.h>
+#include <jsi/jsi.h>
+
+#include <functional>
+#include <memory>
+
+namespace worklets {
+class NetworkingBackend;
+}
+
+namespace facebook::react {
+
+// The WorkletsModule TurboModule: owns react-native-worklets' native proxy and
+// installs it on the main runtime. Worklet runtimes run on Hermes.
+std::shared_ptr<TurboModule> OneMacosCreateWorkletsModule(
+    jsi::Runtime &runtime,
+    std::shared_ptr<CallInvoker> jsInvoker,
+    std::function<bool()> isJavaScriptQueue);
+
+} // namespace facebook::react
+
+// platform pieces in OneMacosWorkletsPlatform.mm
+std::shared_ptr<worklets::NetworkingBackend> OneMacosMakeWorkletsNetworkingBackend();
+// calls back on the main thread with the target timestamp of the next frame, in ms
+void OneMacosRequestAnimationFrame(std::function<void(double)> callback);
+void OneMacosInvalidateAnimationFrames();

package/macos/host/OneMacosWorkletsPlatform.mm

@@ -0,0 +1,88 @@
+#import <AppKit/AppKit.h>
+#import <QuartzCore/QuartzCore.h>
+
+#include <worklets/apple/Networking/AppleNetworkingBackend.h>
+
+#include <mutex>
+#include <vector>
+
+#import "OneMacosWorklets.h"
+
+// requestAnimationFrame for worklet runtimes: a display link that runs only
+// while callbacks are pending, on the main run loop
+@interface OneMacosAnimationFrames : NSObject
++ (instancetype)shared;
+- (void)request:(std::function<void(double)>)callback;
+- (void)invalidate;
+@end
+
+@implementation OneMacosAnimationFrames {
+  CADisplayLink *_link;
+  std::vector<std::function<void(double)>> _callbacks;
+  std::mutex _mutex;
+}
+
++ (instancetype)shared
+{
+  static OneMacosAnimationFrames *frames;
+  static dispatch_once_t once;
+  dispatch_once(&once, ^{
+    frames = [OneMacosAnimationFrames new];
+  });
+  return frames;
+}
+
+- (void)request:(std::function<void(double)>)callback
+{
+  {
+    std::lock_guard<std::mutex> lock(_mutex);
+    _callbacks.push_back(std::move(callback));
+  }
+  dispatch_async(dispatch_get_main_queue(), ^{
+    if (!self->_link) {
+      self->_link = [NSScreen.mainScreen displayLinkWithTarget:self selector:@selector(frame:)];
+      [self->_link addToRunLoop:NSRunLoop.mainRunLoop forMode:NSRunLoopCommonModes];
+    }
+    self->_link.paused = NO;
+  });
+}
+
+- (void)frame:(CADisplayLink *)link
+{
+  std::vector<std::function<void(double)>> callbacks;
+  {
+    std::lock_guard<std::mutex> lock(_mutex);
+    callbacks = std::move(_callbacks);
+    _callbacks.clear();
+  }
+  link.paused = YES;
+  double timestamp = link.targetTimestamp * 1000;
+  for (auto &callback : callbacks) {
+    callback(timestamp);
+  }
+}
+
+- (void)invalidate
+{
+  dispatch_async(dispatch_get_main_queue(), ^{
+    [self->_link invalidate];
+    self->_link = nil;
+  });
+}
+
+@end
+
+std::shared_ptr<worklets::NetworkingBackend> OneMacosMakeWorkletsNetworkingBackend()
+{
+  return std::make_shared<worklets::AppleNetworkingBackend>();
+}
+
+void OneMacosRequestAnimationFrame(std::function<void(double)> callback)
+{
+  [[OneMacosAnimationFrames shared] request:std::move(callback)];
+}
+
+void OneMacosInvalidateAnimationFrames()
+{
+  [[OneMacosAnimationFrames shared] invalidate];
+}

package/macos/host/swift/OneMacControls.swift

@@ -0,0 +1,155 @@
+import AppKit
+
+@objc(OneMacButtonHostView)
+final class OneMacButtonHostView: NSView, OneMacosButtonHosting {
+  private let button = NSButton(title: "", target: nil, action: nil)
+  @objc var onPress: (() -> Void)?
+  @objc var title = "" { didSet { button.title = title } }
+  @objc var systemImage = "" {
+    didSet {
+      button.image = systemImage.isEmpty ? nil : NSImage(systemSymbolName: systemImage, accessibilityDescription: nil)
+      button.imagePosition = title.isEmpty ? .imageOnly : .imageLeading
+    }
+  }
+  @objc var disabled = false { didSet { button.isEnabled = !disabled } }
+  @objc var bordered = true { didSet { button.isBordered = bordered } }
+  // the accent bezel of a dialog's confirming button. it takes no return key
+  // equivalent, so a caller that already handles return does not confirm twice.
+  @objc var prominent = false { didSet { button.bezelColor = prominent ? .controlAccentColor : nil } }
+
+  override init(frame: NSRect) {
+    super.init(frame: frame)
+    button.bezelStyle = .rounded
+    button.setButtonType(.momentaryPushIn)
+    button.target = self
+    button.action = #selector(press)
+    button.autoresizingMask = [.width, .height]
+    button.frame = bounds
+    addSubview(button)
+    setAccessibilityElement(false)
+  }
+
+  required init?(coder: NSCoder) { fatalError("init(coder:) has not been implemented") }
+
+  @objc private func press() {
+    guard !disabled else { return }
+    onPress?()
+  }
+
+  override func accessibilityPerformPress() -> Bool {
+    guard !disabled else { return false }
+    button.performClick(nil)
+    return true
+  }
+}
+
+@objc(OneMacSegmentedControlHostView)
+final class OneMacSegmentedControlHostView: NSView, OneMacosSegmentedControlHosting {
+  private let control = NSSegmentedControl()
+  private var controlled = OneNativeControlled(-1)
+  @objc var onChange: ((Int, Int, Int) -> Void)?
+  @objc var disabled = false { didSet { control.isEnabled = !disabled } }
+  @objc var controlRole = "automatic" {
+    didSet {
+      if #available(macOS 27.0, *) {
+        switch controlRole {
+        case "tabs": control.role = .tabs
+        case "valueSelection": control.role = .valueSelection
+        default: control.role = .automatic
+        }
+        control.segmentStyle = controlRole == "automatic" ? .rounded : .automatic
+      }
+    }
+  }
+  @objc var labels: [String] = [] {
+    didSet {
+      control.segmentCount = labels.count
+      for (index, label) in labels.enumerated() {
+        control.setLabel(label, forSegment: index)
+      }
+      displayValue()
+    }
+  }
+
+  override init(frame: NSRect) {
+    super.init(frame: frame)
+    control.trackingMode = .selectOne
+    control.segmentStyle = .rounded
+    control.target = self
+    control.action = #selector(selectSegment)
+    control.autoresizingMask = [.width, .height]
+    control.frame = bounds
+    addSubview(control)
+    setAccessibilityElement(false)
+  }
+
+  required init?(coder: NSCoder) { fatalError("init(coder:) has not been implemented") }
+
+  private func displayValue() {
+    control.selectedSegment = labels.indices.contains(controlled.value) ? controlled.value : -1
+  }
+
+  @objc func applyValue(_ value: Int, acknowledged: Int, revision: Int) {
+    if let next = controlled.applying(value, acknowledged: acknowledged, revision: revision) {
+      controlled = next
+    }
+    displayValue()
+  }
+
+  @objc private func selectSegment() {
+    guard !disabled, labels.indices.contains(control.selectedSegment) else { return }
+    guard controlled.change(control.selectedSegment) else { return }
+    onChange?(controlled.value, controlled.eventCount, controlled.revision)
+  }
+}
+
+@objc(OneMacPopUpButtonHostView)
+final class OneMacPopUpButtonHostView: NSView, OneMacosPopUpButtonHosting {
+  private let control = NSPopUpButton(frame: .zero, pullsDown: false)
+  private var controlled = OneNativeControlled(-1)
+  @objc var onChange: ((Int, Int, Int) -> Void)?
+  @objc var disabled = false { didSet { control.isEnabled = !disabled } }
+  @objc var labels: [String] = [] {
+    didSet {
+      control.removeAllItems()
+      // addItems(withTitles:) drops duplicate titles, so each item is added on its own
+      for label in labels {
+        control.addItem(withTitle: "")
+        control.lastItem?.title = label
+      }
+      displayValue()
+    }
+  }
+
+  override init(frame: NSRect) {
+    super.init(frame: frame)
+    control.target = self
+    control.action = #selector(selectItem)
+    control.autoresizingMask = [.width, .height]
+    control.frame = bounds
+    addSubview(control)
+    setAccessibilityElement(false)
+  }
+
+  required init?(coder: NSCoder) { fatalError("init(coder:) has not been implemented") }
+
+  private func displayValue() {
+    control.selectItem(at: labels.indices.contains(controlled.value) ? controlled.value : -1)
+  }
+
+  @objc func applyValue(_ value: Int, acknowledged: Int, revision: Int) {
+    if let next = controlled.applying(value, acknowledged: acknowledged, revision: revision) {
+      controlled = next
+    }
+    displayValue()
+  }
+
+  @objc private func selectItem() {
+    guard !disabled, labels.indices.contains(control.indexOfSelectedItem) else { return }
+    guard controlled.change(control.indexOfSelectedItem) else {
+      displayValue()
+      return
+    }
+    onChange?(controlled.value, controlled.eventCount, controlled.revision)
+  }
+}