one 2.10.0 → 2.11.1

package/macos/cpp/textlayoutmanager/OneMacosText.mm

@@ -0,0 +1,207 @@
+#import "OneMacosText.h"
+
+#include <react/renderer/graphics/Color.h>
+#include <react/renderer/textlayoutmanager/TextMeasurementRounding.h>
+
+using namespace facebook::react;
+
+NSColor *OneMacosColorFromSharedColor(SharedColor color)
+{
+  if (!color) {
+    return nil;
+  }
+  // a PlatformColor stays the AppKit color, resolved per appearance when drawn
+  if (NSColor *platformColor = (__bridge NSColor *)(*color).getPlatformColor().get()) {
+    return platformColor;
+  }
+  auto c = colorComponentsFromColor(color);
+  return [NSColor colorWithSRGBRed:c.red green:c.green blue:c.blue alpha:c.alpha];
+}
+
+static NSFontWeight FontWeightValue(int weight)
+{
+  switch (weight) {
+    case 100: return NSFontWeightUltraLight;
+    case 200: return NSFontWeightThin;
+    case 300: return NSFontWeightLight;
+    case 500: return NSFontWeightMedium;
+    case 600: return NSFontWeightSemibold;
+    case 700: return NSFontWeightBold;
+    case 800: return NSFontWeightHeavy;
+    case 900: return NSFontWeightBlack;
+    default: return NSFontWeightRegular;
+  }
+}
+
+static NSFont *FontForAttributes(const TextAttributes &attributes)
+{
+  CGFloat size = std::isnan(attributes.fontSize) ? 14 : attributes.fontSize;
+  NSFontWeight weight = FontWeightValue(attributes.fontWeight ? (int)*attributes.fontWeight : 400);
+  bool italic = attributes.fontStyle && *attributes.fontStyle != FontStyle::Normal;
+
+  NSFont *font = nil;
+  const std::string &family = attributes.fontFamily;
+  bool isSystem = family.empty() || family == "System" || family == "system-ui" || family == "-apple-system";
+  if (!isSystem) {
+    NSString *name = [NSString stringWithUTF8String:family.c_str()];
+    font = [NSFont fontWithName:name size:size];
+    if (!font) {
+      NSFontDescriptor *descriptor = [NSFontDescriptor fontDescriptorWithFontAttributes:@{
+        NSFontFamilyAttribute : name,
+        NSFontTraitsAttribute : @{NSFontWeightTrait : @(weight)}
+      }];
+      font = [NSFont fontWithDescriptor:descriptor size:size];
+    }
+  }
+  if (!font) {
+    font = [NSFont systemFontOfSize:size weight:weight];
+  }
+  if (italic) {
+    NSFontDescriptor *descriptor = [font.fontDescriptor fontDescriptorWithSymbolicTraits:font.fontDescriptor.symbolicTraits | NSFontDescriptorTraitItalic];
+    if (NSFont *italicFont = [NSFont fontWithDescriptor:descriptor size:size]) {
+      font = italicFont;
+    }
+  }
+  return font;
+}
+
+static NSTextAlignment AlignmentValue(std::optional<TextAlignment> alignment)
+{
+  if (!alignment) {
+    return NSTextAlignmentNatural;
+  }
+  switch (*alignment) {
+    case TextAlignment::Left: return NSTextAlignmentLeft;
+    case TextAlignment::Center: return NSTextAlignmentCenter;
+    case TextAlignment::Right: return NSTextAlignmentRight;
+    case TextAlignment::Justified: return NSTextAlignmentJustified;
+    default: return NSTextAlignmentNatural;
+  }
+}
+
+static NSLineBreakMode LineBreakModeValue(EllipsizeMode mode)
+{
+  switch (mode) {
+    case EllipsizeMode::Clip: return NSLineBreakByClipping;
+    case EllipsizeMode::Head: return NSLineBreakByTruncatingHead;
+    case EllipsizeMode::Middle: return NSLineBreakByTruncatingMiddle;
+    case EllipsizeMode::Tail: return NSLineBreakByTruncatingTail;
+  }
+}
+
+static NSAttributedString *AttributedStringValue(const AttributedString &attributedString)
+{
+  NSMutableAttributedString *result = [NSMutableAttributedString new];
+  for (const auto &fragment : attributedString.getFragments()) {
+    if (fragment.isAttachment()) {
+      continue;
+    }
+    const TextAttributes &attributes = fragment.textAttributes;
+    NSMutableDictionary<NSAttributedStringKey, id> *dictionary = [NSMutableDictionary new];
+    dictionary[NSFontAttributeName] = FontForAttributes(attributes);
+
+    NSColor *foreground = OneMacosColorFromSharedColor(attributes.foregroundColor);
+    dictionary[NSForegroundColorAttributeName] = foreground ?: [NSColor textColor];
+    if (attributes.opacity == attributes.opacity && foreground && attributes.opacity != 1) {
+      CGFloat opacity = attributes.opacity;
+      if ((*attributes.foregroundColor).getPlatformColor()) {
+        // colorWithAlphaComponent resolves a semantic color immediately, so keep
+        // opacity resolution inside the appearance-aware provider.
+        dictionary[NSForegroundColorAttributeName] = [NSColor colorWithName:nil dynamicProvider:^NSColor *(NSAppearance *appearance) {
+          __block NSColor *resolved;
+          [appearance performAsCurrentDrawingAppearance:^{
+            resolved = [foreground colorWithAlphaComponent:foreground.alphaComponent * opacity];
+          }];
+          return resolved;
+        }];
+      } else {
+        dictionary[NSForegroundColorAttributeName] = [foreground colorWithAlphaComponent:foreground.alphaComponent * opacity];
+      }
+    }
+    if (NSColor *background = OneMacosColorFromSharedColor(attributes.backgroundColor)) {
+      dictionary[NSBackgroundColorAttributeName] = background;
+    }
+    if (!std::isnan(attributes.letterSpacing)) {
+      dictionary[NSKernAttributeName] = @(attributes.letterSpacing);
+    }
+
+    NSMutableParagraphStyle *style = [NSMutableParagraphStyle new];
+    style.alignment = AlignmentValue(attributes.alignment);
+    if (!std::isnan(attributes.lineHeight) && attributes.lineHeight > 0) {
+      style.minimumLineHeight = attributes.lineHeight;
+      style.maximumLineHeight = attributes.lineHeight;
+    }
+    dictionary[NSParagraphStyleAttributeName] = style;
+
+    if (attributes.textDecorationLineType) {
+      auto line = *attributes.textDecorationLineType;
+      NSColor *decorationColor = OneMacosColorFromSharedColor(attributes.textDecorationColor) ?: foreground;
+      if (line == TextDecorationLineType::Underline || line == TextDecorationLineType::UnderlineStrikethrough) {
+        dictionary[NSUnderlineStyleAttributeName] = @(NSUnderlineStyleSingle);
+        if (decorationColor) dictionary[NSUnderlineColorAttributeName] = decorationColor;
+      }
+      if (line == TextDecorationLineType::Strikethrough || line == TextDecorationLineType::UnderlineStrikethrough) {
+        dictionary[NSStrikethroughStyleAttributeName] = @(NSUnderlineStyleSingle);
+        if (decorationColor) dictionary[NSStrikethroughColorAttributeName] = decorationColor;
+      }
+    }
+
+    NSString *string = [NSString stringWithUTF8String:fragment.string.c_str()] ?: @"";
+    if (attributes.textTransform) {
+      switch (*attributes.textTransform) {
+        case TextTransform::Uppercase: string = string.uppercaseString; break;
+        case TextTransform::Lowercase: string = string.lowercaseString; break;
+        case TextTransform::Capitalize: string = string.capitalizedString; break;
+        default: break;
+      }
+    }
+    [result appendAttributedString:[[NSAttributedString alloc] initWithString:string attributes:dictionary]];
+  }
+  return result;
+}
+
+// AppKit puts all of a fixed line height's extra space above the text. Split
+// it above and below as iOS React Native does, measured against the line
+// height this layout manager gives the font without one.
+static void CenterInLineHeight(NSTextStorage *textStorage, NSLayoutManager *layoutManager)
+{
+  NSRange range = NSMakeRange(0, textStorage.length);
+  __block CGFloat lineHeight = 0;
+  __block CGFloat fontLineHeight = 0;
+  [textStorage enumerateAttributesInRange:range
+                                  options:NSAttributedStringEnumerationLongestEffectiveRangeNotRequired
+                               usingBlock:^(NSDictionary<NSAttributedStringKey, id> *attributes, NSRange, BOOL *) {
+                                 lineHeight = MAX(lineHeight, [attributes[NSParagraphStyleAttributeName] maximumLineHeight]);
+                                 if (NSFont *font = attributes[NSFontAttributeName]) {
+                                   fontLineHeight = MAX(fontLineHeight, [layoutManager defaultLineHeightForFont:font]);
+                                 }
+                               }];
+  if (lineHeight > fontLineHeight) {
+    [textStorage addAttribute:NSBaselineOffsetAttributeName value:@((lineHeight - fontLineHeight) / 2) range:range];
+  }
+}
+
+NSTextStorage *OneMacosTextStorage(const AttributedString &attributedString, const ParagraphAttributes &paragraphAttributes, CGSize size)
+{
+  NSTextStorage *textStorage = [[NSTextStorage alloc] initWithAttributedString:AttributedStringValue(attributedString)];
+  NSLayoutManager *layoutManager = [NSLayoutManager new];
+  layoutManager.usesFontLeading = NO;
+  CenterInLineHeight(textStorage, layoutManager);
+  NSTextContainer *container = [[NSTextContainer alloc] initWithSize:size];
+  container.lineFragmentPadding = 0;
+  container.maximumNumberOfLines = paragraphAttributes.maximumNumberOfLines;
+  container.lineBreakMode = LineBreakModeValue(paragraphAttributes.ellipsizeMode);
+  [layoutManager addTextContainer:container];
+  [textStorage addLayoutManager:layoutManager];
+  return textStorage;
+}
+
+void OneMacosDrawText(const AttributedString &attributedString, const ParagraphAttributes &paragraphAttributes, CGRect frame)
+{
+  NSTextStorage *textStorage = OneMacosTextStorage(attributedString, paragraphAttributes, frame.size);
+  NSLayoutManager *layoutManager = textStorage.layoutManagers.firstObject;
+  NSTextContainer *container = layoutManager.textContainers.firstObject;
+  NSRange glyphRange = [layoutManager glyphRangeForTextContainer:container];
+  [layoutManager drawBackgroundForGlyphRange:glyphRange atPoint:frame.origin];
+  [layoutManager drawGlyphsForGlyphRange:glyphRange atPoint:frame.origin];
+}

package/macos/cpp/textlayoutmanager/react/renderer/textlayoutmanager/TextLayoutManager.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#include <react/renderer/attributedstring/AttributedStringBox.h>
+#include <react/renderer/attributedstring/ParagraphAttributes.h>
+#include <react/renderer/core/LayoutConstraints.h>
+#include <react/renderer/textlayoutmanager/TextLayoutContext.h>
+#include <react/renderer/textlayoutmanager/TextMeasureCache.h>
+#include <react/utils/ContextContainer.h>
+#include <memory>
+
+namespace facebook::react {
+
+// macOS text measurement on TextKit. The paragraph component view draws with
+// the same NSTextStorage construction (OneMacosText.h), so layout and paint agree.
+class TextLayoutManager {
+ public:
+  explicit TextLayoutManager(const std::shared_ptr<const ContextContainer> &contextContainer);
+
+  TextLayoutManager(const TextLayoutManager &) = delete;
+  TextLayoutManager &operator=(const TextLayoutManager &) = delete;
+  TextLayoutManager(TextLayoutManager &&) = delete;
+  TextLayoutManager &operator=(TextLayoutManager &&) = delete;
+
+  TextMeasurement measure(
+      const AttributedStringBox &attributedStringBox,
+      const ParagraphAttributes &paragraphAttributes,
+      const TextLayoutContext &layoutContext,
+      const LayoutConstraints &layoutConstraints) const;
+
+ protected:
+  std::shared_ptr<const ContextContainer> contextContainer_;
+  TextMeasureCache textMeasureCache_;
+};
+
+} // namespace facebook::react

package/macos/cpp/textlayoutmanager/react/renderer/textlayoutmanager/TextLayoutManager.mm

@@ -0,0 +1,74 @@
+#import "TextLayoutManager.h"
+
+#import <AppKit/AppKit.h>
+
+#import <react/renderer/attributedstring/PlaceholderAttributedString.h>
+#import <react/renderer/telemetry/TransactionTelemetry.h>
+#import <react/renderer/textlayoutmanager/TextMeasurementRounding.h>
+
+#import "OneMacosText.h"
+
+namespace facebook::react {
+
+TextLayoutManager::TextLayoutManager(const std::shared_ptr<const ContextContainer> &contextContainer)
+    : contextContainer_(contextContainer), textMeasureCache_(kSimpleThreadSafeCacheSizeCap)
+{
+}
+
+static TextMeasurement measureString(
+    const AttributedString &attributedString,
+    const ParagraphAttributes &paragraphAttributes,
+    const TextLayoutContext &layoutContext,
+    const LayoutConstraints &layoutConstraints)
+{
+  if (attributedString.isEmpty()) {
+    return {};
+  }
+  CGFloat width = std::min<CGFloat>(layoutConstraints.maximumSize.width, 1e7);
+  NSTextStorage *textStorage = OneMacosTextStorage(attributedString, paragraphAttributes, CGSizeMake(width, 1e7));
+  NSLayoutManager *layoutManager = textStorage.layoutManagers.firstObject;
+  NSTextContainer *container = layoutManager.textContainers.firstObject;
+  [layoutManager ensureLayoutForTextContainer:container];
+  CGRect used = [layoutManager usedRectForTextContainer:container];
+
+  TextMeasurement measurement;
+  measurement.size = internal_roundTextMeasurementToPixelGrid(
+      Size{.width = static_cast<Float>(used.size.width), .height = static_cast<Float>(used.size.height)}, layoutContext.pointScaleFactor);
+  return measurement;
+}
+
+TextMeasurement TextLayoutManager::measure(
+    const AttributedStringBox &attributedStringBox,
+    const ParagraphAttributes &paragraphAttributes,
+    const TextLayoutContext &layoutContext,
+    const LayoutConstraints &layoutConstraints) const
+{
+  auto measurement = TextMeasurement{};
+  if (attributedStringBox.getMode() == AttributedStringBox::Mode::Value) {
+    auto original = attributedStringBox.getValue();
+    auto attributedString = ensurePlaceholderIfEmpty_DO_NOT_USE(original);
+    measurement = textMeasureCache_.get(
+        {.attributedString = attributedString,
+         .paragraphAttributes = paragraphAttributes,
+         .layoutConstraints = layoutConstraints,
+         .pointScaleFactor = layoutContext.pointScaleFactor},
+        [&]() {
+          auto telemetry = TransactionTelemetry::threadLocalTelemetry();
+          if (telemetry) {
+            telemetry->willMeasureText();
+          }
+          auto result = measureString(attributedString, paragraphAttributes, layoutContext, layoutConstraints);
+          if (original.isEmpty()) {
+            result.size.width = 0;
+          }
+          if (telemetry) {
+            telemetry->didMeasureText();
+          }
+          return result;
+        });
+  }
+  measurement.size = layoutConstraints.clamp(measurement.size);
+  return measurement;
+}
+
+} // namespace facebook::react

package/macos/host/OneMacosAnimated.mm

@@ -0,0 +1,91 @@
+#import <AppKit/AppKit.h>
+#import <QuartzCore/QuartzCore.h>
+
+#include <mutex>
+
+#include <react/renderer/animated/AnimatedModule.h>
+#include <react/renderer/animated/NativeAnimatedNodesManagerProvider.h>
+
+#import "OneMacosModules.h"
+
+// drives NativeAnimatedNodesManager frames from a display link on the main run
+// loop, the way RCTAnimatedModuleProvider does on iOS
+@interface OneMacosAnimatedFrames : NSObject
+- (void)setOnRender:(std::function<void()>)onRender;
+- (void)start;
+- (void)stop;
+@end
+
+@implementation OneMacosAnimatedFrames {
+  CADisplayLink *_link;
+  std::function<void()> _onRender;
+  std::recursive_mutex _callbackMutex;
+}
+
+- (void)setOnRender:(std::function<void()>)onRender
+{
+  // rn destroys its manager on the js thread. clear its raw callback there,
+  // before an already-enqueued display-link frame can use the freed manager.
+  std::lock_guard<std::recursive_mutex> lock(_callbackMutex);
+  _onRender = std::move(onRender);
+}
+
+- (void)start
+{
+  std::lock_guard<std::recursive_mutex> lock(_callbackMutex);
+  if (_onRender && _link == nil) {
+    _link = [NSScreen.mainScreen displayLinkWithTarget:self selector:@selector(frame:)];
+    [_link addToRunLoop:NSRunLoop.mainRunLoop forMode:NSRunLoopCommonModes];
+  }
+}
+
+- (void)stop
+{
+  [_link invalidate];
+  _link = nil;
+}
+
+- (void)frame:(CADisplayLink *)link
+{
+  // stop can be requested from inside onRender, so keep a local copy while
+  // holding a recursive lock through invocation and synchronous invalidation.
+  // invariant: onRender must never synchronously wait for js, whose teardown
+  // can be blocked in setOnRender. NativeAnimatedNodesManager runs ui tasks and
+  // native commits here; its provider's MergedValueDispatcher and AnimatedModule
+  // callbacks enqueue js work with invokeAsync. preserve that asynchronous edge.
+  std::lock_guard<std::recursive_mutex> lock(_callbackMutex);
+  auto onRender = _onRender;
+  if (onRender) {
+    onRender();
+  }
+}
+
+@end
+
+namespace facebook::react {
+
+std::shared_ptr<TurboModule> OneMacosCreateAnimatedModule(std::shared_ptr<CallInvoker> jsInvoker)
+{
+  auto frames = std::make_shared<OneMacosAnimatedFrames *>([OneMacosAnimatedFrames new]);
+  auto onMain = [](bool isAsync, std::function<void()> work) {
+    if (isAsync || ![NSThread isMainThread]) {
+      dispatch_async(dispatch_get_main_queue(), ^{
+        work();
+      });
+    } else {
+      work();
+    }
+  };
+  auto provider = std::make_shared<NativeAnimatedNodesManagerProvider>(
+      [frames, onMain](std::function<void()> &&onRender, bool isAsync) {
+        [*frames setOnRender:std::move(onRender)];
+        onMain(isAsync, [frames]() { [*frames start]; });
+      },
+      [frames, onMain](bool isAsync) {
+        [*frames setOnRender:nullptr];
+        onMain(isAsync, [frames]() { [*frames stop]; });
+      });
+  return std::make_shared<AnimatedModule>(std::move(jsInvoker), std::move(provider));
+}
+
+} // namespace facebook::react

package/macos/host/OneMacosAppCommands.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#import <AppKit/AppKit.h>
+
+#include <folly/dynamic.h>
+
+#include <string>
+
+NS_ASSUME_NONNULL_BEGIN
+
+// A validated `{ bindings, menus, toolbar? }` config from AppCommands.configure. Building
+// one touches no AppKit state, so it may happen on the JS thread.
+@interface OneMacosAppCommandConfig : NSObject
+@property (nonatomic, readonly) NSSet<NSString *> *commandIds;
+@end
+
+// nil, with `error` set, for a config the menu bar cannot represent
+OneMacosAppCommandConfig *_Nullable OneMacosParseAppCommands(const folly::dynamic &config, std::string &error);
+
+// A root view runs the commands its window's runtime configured.
+@protocol OneMacosAppCommandTarget <NSObject>
+- (nullable OneMacosAppCommandConfig *)oneMacosAppCommandConfig;
+- (BOOL)oneMacosCanPerformAppCommand:(NSString *)commandId;
+- (void)oneMacosPerformAppCommand:(NSString *)commandId;
+@end
+
+// main thread. Shows the commands of the current root, the key window's or else
+// the frontmost one's, in the menu bar. Call it when a root's config changes;
+// window changes and SwiftUI menu rebuilds are followed on their own. Every
+// other menu item, such as Edit, Window and Services, stays in place.
+void OneMacosUpdateAppCommands(void);
+
+// main thread; the registry holds views weakly
+void OneMacosRegisterAppCommandTarget(NSView<OneMacosAppCommandTarget> *view);
+
+NS_ASSUME_NONNULL_END