one 2.10.0 → 2.11.0

package/macos/host/OneMacosDebug.mm

@@ -0,0 +1,337 @@
+#import "OneMacosDebug.h"
+
+#include <signal.h>
+#include <folly/json.h>
+
+#include <react/renderer/components/view/AccessibilityProps.h>
+#include <react/renderer/components/view/ViewProps.h>
+
+#import "OneMacosComponentView.h"
+
+// DEBUG builds only. With ONE_MACOS_DEBUG_DIR set, the app drives itself for
+// screenshots and interaction proofs:
+//   SIGUSR1  writes snapshot-N.png
+//   SIGUSR2  runs the ops in $DIR/command.json, a list like
+//            [{"op": "click", "testId": "press-me", "wait": 0.3}, {"op": "snapshot", "name": "hover"}]
+// ops: snapshot, click, move, drag, scroll (deltaX/deltaY), key, type, tab, appearance, resize,
+// inspect, press, accessibilityPress, command, log. Points are `x`/`y` in the root view's top left space, or `testId` for the
+// center of a view.
+
+using namespace facebook::react;
+
+static NSView *OneMacosFindTestId(NSView *view, NSString *testId)
+{
+  if (![testId isKindOfClass:NSString.class] || testId.length == 0) {
+    return nil;
+  }
+  if ([view isKindOfClass:OneMacosViewComponentView.class]) {
+    auto props = ((OneMacosViewComponentView *)view).props;
+    if (props && static_cast<const ViewProps &>(*props).testId == testId.UTF8String) {
+      return view;
+    }
+  }
+  for (NSView *child in view.subviews) {
+    if (NSView *found = OneMacosFindTestId(child, testId)) {
+      return found;
+    }
+  }
+  return nil;
+}
+
+static NSString *OneMacosTestIdOf(NSResponder *responder)
+{
+  while (responder) {
+    if ([responder isKindOfClass:OneMacosViewComponentView.class]) {
+      auto props = ((OneMacosViewComponentView *)responder).props;
+      if (props && !static_cast<const ViewProps &>(*props).testId.empty()) {
+        return [NSString stringWithUTF8String:static_cast<const ViewProps &>(*props).testId.c_str()];
+      }
+    }
+    responder = responder.nextResponder;
+  }
+  return @"";
+}
+
+static void OneMacosWriteSnapshot(NSView *rootView, NSString *dir, NSString *name)
+{
+  NSView *content = rootView.window.contentView;
+  NSBitmapImageRep *rep = [content bitmapImageRepForCachingDisplayInRect:content.bounds];
+  [content cacheDisplayInRect:content.bounds toBitmapImageRep:rep];
+  static int count = 0;
+  NSString *label = name ?: [NSString stringWithFormat:@"%d", ++count];
+  NSString *path = [dir stringByAppendingFormat:@"/snapshot-%@.png", label];
+  [[rep representationUsingType:NSBitmapImageFileTypePNG properties:@{}] writeToFile:path atomically:YES];
+  NSLog(@"[one-macos] snapshot %@", path);
+}
+
+// op point -> root view space
+static BOOL OneMacosPoint(NSView *root, NSDictionary *op, NSString *xKey, NSString *yKey, NSPoint *out)
+{
+  NSString *testId = op[@"testId"];
+  if (testId && [xKey isEqualToString:@"x"]) {
+    NSView *view = OneMacosFindTestId(root, testId);
+    if (!view) {
+      NSLog(@"[one-macos] no view with testId %@", testId);
+      return NO;
+    }
+    NSPoint center = [root convertPoint:NSMakePoint(NSMidX(view.bounds), NSMidY(view.bounds)) fromView:view];
+    *out = NSMakePoint(center.x + [op[@"dx"] doubleValue], center.y + [op[@"dy"] doubleValue]);
+    return YES;
+  }
+  if (!op[xKey] || !op[yKey]) {
+    return NO;
+  }
+  *out = NSMakePoint([op[xKey] doubleValue], [op[yKey] doubleValue]);
+  return YES;
+}
+
+static NSEvent *OneMacosMouseEvent(NSView *root, NSEventType type, NSPoint rootPoint)
+{
+  NSWindow *window = root.window;
+  return [NSEvent mouseEventWithType:type
+                            location:[root convertPoint:rootPoint toView:nil]
+                       modifierFlags:0
+                           timestamp:NSProcessInfo.processInfo.systemUptime
+                        windowNumber:window.windowNumber
+                             context:nil
+                         eventNumber:0
+                          clickCount:1
+                            pressure:type == NSEventTypeLeftMouseUp ? 0 : 1];
+}
+
+static void OneMacosSendKey(NSView *root, NSString *characters, unsigned short keyCode, NSEventModifierFlags flags)
+{
+  NSWindow *window = root.window;
+  for (NSNumber *type in @[ @(NSEventTypeKeyDown), @(NSEventTypeKeyUp) ]) {
+    NSEvent *event = [NSEvent keyEventWithType:(NSEventType)type.integerValue
+                                      location:NSZeroPoint
+                                 modifierFlags:flags
+                                     timestamp:NSProcessInfo.processInfo.systemUptime
+                                  windowNumber:window.windowNumber
+                                       context:nil
+                                    characters:characters
+                   charactersIgnoringModifiers:characters
+                                     isARepeat:NO
+                                       keyCode:keyCode];
+    [window sendEvent:event];
+  }
+}
+
+static NSString *OneMacosCursorName(void)
+{
+  NSCursor *current = NSCursor.currentCursor;
+  NSDictionary<NSString *, NSCursor *> *cursors = @{
+    @"arrow" : NSCursor.arrowCursor,
+    @"pointingHand" : NSCursor.pointingHandCursor,
+    @"iBeam" : NSCursor.IBeamCursor,
+    @"crosshair" : NSCursor.crosshairCursor,
+    @"openHand" : NSCursor.openHandCursor,
+    @"notAllowed" : NSCursor.operationNotAllowedCursor,
+  };
+  for (NSString *name in cursors) {
+    if ([cursors[name].image isEqual:current.image] && NSEqualPoints(cursors[name].hotSpot, current.hotSpot)) {
+      return name;
+    }
+  }
+  return @"other";
+}
+
+static void OneMacosInspectSubviews(NSView *view, NSMutableArray *values)
+{
+  if ([view isKindOfClass:NSTextField.class]) {
+    [values addObject:@{ @"class": NSStringFromClass(view.class), @"text": ((NSTextField *)view).stringValue }];
+  } else if ([view isKindOfClass:NSTextView.class]) {
+    [values addObject:@{ @"class": NSStringFromClass(view.class), @"text": ((NSTextView *)view).string }];
+  } else if ([view isKindOfClass:NSScrollView.class]) {
+    NSScrollView *scroll = (NSScrollView *)view;
+    [values addObject:@{ @"class": NSStringFromClass(view.class), @"offset": NSStringFromPoint(scroll.contentView.bounds.origin),
+                        @"contentSize": NSStringFromSize(scroll.documentView.frame.size) }];
+  }
+  for (NSView *child in view.subviews) {
+    OneMacosInspectSubviews(child, values);
+  }
+}
+
+static void OneMacosRunOp(NSView *root, NSString *dir, NSDictionary *op)
+{
+  NSWindow *window = root.window;
+  NSString *name = op[@"op"];
+  NSPoint point;
+  if ([name isEqualToString:@"snapshot"]) {
+    OneMacosWriteSnapshot(root, dir, op[@"name"]);
+  } else if ([name isEqualToString:@"inspect"]) {
+    NSView *view = OneMacosFindTestId(root, op[@"testId"]);
+    if (!view) {
+      NSLog(@"[one-macos] inspect missing %@", op[@"testId"]);
+      return;
+    }
+    CATransform3D transform = view.layer.transform;
+    NSMutableDictionary *state = [@{
+      @"testId": op[@"testId"],
+      @"alpha": @(view.alphaValue),
+      @"translateX": @(transform.m41),
+      @"translateY": @(transform.m42),
+      @"frame": NSStringFromRect(view.frame),
+      @"frontmostPid": @(NSWorkspace.sharedWorkspace.frontmostApplication.processIdentifier),
+    } mutableCopy];
+    if ([view isKindOfClass:OneMacosViewComponentView.class]) {
+      auto props = ((OneMacosViewComponentView *)view).props;
+      if (props) {
+        state[@"propOpacity"] = @(static_cast<const ViewProps &>(*props).opacity);
+      }
+    }
+    NSMutableArray *values = [NSMutableArray new];
+    OneMacosInspectSubviews(view, values);
+    state[@"nativeSubviews"] = values;
+    NSData *data = [NSJSONSerialization dataWithJSONObject:state options:NSJSONWritingPrettyPrinted error:nil];
+    [data writeToFile:[dir stringByAppendingFormat:@"/inspect-%@.json", op[@"name"] ?: op[@"testId"]] atomically:YES];
+  } else if ([name isEqualToString:@"command"]) {
+    id<OneMacosComponentView> view = (id)OneMacosFindTestId(root, op[@"testId"]);
+    if ([view respondsToSelector:@selector(handleCommand:args:)]) {
+      NSData *args = [NSJSONSerialization dataWithJSONObject:op[@"args"] ?: @[] options:0 error:nil];
+      std::string json((const char *)args.bytes, args.length);
+      [view handleCommand:std::string([op[@"name"] UTF8String]) args:folly::parseJson(json)];
+    }
+  } else if ([name isEqualToString:@"accessibilityPress"]) {
+    NSView *view = OneMacosFindTestId(root, op[@"testId"]);
+    BOOL accepted = [view accessibilityPerformPress];
+    NSDictionary *result = @{ @"accepted": @(accepted), @"focusable": @(view.acceptsFirstResponder),
+                              @"appActive": @(NSApp.active), @"windowKey": @(window.keyWindow) };
+    NSData *data = [NSJSONSerialization dataWithJSONObject:result options:NSJSONWritingPrettyPrinted error:nil];
+    [data writeToFile:[dir stringByAppendingFormat:@"/axPress-%@.json", op[@"name"] ?: op[@"testId"]] atomically:YES];
+  } else if ([name isEqualToString:@"press"]) {
+    [(id<OneMacosPressTarget>)root oneMacosPressView:OneMacosFindTestId(root, op[@"testId"])];
+  } else if ([name isEqualToString:@"click"]) {
+    if (OneMacosPoint(root, op, @"x", @"y", &point)) {
+      NSEvent *down = OneMacosMouseEvent(root, NSEventTypeLeftMouseDown, point);
+      NSEvent *up = OneMacosMouseEvent(root, NSEventTypeLeftMouseUp, point);
+      [window sendEvent:down];
+      [window sendEvent:up];
+      NSLog(@"[one-macos] clicked %@ at %@", op[@"testId"] ?: @"", NSStringFromPoint(point));
+    }
+  } else if ([name isEqualToString:@"move"]) {
+    // tracking areas need real hardware events, so hand the move to the root directly
+    if (OneMacosPoint(root, op, @"x", @"y", &point)) {
+      [root mouseMoved:OneMacosMouseEvent(root, NSEventTypeMouseMoved, point)];
+      NSLog(@"[one-macos] moved to %@", NSStringFromPoint(point));
+    }
+  } else if ([name isEqualToString:@"drag"]) {
+    NSPoint from, to;
+    if (OneMacosPoint(root, op, @"x", @"y", &from) && op[@"toX"] && op[@"toY"]) {
+      to = NSMakePoint([op[@"toX"] doubleValue], [op[@"toY"] doubleValue]);
+      [window sendEvent:OneMacosMouseEvent(root, NSEventTypeLeftMouseDown, from)];
+      int steps = 8;
+      for (int step = 1; step <= steps; step++) {
+        NSPoint p = NSMakePoint(from.x + (to.x - from.x) * step / steps, from.y + (to.y - from.y) * step / steps);
+        [window sendEvent:OneMacosMouseEvent(root, NSEventTypeLeftMouseDragged, p)];
+      }
+      [window sendEvent:OneMacosMouseEvent(root, NSEventTypeLeftMouseUp, to)];
+    }
+  } else if ([name isEqualToString:@"scroll"]) {
+    if (OneMacosPoint(root, op, @"x", @"y", &point)) {
+      CGEventRef cg = CGEventCreateScrollWheelEvent2(
+          NULL, kCGScrollEventUnitPixel, 2, (int32_t)[op[@"deltaY"] doubleValue], (int32_t)[op[@"deltaX"] doubleValue], 0);
+      NSEvent *event = [NSEvent eventWithCGEvent:cg];
+      CFRelease(cg);
+      NSPoint inWindow = [root convertPoint:point toView:nil];
+      // the factory events carry no window, so deliver to the view under the point
+      NSView *hit = [window.contentView.superview hitTest:inWindow];
+      NSLog(@"[one-macos] scroll %@ over %@", op[@"deltaY"], hit.class);
+      [hit scrollWheel:event];
+    }
+  } else if ([name isEqualToString:@"key"]) {
+    NSDictionary<NSString *, NSArray *> *keys = @{
+      @"space" : @[ @" ", @49 ],
+      @"return" : @[ @"\r", @36 ],
+      @"tab" : @[ @"\t", @48 ],
+      @"escape" : @[ @"\e", @53 ],
+      @"delete" : @[ @"\x7f", @51 ],
+    };
+    NSArray *entry = keys[op[@"key"]];
+    NSEventModifierFlags flags = [op[@"shift"] boolValue] ? NSEventModifierFlagShift : 0;
+    if (entry) {
+      OneMacosSendKey(root, entry[0], (unsigned short)[entry[1] intValue], flags);
+    } else {
+      OneMacosSendKey(root, op[@"key"], 0, flags);
+    }
+    NSLog(@"[one-macos] key %@", op[@"key"]);
+  } else if ([name isEqualToString:@"type"]) {
+    NSString *text = op[@"text"];
+    for (NSUInteger i = 0; i < text.length; i++) {
+      OneMacosSendKey(root, [text substringWithRange:NSMakeRange(i, 1)], 0, 0);
+    }
+  } else if ([name isEqualToString:@"appearance"]) {
+    NSString *mode = op[@"mode"];
+    NSApp.appearance = [mode isEqualToString:@"system"]
+        ? nil
+        : [NSAppearance appearanceNamed:[mode isEqualToString:@"dark"] ? NSAppearanceNameDarkAqua : NSAppearanceNameAqua];
+    NSLog(@"[one-macos] appearance %@", mode);
+  } else if ([name isEqualToString:@"resize"]) {
+    [window setContentSize:NSMakeSize([op[@"width"] doubleValue], [op[@"height"] doubleValue])];
+    NSLog(@"[one-macos] resized to %@", NSStringFromSize(window.contentView.bounds.size));
+  } else if ([name isEqualToString:@"log"]) {
+    NSLog(@"[one-macos] state firstResponder=%@ testId=%@ cursor=%@",
+          window.firstResponder.class,
+          OneMacosTestIdOf(window.firstResponder),
+          OneMacosCursorName());
+  }
+}
+
+static void OneMacosRunCommands(NSView *root, NSString *dir)
+{
+  NSData *data = [NSData dataWithContentsOfFile:[dir stringByAppendingPathComponent:@"command.json"]];
+  NSArray<NSDictionary *> *ops = data ? [NSJSONSerialization JSONObjectWithData:data options:0 error:nil] : nil;
+  if (![ops isKindOfClass:NSArray.class]) {
+    NSLog(@"[one-macos] no commands in %@/command.json", dir);
+    return;
+  }
+
+  __block NSUInteger index = 0;
+  __weak NSView *weakRoot = root;
+  __block void (^step)(void);
+  step = ^{
+    NSView *strongRoot = weakRoot;
+    if (!strongRoot || index >= ops.count) {
+      step = nil;
+      return;
+    }
+    NSDictionary *op = ops[index++];
+    OneMacosRunOp(strongRoot, dir, op);
+    double wait = op[@"wait"] ? [op[@"wait"] doubleValue] : 0.3;
+    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(wait * NSEC_PER_SEC)), dispatch_get_main_queue(), step);
+  };
+  step();
+}
+
+static dispatch_source_t OneMacosSignalSource(int sig, dispatch_block_t handler)
+{
+  signal(sig, SIG_IGN);
+  dispatch_source_t source = dispatch_source_create(DISPATCH_SOURCE_TYPE_SIGNAL, sig, 0, dispatch_get_main_queue());
+  dispatch_source_set_event_handler(source, handler);
+  dispatch_resume(source);
+  return source;
+}
+
+void OneMacosInstallDebugHooks(NSView *rootView)
+{
+#if DEBUG
+  NSString *dir = NSProcessInfo.processInfo.environment[@"ONE_MACOS_DEBUG_DIR"];
+  if (dir.length == 0) {
+    return;
+  }
+  static NSArray *sources;
+  __weak NSView *weakView = rootView;
+  sources = @[
+    OneMacosSignalSource(SIGUSR1, ^{
+      if (weakView) {
+        OneMacosWriteSnapshot(weakView, dir, nil);
+      }
+    }),
+    OneMacosSignalSource(SIGUSR2, ^{
+      if (weakView) {
+        OneMacosRunCommands(weakView, dir);
+      }
+    }),
+  ];
+#endif
+}

package/macos/host/OneMacosImageComponentView.h

@@ -0,0 +1,6 @@
+#import "OneMacosComponentView.h"
+
+// Image: paints the NSImage an observer of the shadow node's image request
+// delivers, honoring resizeMode and tintColor.
+@interface OneMacosImageComponentView : OneMacosViewComponentView
+@end

package/macos/host/OneMacosImageComponentView.mm

@@ -0,0 +1,245 @@
+#import "OneMacosImageComponentView.h"
+
+#include <react/renderer/components/image/ImageEventEmitter.h>
+#include <react/renderer/components/image/ImageProps.h>
+#include <react/renderer/components/image/ImageShadowNode.h>
+#include <react/renderer/imagemanager/ImageResponseObserver.h>
+
+#import "OneMacosText.h"
+
+using namespace facebook::react;
+
+@class OneMacosImageComponentView;
+
+namespace {
+
+// observers are called from any thread; the view applies them on the main one
+class ImageObserver final : public ImageResponseObserver {
+ public:
+  explicit ImageObserver(OneMacosImageComponentView *view) : view_(view) {}
+  void didReceiveProgress(float progress, int64_t loaded, int64_t total) const override;
+  void didReceiveImage(const ImageResponse &imageResponse) const override;
+  void didReceiveFailure(const ImageLoadError &error) const override;
+
+ private:
+  __weak OneMacosImageComponentView *view_;
+};
+
+} // namespace
+
+@interface OneMacosImageComponentView ()
+- (void)applyImage:(NSImage *)image;
+- (void)applyProgress:(float)progress loaded:(int64_t)loaded total:(int64_t)total;
+- (void)applyFailure:(NSString *)message;
+@end
+
+void ImageObserver::didReceiveProgress(float progress, int64_t loaded, int64_t total) const
+{
+  OneMacosImageComponentView *view = view_;
+  dispatch_async(dispatch_get_main_queue(), ^{
+    [view applyProgress:progress loaded:loaded total:total];
+  });
+}
+
+void ImageObserver::didReceiveImage(const ImageResponse &imageResponse) const
+{
+  OneMacosImageComponentView *view = view_;
+  auto holder = imageResponse.getImage();
+  dispatch_async(dispatch_get_main_queue(), ^{
+    [view applyImage:(__bridge NSImage *)holder.get()];
+  });
+}
+
+void ImageObserver::didReceiveFailure(const ImageLoadError &error) const
+{
+  OneMacosImageComponentView *view = view_;
+  auto message = std::static_pointer_cast<std::string>(error.getError());
+  NSString *text = [NSString stringWithUTF8String:message ? message->c_str() : "image failed to load"];
+  dispatch_async(dispatch_get_main_queue(), ^{
+    [view applyFailure:text];
+  });
+}
+
+@implementation OneMacosImageComponentView {
+  ImageShadowNode::ConcreteState::Shared _state;
+  std::shared_ptr<const ImageObserver> _observer;
+  std::shared_ptr<const ImageResponseObserverCoordinator> _coordinator;
+  NSImage *_image;
+  NSImage *_tintedImage;
+}
+
+- (instancetype)initWithFrame:(NSRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    _observer = std::make_shared<const ImageObserver>(self);
+  }
+  return self;
+}
+
+- (void)dealloc
+{
+  if (_coordinator) {
+    _coordinator->removeObserver(_observer);
+  }
+}
+
+- (std::shared_ptr<const ImageEventEmitter>)imageEmitter
+{
+  return std::static_pointer_cast<const ImageEventEmitter>(self.eventEmitter);
+}
+
+#pragma mark - Updates
+
+- (void)updateProps:(const Props::Shared &)props oldProps:(const Props::Shared &)oldProps
+{
+  [super updateProps:props oldProps:oldProps];
+  _tintedImage = nil;
+}
+
+- (void)updateState:(const State::Shared &)state oldState:(const State::Shared &)oldState
+{
+  auto newState = std::static_pointer_cast<const ImageShadowNode::ConcreteState>(state);
+  auto oldImageState = std::static_pointer_cast<const ImageShadowNode::ConcreteState>(oldState);
+  BOOL sourceChanged = !oldImageState || oldImageState->getData().getImageSource() != newState->getData().getImageSource();
+  _state = newState;
+  if (!sourceChanged) {
+    return;
+  }
+  if (_coordinator) {
+    _coordinator->removeObserver(_observer);
+  }
+  _image = nil;
+  _tintedImage = nil;
+  [self setNeedsRender];
+
+  const auto &request = _state->getData().getImageRequest();
+  _coordinator = request.getSharedObserverCoordinator();
+  if (auto emitter = [self imageEmitter]) {
+    emitter->onLoadStart();
+  }
+  _coordinator->addObserver(_observer);
+}
+
+#pragma mark - Observer callbacks
+
+- (void)applyImage:(NSImage *)image
+{
+  _image = image;
+  _tintedImage = nil;
+  [self setNeedsRender];
+  if (auto emitter = [self imageEmitter]) {
+    ImageSource source = _state ? _state->getData().getImageSource() : ImageSource{};
+    CGFloat scale = source.scale > 0 ? source.scale : 1;
+    source.size = {(Float)(image.size.width / scale), (Float)(image.size.height / scale)};
+    emitter->onLoad(source);
+    emitter->onLoadEnd();
+  }
+}
+
+- (void)applyProgress:(float)progress loaded:(int64_t)loaded total:(int64_t)total
+{
+  if (auto emitter = [self imageEmitter]) {
+    emitter->onProgress(progress, loaded, total);
+  }
+}
+
+- (void)applyFailure:(NSString *)message
+{
+  if (auto emitter = [self imageEmitter]) {
+    ImageErrorInfo info;
+    info.error = message.UTF8String;
+    emitter->onError(info);
+    emitter->onLoadEnd();
+  }
+}
+
+#pragma mark - Painting
+
+- (NSImage *)paintedImage
+{
+  const auto &imageProps = static_cast<const ImageProps &>(*self.props);
+  if (!imageProps.tintColor || !*imageProps.tintColor) {
+    return _image;
+  }
+  if (!_tintedImage) {
+    NSColor *tint = OneMacosColorFromSharedColor(*imageProps.tintColor);
+    NSImage *source = _image;
+    _tintedImage = [NSImage imageWithSize:source.size
+                                  flipped:NO
+                           drawingHandler:^BOOL(NSRect rect) {
+                             [source drawInRect:rect];
+                             [tint set];
+                             NSRectFillUsingOperation(rect, NSCompositingOperationSourceIn);
+                             return YES;
+                           }];
+  }
+  return _tintedImage;
+}
+
+- (void)drawRect:(NSRect)dirtyRect
+{
+  [super drawRect:dirtyRect];
+  if (!_image || !self.props) {
+    return;
+  }
+  const auto &imageProps = static_cast<const ImageProps &>(*self.props);
+  NSImage *image = [self paintedImage];
+  NSSize natural = image.size;
+  CGFloat scale = _state && _state->getData().getImageSource().scale > 0 ? _state->getData().getImageSource().scale : 1;
+  NSSize size = NSMakeSize(natural.width / scale, natural.height / scale);
+  NSRect bounds = self.bounds;
+  if (size.width <= 0 || size.height <= 0 || bounds.size.width <= 0 || bounds.size.height <= 0) {
+    return;
+  }
+
+  const auto border = imageProps.resolveBorderMetrics(self.layoutMetrics);
+  CGFloat radius = MIN((CGFloat)border.borderRadii.topLeft.horizontal, MIN(bounds.size.width, bounds.size.height) / 2);
+  [NSGraphicsContext saveGraphicsState];
+  [[NSBezierPath bezierPathWithRoundedRect:bounds xRadius:radius yRadius:radius] addClip];
+
+  NSRect target = bounds;
+  switch (imageProps.resizeMode) {
+    case ImageResizeMode::Cover: {
+      CGFloat factor = MAX(bounds.size.width / size.width, bounds.size.height / size.height);
+      target = NSMakeRect(0, 0, size.width * factor, size.height * factor);
+      target.origin = NSMakePoint((bounds.size.width - target.size.width) / 2, (bounds.size.height - target.size.height) / 2);
+      break;
+    }
+    case ImageResizeMode::Contain: {
+      CGFloat factor = MIN(bounds.size.width / size.width, bounds.size.height / size.height);
+      target = NSMakeRect(0, 0, size.width * factor, size.height * factor);
+      target.origin = NSMakePoint((bounds.size.width - target.size.width) / 2, (bounds.size.height - target.size.height) / 2);
+      break;
+    }
+    case ImageResizeMode::Center:
+      target = NSMakeRect((bounds.size.width - size.width) / 2, (bounds.size.height - size.height) / 2, size.width, size.height);
+      break;
+    case ImageResizeMode::None:
+      target = NSMakeRect(0, 0, size.width, size.height);
+      break;
+    case ImageResizeMode::Repeat:
+      for (CGFloat y = 0; y < bounds.size.height; y += size.height) {
+        for (CGFloat x = 0; x < bounds.size.width; x += size.width) {
+          [image drawInRect:NSMakeRect(x, y, size.width, size.height)
+                   fromRect:NSZeroRect
+                  operation:NSCompositingOperationSourceOver
+                   fraction:1
+             respectFlipped:YES
+                      hints:nil];
+        }
+      }
+      [NSGraphicsContext restoreGraphicsState];
+      return;
+    case ImageResizeMode::Stretch:
+      break;
+  }
+  [image drawInRect:target
+           fromRect:NSZeroRect
+          operation:NSCompositingOperationSourceOver
+           fraction:1
+     respectFlipped:YES
+              hints:nil];
+  [NSGraphicsContext restoreGraphicsState];
+}
+
+@end

package/macos/host/OneMacosImageManager.mm

@@ -0,0 +1,91 @@
+#import <AppKit/AppKit.h>
+
+#include <react/renderer/imagemanager/ImageManager.h>
+#include <react/renderer/imagemanager/ImageResponse.h>
+#include <react/renderer/imagemanager/ImageTelemetry.h>
+
+using namespace facebook::react;
+
+// The host's ImageManager: loads http(s), file and data URIs through
+// NSURLSession and hands the decoded NSImage to the request's observers. The
+// cxx stub that ships with react-native is left out of the core build.
+
+ImageManager::ImageManager(const std::shared_ptr<const ContextContainer> &) {}
+
+ImageManager::~ImageManager() {}
+
+ImageRequest ImageManager::requestImage(
+    const ImageSource &imageSource, SurfaceId surfaceId, const ImageRequestParams &, Tag) const
+{
+  auto telemetry = std::make_shared<ImageTelemetry>(surfaceId);
+  if (imageSource.type == ImageSource::Type::Invalid || imageSource.uri.empty()) {
+    return {imageSource, telemetry, {}};
+  }
+
+  // the coordinator is created by the request, so the load closures reach it
+  // through a slot filled right after
+  auto coordinatorSlot = std::make_shared<std::weak_ptr<const ImageResponseObserverCoordinator>>();
+  auto task = std::make_shared<NSURLSessionDataTask *__strong>(nil);
+  NSURL *url = [NSURL URLWithString:[NSString stringWithUTF8String:imageSource.uri.c_str()]];
+  NSMutableURLRequest *urlRequest = url ? [NSMutableURLRequest requestWithURL:url] : nil;
+  if (urlRequest) {
+    if (!imageSource.method.empty()) {
+      urlRequest.HTTPMethod = [NSString stringWithUTF8String:imageSource.method.c_str()];
+    }
+    for (const auto &header : imageSource.headers) {
+      [urlRequest setValue:[NSString stringWithUTF8String:header.second.c_str()]
+          forHTTPHeaderField:[NSString stringWithUTF8String:header.first.c_str()]];
+    }
+  }
+
+  // the coordinator starts out loading, so the request starts now; resume only
+  // restarts one that was cancelled
+  auto start = [=] {
+    auto coordinator = coordinatorSlot->lock();
+    if (!coordinator || *task) {
+      return;
+    }
+    auto fail = [coordinator](const std::string &message) {
+      auto error = std::make_shared<std::string>(message);
+      coordinator->nativeImageResponseFailed(ImageLoadError(error));
+    };
+    if (!urlRequest) {
+      fail("invalid image uri");
+      return;
+    }
+    *task = [NSURLSession.sharedSession
+        dataTaskWithRequest:urlRequest
+          completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
+            if (error.code == NSURLErrorCancelled) {
+              return;
+            }
+            NSImage *image = data ? [[NSImage alloc] initWithData:data] : nil;
+            if (!image) {
+              fail(error ? error.localizedDescription.UTF8String : "image could not be decoded");
+              return;
+            }
+            // keep the pixel size, which is what scale-aware layout wants
+            NSBitmapImageRep *rep = [image.representations.firstObject isKindOfClass:NSBitmapImageRep.class]
+                ? (NSBitmapImageRep *)image.representations.firstObject
+                : nil;
+            if (rep) {
+              image.size = NSMakeSize(rep.pixelsWide, rep.pixelsHigh);
+            }
+            std::shared_ptr<void> holder((void *)CFBridgingRetain(image), [](void *pointer) { CFRelease(pointer); });
+            coordinator->nativeImageResponseComplete(ImageResponse(holder, nullptr));
+          }];
+    [*task resume];
+  };
+  SharedFunction<> resume(start);
+  SharedFunction<> cancel([=] {
+    if (*task) {
+      [*task cancel];
+      *task = nil;
+    }
+  });
+
+  ImageRequest request(imageSource, telemetry, std::move(resume), std::move(cancel));
+  *coordinatorSlot = request.getSharedObserverCoordinator();
+  start();
+  return request;
+}