one 2.10.0 → 2.11.0

package/macos/cpp/OneMacSegmentedControl/OneMacSegmentedControlProps.cpp

@@ -0,0 +1,12 @@
+#include "OneMacSegmentedControlProps.h"
+#include <react/renderer/core/propsConversions.h>
+namespace facebook::react {
+OneMacSegmentedControlProps::OneMacSegmentedControlProps(const PropsParserContext &context, const OneMacSegmentedControlProps &sourceProps, const RawProps &rawProps)
+    : ViewProps(context, sourceProps, rawProps),
+      labels(convertRawProp(context, rawProps, "labels", sourceProps.labels, std::vector<std::string>{})),
+      selectedIndex(convertRawProp(context, rawProps, "selectedIndex", sourceProps.selectedIndex, -1)),
+      disabled(convertRawProp(context, rawProps, "disabled", sourceProps.disabled, false)),
+      controlRole(convertRawProp(context, rawProps, "controlRole", sourceProps.controlRole, std::string{"automatic"})),
+      revision(convertRawProp(context, rawProps, "revision", sourceProps.revision, 0)),
+      acknowledgedEvent(convertRawProp(context, rawProps, "acknowledgedEvent", sourceProps.acknowledgedEvent, 0)) {}
+}

package/macos/cpp/OneMacSegmentedControl/OneMacSegmentedControlProps.h

@@ -0,0 +1,18 @@
+#pragma once
+#include <react/renderer/components/view/ViewProps.h>
+#include <react/renderer/core/PropsParserContext.h>
+#include <string>
+#include <vector>
+namespace facebook::react {
+class OneMacSegmentedControlProps final : public ViewProps {
+ public:
+  OneMacSegmentedControlProps() = default;
+  OneMacSegmentedControlProps(const PropsParserContext &, const OneMacSegmentedControlProps &, const RawProps &);
+  std::vector<std::string> labels{};
+  int selectedIndex{-1};
+  bool disabled{false};
+  std::string controlRole{"automatic"};
+  int revision{0};
+  int acknowledgedEvent{0};
+};
+}

package/macos/cpp/OneMacSegmentedControl/OneMacSegmentedControlShadowNode.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include "OneMacSegmentedControlEventEmitter.h"
+#include "OneMacSegmentedControlProps.h"
+
+#include <react/renderer/components/view/ConcreteViewShadowNode.h>
+
+namespace facebook::react {
+
+extern const char OneMacSegmentedControlComponentName[];
+
+// leaf layout uses the system control font and standard AppKit control insets
+class OneMacSegmentedControlShadowNode final
+    : public ConcreteViewShadowNode<OneMacSegmentedControlComponentName, OneMacSegmentedControlProps, OneMacSegmentedControlEventEmitter> {
+ public:
+  using ConcreteViewShadowNode::ConcreteViewShadowNode;
+
+  static ShadowNodeTraits BaseTraits() {
+    auto traits = ConcreteViewShadowNode::BaseTraits();
+    traits.set(ShadowNodeTraits::Trait::LeafYogaNode);
+    traits.set(ShadowNodeTraits::Trait::MeasurableYogaNode);
+    return traits;
+  }
+
+  Size measureContent(const LayoutContext &layoutContext, const LayoutConstraints &layoutConstraints) const override;
+};
+
+} // namespace facebook::react

package/macos/cpp/OneMacSegmentedControl/OneMacSegmentedControlShadowNode.mm

@@ -0,0 +1,15 @@
+#include "OneMacSegmentedControlShadowNode.h"
+#import <AppKit/AppKit.h>
+#include <react/renderer/core/LayoutConstraints.h>
+namespace facebook::react {
+const char OneMacSegmentedControlComponentName[] = "OneMacSegmentedControl";
+static CGFloat textWidth(const std::string &text) {
+  return ceil([[NSString stringWithUTF8String:text.c_str()] sizeWithAttributes:@{NSFontAttributeName: [NSFont systemFontOfSize:[NSFont systemFontSize]]}].width);
+}
+Size OneMacSegmentedControlShadowNode::measureContent(const LayoutContext &, const LayoutConstraints &constraints) const {
+  const auto &props = getConcreteProps();
+  CGFloat width = 0;
+  for (const auto &label : props.labels) width += 24 + textWidth(label);
+  return constraints.clamp({static_cast<Float>(width), 28});
+}
+}

package/macos/cpp/OneMacToggle/OneMacToggleComponentDescriptor.h

@@ -0,0 +1,11 @@
+#pragma once
+
+#include "OneMacToggleShadowNode.h"
+
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+
+namespace facebook::react {
+
+using OneMacToggleComponentDescriptor = ConcreteComponentDescriptor<OneMacToggleShadowNode>;
+
+} // namespace facebook::react

package/macos/cpp/OneMacToggle/OneMacToggleEventEmitter.cpp

@@ -0,0 +1,13 @@
+#include "OneMacToggleEventEmitter.h"
+
+#include <folly/dynamic.h>
+
+namespace facebook::react {
+
+void OneMacToggleEventEmitter::onIsOnChange(const OnIsOnChange &event) const {
+  folly::dynamic payload = folly::dynamic::object("isOn", event.isOn)("eventCount", event.eventCount)(
+      "revision", event.revision);
+  dispatchEvent("isOnChange", std::move(payload), RawEvent::Category::Discrete);
+}
+
+} // namespace facebook::react

package/macos/cpp/OneMacToggle/OneMacToggleEventEmitter.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include <react/renderer/components/view/ViewEventEmitter.h>
+
+namespace facebook::react {
+
+class OneMacToggleEventEmitter : public ViewEventEmitter {
+ public:
+  using ViewEventEmitter::ViewEventEmitter;
+
+  struct OnIsOnChange {
+    bool isOn;
+    int eventCount;
+    int revision;
+  };
+
+  void onIsOnChange(const OnIsOnChange &event) const;
+};
+
+} // namespace facebook::react

package/macos/cpp/OneMacToggle/OneMacToggleProps.cpp

@@ -0,0 +1,17 @@
+#include "OneMacToggleProps.h"
+
+#include <react/renderer/core/propsConversions.h>
+
+namespace facebook::react {
+
+OneMacToggleProps::OneMacToggleProps(
+    const PropsParserContext &context,
+    const OneMacToggleProps &sourceProps,
+    const RawProps &rawProps)
+    : ViewProps(context, sourceProps, rawProps),
+      label(convertRawProp(context, rawProps, "label", sourceProps.label, {})),
+      isOn(convertRawProp(context, rawProps, "isOn", sourceProps.isOn, false)),
+      revision(convertRawProp(context, rawProps, "revision", sourceProps.revision, 0)),
+      acknowledgedEvent(convertRawProp(context, rawProps, "acknowledgedEvent", sourceProps.acknowledgedEvent, 0)) {}
+
+} // namespace facebook::react

package/macos/cpp/OneMacToggle/OneMacToggleProps.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include <react/renderer/components/view/ViewProps.h>
+#include <react/renderer/core/PropsParserContext.h>
+
+#include <string>
+
+namespace facebook::react {
+
+// controlled props: `isOn` is the value React last accepted, `revision` scopes
+// it, `acknowledgedEvent` is the highest native event React has processed
+class OneMacToggleProps final : public ViewProps {
+ public:
+  OneMacToggleProps() = default;
+  OneMacToggleProps(const PropsParserContext &context, const OneMacToggleProps &sourceProps, const RawProps &rawProps);
+
+  std::string label{};
+  bool isOn{false};
+  int revision{0};
+  int acknowledgedEvent{0};
+};
+
+} // namespace facebook::react

package/macos/cpp/OneMacToggle/OneMacToggleShadowNode.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include "OneMacToggleEventEmitter.h"
+#include "OneMacToggleProps.h"
+
+#include <react/renderer/components/view/ConcreteViewShadowNode.h>
+
+namespace facebook::react {
+
+extern const char OneMacToggleComponentName[];
+
+// a leaf node: SwiftUI sizes the control, so layout measures it with the same
+// label font the switch style uses
+class OneMacToggleShadowNode final
+    : public ConcreteViewShadowNode<OneMacToggleComponentName, OneMacToggleProps, OneMacToggleEventEmitter> {
+ public:
+  using ConcreteViewShadowNode::ConcreteViewShadowNode;
+
+  static ShadowNodeTraits BaseTraits() {
+    auto traits = ConcreteViewShadowNode::BaseTraits();
+    traits.set(ShadowNodeTraits::Trait::LeafYogaNode);
+    traits.set(ShadowNodeTraits::Trait::MeasurableYogaNode);
+    return traits;
+  }
+
+  Size measureContent(const LayoutContext &layoutContext, const LayoutConstraints &layoutConstraints) const override;
+};
+
+} // namespace facebook::react

package/macos/cpp/OneMacToggle/OneMacToggleShadowNode.mm

@@ -0,0 +1,27 @@
+#include "OneMacToggleShadowNode.h"
+
+#import <AppKit/AppKit.h>
+
+#include <react/renderer/core/LayoutConstraints.h>
+
+namespace facebook::react {
+
+const char OneMacToggleComponentName[] = "OneMacToggle";
+
+// switch track and the gap SwiftUI leaves between it and the label
+static constexpr CGFloat kSwitchWidth = 52;
+static constexpr CGFloat kLabelGap = 10;
+static constexpr CGFloat kRowHeight = 22;
+
+Size OneMacToggleShadowNode::measureContent(const LayoutContext &, const LayoutConstraints &layoutConstraints) const {
+  const auto &label = getConcreteProps().label;
+  CGFloat width = kSwitchWidth;
+  if (!label.empty()) {
+    NSString *text = [NSString stringWithUTF8String:label.c_str()];
+    NSDictionary *attributes = @{NSFontAttributeName : [NSFont systemFontOfSize:[NSFont systemFontSize]]};
+    width += kLabelGap + ceil([text sizeWithAttributes:attributes].width);
+  }
+  return layoutConstraints.clamp({static_cast<Float>(width), static_cast<Float>(kRowHeight)});
+}
+
+} // namespace facebook::react

package/macos/cpp/graphics/react/renderer/graphics/HostPlatformColor.h

@@ -0,0 +1,129 @@
+#pragma once
+
+#include <react/renderer/graphics/ColorComponents.h>
+#include <cmath>
+#include <cstdint>
+#include <functional>
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace facebook::react {
+
+// macOS host color. An ordinary color is the same packed ARGB integer the cxx
+// backend uses. A PlatformColor keeps its AppKit NSColor, so drawing resolves
+// it against the view's appearance, accent and contrast instead of a snapshot.
+class Color {
+ public:
+  Color() = default;
+  Color(int32_t color) : argb_(color), defined_(true) {}
+
+  // packed ARGB; a platform color resolves under the current drawing appearance
+  int32_t getColor() const;
+
+  // the retained NSColor of a platform color, null for an ordinary color
+  const std::shared_ptr<void> &getPlatformColor() const
+  {
+    return platformColor_;
+  }
+
+  // the undefined color when no name resolves
+  static Color createSemanticColor(const std::vector<std::string> &semanticItems);
+
+  bool operator==(const Color &other) const
+  {
+    if (defined_ != other.defined_) {
+      return false;
+    }
+    if (!platformColor_ && !other.platformColor_) {
+      return argb_ == other.argb_;
+    }
+    return platformColorEquals(other);
+  }
+
+  bool operator!=(const Color &other) const
+  {
+    return !(*this == other);
+  }
+
+  operator int32_t() const
+  {
+    return getColor();
+  }
+
+  std::size_t hash() const;
+
+ private:
+  explicit Color(std::shared_ptr<void> platformColor) : defined_(true), platformColor_(std::move(platformColor)) {}
+  bool platformColorEquals(const Color &other) const;
+
+  int32_t argb_{0};
+  // explicit transparent black is a color; only the default is undefined.
+  bool defined_{false};
+  std::shared_ptr<void> platformColor_;
+};
+
+namespace HostPlatformColor {
+[[clang::no_destroy]] inline const facebook::react::Color UndefinedColor = Color();
+}
+
+inline Color hostPlatformColorFromRGBA(uint8_t r, uint8_t g, uint8_t b, uint8_t a)
+{
+  return Color((a & 0xff) << 24 | (r & 0xff) << 16 | (g & 0xff) << 8 | (b & 0xff));
+}
+
+inline Color hostPlatformColorFromComponents(ColorComponents components)
+{
+  float ratio = 255;
+  return hostPlatformColorFromRGBA(
+      static_cast<uint8_t>(std::round(components.red * ratio)),
+      static_cast<uint8_t>(std::round(components.green * ratio)),
+      static_cast<uint8_t>(std::round(components.blue * ratio)),
+      static_cast<uint8_t>(std::round(components.alpha * ratio)));
+}
+
+inline float alphaFromHostPlatformColor(Color color)
+{
+  return static_cast<float>((color.getColor() >> 24) & 0xff);
+}
+
+inline float redFromHostPlatformColor(Color color)
+{
+  return static_cast<float>((color.getColor() >> 16) & 0xff);
+}
+
+inline float greenFromHostPlatformColor(Color color)
+{
+  return static_cast<float>((color.getColor() >> 8) & 0xff);
+}
+
+inline float blueFromHostPlatformColor(Color color)
+{
+  return static_cast<float>(color.getColor() & 0xff);
+}
+
+inline bool hostPlatformColorIsColorMeaningful(Color color) noexcept
+{
+  return alphaFromHostPlatformColor(color) > 0;
+}
+
+inline ColorComponents colorComponentsFromHostPlatformColor(Color color)
+{
+  float ratio = 255;
+  int32_t argb = color.getColor();
+  return ColorComponents{
+      .red = static_cast<float>((argb >> 16) & 0xff) / ratio,
+      .green = static_cast<float>((argb >> 8) & 0xff) / ratio,
+      .blue = static_cast<float>(argb & 0xff) / ratio,
+      .alpha = static_cast<float>((argb >> 24) & 0xff) / ratio};
+}
+
+} // namespace facebook::react
+
+template <>
+struct std::hash<facebook::react::Color> {
+  size_t operator()(const facebook::react::Color &color) const
+  {
+    return color.hash();
+  }
+};

package/macos/cpp/graphics/react/renderer/graphics/HostPlatformColor.mm

@@ -0,0 +1,83 @@
+#import "HostPlatformColor.h"
+
+#import <AppKit/AppKit.h>
+#import <objc/message.h>
+
+namespace facebook::react {
+
+namespace {
+
+NSColor *NSColorFromPlatformColor(const std::shared_ptr<void> &platformColor)
+{
+  return (__bridge NSColor *)platformColor.get();
+}
+
+std::shared_ptr<void> PlatformColorFromNSColor(NSColor *color)
+{
+  return std::shared_ptr<void>((void *)CFBridgingRetain(color), CFRelease);
+}
+
+// an app asset catalog color first, then an NSColor class getter such as
+// labelColor, accepting both "label" and "labelColor" like iOS PlatformColor
+NSColor *NSColorFromSemanticName(const std::string &name)
+{
+  NSString *string = [NSString stringWithUTF8String:name.c_str()];
+  if (string.length == 0 || [string containsString:@":"]) {
+    return nil;
+  }
+  if (NSColor *named = [NSColor colorNamed:string]) {
+    return named;
+  }
+  if (![string hasSuffix:@"Color"]) {
+    string = [string stringByAppendingString:@"Color"];
+  }
+  SEL selector = NSSelectorFromString(string);
+  if (![NSColor respondsToSelector:selector]) {
+    return nil;
+  }
+  id color = ((id (*)(Class, SEL))objc_msgSend)(NSColor.class, selector);
+  return [color isKindOfClass:NSColor.class] ? color : nil;
+}
+
+} // namespace
+
+int32_t Color::getColor() const
+{
+  NSColor *color = NSColorFromPlatformColor(platformColor_);
+  if (color == nil) {
+    return argb_;
+  }
+  // resolves a dynamic system color under NSAppearance.currentDrawingAppearance
+  NSColor *srgb = [color colorUsingColorSpace:NSColorSpace.sRGBColorSpace];
+  if (srgb == nil) {
+    return 0;
+  }
+  auto channel = [](CGFloat value) { return (int32_t)std::round(value * 255) & 0xff; };
+  return channel(srgb.alphaComponent) << 24 | channel(srgb.redComponent) << 16 | channel(srgb.greenComponent) << 8 |
+      channel(srgb.blueComponent);
+}
+
+bool Color::platformColorEquals(const Color &other) const
+{
+  NSColor *color = NSColorFromPlatformColor(platformColor_);
+  NSColor *otherColor = NSColorFromPlatformColor(other.platformColor_);
+  return color == otherColor || [color isEqual:otherColor];
+}
+
+std::size_t Color::hash() const
+{
+  NSColor *color = NSColorFromPlatformColor(platformColor_);
+  return color != nil ? (std::size_t)color.hash : std::hash<int32_t>{}(argb_);
+}
+
+Color Color::createSemanticColor(const std::vector<std::string> &semanticItems)
+{
+  for (const auto &name : semanticItems) {
+    if (NSColor *color = NSColorFromSemanticName(name)) {
+      return Color(PlatformColorFromNSColor(color));
+    }
+  }
+  return HostPlatformColor::UndefinedColor;
+}
+
+} // namespace facebook::react

package/macos/cpp/graphics/react/renderer/graphics/PlatformColorParser.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include <react/debug/react_native_expect.h>
+#include <react/renderer/core/RawValue.h>
+#include <react/renderer/graphics/Color.h>
+#include <react/renderer/graphics/fromRawValueShared.h>
+#include <react/utils/ContextContainer.h>
+
+namespace facebook::react {
+
+// PlatformColor('labelColor', ...) arrives as {semantic: names, fallback?}
+SharedColor parsePlatformColor(const ContextContainer &contextContainer, int32_t surfaceId, const RawValue &value);
+
+inline void
+fromRawValue(const ContextContainer &contextContainer, int32_t surfaceId, const RawValue &value, SharedColor &result)
+{
+  fromRawValueShared(contextContainer, surfaceId, value, result, parsePlatformColor);
+}
+
+} // namespace facebook::react

package/macos/cpp/graphics/react/renderer/graphics/PlatformColorParser.mm

@@ -0,0 +1,38 @@
+#import "PlatformColorParser.h"
+
+#import <react/renderer/css/CSSColor.h>
+#import <react/renderer/css/CSSValueParser.h>
+#import <react/renderer/graphics/HostPlatformColor.h>
+
+#import <string>
+#import <unordered_map>
+
+namespace facebook::react {
+
+SharedColor parsePlatformColor(const ContextContainer & /*contextContainer*/, int32_t /*surfaceId*/, const RawValue &value)
+{
+  if (!value.hasType<std::unordered_map<std::string, RawValue>>()) {
+    return clearColor();
+  }
+  auto items = (std::unordered_map<std::string, RawValue>)value;
+  auto semantic = items.find("semantic");
+  if (semantic == items.end() || !semantic->second.hasType<std::vector<std::string>>()) {
+    return clearColor();
+  }
+  auto color = Color::createSemanticColor((std::vector<std::string>)semantic->second);
+  if (color != HostPlatformColor::UndefinedColor) {
+    return color;
+  }
+  // only a miss uses the fallback, so a name resolving to clear stays clear
+  auto fallback = items.find("fallback");
+  if (fallback != items.end() && fallback->second.hasType<std::string>()) {
+    auto css = parseCSSProperty<CSSColor>((std::string)fallback->second);
+    if (std::holds_alternative<CSSColor>(css)) {
+      const auto &c = std::get<CSSColor>(css);
+      return colorFromRGBA(c.r, c.g, c.b, c.a);
+    }
+  }
+  return clearColor();
+}
+
+} // namespace facebook::react

package/macos/cpp/textlayoutmanager/OneMacosText.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#import <AppKit/AppKit.h>
+
+#include <react/renderer/attributedstring/AttributedString.h>
+#include <react/renderer/attributedstring/ParagraphAttributes.h>
+
+// Builds the NSTextStorage that both measurement and painting use. The text
+// container has zero line fragment padding and the paragraph's line and
+// ellipsis settings, so a measured size reproduces when drawn.
+NSTextStorage *OneMacosTextStorage(
+    const facebook::react::AttributedString &attributedString,
+    const facebook::react::ParagraphAttributes &paragraphAttributes,
+    CGSize size);
+
+NSColor *OneMacosColorFromSharedColor(facebook::react::SharedColor color);
+
+// Draws at `frame` in the current (flipped) graphics context.
+void OneMacosDrawText(
+    const facebook::react::AttributedString &attributedString,
+    const facebook::react::ParagraphAttributes &paragraphAttributes,
+    CGRect frame);