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

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

@@ -1,135 +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 <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();
-
-} // 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

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/renderer/core/ConcreteComponentDescriptor.h

@@ -1,217 +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 <memory>
-
-#include <react/debug/react_native_assert.h>
-#include <react/renderer/components/view/ViewPropsInterpolation.h>
-#include <react/renderer/core/ComponentDescriptor.h>
-#include <react/renderer/core/CoreFeatures.h>
-#include <react/renderer/core/EventDispatcher.h>
-#include <react/renderer/core/Props.h>
-#include <react/renderer/core/PropsParserContext.h>
-#include <react/renderer/core/ShadowNode.h>
-#include <react/renderer/core/ShadowNodeFragment.h>
-#include <react/renderer/core/State.h>
-#include <react/renderer/graphics/Float.h>
-
-namespace facebook {
-namespace react {
-
-/*
- * Default template-based implementation of ComponentDescriptor.
- * Use your `ShadowNode` type as a template argument and override any methods
- * if necessary.
- */
-template <typename ShadowNodeT>
-class ConcreteComponentDescriptor : public ComponentDescriptor {
-  static_assert(
-      std::is_base_of<ShadowNode, ShadowNodeT>::value,
-      "ShadowNodeT must be a descendant of ShadowNode");
-
-  using SharedShadowNodeT = std::shared_ptr<const ShadowNodeT>;
-
- public:
-  using ConcreteShadowNode = ShadowNodeT;
-  using ConcreteProps = typename ShadowNodeT::ConcreteProps;
-  using SharedConcreteProps = typename ShadowNodeT::SharedConcreteProps;
-  using ConcreteEventEmitter = typename ShadowNodeT::ConcreteEventEmitter;
-  using SharedConcreteEventEmitter =
-      typename ShadowNodeT::SharedConcreteEventEmitter;
-  using ConcreteState = typename ShadowNodeT::ConcreteState;
-  using ConcreteStateData = typename ShadowNodeT::ConcreteState::Data;
-
-  ConcreteComponentDescriptor(ComponentDescriptorParameters const &parameters)
-      : ComponentDescriptor(parameters) {
-    rawPropsParser_.prepare<ConcreteProps>();
-  }
-
-  ComponentHandle getComponentHandle() const override {
-    return ShadowNodeT::Handle();
-  }
-
-  ComponentName getComponentName() const override {
-    return ShadowNodeT::Name();
-  }
-
-  ShadowNodeTraits getTraits() const override {
-    return ShadowNodeT::BaseTraits();
-  }
-
-  ShadowNode::Shared createShadowNode(
-      const ShadowNodeFragment &fragment,
-      ShadowNodeFamily::Shared const &family) const override {
-    auto shadowNode =
-        std::make_shared<ShadowNodeT>(fragment, family, getTraits());
-
-    adopt(shadowNode);
-
-    return shadowNode;
-  }
-
-  ShadowNode::Unshared cloneShadowNode(
-      const ShadowNode &sourceShadowNode,
-      const ShadowNodeFragment &fragment) const override {
-    auto shadowNode = std::make_shared<ShadowNodeT>(sourceShadowNode, fragment);
-
-    adopt(shadowNode);
-    return shadowNode;
-  }
-
-  void appendChild(
-      const ShadowNode::Shared &parentShadowNode,
-      const ShadowNode::Shared &childShadowNode) const override {
-    auto concreteParentShadowNode =
-        std::static_pointer_cast<const ShadowNodeT>(parentShadowNode);
-    auto concreteNonConstParentShadowNode =
-        std::const_pointer_cast<ShadowNodeT>(concreteParentShadowNode);
-    concreteNonConstParentShadowNode->appendChild(childShadowNode);
-  }
-
-  virtual Props::Shared cloneProps(
-      const PropsParserContext &context,
-      const Props::Shared &props,
-      const RawProps &rawProps) const override {
-    // Optimization:
-    // Quite often nodes are constructed with default/empty props: the base
-    // `props` object is `null` (there no base because it's not cloning) and the
-    // `rawProps` is empty. In this case, we can return the default props object
-    // of a concrete type entirely bypassing parsing.
-    if (!props && rawProps.isEmpty()) {
-      return ShadowNodeT::defaultSharedProps();
-    }
-
-    rawProps.parse(rawPropsParser_, context);
-
-    // Call old-style constructor
-    auto shadowNodeProps = ShadowNodeT::Props(context, rawProps, props);
-
-    // Use the new-style iterator
-    // Note that we just check if `Props` has this flag set, no matter
-    // the type of ShadowNode; it acts as the single global flag.
-    if (CoreFeatures::enablePropIteratorSetter) {
-      rawProps.iterateOverValues([&](RawPropsPropNameHash hash,
-                                     const char *propName,
-                                     RawValue const &fn) {
-        shadowNodeProps.get()->Props::setProp(context, hash, propName, fn);
-      });
-    }
-
-    return shadowNodeProps;
-  };
-
-  Props::Shared interpolateProps(
-      const PropsParserContext &context,
-      Float animationProgress,
-      const Props::Shared &props,
-      const Props::Shared &newProps) const override {
-#ifdef ANDROID
-    // On Android only, the merged props should have the same RawProps as the
-    // final props struct
-    Props::Shared interpolatedPropsShared =
-        (newProps != nullptr ? cloneProps(context, newProps, newProps->rawProps)
-                             : cloneProps(context, newProps, {}));
-#else
-    Props::Shared interpolatedPropsShared = cloneProps(context, newProps, {});
-#endif
-
-    if (ConcreteShadowNode::BaseTraits().check(
-            ShadowNodeTraits::Trait::ViewKind)) {
-      interpolateViewProps(
-          animationProgress, props, newProps, interpolatedPropsShared);
-    }
-
-    return interpolatedPropsShared;
-  };
-
-  virtual State::Shared createInitialState(
-      ShadowNodeFragment const &fragment,
-      ShadowNodeFamily::Shared const &family) const override {
-    if (std::is_same<ConcreteStateData, StateData>::value) {
-      // Default case: Returning `null` for nodes that don't use `State`.
-      return nullptr;
-    }
-
-    return std::make_shared<ConcreteState>(
-        std::make_shared<ConcreteStateData const>(
-            ConcreteShadowNode::initialStateData(
-                fragment, ShadowNodeFamilyFragment::build(*family), *this)),
-        family);
-  }
-
-  virtual State::Shared createState(
-      ShadowNodeFamily const &family,
-      StateData::Shared const &data) const override {
-    if (std::is_same<ConcreteStateData, StateData>::value) {
-      // Default case: Returning `null` for nodes that don't use `State`.
-      return nullptr;
-    }
-
-    react_native_assert(data && "Provided `data` is nullptr.");
-
-    return std::make_shared<ConcreteState const>(
-        std::static_pointer_cast<ConcreteStateData const>(data),
-        *family.getMostRecentState());
-  }
-
-  ShadowNodeFamily::Shared createFamily(
-      ShadowNodeFamilyFragment const &fragment,
-      SharedEventTarget eventTarget) const override {
-    auto eventEmitter = std::make_shared<ConcreteEventEmitter const>(
-        std::move(eventTarget), fragment.tag, eventDispatcher_);
-    return std::make_shared<ShadowNodeFamily>(
-        ShadowNodeFamilyFragment{
-            fragment.tag, fragment.surfaceId, eventEmitter},
-        eventDispatcher_,
-        *this);
-  }
-
- protected:
-  /*
-   * Called immediatelly after `ShadowNode` is created or cloned.
-   *
-   * Override this method to pass information from custom `ComponentDescriptor`
-   * to new instance of `ShadowNode`.
-   *
-   * Example usages:
-   *   - Inject image manager to `ImageShadowNode` in
-   * `ImageComponentDescriptor`.
-   *   - Set `ShadowNode`'s size from state in
-   * `ModalHostViewComponentDescriptor`.
-   */
-  virtual void adopt(ShadowNode::Unshared const &shadowNode) const {
-    // Default implementation does nothing.
-    react_native_assert(
-        shadowNode->getComponentHandle() == getComponentHandle());
-  }
-};
-
-} // namespace react
-} // namespace facebook

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/renderer/graphics/RectangleEdges.h

@@ -1,100 +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 <tuple>
-
-#include <folly/Hash.h>
-#include <react/renderer/graphics/Float.h>
-#include <react/renderer/graphics/Rect.h>
-
-namespace facebook {
-namespace react {
-
-/*
- * Generic data structure describes some values associated with *edges*
- * of a rectangle.
- */
-template <typename T>
-struct RectangleEdges {
-  T left{};
-  T top{};
-  T right{};
-  T bottom{};
-
-  bool operator==(RectangleEdges<T> const &rhs) const noexcept {
-    return std::tie(this->left, this->top, this->right, this->bottom) ==
-        std::tie(rhs.left, rhs.top, rhs.right, rhs.bottom);
-  }
-
-  bool operator!=(RectangleEdges<T> const &rhs) const noexcept {
-    return !(*this == rhs);
-  }
-
-  bool isUniform() const noexcept {
-    return left == top && left == right && left == bottom;
-  }
-
-  static RectangleEdges<T> const ZERO;
-};
-
-template <typename T>
-RectangleEdges<T> const RectangleEdges<T>::ZERO = {};
-
-template <typename T>
-RectangleEdges<T> operator+(
-    RectangleEdges<T> const &lhs,
-    RectangleEdges<T> const &rhs) noexcept {
-  return RectangleEdges<T>{
-      lhs.left + rhs.left,
-      lhs.top + rhs.top,
-      lhs.right + rhs.right,
-      lhs.bottom + rhs.bottom};
-}
-
-template <typename T>
-RectangleEdges<T> operator-(
-    RectangleEdges<T> const &lhs,
-    RectangleEdges<T> const &rhs) noexcept {
-  return RectangleEdges<T>{
-      lhs.left - rhs.left,
-      lhs.top - rhs.top,
-      lhs.right - rhs.right,
-      lhs.bottom - rhs.bottom};
-}
-
-/*
- * EdgeInsets
- */
-using EdgeInsets = RectangleEdges<Float>;
-
-/*
- * Adjusts a rectangle by the given edge insets.
- */
-inline Rect insetBy(Rect const &rect, EdgeInsets const &insets) noexcept {
-  return Rect{
-      {rect.origin.x + insets.left, rect.origin.y + insets.top},
-      {rect.size.width - insets.left - insets.right,
-       rect.size.height - insets.top - insets.bottom}};
-}
-
-} // namespace react
-} // namespace facebook
-
-namespace std {
-
-template <typename T>
-struct hash<facebook::react::RectangleEdges<T>> {
-  size_t operator()(
-      facebook::react::RectangleEdges<T> const &edges) const noexcept {
-    return folly::hash::hash_combine(
-        0, edges.left, edges.right, edges.top, edges.bottom);
-  }
-};
-
-} // namespace std

package/Shared/AsyncStorage/AsyncStorageManager.cpp

@@ -1,149 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-
-#include <AsyncStorage/AsyncStorageManager.h>
-
-using namespace std;
-using namespace folly;
-using namespace facebook::xplat;
-
-namespace facebook {
-namespace react {
-const folly::dynamic noError;
-const std::vector<folly::dynamic> noErrorVector = {noError};
-
-AsyncStorageManager::AsyncStorageManager(const WCHAR *storageFileName)
-    : m_aofKVStorage{make_unique<KeyValueStorage>(storageFileName)},
-      m_stopConsumer{false},
-      m_consumerTask{std::async(std::launch::async, &AsyncStorageManager::consumeSetRequest, this)} {}
-
-AsyncStorageManager::~AsyncStorageManager() {
-  m_stopConsumer = true;
-  m_storageQueueConditionVariable.notify_one();
-  m_consumerTask.get();
-}
-
-void AsyncStorageManager::putRequestOnQueue(
-    AsyncStorageOperation operation,
-    const dynamic &args,
-    const module::CxxModule::Callback &jsCallback) noexcept {
-  std::unique_ptr<AsyncRequestQueueArguments> arguments =
-      make_unique<AsyncRequestQueueArguments>(operation, std::move(args), std::move(jsCallback));
-  {
-    std::lock_guard<std::mutex> lockGuard(m_setQueueMutex);
-    m_asyncQueue.push(std::move(arguments));
-  }
-
-  m_storageQueueConditionVariable.notify_one();
-}
-
-void AsyncStorageManager::consumeSetRequest() noexcept {
-  while (!m_stopConsumer) {
-    std::unique_lock<std::mutex> uniqueMutex(m_setQueueMutex);
-    m_storageQueueConditionVariable.wait(uniqueMutex, [this] { return m_stopConsumer || !m_asyncQueue.empty(); });
-
-    if (!m_asyncQueue.empty()) {
-      std::unique_ptr<AsyncRequestQueueArguments> arguments = std::move(m_asyncQueue.front());
-      m_asyncQueue.pop();
-
-      uniqueMutex.unlock();
-
-      executeAsyncKVOperation(arguments->m_operation, arguments->m_args, arguments->m_jsCallback);
-    }
-  }
-}
-
-folly::dynamic AsyncStorageManager::makeError(std::string &&strErrorMessage) noexcept {
-  folly::dynamic error = folly::dynamic::object("message", strErrorMessage);
-  return {error};
-}
-
-void AsyncStorageManager::executeKVOperation(
-    AsyncStorageOperation operation,
-    const dynamic &args,
-    const module::CxxModule::Callback &jsCallback) noexcept {
-  try {
-    switch (operation) {
-      case AsyncStorageOperation::multiGet:
-        multiGetInternal(args, jsCallback);
-        break;
-
-      case AsyncStorageOperation::getAllKeys:
-        getAllKeysInternal(args, jsCallback);
-        break;
-
-      default:
-        putRequestOnQueue(operation, args, jsCallback);
-        break;
-    }
-  } catch (std::exception &e) {
-    jsCallback({makeError(e.what())});
-  }
-}
-
-void AsyncStorageManager::executeAsyncKVOperation(
-    AsyncStorageOperation operation,
-    const dynamic &args,
-    const module::CxxModule::Callback &jsCallback) noexcept {
-  try {
-    switch (operation) {
-      case AsyncStorageOperation::multiSet:
-        multiSetInternal(args, jsCallback);
-        break;
-
-      case AsyncStorageOperation::multiRemove:
-        multiRemoveInternal(args, jsCallback);
-        break;
-
-      case AsyncStorageOperation::clear:
-        clearInternal(args, jsCallback);
-        break;
-
-      case AsyncStorageOperation::multiMerge:
-        multiMergeInternal(args, jsCallback);
-        break;
-
-      default:
-        jsCallback({makeError("Invalid AsyncStorage operation")});
-        break;
-    }
-  } catch (std::exception &e) {
-    jsCallback({makeError(e.what())});
-  }
-}
-
-void AsyncStorageManager::multiGetInternal(const dynamic &args, const module::CxxModule::Callback &jsCallback) {
-  std::vector<std::tuple<std::string, std::string>> retVals =
-      m_aofKVStorage->multiGet(FollyDynamicConverter::jsArgAsStringVector(args));
-  folly::dynamic jsRetVal = FollyDynamicConverter::tupleStringVectorAsRetVal(retVals);
-  jsCallback({noError, jsRetVal});
-}
-
-void AsyncStorageManager::multiSetInternal(const dynamic &args, const module::CxxModule::Callback &jsCallback) {
-  m_aofKVStorage->multiSet(FollyDynamicConverter::jsArgAsTupleStringVector(args));
-  jsCallback(noErrorVector);
-}
-
-void AsyncStorageManager::multiRemoveInternal(const dynamic &args, const module::CxxModule::Callback &jsCallback) {
-  m_aofKVStorage->multiRemove(FollyDynamicConverter::jsArgAsStringVector(args));
-  jsCallback(noErrorVector);
-}
-
-void AsyncStorageManager::clearInternal(const dynamic &args, const module::CxxModule::Callback &jsCallback) {
-  UNREFERENCED_PARAMETER(args);
-  m_aofKVStorage->clear();
-  jsCallback(noErrorVector);
-}
-
-void AsyncStorageManager::multiMergeInternal(const dynamic &args, const module::CxxModule::Callback &jsCallback) {
-  m_aofKVStorage->multiMerge(FollyDynamicConverter::jsArgAsTupleStringVector(args));
-  jsCallback(noErrorVector);
-}
-
-void AsyncStorageManager::getAllKeysInternal(const dynamic &args, const module::CxxModule::Callback &jsCallback) {
-  std::vector<std::string> keys = m_aofKVStorage->getAllKeys();
-  folly::dynamic jsRetVal = FollyDynamicConverter::stringVectorAsRetVal(keys);
-  jsCallback({noError, jsRetVal});
-}
-} // namespace react
-} // namespace facebook

package/Shared/AsyncStorage/AsyncStorageManager.h

@@ -1,71 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include <AsyncStorage/FollyDynamicConverter.h>
-#include <AsyncStorage/KeyValueStorage.h>
-#include <cxxreact/CxxModule.h>
-#include <folly/dynamic.h>
-
-#include <condition_variable>
-#include <future>
-#include <queue>
-
-namespace facebook {
-namespace react {
-class AsyncStorageManager {
- public:
-  AsyncStorageManager(const WCHAR *storageFileName);
-  ~AsyncStorageManager();
-
-  enum class AsyncStorageOperation { multiGet, multiSet, multiRemove, clear, multiMerge, getAllKeys };
-  void executeKVOperation(
-      AsyncStorageOperation operation,
-      const folly::dynamic &args,
-      const xplat::module::CxxModule::Callback &jsCallback) noexcept;
-
- private:
-  struct AsyncRequestQueueArguments {
-    AsyncRequestQueueArguments(
-        AsyncStorageOperation paramOperation,
-        const folly::dynamic &&paramArgs,
-        const xplat::module::CxxModule::Callback &&paramJsCallback) noexcept
-        : m_operation(paramOperation), m_args(std::move(paramArgs)), m_jsCallback(std::move(paramJsCallback)) {}
-
-    AsyncStorageOperation m_operation;
-    folly::dynamic m_args;
-    xplat::module::CxxModule::Callback m_jsCallback;
-  };
-
- private:
-  std::atomic_bool m_stopConsumer;
-  std::mutex m_setQueueMutex;
-  std::condition_variable m_storageQueueConditionVariable;
-  std::future<void> m_consumerTask;
-  std::queue<std::unique_ptr<AsyncStorageManager::AsyncRequestQueueArguments>> m_asyncQueue;
-  std::unique_ptr<KeyValueStorage> m_aofKVStorage;
-
- private:
-  folly::dynamic makeError(std::string &&strErrorMessage) noexcept;
-
-  void executeAsyncKVOperation(
-      AsyncStorageOperation operation,
-      const folly::dynamic &args,
-      const xplat::module::CxxModule::Callback &jsCallback) noexcept;
-
-  void consumeSetRequest() noexcept;
-  void putRequestOnQueue(
-      AsyncStorageOperation operation,
-      const folly::dynamic &args,
-      const xplat::module::CxxModule::Callback &jsCallback) noexcept;
-
-  void multiGetInternal(const folly::dynamic &args, const xplat::module::CxxModule::Callback &jsCallback);
-  void multiSetInternal(const folly::dynamic &args, const xplat::module::CxxModule::Callback &jsCallback);
-  void multiRemoveInternal(const folly::dynamic &args, const xplat::module::CxxModule::Callback &jsCallback);
-  void clearInternal(const folly::dynamic &args, const xplat::module::CxxModule::Callback &jsCallback);
-  void multiMergeInternal(const folly::dynamic &args, const xplat::module::CxxModule::Callback &jsCallback);
-  void getAllKeysInternal(const folly::dynamic &args, const xplat::module::CxxModule::Callback &jsCallback);
-};
-} // namespace react
-} // namespace facebook