one 2.10.0 → 2.11.1

package/macos/host/OneMacosModules.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "OneHostModules.h"
+
+// format for js console text in the unified log: readable in Debug builds,
+// redacted in Release so app logs never persist tokens or credentialed urls
+#if DEBUG
+#define ONE_MACOS_JS_TEXT "%{public}s"
+#else
+#define ONE_MACOS_JS_TEXT "%{private}s"
+#endif
+
+namespace facebook::react {
+
+// NativeAnimatedModule on RN's C++ animated renderer, frames from a display link
+std::shared_ptr<TurboModule> OneMacosCreateAnimatedModule(std::shared_ptr<CallInvoker> jsInvoker);
+
+// Returns nullptr for modules the host does not provide.
+std::shared_ptr<TurboModule> OneMacosCreateTurboModule(
+    jsi::Runtime &runtime,
+    const std::string &name,
+    std::shared_ptr<CallInvoker> jsInvoker,
+    const OneHostModuleContext &context);
+
+} // namespace facebook::react
+
+#ifdef __OBJC__
+#import <AppKit/AppKit.h>
+
+// "light" or "dark", the value of the Appearance module's color scheme
+NSString *OneMacosColorSchemeName(NSAppearance *appearance);
+#endif

package/macos/host/OneMacosModules.mm

@@ -0,0 +1,287 @@
+#import <os/log.h>
+#import <AppKit/AppKit.h>
+
+#include <chrono>
+
+#include <folly/json.h>
+#include <jsi/JSIDynamic.h>
+
+#include <CallInvokerDispatcher.hpp>
+#include <InstallNitro.hpp>
+
+#import "OneMacosModules.h"
+#import "OneMacosOpSqlite.h"
+#import "OneMacosWebSocket.h"
+#import "OneMacosNetworking.h"
+#import "OneMacosWorklets.h"
+
+namespace facebook::react {
+
+namespace {
+// urls open in the default app through NSWorkspace; the app has no initial url
+std::shared_ptr<OneHostModule> linkingManager(std::shared_ptr<CallInvoker> invoker)
+{
+  auto module = std::make_shared<OneHostModule>("LinkingManager", std::move(invoker));
+  module->method("getInitialURL", 0, [](jsi::Runtime &rt, const jsi::Value *, size_t) {
+    return resolvedPromise(rt, jsi::Value::null());
+  });
+  module->method("canOpenURL", 1, [](jsi::Runtime &rt, const jsi::Value *args, size_t count) {
+    NSURL *url = [NSURL URLWithString:@(stringArg(rt, args, count, 0).c_str())];
+    return resolvedPromise(rt, jsi::Value(url != nil && [NSWorkspace.sharedWorkspace URLForApplicationToOpenURL:url] != nil));
+  });
+  module->method("openURL", 1, [](jsi::Runtime &rt, const jsi::Value *args, size_t count) {
+    NSURL *url = [NSURL URLWithString:@(stringArg(rt, args, count, 0).c_str())];
+    bool opened = url != nil && [NSWorkspace.sharedWorkspace openURL:url];
+    return resolvedPromise(rt, jsi::Value(opened));
+  });
+  module->method("openSettings", 0, [](jsi::Runtime &rt, const jsi::Value *, size_t) {
+    NSURL *url = [NSURL URLWithString:@"x-apple.systempreferences:"];
+    return resolvedPromise(rt, jsi::Value([NSWorkspace.sharedWorkspace openURL:url]));
+  });
+  module->noop("addListener");
+  module->noop("removeListeners");
+  return module;
+}
+
+// image loading is not provided on macOS yet, so every request rejects
+std::shared_ptr<OneHostModule> imageLoader(std::shared_ptr<CallInvoker> invoker)
+{
+  auto module = std::make_shared<OneHostModule>("ImageLoader", std::move(invoker));
+  for (const char *name : {"getSize", "getSizeWithHeaders", "prefetchImage", "prefetchImageWithMetadata", "queryCache"}) {
+    module->method(name, 0, [name](jsi::Runtime &rt, const jsi::Value *, size_t) {
+      auto reject = rt.global().getPropertyAsObject(rt, "Promise").getPropertyAsFunction(rt, "reject");
+      return reject.call(rt, jsi::String::createFromUtf8(rt, std::string("ImageLoader.") + name + " is not available on macOS"));
+    });
+  }
+  return module;
+}
+
+std::shared_ptr<OneHostModule> webSocket(std::shared_ptr<CallInvoker> invoker, const OneHostModuleContext &context)
+{
+  auto module = std::make_shared<OneHostModule>("WebSocketModule", std::move(invoker));
+  auto emit = context.emitDeviceEvent;
+  OneMacosWebSocketManager *manager = [[OneMacosWebSocketManager alloc]
+      initWithEmitter:[emit](const std::string &name, folly::dynamic payload) { emit(name, std::move(payload)); }];
+
+  module->method("connect", 4, [manager](jsi::Runtime &rt, const jsi::Value *args, size_t count) {
+    NSURL *url = [NSURL URLWithString:@(stringArg(rt, args, count, 0).c_str())];
+    NSMutableArray<NSString *> *protocols = [NSMutableArray new];
+    if (count > 1 && args[1].isObject() && args[1].getObject(rt).isArray(rt)) {
+      auto list = args[1].getObject(rt).getArray(rt);
+      for (size_t i = 0; i < list.size(rt); i++) {
+        [protocols addObject:@(list.getValueAtIndex(rt, i).getString(rt).utf8(rt).c_str())];
+      }
+    }
+    [manager connect:url protocols:protocols socketID:(NSInteger)numberArg(args, count, 3)];
+    return jsi::Value::undefined();
+  });
+  module->method("send", 2, [manager](jsi::Runtime &rt, const jsi::Value *args, size_t count) {
+    [manager sendText:@(stringArg(rt, args, count, 0).c_str()) socketID:(NSInteger)numberArg(args, count, 1)];
+    return jsi::Value::undefined();
+  });
+  module->method("sendBinary", 2, [manager](jsi::Runtime &rt, const jsi::Value *args, size_t count) {
+    [manager sendBase64:@(stringArg(rt, args, count, 0).c_str()) socketID:(NSInteger)numberArg(args, count, 1)];
+    return jsi::Value::undefined();
+  });
+  module->method("ping", 1, [manager](jsi::Runtime &, const jsi::Value *args, size_t count) {
+    [manager ping:(NSInteger)numberArg(args, count, 0)];
+    return jsi::Value::undefined();
+  });
+  module->method("close", 3, [manager](jsi::Runtime &rt, const jsi::Value *args, size_t count) {
+    [manager close:(NSInteger)numberArg(args, count, 2)
+              code:(NSInteger)numberArg(args, count, 0)
+            reason:@(stringArg(rt, args, count, 1).c_str())];
+    return jsi::Value::undefined();
+  });
+  addEventEmitterStubs(*module);
+  return module;
+}
+
+// the global owns the store for exactly this runtime; module callbacks may also
+// retain it until their in-flight work is cancelled during runtime teardown.
+class OneMacosBlobStoreHolder : public jsi::HostObject {
+ public:
+  OneMacosBlobStore *store = [OneMacosBlobStore new];
+};
+
+class OneMacosBlobCollector : public jsi::HostObject {
+ public:
+  OneMacosBlobCollector(OneMacosBlobStore *store, NSString *identifier) : store_(store), identifier_(identifier) {}
+  ~OneMacosBlobCollector() override { [store_ remove:identifier_]; }
+ private:
+  OneMacosBlobStore *store_;
+  NSString *identifier_;
+};
+
+OneMacosBlobStore *runtimeBlobStore(jsi::Runtime &rt)
+{
+  constexpr const char *key = "__oneMacosBlobStore";
+  auto value = rt.global().getProperty(rt, key);
+  if (!value.isUndefined()) return value.getObject(rt).getHostObject<OneMacosBlobStoreHolder>(rt)->store;
+  auto holder = std::make_shared<OneMacosBlobStoreHolder>();
+  rt.global().setProperty(rt, key, jsi::Object::createFromHostObject(rt, holder));
+  return holder->store;
+}
+
+id nativeJSON(jsi::Runtime &rt, const jsi::Value &value)
+{
+  auto json = folly::toJson(jsi::dynamicFromValue(rt, value));
+  return [NSJSONSerialization JSONObjectWithData:[NSData dataWithBytes:json.data() length:json.size()]
+                                      options:NSJSONReadingFragmentsAllowed error:nil];
+}
+
+std::shared_ptr<TurboModule> networking(jsi::Runtime &runtime, std::shared_ptr<CallInvoker> jsInvoker, const OneHostModuleContext &context)
+{
+  auto module = std::make_shared<OneHostModule>("Networking", std::move(jsInvoker));
+  addEventEmitterStubs(*module);
+  OneMacosNetworking *manager = [[OneMacosNetworking alloc] initWithEmitter:context.emitDeviceEvent blobStore:runtimeBlobStore(runtime)];
+  module->method("sendRequest", 2, [manager](jsi::Runtime &rt, const jsi::Value *args, size_t count) {
+    if (count < 2) throw jsi::JSError(rt, "Networking.sendRequest requires a query and callback");
+    NSDictionary *query = nativeJSON(rt, args[0]);
+    NSInteger requestID = [manager nextRequestID];
+    args[1].getObject(rt).getFunction(rt).call(rt, (double)requestID);
+    [manager sendRequest:query requestID:requestID];
+    return jsi::Value::undefined();
+  });
+  module->method("abortRequest", 1, [manager](jsi::Runtime &, const jsi::Value *args, size_t count) {
+    [manager abortRequest:(NSInteger)numberArg(args, count, 0)];
+    return jsi::Value::undefined();
+  });
+  module->method("clearCookies", 1, [manager](jsi::Runtime &rt, const jsi::Value *args, size_t count) {
+    BOOL cleared = [manager clearCookies];
+    if (count) args[0].getObject(rt).getFunction(rt).call(rt, (bool)cleared);
+    return jsi::Value::undefined();
+  });
+  return module;
+}
+
+std::shared_ptr<TurboModule> blobModule(jsi::Runtime &runtime, std::shared_ptr<CallInvoker> jsInvoker)
+{
+  auto module = std::make_shared<OneHostModule>("BlobModule", std::move(jsInvoker));
+  module->constants(folly::dynamic::object("BLOB_URI_SCHEME", "blob")("BLOB_URI_HOST", nullptr));
+  module->noop("addNetworkingHandler");
+  module->noop("addWebSocketHandler");
+  module->noop("removeWebSocketHandler");
+  OneMacosBlobStore *store = runtimeBlobStore(runtime);
+  runtime.global().setProperty(runtime, "__blobCollectorProvider", jsi::Function::createFromHostFunction(
+      runtime, jsi::PropNameID::forAscii(runtime, "__blobCollectorProvider"), 1,
+      [store](jsi::Runtime &rt, const jsi::Value &, const jsi::Value *args, size_t count) -> jsi::Value {
+        NSString *identifier = @(stringArg(rt, args, count, 0).c_str());
+        return jsi::Object::createFromHostObject(rt, std::make_shared<OneMacosBlobCollector>(store, identifier));
+      }));
+  module->method("sendOverSocket", 2, [](jsi::Runtime &rt, const jsi::Value *, size_t) -> jsi::Value {
+    throw jsi::JSError(rt, "Sending blobs over WebSocket is not supported by the macOS host");
+  });
+  module->method("createFromParts", 2, [store](jsi::Runtime &rt, const jsi::Value *args, size_t count) {
+    if (count < 2 || ![store createFromParts:nativeJSON(rt, args[0]) identifier:@(stringArg(rt, args, count, 1).c_str())]) {
+      throw jsi::JSError(rt, "Unable to resolve blob parts");
+    }
+    return jsi::Value::undefined();
+  });
+  module->method("release", 1, [store](jsi::Runtime &rt, const jsi::Value *args, size_t count) {
+    [store remove:@(stringArg(rt, args, count, 0).c_str())];
+    return jsi::Value::undefined();
+  });
+  return module;
+}
+
+std::shared_ptr<TurboModule> fileReaderModule(jsi::Runtime &runtime, std::shared_ptr<CallInvoker> jsInvoker)
+{
+  auto module = std::make_shared<OneHostModule>("FileReaderModule", std::move(jsInvoker));
+  OneMacosBlobStore *store = runtimeBlobStore(runtime);
+  for (const auto &name : {"readAsText", "readAsDataURL"}) {
+    bool asText = std::string(name) == "readAsText";
+    module->method(name, asText ? 2 : 1, [store, asText](jsi::Runtime &rt, const jsi::Value *args, size_t count) {
+      NSDictionary *blob = count ? nativeJSON(rt, args[0]) : nil;
+      NSData *bytes = [store resolve:blob];
+      NSString *text = nil;
+      if (bytes && asText) {
+        NSString *charset = @(stringArg(rt, args, count, 1).c_str());
+        CFStringEncoding encoding = charset.length ? CFStringConvertIANACharSetNameToEncoding((__bridge CFStringRef)charset) : kCFStringEncodingUTF8;
+        if (encoding != kCFStringEncodingInvalidId) {
+          text = [[NSString alloc] initWithData:bytes encoding:CFStringConvertEncodingToNSStringEncoding(encoding)];
+        }
+      } else if (bytes) {
+        NSString *type = [blob[@"type"] isKindOfClass:NSString.class] && [blob[@"type"] length] ? blob[@"type"] : @"application/octet-stream";
+        text = [NSString stringWithFormat:@"data:%@;base64,%@", type, [bytes base64EncodedStringWithOptions:0]];
+      }
+      auto promise = rt.global().getPropertyAsObject(rt, "Promise");
+      if (!text) {
+        auto error = rt.global().getPropertyAsFunction(rt, "Error").callAsConstructor(rt, "Unable to read blob data or encoding");
+        return promise.getPropertyAsFunction(rt, "reject").callWithThis(rt, promise, error);
+      }
+      auto value = jsi::String::createFromUtf8(rt, std::string(text.UTF8String, [text lengthOfBytesUsingEncoding:NSUTF8StringEncoding]));
+      return promise.getPropertyAsFunction(rt, "resolve").callWithThis(rt, promise, value);
+    });
+  }
+  return module;
+}
+
+
+} // namespace
+
+// installs global.NitroModulesProxy; no hybrid objects are registered here, so
+// services that One's native build provides fail at createHybridObject
+std::shared_ptr<TurboModule> nitro(std::shared_ptr<CallInvoker> jsInvoker)
+{
+  auto module = std::make_shared<OneHostModule>("NitroModules", jsInvoker);
+  module->method("install", 0, [jsInvoker](jsi::Runtime &rt, const jsi::Value *, size_t) -> jsi::Value {
+    try {
+      margelo::nitro::install(rt, std::make_shared<margelo::nitro::CallInvokerDispatcher>(jsInvoker));
+    } catch (const std::exception &error) {
+      return jsi::String::createFromUtf8(rt, error.what());
+    }
+    return jsi::Value::null();
+  });
+  return module;
+}
+
+std::shared_ptr<TurboModule> OneMacosCreateTurboModule(
+    jsi::Runtime &runtime,
+    const std::string &name,
+    std::shared_ptr<CallInvoker> jsInvoker,
+    const OneHostModuleContext &context)
+{
+  if (name == "Networking") {
+    return networking(runtime, std::move(jsInvoker), context);
+  }
+  if (name == "BlobModule") {
+    return blobModule(runtime, std::move(jsInvoker));
+  }
+  if (name == "FileReaderModule") {
+    return fileReaderModule(runtime, std::move(jsInvoker));
+  }
+  if (name == "OneMacAppCommands") {
+    return OneHostCreateAppCommandsModule(name, std::move(jsInvoker), context);
+  }
+  if (name == "NativeAnimatedModule") {
+    return OneMacosCreateAnimatedModule(std::move(jsInvoker));
+  }
+  if (name == "NitroModules") {
+    return nitro(std::move(jsInvoker));
+  }
+  if (name == "WorkletsModule") {
+    return OneMacosCreateWorkletsModule(runtime, std::move(jsInvoker), context.isJavaScriptQueue);
+  }
+  if (name == "WebSocketModule") {
+    return webSocket(std::move(jsInvoker), context);
+  }
+  if (name == "OPSQLite") {
+    return OneMacosCreateOpSqliteModule(runtime, std::move(jsInvoker));
+  }
+  if (name == "LinkingManager") {
+    return linkingManager(std::move(jsInvoker));
+  }
+  if (name == "ImageLoader") {
+    return imageLoader(std::move(jsInvoker));
+  }
+  return OneHostCreateTurboModule(name, std::move(jsInvoker), context);
+}
+
+} // namespace facebook::react
+
+NSString *OneMacosColorSchemeName(NSAppearance *appearance)
+{
+  NSAppearanceName match = [appearance bestMatchFromAppearancesWithNames:@[ NSAppearanceNameAqua, NSAppearanceNameDarkAqua ]];
+  return [match isEqualToString:NSAppearanceNameDarkAqua] ? @"dark" : @"light";
+}

package/macos/host/OneMacosMountingManager.h

@@ -0,0 +1,36 @@
+#import <AppKit/AppKit.h>
+
+#include <react/renderer/componentregistry/ComponentDescriptorProviderRegistry.h>
+#include <react/renderer/componentregistry/ComponentDescriptorRegistry.h>
+#include <react/renderer/mounting/MountingCoordinator.h>
+
+#import "OneMacosComponentView.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+// Applies Fabric mutations to AppKit views on the main thread. Component
+// descriptors and view classes register in one place so the two stay paired.
+@interface OneMacosMountingManager : NSObject
+
+- (void)setContextContainer:(std::shared_ptr<const facebook::react::ContextContainer>)contextContainer;
+
+- (void)setComponentDescriptorRegistry:(facebook::react::SharedComponentDescriptorRegistry)registry;
+- (void)synchronouslyUpdateViewOnTag:(facebook::react::Tag)tag props:(const folly::dynamic &)props;
+
++ (std::shared_ptr<facebook::react::ComponentDescriptorProviderRegistry>)componentDescriptorProviderRegistry;
++ (BOOL)hasComponentNamed:(const std::string &)name;
+
+- (void)attachSurface:(facebook::react::SurfaceId)surfaceId toView:(NSView *)view;
+- (void)detachSurface:(facebook::react::SurfaceId)surfaceId fromView:(NSView *)view;
+
+// safe from any thread; the work happens on the main thread
+- (void)scheduleTransaction:(std::shared_ptr<const facebook::react::MountingCoordinator>)mountingCoordinator;
+
+// native commands from JS refs, delivered to the view on the main thread
+- (void)dispatchCommandOnTag:(facebook::react::Tag)tag name:(const std::string &)name args:(const folly::dynamic &)args;
+
+- (nullable NSView<OneMacosComponentView> *)findComponentViewWithTag:(facebook::react::Tag)tag;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/macos/host/OneMacosMountingManager.mm

@@ -0,0 +1,285 @@
+#import "OneMacosMountingManager.h"
+
+#include <react/renderer/components/image/ImageComponentDescriptor.h>
+#include <react/renderer/components/iostextinput/TextInputComponentDescriptor.h>
+#include <react/renderer/components/root/RootComponentDescriptor.h>
+#include <react/renderer/components/scrollview/ScrollViewComponentDescriptor.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>
+#include <react/renderer/mounting/ShadowView.h>
+#include <react/renderer/mounting/ShadowViewMutation.h>
+
+#include <unordered_map>
+
+#include <OneMacButton/OneMacButtonComponentDescriptor.h>
+#include <OneMacImage/OneMacImageComponentDescriptor.h>
+#include <OneMacSegmentedControl/OneMacSegmentedControlComponentDescriptor.h>
+#include <OneMacPopUpButton/OneMacPopUpButtonComponentDescriptor.h>
+#include <OneMacToggle/OneMacToggleComponentDescriptor.h>
+
+#import "OneMacosImageComponentView.h"
+#import "OneMacosParagraphComponentView.h"
+#import "OneMacosScrollViewComponentView.h"
+#import "OneMacosTextInputComponentView.h"
+#import "OneMacosButtonComponentView.h"
+#import "OneMacosSymbolImageComponentView.h"
+#import "OneMacosSegmentedControlComponentView.h"
+#import "OneMacosPopUpButtonComponentView.h"
+#import "OneMacosToggleComponentView.h"
+
+using namespace facebook::react;
+
+namespace {
+
+// component descriptor and the AppKit class that paints it; Text and RawText
+// are virtual nodes with no view of their own
+struct ComponentEntry {
+  ComponentDescriptorProvider provider;
+  Class viewClass;
+};
+
+std::vector<ComponentEntry> &componentEntries()
+{
+  static std::vector<ComponentEntry> entries = {
+      {concreteComponentDescriptorProvider<RootComponentDescriptor>(), [OneMacosViewComponentView class]},
+      {concreteComponentDescriptorProvider<ViewComponentDescriptor>(), [OneMacosViewComponentView class]},
+      {concreteComponentDescriptorProvider<ImageComponentDescriptor>(), [OneMacosImageComponentView class]},
+      {concreteComponentDescriptorProvider<TextInputComponentDescriptor>(), [OneMacosTextInputComponentView class]},
+      {concreteComponentDescriptorProvider<ScrollViewComponentDescriptor>(),
+       [OneMacosScrollViewComponentView class]},
+      {concreteComponentDescriptorProvider<ParagraphComponentDescriptor>(),
+       [OneMacosParagraphComponentView class]},
+      {concreteComponentDescriptorProvider<TextComponentDescriptor>(), nil},
+      {concreteComponentDescriptorProvider<RawTextComponentDescriptor>(), nil},
+      {concreteComponentDescriptorProvider<OneMacImageComponentDescriptor>(), [OneMacosSymbolImageComponentView class]},
+      {concreteComponentDescriptorProvider<OneMacButtonComponentDescriptor>(), [OneMacosButtonComponentView class]},
+      {concreteComponentDescriptorProvider<OneMacSegmentedControlComponentDescriptor>(), [OneMacosSegmentedControlComponentView class]},
+      {concreteComponentDescriptorProvider<OneMacPopUpButtonComponentDescriptor>(), [OneMacosPopUpButtonComponentView class]},
+      {concreteComponentDescriptorProvider<OneMacToggleComponentDescriptor>(),
+       [OneMacosToggleComponentView class]},
+  };
+  return entries;
+}
+
+} // namespace
+
+@implementation OneMacosMountingManager {
+  NSMutableDictionary<NSNumber *, NSView<OneMacosComponentView> *> *_views;
+  std::shared_ptr<const ContextContainer> _contextContainer;
+  SharedComponentDescriptorRegistry _componentDescriptorRegistry;
+  std::unordered_map<Tag, ComponentHandle> _componentHandles;
+  SurfaceId _surfaceId;
+  BOOL _transactionInFlight;
+  BOOL _followUpTransactionRequired;
+}
+
++ (std::shared_ptr<ComponentDescriptorProviderRegistry>)componentDescriptorProviderRegistry
+{
+  auto registry = std::make_shared<ComponentDescriptorProviderRegistry>();
+  for (const auto &entry : componentEntries()) {
+    registry->add(entry.provider);
+  }
+  return registry;
+}
+
++ (BOOL)hasComponentNamed:(const std::string &)name
+{
+  for (const auto &entry : componentEntries()) {
+    if (name == entry.provider.name) {
+      return YES;
+    }
+  }
+  return NO;
+}
+
+- (instancetype)init
+{
+  if (self = [super init]) {
+    _views = [NSMutableDictionary new];
+  }
+  return self;
+}
+
+- (void)setContextContainer:(std::shared_ptr<const ContextContainer>)contextContainer
+{
+  _contextContainer = contextContainer;
+}
+
+- (void)setComponentDescriptorRegistry:(SharedComponentDescriptorRegistry)registry
+{
+  _componentDescriptorRegistry = std::move(registry);
+}
+
+- (void)synchronouslyUpdateViewOnTag:(Tag)tag props:(const folly::dynamic &)props
+{
+  NSAssert([NSThread isMainThread], @"native props update on the main thread");
+  OneMacosViewComponentView *view = (OneMacosViewComponentView *)_views[@(tag)];
+  auto handle = _componentHandles.find(tag);
+  if (!view || !view.props || handle == _componentHandles.end()) {
+    return; // an animation can finish after its target was removed
+  }
+  auto descriptor = _componentDescriptorRegistry->findComponentDescriptorByHandle_DO_NOT_USE_THIS_IS_BROKEN(handle->second);
+  if (!descriptor) {
+    return;
+  }
+  auto oldProps = view.props;
+  auto newProps = descriptor->cloneProps(PropsParserContext{_surfaceId, *_contextContainer}, oldProps, RawProps(props));
+  [view updateProps:newProps oldProps:oldProps];
+  [view finalizeUpdates:OneMacosUpdateMaskProps];
+}
+
+- (NSView<OneMacosComponentView> *)createViewForHandle:(ComponentHandle)handle tag:(Tag)tag
+{
+  Class viewClass = [OneMacosViewComponentView class];
+  for (const auto &entry : componentEntries()) {
+    if (entry.provider.handle == handle && entry.viewClass) {
+      viewClass = entry.viewClass;
+      break;
+    }
+  }
+  NSView<OneMacosComponentView> *view = [[viewClass alloc] initWithFrame:NSZeroRect];
+  view.reactTag = tag;
+  _views[@(tag)] = view;
+  _componentHandles[tag] = handle;
+  return view;
+}
+
+- (NSView<OneMacosComponentView> *)findComponentViewWithTag:(Tag)tag
+{
+  return _views[@(tag)];
+}
+
+- (void)attachSurface:(SurfaceId)surfaceId toView:(NSView *)view
+{
+  _surfaceId = surfaceId;
+  NSView *root = [self createViewForHandle:RootShadowNode::Handle() tag:surfaceId];
+  root.autoresizingMask = NSViewNotSizable;
+  [view addSubview:root];
+}
+
+- (void)detachSurface:(SurfaceId)surfaceId fromView:(NSView *)view
+{
+  NSView *root = _views[@(surfaceId)];
+  [root removeFromSuperview];
+  [_views removeObjectForKey:@(surfaceId)];
+  _componentHandles.erase(surfaceId);
+}
+
+- (void)dispatchCommandOnTag:(Tag)tag name:(const std::string &)name args:(const folly::dynamic &)args
+{
+  // the command outlives the call: copy what the block needs
+  std::string commandName = name;
+  folly::dynamic commandArgs = args;
+  dispatch_async(dispatch_get_main_queue(), ^{
+    NSView<OneMacosComponentView> *view = self->_views[@(tag)];
+    if ([view respondsToSelector:@selector(handleCommand:args:)]) {
+      [view handleCommand:commandName args:commandArgs];
+    }
+  });
+}
+
+- (void)scheduleTransaction:(std::shared_ptr<const MountingCoordinator>)mountingCoordinator
+{
+  if ([NSThread isMainThread]) {
+    [self initiateTransaction:*mountingCoordinator];
+    return;
+  }
+  dispatch_async(dispatch_get_main_queue(), ^{
+    [self initiateTransaction:*mountingCoordinator];
+  });
+}
+
+- (void)initiateTransaction:(const MountingCoordinator &)mountingCoordinator
+{
+  if (_transactionInFlight) {
+    _followUpTransactionRequired = YES;
+    return;
+  }
+  do {
+    _followUpTransactionRequired = NO;
+    _transactionInFlight = YES;
+    [self performTransaction:mountingCoordinator];
+    _transactionInFlight = NO;
+  } while (_followUpTransactionRequired);
+}
+
+- (void)performTransaction:(const MountingCoordinator &)mountingCoordinator
+{
+  mountingCoordinator.getTelemetryController().pullTransaction(
+      [&](const MountingTransaction &, const SurfaceTelemetry &) {},
+      [&](const MountingTransaction &transaction, const SurfaceTelemetry &) {
+        [self performMutations:transaction.getMutations()];
+      },
+      [&](const MountingTransaction &, const SurfaceTelemetry &) {});
+}
+
+- (void)performMutations:(const ShadowViewMutationList &)mutations
+{
+  for (const auto &mutation : mutations) {
+    switch (mutation.type) {
+      case ShadowViewMutation::Create: {
+        const auto &child = mutation.newChildShadowView;
+        [self createViewForHandle:child.componentHandle tag:child.tag];
+        break;
+      }
+
+      case ShadowViewMutation::Delete: {
+        [_views removeObjectForKey:@(mutation.oldChildShadowView.tag)];
+        _componentHandles.erase(mutation.oldChildShadowView.tag);
+        break;
+      }
+
+      case ShadowViewMutation::Insert: {
+        const auto &child = mutation.newChildShadowView;
+        NSView<OneMacosComponentView> *childView = _views[@(child.tag)];
+        NSView<OneMacosComponentView> *parentView = _views[@(mutation.parentTag)];
+        [childView updateProps:child.props oldProps:nullptr];
+        [childView updateEventEmitter:child.eventEmitter];
+        [childView updateState:child.state oldState:nullptr];
+        [childView updateLayoutMetrics:child.layoutMetrics oldLayoutMetrics:EmptyLayoutMetrics];
+        [childView finalizeUpdates:OneMacosUpdateMaskAll];
+        [parentView mountChildComponentView:childView index:mutation.index];
+        break;
+      }
+
+      case ShadowViewMutation::Remove: {
+        NSView<OneMacosComponentView> *childView = _views[@(mutation.oldChildShadowView.tag)];
+        NSView<OneMacosComponentView> *parentView = _views[@(mutation.parentTag)];
+        [parentView unmountChildComponentView:childView index:mutation.index];
+        break;
+      }
+
+      case ShadowViewMutation::Update: {
+        const auto &oldChild = mutation.oldChildShadowView;
+        const auto &newChild = mutation.newChildShadowView;
+        NSView<OneMacosComponentView> *childView = _views[@(newChild.tag)];
+        OneMacosUpdateMask mask = OneMacosUpdateMaskNone;
+
+        if (oldChild.props != newChild.props) {
+          [childView updateProps:newChild.props oldProps:oldChild.props];
+          mask |= OneMacosUpdateMaskProps;
+        }
+        if (oldChild.eventEmitter != newChild.eventEmitter) {
+          [childView updateEventEmitter:newChild.eventEmitter];
+          mask |= OneMacosUpdateMaskEventEmitter;
+        }
+        if (oldChild.state != newChild.state) {
+          [childView updateState:newChild.state oldState:oldChild.state];
+          mask |= OneMacosUpdateMaskState;
+        }
+        if (oldChild.layoutMetrics != newChild.layoutMetrics) {
+          [childView updateLayoutMetrics:newChild.layoutMetrics oldLayoutMetrics:oldChild.layoutMetrics];
+          mask |= OneMacosUpdateMaskLayoutMetrics;
+        }
+        if (mask != OneMacosUpdateMaskNone) {
+          [childView finalizeUpdates:mask];
+        }
+        break;
+      }
+    }
+  }
+}
+
+@end

package/macos/host/OneMacosNetworking.h

@@ -0,0 +1,13 @@
+#import <Foundation/Foundation.h>
+#include <folly/dynamic.h>
+#include <functional>
+#import "OneMacosBlobStore.h"
+
+@interface OneMacosNetworking : NSObject
+- (instancetype)initWithEmitter:(std::function<void(const std::string &, folly::dynamic)>)emitter blobStore:(OneMacosBlobStore *)blobStore;
+- (NSInteger)nextRequestID;
+- (void)sendRequest:(NSDictionary *)query requestID:(NSInteger)requestID;
+- (void)abortRequest:(NSInteger)requestID;
+- (BOOL)clearCookies;
+- (void)invalidate;
+@end