react-native-windows 0.73.10 → 0.74.0-preview.1

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

@@ -1,245 +0,0 @@
-/*
- * 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 <unordered_map>
-
-#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::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<std::unordered_map<std::string, std::vector<std::string>>>()) {
-    auto map = (std::unordered_map<std::string, std::vector<std::string>>)value;
-    if (map.find("windowsbrush") != map.end()) {
-      result = SharedColor(std::move(map["windowsbrush"]));
-      return;
-    }
-  }
-  // Windows]
-  result = colorFromComponents(colorComponents);
-  return;
-}
-
-#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<std::unordered_map<std::string, Float>>()) {
-    auto map = (std::unordered_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<std::unordered_map<std::string, Float>>()) {
-    auto map = (std::unordered_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<std::unordered_map<std::string, Float>>()) {
-    auto map = (std::unordered_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<std::unordered_map<std::string, Float>>()) {
-    auto map = (std::unordered_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 facebook::react

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

@@ -1,134 +0,0 @@
-/*
- * 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 <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::vector<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. Hence instead of using shared_ptr, we use a simple wrapper class
- * which provides a pointer-like interface. On other platforms, colors may be
- * represented by more complex objects that cannot be represented as 32-bits
- * integers, so we hide the implementation detail in HostPlatformColor.h.
- */
-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::vector<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;
-
-  winrt::Windows::UI::Color AsWindowsColor() const;
-
-  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(const SharedColor &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);
-
-    for (auto s : sharedColor.m_color->m_platformColor) {
-      h ^= hash<decltype(s)>{}(s);
-    }
-
-    return h;
-  }
-};
-} // namespace std

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

@@ -1,27 +0,0 @@
-/*
- * 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 <react/renderer/core/graphicsConversions.h>
-
-// This file belongs to the React-graphics module.
-// This file also used to have a reference to two files that are located in the
-// react/renderer/core folder. That folder belongs to a module that is called
-// React-Fabric.
-// The React-Fabric module declares an explicit dependency on
-// React-graphics. Including those files in a React-graphics' file created a
-// circular dependency because React-Fabric was explicitly depending on
-// React-graphics, which was implicitly depending on React-Fabric. We break that
-// dependency by moving the old `graphics/conversions.h` file to the
-// React-Fabric module and renaming it `core/graphicsConversions.h`.
-
-#warning \
-    "[DEPRECATION] `graphics/conversions.h` is deprecated and will be removed in the future. \
-    If this warning appears due to a library, please open an issue in that library, and ask for an update. \
-    Please, replace the `#include <react/renderer/graphics/conversions.h>` statements \
-    with `#include <react/renderer/core/graphicsConversions.h>`."

package/Microsoft.ReactNative/Modules/TimingModule.cpp

@@ -1,229 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-
-#include "pch.h"
-#undef Check
-
-#include "TimingModule.h"
-
-#include <InstanceManager.h>
-#include <UI.Xaml.Media.h>
-#include <Utils/ValueUtils.h>
-#include <XamlUtils.h>
-
-#include <unknwnbase.h>
-
-using namespace facebook::xplat;
-using namespace folly;
-namespace winrt {
-using namespace Windows::Foundation;
-using namespace xaml::Media;
-} // namespace winrt
-using namespace std;
-
-namespace Microsoft::ReactNative {
-
-//
-// IsAnimationFrameRequest
-//
-static bool IsAnimationFrameRequest(TTimeSpan period, bool repeat) {
-  return !repeat && period == std::chrono::milliseconds(1);
-}
-
-//
-// TimerQueue
-//
-
-TimerQueue::TimerQueue() {
-  std::make_heap(m_timerVector.begin(), m_timerVector.end());
-}
-
-void TimerQueue::Push(int64_t id, TDateTime targetTime, TTimeSpan period, bool repeat) {
-  m_timerVector.emplace_back(id, targetTime, period, repeat);
-  std::push_heap(m_timerVector.begin(), m_timerVector.end());
-}
-
-void TimerQueue::Pop() {
-  std::pop_heap(m_timerVector.begin(), m_timerVector.end());
-  m_timerVector.pop_back();
-}
-
-Timer &TimerQueue::Front() {
-  return m_timerVector.front();
-}
-
-void TimerQueue::Remove(int64_t id) {
-  // TODO: This is very inefficient, but doing this with a heap is inherently
-  // hard. If performance is not good
-  //	enough for the scenarios then a different structure is probably needed.
-  auto found = std::find(m_timerVector.begin(), m_timerVector.end(), id);
-  if (found != m_timerVector.end())
-    m_timerVector.erase(found);
-
-  std::make_heap(m_timerVector.begin(), m_timerVector.end());
-}
-
-bool TimerQueue::IsEmpty() {
-  return m_timerVector.empty();
-}
-
-//
-// Timing
-//
-
-void Timing::Initialize(winrt::Microsoft::ReactNative::ReactContext const &reactContext) noexcept {
-  m_context = reactContext;
-  m_usePostForRendering = !xaml::TryGetCurrentApplication();
-}
-
-void Timing::OnTick() {
-  winrt::Microsoft::ReactNative::JSValueArray readyTimers;
-  auto now = TDateTime::clock::now();
-
-  auto emittedAnimationFrame = false;
-  while (!m_timerQueue.IsEmpty() && m_timerQueue.Front().TargetTime < now) {
-    // Pop first timer from the queue and add it to list of timers ready to fire
-    Timer next = m_timerQueue.Front();
-    m_timerQueue.Pop();
-    readyTimers.push_back(next.Id);
-
-    // If timer is repeating push it back onto the queue for the next repetition
-    if (next.Repeat)
-      m_timerQueue.Push(next.Id, now + next.Period, next.Period, true);
-    else if (IsAnimationFrameRequest(next.Period, next.Repeat))
-      emittedAnimationFrame = true;
-  }
-
-  if (m_timerQueue.IsEmpty()) {
-    StopTicks();
-  } else if (m_usePostForRendering && m_usingRendering && emittedAnimationFrame) {
-    PostRenderFrame(); // Repost
-  } else if (!m_usingRendering || !emittedAnimationFrame) {
-    // If we're using a rendering callback, check if any animation frame
-    // requests were emitted in this tick. If not, start the dispatcher timer.
-    // This extra frame gives JS a chance to enqueue an additional animation
-    // frame request before switching tick schedulers.
-    StartDispatcherTimer();
-  }
-
-  if (!readyTimers.empty()) {
-    m_context.CallJSFunction(
-        L"JSTimers", L"callTimers", winrt::Microsoft::ReactNative::JSValueArray{std::move(readyTimers)});
-  }
-}
-
-winrt::dispatching::DispatcherQueueTimer Timing::EnsureDispatcherTimer() {
-  if (!m_dispatcherQueueTimer) {
-    const auto queue = winrt::dispatching::DispatcherQueue::GetForCurrentThread();
-    m_dispatcherQueueTimer = queue.CreateTimer();
-    m_dispatcherQueueTimer.Tick([wkThis = std::weak_ptr(this->shared_from_this())](auto &&...) {
-      if (auto pThis = wkThis.lock()) {
-        pThis->OnTick();
-      }
-    });
-  }
-
-  return m_dispatcherQueueTimer;
-}
-
-void Timing::PostRenderFrame() noexcept {
-  assert(m_usePostForRendering);
-  m_usingRendering = true;
-  m_context.UIDispatcher().Post([wkThis = std::weak_ptr(this->shared_from_this())]() {
-    if (auto pThis = wkThis.lock()) {
-      pThis->m_usingRendering = false;
-      pThis->OnTick();
-    }
-  });
-}
-
-void Timing::StartRendering() {
-  if (m_dispatcherQueueTimer)
-    m_dispatcherQueueTimer.Stop();
-
-  if (m_usePostForRendering) {
-    PostRenderFrame();
-    return;
-  }
-  m_rendering.revoke();
-  m_usingRendering = true;
-  m_rendering = xaml::Media::CompositionTarget::Rendering(
-      winrt::auto_revoke,
-      [wkThis = std::weak_ptr(this->shared_from_this())](
-          const winrt::IInspectable &, const winrt::IInspectable & /*args*/) {
-        if (auto pThis = wkThis.lock()) {
-          pThis->OnTick();
-        }
-      });
-}
-
-void Timing::StartDispatcherTimer() {
-  const auto &nextTimer = m_timerQueue.Front();
-  m_rendering.revoke();
-  m_usingRendering = false;
-  auto timer = EnsureDispatcherTimer();
-  timer.Interval(std::max(nextTimer.TargetTime - TDateTime::clock::now(), TTimeSpan::zero()));
-  timer.Start();
-}
-
-void Timing::StopTicks() {
-  m_rendering.revoke();
-  m_usingRendering = false;
-  if (m_dispatcherQueueTimer)
-    m_dispatcherQueueTimer.Stop();
-}
-
-void Timing::createTimerOnQueue(int64_t id, double duration, double jsSchedulingTime, bool repeat) noexcept {
-  if (duration == 0 && !repeat) {
-    m_context.CallJSFunction(
-        L"JSTimers",
-        L"callTimers",
-        winrt::Microsoft::ReactNative::JSValueArray{winrt::Microsoft::ReactNative::JSValueArray{id}});
-
-    return;
-  }
-
-  // Convert double duration in ms to TimeSpan
-  auto period = TimeSpanFromMs(duration);
-  const int64_t msFrom1601to1970 = 11644473600000;
-  TDateTime scheduledTime(TimeSpanFromMs(jsSchedulingTime + msFrom1601to1970));
-  auto initialTargetTime = scheduledTime + period;
-  m_timerQueue.Push(id, initialTargetTime, period, repeat);
-  if (!m_usingRendering) {
-    if (IsAnimationFrameRequest(period, repeat)) {
-      StartRendering();
-    } else if (initialTargetTime <= m_timerQueue.Front().TargetTime) {
-      StartDispatcherTimer();
-    }
-  }
-}
-
-void Timing::createTimer(double id, double duration, double jsSchedulingTime, bool repeat) noexcept {
-  winrt::Microsoft::ReactNative::implementation::ReactCoreInjection::PostToUIBatchingQueue(
-      m_context.Handle(), [wkThis = std::weak_ptr(this->shared_from_this()), id, duration, jsSchedulingTime, repeat]() {
-        if (auto pThis = wkThis.lock()) {
-          pThis->createTimerOnQueue(static_cast<int64_t>(id), duration, jsSchedulingTime, repeat);
-        }
-      });
-}
-
-void Timing::deleteTimerOnQueue(int64_t id) noexcept {
-  m_timerQueue.Remove(id);
-  if (m_timerQueue.IsEmpty())
-    StopTicks();
-}
-
-void Timing::deleteTimer(double id) noexcept {
-  winrt::Microsoft::ReactNative::implementation::ReactCoreInjection::PostToUIBatchingQueue(
-      m_context.Handle(), [wkThis = std::weak_ptr(this->shared_from_this()), id]() {
-        if (auto pThis = wkThis.lock()) {
-          pThis->deleteTimerOnQueue(static_cast<int64_t>(id));
-        }
-      });
-}
-
-void Timing::setSendIdleEvents(bool /*sendIdleEvents*/) noexcept {
-  // TODO: Implement.
-}
-
-} // namespace Microsoft::ReactNative