react-native-windows 0.71.7 → 0.72.0-preview.1

package/Microsoft.ReactNative/Fabric/platform/react/components/view/windows/primitives.h

@@ -0,0 +1,42 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include <array>
+#include <bitset>
+#include <cmath>
+#include <optional>
+
+namespace facebook {
+namespace react {
+
+struct WindowsViewEvents {
+  std::bitset<32> bits{};
+
+  enum class Offset : std::size_t {
+    Focus = 0,
+    Blur = 1,
+    KeyUp = 2,
+    KeyDown = 3,
+  };
+
+  constexpr bool operator[](const Offset offset) const {
+    return bits[static_cast<std::size_t>(offset)];
+  }
+
+  std::bitset<32>::reference operator[](const Offset offset) {
+    return bits[static_cast<std::size_t>(offset)];
+  }
+};
+
+inline static bool operator==(WindowsViewEvents const &lhs, WindowsViewEvents const &rhs) {
+  return lhs.bits == rhs.bits;
+}
+
+inline static bool operator!=(WindowsViewEvents const &lhs, WindowsViewEvents const &rhs) {
+  return lhs.bits != rhs.bits;
+}
+
+} // namespace react
+} // namespace facebook

package/Microsoft.ReactNative/Fabric/platform/react/renderer/components/view/HostPlatformViewProps.h

@@ -0,0 +1,10 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include <react/components/view/windows/WindowsViewProps.h>
+
+namespace facebook::react {
+using HostPlatformViewProps = WindowsViewProps;
+} // namespace facebook::react

package/Microsoft.ReactNative/Fabric/platform/react/renderer/core/graphicsConversions.h

@@ -0,0 +1,248 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <butter/map.h>
+#include <glog/logging.h>
+#include <react/debug/react_native_expect.h>
+#include <react/renderer/core/PropsParserContext.h>
+#include <react/renderer/core/RawProps.h>
+#include <react/renderer/graphics/Color.h>
+#include <react/renderer/graphics/Point.h>
+#include <react/renderer/graphics/Rect.h>
+#include <react/renderer/graphics/RectangleCorners.h>
+#include <react/renderer/graphics/RectangleEdges.h>
+#include <react/renderer/graphics/Size.h>
+#include <react/renderer/graphics/Vector.h>
+// [Windows Windows does not parse PlatformColor to RGB
+// #include <react/renderer/graphis/PlatformColorParser.h>
+// WIndows]
+
+namespace facebook {
+namespace react {
+
+#pragma mark - Color
+
+inline void fromRawValue(const PropsParserContext &context, const RawValue &value, SharedColor &result) {
+  ColorComponents colorComponents = {0, 0, 0, 0};
+
+  if (value.hasType<int>()) {
+    auto argb = (int64_t)value;
+    auto ratio = 255.f;
+    colorComponents.alpha = ((argb >> 24) & 0xFF) / ratio;
+    colorComponents.red = ((argb >> 16) & 0xFF) / ratio;
+    colorComponents.green = ((argb >> 8) & 0xFF) / ratio;
+    colorComponents.blue = (argb & 0xFF) / ratio;
+  } else if (value.hasType<std::vector<float>>()) {
+    auto items = (std::vector<float>)value;
+    auto length = items.size();
+    react_native_expect(length == 3 || length == 4);
+    colorComponents.red = items.at(0);
+    colorComponents.green = items.at(1);
+    colorComponents.blue = items.at(2);
+    colorComponents.alpha = length == 4 ? items.at(3) : 1.0f;
+    // [Windows - Embed WindowBrush into SharedColor instead of trying to parse PlatformColor into RGB
+  } else if (value.hasType<butter::map<std::string, std::string>>()) {
+    auto map = (butter::map<std::string, std::string>)value;
+    for (const auto &pair : map) {
+      if (pair.first == "windowsbrush") {
+        result = SharedColor(std::string(pair.second));
+        return;
+      }
+    }
+  }
+  // Windows]
+
+  result = colorFromComponents(colorComponents);
+}
+
+#ifdef ANDROID
+inline int toAndroidRepr(const SharedColor &color) {
+  return *color;
+}
+#endif
+
+inline std::string toString(const SharedColor &value) {
+  ColorComponents components = colorComponentsFromColor(value);
+  auto ratio = 255.f;
+  return "rgba(" + folly::to<std::string>(round(components.red * ratio)) + ", " +
+      folly::to<std::string>(round(components.green * ratio)) + ", " +
+      folly::to<std::string>(round(components.blue * ratio)) + ", " +
+      folly::to<std::string>(round(components.alpha * ratio)) + ")";
+}
+
+#pragma mark - Geometry
+
+inline void fromRawValue(const PropsParserContext &context, const RawValue &value, Point &result) {
+  if (value.hasType<butter::map<std::string, Float>>()) {
+    auto map = (butter::map<std::string, Float>)value;
+    for (const auto &pair : map) {
+      if (pair.first == "x") {
+        result.x = pair.second;
+      } else if (pair.first == "y") {
+        result.y = pair.second;
+      }
+    }
+    return;
+  }
+
+  react_native_expect(value.hasType<std::vector<Float>>());
+  if (value.hasType<std::vector<Float>>()) {
+    auto array = (std::vector<Float>)value;
+    react_native_expect(array.size() == 2);
+    if (array.size() >= 2) {
+      result = {array.at(0), array.at(1)};
+    } else {
+      result = {0, 0};
+      LOG(ERROR) << "Unsupported Point vector size: " << array.size();
+    }
+  } else {
+    LOG(ERROR) << "Unsupported Point type";
+  }
+}
+
+inline void fromRawValue(const PropsParserContext &context, const RawValue &value, Size &result) {
+  if (value.hasType<butter::map<std::string, Float>>()) {
+    auto map = (butter::map<std::string, Float>)value;
+    for (const auto &pair : map) {
+      if (pair.first == "width") {
+        result.width = pair.second;
+      } else if (pair.first == "height") {
+        result.height = pair.second;
+      } else {
+        LOG(ERROR) << "Unsupported Size map key: " << pair.first;
+        react_native_expect(false);
+      }
+    }
+    return;
+  }
+
+  react_native_expect(value.hasType<std::vector<Float>>());
+  if (value.hasType<std::vector<Float>>()) {
+    auto array = (std::vector<Float>)value;
+    react_native_expect(array.size() == 2);
+    if (array.size() >= 2) {
+      result = {array.at(0), array.at(1)};
+    } else {
+      result = {0, 0};
+      LOG(ERROR) << "Unsupported Size vector size: " << array.size();
+    }
+  } else {
+    LOG(ERROR) << "Unsupported Size type";
+  }
+}
+
+inline void fromRawValue(const PropsParserContext &context, const RawValue &value, EdgeInsets &result) {
+  if (value.hasType<Float>()) {
+    auto number = (Float)value;
+    result = {number, number, number, number};
+    return;
+  }
+
+  if (value.hasType<butter::map<std::string, Float>>()) {
+    auto map = (butter::map<std::string, Float>)value;
+    for (const auto &pair : map) {
+      if (pair.first == "top") {
+        result.top = pair.second;
+      } else if (pair.first == "left") {
+        result.left = pair.second;
+      } else if (pair.first == "bottom") {
+        result.bottom = pair.second;
+      } else if (pair.first == "right") {
+        result.right = pair.second;
+      } else {
+        LOG(ERROR) << "Unsupported EdgeInsets map key: " << pair.first;
+        react_native_expect(false);
+      }
+    }
+    return;
+  }
+
+  react_native_expect(value.hasType<std::vector<Float>>());
+  if (value.hasType<std::vector<Float>>()) {
+    auto array = (std::vector<Float>)value;
+    react_native_expect(array.size() == 4);
+    if (array.size() >= 4) {
+      result = {array.at(0), array.at(1), array.at(2), array.at(3)};
+    } else {
+      result = {0, 0, 0, 0};
+      LOG(ERROR) << "Unsupported EdgeInsets vector size: " << array.size();
+    }
+  } else {
+    LOG(ERROR) << "Unsupported EdgeInsets type";
+  }
+}
+
+inline void fromRawValue(const PropsParserContext &context, const RawValue &value, CornerInsets &result) {
+  if (value.hasType<Float>()) {
+    auto number = (Float)value;
+    result = {number, number, number, number};
+    return;
+  }
+
+  if (value.hasType<butter::map<std::string, Float>>()) {
+    auto map = (butter::map<std::string, Float>)value;
+    for (const auto &pair : map) {
+      if (pair.first == "topLeft") {
+        result.topLeft = pair.second;
+      } else if (pair.first == "topRight") {
+        result.topRight = pair.second;
+      } else if (pair.first == "bottomLeft") {
+        result.bottomLeft = pair.second;
+      } else if (pair.first == "bottomRight") {
+        result.bottomRight = pair.second;
+      } else {
+        LOG(ERROR) << "Unsupported CornerInsets map key: " << pair.first;
+        react_native_expect(false);
+      }
+    }
+    return;
+  }
+
+  react_native_expect(value.hasType<std::vector<Float>>());
+  if (value.hasType<std::vector<Float>>()) {
+    auto array = (std::vector<Float>)value;
+    react_native_expect(array.size() == 4);
+    if (array.size() >= 4) {
+      result = {array.at(0), array.at(1), array.at(2), array.at(3)};
+    } else {
+      LOG(ERROR) << "Unsupported CornerInsets vector size: " << array.size();
+    }
+  }
+
+  // Error case - we should only here if all other supported cases fail
+  // In dev we would crash on assert before this point
+  result = {0, 0, 0, 0};
+  LOG(ERROR) << "Unsupported CornerInsets type";
+}
+
+inline std::string toString(const Point &point) {
+  return "{" + folly::to<std::string>(point.x) + ", " + folly::to<std::string>(point.y) + "}";
+}
+
+inline std::string toString(const Size &size) {
+  return "{" + folly::to<std::string>(size.width) + ", " + folly::to<std::string>(size.height) + "}";
+}
+
+inline std::string toString(const Rect &rect) {
+  return "{" + toString(rect.origin) + ", " + toString(rect.size) + "}";
+}
+
+inline std::string toString(const EdgeInsets &edgeInsets) {
+  return "{" + folly::to<std::string>(edgeInsets.left) + ", " + folly::to<std::string>(edgeInsets.top) + ", " +
+      folly::to<std::string>(edgeInsets.right) + ", " + folly::to<std::string>(edgeInsets.bottom) + "}";
+}
+
+inline std::string toString(const CornerInsets &cornerInsets) {
+  return "{" + folly::to<std::string>(cornerInsets.topLeft) + ", " + folly::to<std::string>(cornerInsets.topRight) +
+      ", " + folly::to<std::string>(cornerInsets.bottomLeft) + ", " + folly::to<std::string>(cornerInsets.bottomRight) +
+      "}";
+}
+
+} // namespace react
+} // namespace facebook

package/Microsoft.ReactNative/Fabric/platform/react/renderer/graphics/Color.cpp

@@ -56,4 +56,9 @@ SharedColor whiteColor() {
   return color;
 }
 
+SharedColor greyColor() {
+  static SharedColor color = colorFromComponents(ColorComponents{133, 133, 133, 1});
+  return color;
+}
+
 } // namespace facebook::react

package/Microsoft.ReactNative/Fabric/platform/react/renderer/graphics/Color.h

@@ -1,5 +1,136 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
 
-// RN has some weird include directory redirections..this forwards the include to the right place
-#include <react/renderer/graphics/platform/cxx/react/renderer/graphics/Color.h>
+#pragma once
+
+#include <cmath>
+#include <functional>
+#include <limits>
+
+#include <CppWinRTIncludes.h>
+#include <d2d1_1.h>
+#include <react/renderer/graphics/ColorComponents.h>
+#include <optional>
+
+namespace facebook {
+namespace react {
+
+struct Color {
+  bool operator==(const Color &otherColor) const {
+    return m_color == otherColor.m_color && m_platformColor == otherColor.m_platformColor;
+  }
+  bool operator!=(const Color &otherColor) const {
+    return m_color != otherColor.m_color || m_platformColor != otherColor.m_platformColor;
+  }
+
+  winrt::Windows::UI::Color m_color;
+  std::string m_platformColor;
+};
+
+/*
+ * On Android, a color can be represented as 32 bits integer, so there is no
+ * need to instantiate complex color objects and then pass them as shared
+ * pointers. Hense instead of using shared_ptr, we use a simple wrapper class
+ * which provides a pointer-like interface.
+ */
+class SharedColor {
+  friend std::hash<SharedColor>;
+
+ public:
+  SharedColor() : m_color(nullptr) {}
+
+  SharedColor(const SharedColor &sharedColor) : m_color(sharedColor.m_color) {}
+
+  SharedColor(winrt::Windows::UI::Color color) {
+    m_color = std::make_shared<Color>();
+    m_color->m_color = color;
+  }
+
+  SharedColor(std::string &&windowsBrush) {
+    m_color = std::make_shared<Color>();
+    m_color->m_platformColor = std::move(windowsBrush);
+  }
+
+  SharedColor &operator=(const SharedColor &sharedColor) {
+    m_color = sharedColor.m_color;
+    return *this;
+  }
+
+  Color operator*() const {
+    return *m_color;
+  }
+
+  bool operator==(const SharedColor &otherColor) const {
+    if (!m_color && !otherColor.m_color)
+      return true;
+    if (!m_color || !otherColor.m_color)
+      return false;
+    return *m_color == *otherColor.m_color;
+  }
+
+  bool operator!=(const SharedColor &otherColor) const {
+    if (!m_color && !otherColor.m_color)
+      return false;
+    if (!m_color || !otherColor.m_color)
+      return true;
+    return *m_color != *otherColor.m_color;
+  }
+
+  operator bool() const {
+    return m_color != nullptr;
+  }
+
+  D2D1::ColorF AsD2DColor() const {
+    return {
+        m_color->m_color.R / 255.0f,
+        m_color->m_color.G / 255.0f,
+        m_color->m_color.B / 255.0f,
+        m_color->m_color.A / 255.0f};
+  }
+
+  winrt::Windows::UI::Color AsWindowsColor() const {
+    return m_color->m_color;
+  }
+
+  COLORREF AsColorRefNoAlpha() const {
+    return RGB(m_color->m_color.R, m_color->m_color.G, m_color->m_color.B);
+  }
+
+  COLORREF AsColorRefWithAlpha() const {
+    return RGB(m_color->m_color.R, m_color->m_color.G, m_color->m_color.B) | (m_color->m_color.A << 24);
+  }
+
+#ifndef CORE_ABI
+  xaml::Media::Brush AsWindowsBrush() const;
+#endif
+
+ private:
+  std::shared_ptr<Color> m_color;
+};
+
+bool isColorMeaningful(SharedColor const &color) noexcept;
+SharedColor colorFromComponents(ColorComponents components);
+ColorComponents colorComponentsFromColor(SharedColor const &color);
+
+SharedColor clearColor();
+SharedColor blackColor();
+SharedColor whiteColor();
+SharedColor greyColor();
+
+} // namespace react
+} // namespace facebook
+
+namespace std {
+template <>
+struct hash<facebook::react::SharedColor> {
+  size_t operator()(const facebook::react::SharedColor &sharedColor) const {
+    size_t h = sharedColor.m_color->m_color.A + (sharedColor.m_color->m_color.B << 8) +
+        (sharedColor.m_color->m_color.G << 16) + (sharedColor.m_color->m_color.R << 24);
+    return h ^ hash<decltype(sharedColor.m_color->m_platformColor)>{}(sharedColor.m_color->m_platformColor);
+  }
+};
+} // namespace std