react-native-windows 0.81.3 → 0.82.0-preview.10

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/renderer/components/image/conversions.h

@@ -0,0 +1,174 @@
+/*
+ * 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 <folly/dynamic.h>
+#include <glog/logging.h>
+#include <react/debug/react_native_expect.h>
+#include <react/renderer/core/PropsParserContext.h>
+#include <react/renderer/core/graphicsConversions.h>
+#include <react/renderer/imagemanager/primitives.h>
+
+namespace facebook::react {
+
+inline void fromRawValue(const PropsParserContext &context, const RawValue &value, ImageSource &result) {
+  if (value.hasType<std::string>()) {
+    result = {
+        /* .type = */ ImageSource::Type::Remote,
+        /* .uri = */ (std::string)value,
+    };
+    return;
+  }
+
+  if (value.hasType<std::unordered_map<std::string, RawValue>>()) {
+    auto items = (std::unordered_map<std::string, RawValue>)value;
+    result = {};
+
+    result.type = ImageSource::Type::Remote;
+
+    if (items.find("__packager_asset") != items.end()) {
+      result.type = ImageSource::Type::Local;
+    }
+
+    if (items.find("width") != items.end() && items.find("height") != items.end() &&
+        // The following checks have to be removed after codegen is shipped.
+        // See T45151459.
+        items.at("width").hasType<Float>() && items.at("height").hasType<Float>()) {
+      result.size = {(Float)items.at("width"), (Float)items.at("height")};
+    }
+
+    if (items.find("scale") != items.end() &&
+        // The following checks have to be removed after codegen is shipped.
+        // See T45151459.
+        items.at("scale").hasType<Float>()) {
+      result.scale = (Float)items.at("scale");
+    } else {
+      result.scale = items.find("deprecated") != items.end() ? 0.0f : 1.0f;
+    }
+
+    if (items.find("url") != items.end() &&
+        // The following should be removed after codegen is shipped.
+        // See T45151459.
+        items.at("url").hasType<std::string>()) {
+      result.uri = (std::string)items.at("url");
+    }
+
+    if (items.find("uri") != items.end() &&
+        // The following should be removed after codegen is shipped.
+        // See T45151459.
+        items.at("uri").hasType<std::string>()) {
+      result.uri = (std::string)items.at("uri");
+    }
+
+    if (items.find("bundle") != items.end() &&
+        // The following should be removed after codegen is shipped.
+        // See T45151459.
+        items.at("bundle").hasType<std::string>()) {
+      result.bundle = (std::string)items.at("bundle");
+      result.type = ImageSource::Type::Local;
+    }
+
+    if (items.find("headers") != items.end() &&
+        items.at("headers").hasType<std::unordered_map<std::string, std::string>>()) {
+      auto headers = (std::unordered_map<std::string, std::string>)items.at("headers");
+      for (const auto &header : headers) {
+        result.headers.push_back(header);
+      }
+    }
+
+    if (items.find("body") != items.end() && items.at("body").hasType<std::string>()) {
+      result.body = (std::string)items.at("body");
+    }
+
+    if (items.find("method") != items.end() && items.at("method").hasType<std::string>()) {
+      result.method = (std::string)items.at("method");
+    }
+
+    if (items.find("cache") != items.end() && items.at("cache").hasType<std::string>()) {
+      auto cache = (std::string)items.at("cache");
+      if (cache == "reload") {
+        result.cache = ImageSource::CacheStategy::Reload;
+      } else if (cache == "force-cache") {
+        result.cache = ImageSource::CacheStategy::ForceCache;
+      } else if (cache == "only-if-cached") {
+        result.cache = ImageSource::CacheStategy::OnlyIfCached;
+      }
+    }
+
+    return;
+  }
+
+  // The following should be removed after codegen is shipped.
+  // See T45151459.
+  result = {};
+  result.type = ImageSource::Type::Invalid;
+}
+
+inline std::string toString(const ImageSource &value) {
+  return "{uri: " + value.uri + "}";
+}
+
+inline void fromRawValue(const PropsParserContext &context, const RawValue &value, ImageResizeMode &result) {
+  react_native_expect(value.hasType<std::string>());
+  if (!value.hasType<std::string>()) {
+    LOG(ERROR) << "Unsupported ImageResizeMode type";
+    // "cover" is default in non-Fabric web and iOS
+    result = ImageResizeMode::Cover;
+    return;
+  }
+
+  auto stringValue = (std::string)value;
+  if (stringValue == "cover") {
+    result = ImageResizeMode::Cover;
+  } else if (stringValue == "contain") {
+    result = ImageResizeMode::Contain;
+  } else if (stringValue == "stretch") {
+    result = ImageResizeMode::Stretch;
+  } else if (stringValue == "center") {
+    result = ImageResizeMode::Center;
+  } else if (stringValue == "repeat") {
+    result = ImageResizeMode::Repeat;
+  } else if (stringValue == "none") {
+    result = ImageResizeMode::None;
+  } else {
+    LOG(ERROR) << "Unsupported ImageResizeMode value: " << stringValue;
+    react_native_expect(false);
+    // "cover" is default in non-Fabric web and iOS
+    result = ImageResizeMode::Cover;
+  }
+}
+
+inline std::string toString(const ImageResizeMode &value) {
+  switch (value) {
+    case ImageResizeMode::Cover:
+      return "cover";
+    case ImageResizeMode::Contain:
+      return "contain";
+    case ImageResizeMode::Stretch:
+      return "stretch";
+    case ImageResizeMode::Center:
+      return "center";
+    case ImageResizeMode::Repeat:
+      return "repeat";
+    case ImageResizeMode::None:
+      return "none";
+//#[Windows
+#if defined(_MSC_VER)
+    default:
+        __assume(0);
+#elif defined(__GNUC__) || defined(__clang__)
+    default:
+        __builtin_unreachable();
+#endif
+// 15379 #Windows]
+  }
+}
+
+} // namespace facebook::react

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/renderer/components/text/BaseParagraphProps.cpp

@@ -0,0 +1,174 @@
+/*
+ * 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.
+ */
+
+#include "BaseParagraphProps.h"
+
+#include <react/featureflags/ReactNativeFeatureFlags.h>
+#include <react/renderer/attributedstring/conversions.h>
+#include <react/renderer/attributedstring/primitives.h>
+#include <react/renderer/core/propsConversions.h>
+#include <react/renderer/debug/debugStringConvertibleUtils.h>
+
+#include <glog/logging.h>
+
+namespace facebook::react {
+
+BaseParagraphProps::BaseParagraphProps(
+    const PropsParserContext& context,
+    const BaseParagraphProps& sourceProps,
+    const RawProps& rawProps)
+    : ViewProps(context, sourceProps, rawProps),
+      BaseTextProps(context, sourceProps, rawProps),
+      paragraphAttributes(
+          ReactNativeFeatureFlags::enableCppPropsIteratorSetter()
+              ? sourceProps.paragraphAttributes
+              : convertRawProp(
+                    context,
+                    rawProps,
+                    sourceProps.paragraphAttributes,
+                    {})),
+      isSelectable(
+          ReactNativeFeatureFlags::enableCppPropsIteratorSetter()
+              ? sourceProps.isSelectable
+              : convertRawProp(
+                    context,
+                    rawProps,
+                    "selectable",
+                    sourceProps.isSelectable,
+                    false)),
+      onTextLayout(
+          ReactNativeFeatureFlags::enableCppPropsIteratorSetter()
+              ? sourceProps.onTextLayout
+              : convertRawProp(
+                    context,
+                    rawProps,
+                    "onTextLayout",
+                    sourceProps.onTextLayout,
+                    {})),
+      // [Windows]
+      selectionColor(
+          ReactNativeFeatureFlags::enableCppPropsIteratorSetter()
+              ? sourceProps.selectionColor
+              : convertRawProp(
+                    context,
+                    rawProps,
+                    "selectionColor",
+                    sourceProps.selectionColor,
+                    {})) {
+  /*
+   * These props are applied to `View`, therefore they must not be a part of
+   * base text attributes.
+   */
+  textAttributes.opacity = std::numeric_limits<Float>::quiet_NaN();
+  textAttributes.backgroundColor = {};
+};
+
+void BaseParagraphProps::setProp(
+    const PropsParserContext& context,
+    RawPropsPropNameHash hash,
+    const char* propName,
+    const RawValue& value) {
+  // All Props structs setProp methods must always, unconditionally,
+  // call all super::setProp methods, since multiple structs may
+  // reuse the same values.
+  ViewProps::setProp(context, hash, propName, value);
+  BaseTextProps::setProp(context, hash, propName, value);
+
+  static auto defaults = BaseParagraphProps{};
+
+  // ParagraphAttributes has its own switch statement - to keep all
+  // of these fields together, and because there are some collisions between
+  // propnames parsed here and outside of ParagraphAttributes.
+  // This code is also duplicated in AndroidTextInput.
+  static auto paDefaults = ParagraphAttributes{};
+  switch (hash) {
+    REBUILD_FIELD_SWITCH_CASE(
+        paDefaults,
+        value,
+        paragraphAttributes,
+        maximumNumberOfLines,
+        "numberOfLines");
+    REBUILD_FIELD_SWITCH_CASE(
+        paDefaults, value, paragraphAttributes, ellipsizeMode, "ellipsizeMode");
+    REBUILD_FIELD_SWITCH_CASE(
+        paDefaults,
+        value,
+        paragraphAttributes,
+        textBreakStrategy,
+        "textBreakStrategy");
+    REBUILD_FIELD_SWITCH_CASE(
+        paDefaults,
+        value,
+        paragraphAttributes,
+        adjustsFontSizeToFit,
+        "adjustsFontSizeToFit");
+    REBUILD_FIELD_SWITCH_CASE(
+        paDefaults,
+        value,
+        paragraphAttributes,
+        minimumFontScale,
+        "minimumFontScale");
+    REBUILD_FIELD_SWITCH_CASE(
+        paDefaults,
+        value,
+        paragraphAttributes,
+        minimumFontSize,
+        "minimumFontSize");
+    REBUILD_FIELD_SWITCH_CASE(
+        paDefaults,
+        value,
+        paragraphAttributes,
+        maximumFontSize,
+        "maximumFontSize");
+    REBUILD_FIELD_SWITCH_CASE(
+        paDefaults,
+        value,
+        paragraphAttributes,
+        includeFontPadding,
+        "includeFontPadding");
+    REBUILD_FIELD_SWITCH_CASE(
+        paDefaults,
+        value,
+        paragraphAttributes,
+        android_hyphenationFrequency,
+        "android_hyphenationFrequency");
+    REBUILD_FIELD_SWITCH_CASE(
+        paDefaults,
+        value,
+        paragraphAttributes,
+        textAlignVertical,
+        "textAlignVertical");
+  }
+
+  switch (hash) {
+    RAW_SET_PROP_SWITCH_CASE(isSelectable, "selectable");
+    RAW_SET_PROP_SWITCH_CASE_BASIC(onTextLayout);
+    // [Windows]
+    RAW_SET_PROP_SWITCH_CASE_BASIC(selectionColor);
+  }
+
+  /*
+   * These props are applied to `View`, therefore they must not be a part of
+   * base text attributes.
+   */
+  textAttributes.opacity = std::numeric_limits<Float>::quiet_NaN();
+  textAttributes.backgroundColor = {};
+}
+
+#pragma mark - DebugStringConvertible
+
+#if RN_DEBUG_STRING_CONVERTIBLE
+SharedDebugStringConvertibleList BaseParagraphProps::getDebugProps() const {
+  return ViewProps::getDebugProps() + BaseTextProps::getDebugProps() +
+      paragraphAttributes.getDebugProps() +
+      SharedDebugStringConvertibleList{
+          debugStringConvertibleItem("selectable", isSelectable),
+          // [Windows]
+          debugStringConvertibleItem("selectionColor", selectionColor)};
+}
+#endif
+} // namespace facebook::react

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/renderer/components/text/BaseParagraphProps.h

@@ -0,0 +1,69 @@
+/*
+ * 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 <limits>
+#include <memory>
+// [Windows]
+#include <optional>
+
+#include <react/renderer/attributedstring/ParagraphAttributes.h>
+#include <react/renderer/components/text/BaseTextProps.h>
+#include <react/renderer/components/view/ViewProps.h>
+#include <react/renderer/core/Props.h>
+#include <react/renderer/core/PropsParserContext.h>
+// [Windows]
+#include <react/renderer/graphics/Color.h>
+
+namespace facebook::react {
+
+/*
+ * Props of <Paragraph> component.
+ * Most of the props are directly stored in composed `ParagraphAttributes`
+ * object.
+ */
+class BaseParagraphProps : public ViewProps, public BaseTextProps {
+ public:
+  BaseParagraphProps() = default;
+  BaseParagraphProps(
+      const PropsParserContext &context,
+      const BaseParagraphProps &sourceProps,
+      const RawProps &rawProps);
+
+  void
+  setProp(const PropsParserContext &context, RawPropsPropNameHash hash, const char *propName, const RawValue &value);
+
+#pragma mark - Props
+
+  /*
+   * Contains all prop values that affect visual representation of the
+   * paragraph.
+   */
+  ParagraphAttributes paragraphAttributes{};
+
+  /*
+   * Defines can the text be selected (and copied) or not.
+   */
+  bool isSelectable{};
+
+  bool onTextLayout{};
+
+  /*
+   * Defines the color of the selection highlight.
+   * [Windows]
+   */
+  std::optional<SharedColor> selectionColor{};
+
+#pragma mark - DebugStringConvertible
+
+#if RN_DEBUG_STRING_CONVERTIBLE
+  SharedDebugStringConvertibleList getDebugProps() const override;
+#endif
+};
+
+} // namespace facebook::react

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/renderer/components/text/ParagraphShadowNode.cpp

@@ -36,6 +36,7 @@
 namespace facebook::react {
 using Content = ParagraphShadowNode::Content;
 
+// NOLINTNEXTLINE(facebook-hte-CArray)
 const char ParagraphComponentName[] = "Paragraph";
 
 void ParagraphShadowNode::initialize() noexcept {

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/renderer/components/view/AccessibilityPrimitives.h

@@ -12,6 +12,8 @@
 #include <string>
 #include <vector>
 
+#include <react/renderer/debug/DebugStringConvertible.h>
+
 namespace facebook::react {
 
 enum class AccessibilityTraits : uint32_t {
@@ -91,10 +93,10 @@ struct AccessibilityState {
   std::optional<bool> selected{std::nullopt}; // [Windows] - Do not remove; required for Windows ISelectionItemProvider Implementation
   bool busy{false};
   std::optional<bool> expanded{std::nullopt};
+  enum CheckedState { Unchecked, Checked, Mixed, None } checked{None};
   std::optional<bool> readOnly{std::nullopt}; // [Windows] - Do not remove; required for Windows IRangeValueProvider and IValueProvider Implementation
   std::optional<bool> multiselectable{std::nullopt}; // [Windows] - Do not remove; required for Windows ISelectionProvider Implementation
   std::optional<bool> required{std::nullopt}; // [Windows] - Do not remove; required for Windows ISelectionProvider Implementation
-  enum { Unchecked, Checked, Mixed, None } checked{None};
 };
 
 constexpr bool operator==(
@@ -111,6 +113,29 @@ constexpr bool operator!=(
   return !(rhs == lhs);
 }
 
+#if RN_DEBUG_STRING_CONVERTIBLE
+inline std::string toString(AccessibilityState::CheckedState state) {
+  switch (state) {
+    case AccessibilityState::Unchecked:
+      return "Unchecked";
+    case AccessibilityState::Checked:
+      return "Checked";
+    case AccessibilityState::Mixed:
+      return "Mixed";
+    case AccessibilityState::None:
+      return "None";
+  }
+}
+
+inline std::string toString(const AccessibilityState& accessibilityState) {
+  return "{disabled:" + toString(accessibilityState.disabled) +
+      ",selected:" + toString(accessibilityState.selected) +
+      ",checked:" + toString(accessibilityState.checked) +
+      ",busy:" + toString(accessibilityState.busy) +
+      ",expanded:" + toString(accessibilityState.expanded) + "}";
+}
+#endif
+
 struct AccessibilityLabelledBy {
   std::vector<std::string> value{};
 };
@@ -170,8 +195,6 @@ inline std::string toString(
     case AccessibilityLiveRegion::Assertive:
       return "assertive";
   }
-  // [windows] Default return for unexpected enum values
-  return "none";
 }
 
 enum class AccessibilityRole {

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/renderer/components/view/conversions.h

@@ -1571,4 +1571,4 @@ inline std::string toString(const Transform& transform) {
   return result;
 }
 
-} // namespace facebook::react
+} // namespace facebook::react

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/renderer/core/ShadowNode.cpp

@@ -163,7 +163,7 @@ std::shared_ptr<ShadowNode> ShadowNode::clone(
   }
 }
 
-ContextContainer::Shared ShadowNode::getContextContainer() const {
+std::shared_ptr<const ContextContainer> ShadowNode::getContextContainer() const {
   return family_->componentDescriptor_.getContextContainer();
 }
 

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/renderer/imagemanager/primitives.h

@@ -0,0 +1,189 @@
+/*
+ * 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 <string>
+#include <vector>
+
+#include <react/renderer/core/graphicsConversions.h>
+#include <react/renderer/core/propsConversions.h>
+#include <react/renderer/debug/debugStringConvertibleUtils.h>
+#include <react/renderer/graphics/Float.h>
+#include <react/renderer/graphics/Size.h>
+
+namespace facebook::react {
+
+class ImageSource {
+ public:
+  enum class Type { Invalid, Remote, Local };
+  enum class CacheStategy { Default, Reload, ForceCache, OnlyIfCached };
+
+  Type type{};
+  std::string uri{};
+  std::string bundle{};
+  Float scale{3};
+  Size size{0};
+  std::string body{};
+  std::string method{};
+  CacheStategy cache = CacheStategy::Default;
+  std::vector<std::pair<std::string, std::string>> headers{};
+
+  bool operator==(const ImageSource& rhs) const {
+    return std::tie(this->type, this->uri) == std::tie(rhs.type, rhs.uri);
+  }
+
+  bool operator!=(const ImageSource& rhs) const {
+    return !(*this == rhs);
+  }
+
+#ifdef RN_SERIALIZABLE_STATE
+  folly::dynamic toDynamic() const {
+    folly::dynamic imageSourceResult = folly::dynamic::object();
+    switch (type) {
+      case ImageSource::Type::Invalid:
+        imageSourceResult["type"] = "invalid";
+        break;
+      case ImageSource::Type::Remote:
+        imageSourceResult["type"] = "remote";
+        break;
+      case ImageSource::Type::Local:
+        imageSourceResult["type"] = "local";
+        break;
+    }
+
+    imageSourceResult["uri"] = uri;
+    imageSourceResult["bundle"] = bundle;
+    imageSourceResult["scale"] = scale;
+
+    folly::dynamic sizeResult = folly::dynamic::object();
+    sizeResult["width"] = size.width;
+    sizeResult["height"] = size.height;
+    imageSourceResult["size"] = sizeResult;
+
+    imageSourceResult["body"] = body;
+    imageSourceResult["method"] = method;
+
+    switch (cache) {
+      case ImageSource::CacheStategy::Default:
+        imageSourceResult["cache"] = "default";
+        break;
+      case ImageSource::CacheStategy::Reload:
+        imageSourceResult["cache"] = "reload";
+        break;
+      case ImageSource::CacheStategy::ForceCache:
+        imageSourceResult["cache"] = "force-cache";
+        break;
+      case ImageSource::CacheStategy::OnlyIfCached:
+        imageSourceResult["cache"] = "only-if-cached";
+        break;
+    }
+
+    folly::dynamic headersObject = folly::dynamic::object();
+    for (const auto& header : headers) {
+      headersObject[header.first] = header.second;
+    }
+    imageSourceResult["headers"] = headersObject;
+    return imageSourceResult;
+  }
+
+#endif
+
+#if RN_DEBUG_STRING_CONVERTIBLE
+  SharedDebugStringConvertibleList getDebugProps(
+      const std::string& prefix) const {
+    ImageSource imageSource{};
+
+    SharedDebugStringConvertibleList headersList;
+    for (const auto& header : headers) {
+      headersList.push_back(debugStringConvertibleItem(
+          prefix + "-header-" + header.first, header.second));
+    }
+
+    return headersList +
+        SharedDebugStringConvertibleList{
+            debugStringConvertibleItem(
+                prefix + "-type", toString(type), toString(imageSource.type)),
+            debugStringConvertibleItem(prefix + "-uri", uri, imageSource.uri),
+            debugStringConvertibleItem(
+                prefix + "-bundle", bundle, imageSource.bundle),
+            debugStringConvertibleItem(
+                prefix + "-scale", scale, imageSource.scale),
+            debugStringConvertibleItem(
+                prefix + "-size",
+                react::toString(size),
+                react::toString(imageSource.size)),
+            debugStringConvertibleItem(
+                prefix + "-body", body, imageSource.body),
+            debugStringConvertibleItem(
+                prefix + "-method", method, imageSource.method),
+            debugStringConvertibleItem(
+                prefix + "-cache",
+                toString(cache),
+                toString(imageSource.cache)),
+        };
+  }
+
+  std::string toString(const Type& typeValue) const {
+    switch (typeValue) {
+      case ImageSource::Type::Invalid:
+        return "invalid";
+      case ImageSource::Type::Remote:
+        return "remote";
+      case ImageSource::Type::Local:
+        return "local";
+    //[Windows #15263
+    default:
+        return "Unknown"; 
+        //]
+    }
+  }
+
+  std::string toString(const CacheStategy& cacheValue) const {
+    switch (cacheValue) {
+      case ImageSource::CacheStategy::Default:
+        return "default";
+      case ImageSource::CacheStategy::Reload:
+        return "reload";
+      case ImageSource::CacheStategy::ForceCache:
+        return "force-cache";
+      case ImageSource::CacheStategy::OnlyIfCached:
+        return "only-if-cached";
+        //[Windows #15263
+    default:
+        return "Unknown"; 
+        //]
+    }
+  }
+#endif
+};
+
+#ifdef RN_SERIALIZABLE_STATE
+inline folly::dynamic toDynamic(const ImageSource& imageSource) {
+  return imageSource.toDynamic();
+}
+#endif
+
+using ImageSources = std::vector<ImageSource>;
+
+enum class ImageResizeMode : int8_t {
+  Cover = 0,
+  Contain = 1,
+  Stretch = 2,
+  Center = 3,
+  Repeat = 4,
+  None = 5,
+};
+
+class ImageErrorInfo {
+ public:
+  std::string error{};
+  int responseCode{};
+  std::vector<std::pair<std::string, std::string>> httpResponseHeaders{};
+};
+
+} // namespace facebook::react