react-native-tvos 0.76.6-0 → 0.77.0-0

package/ReactCommon/react/renderer/graphics/LinearGradient.h

@@ -0,0 +1,62 @@
+/*
+ * 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/graphics/Float.h>
+#include <string>
+#include <variant>
+#include <vector>
+
+namespace facebook::react {
+
+enum class GradientDirectionType { Angle, Keyword };
+
+enum class GradientKeyword {
+  ToTopRight,
+  ToBottomRight,
+  ToTopLeft,
+  ToBottomLeft,
+};
+
+struct GradientDirection {
+  GradientDirectionType type;
+  std::variant<Float, GradientKeyword> value;
+
+  bool operator==(const GradientDirection& other) const {
+    return type == other.type && value == other.value;
+  }
+};
+
+struct ColorStop {
+  bool operator==(const ColorStop& other) const = default;
+  SharedColor color;
+  Float position = 0.0f;
+};
+
+struct LinearGradient {
+  GradientDirection direction;
+  std::vector<ColorStop> colorStops;
+
+  bool operator==(const LinearGradient& other) const {
+    return direction == other.direction && colorStops == other.colorStops;
+  }
+};
+
+inline GradientKeyword parseGradientKeyword(const std::string& keyword) {
+  if (keyword == "to top right")
+    return GradientKeyword::ToTopRight;
+  if (keyword == "to bottom right")
+    return GradientKeyword::ToBottomRight;
+  if (keyword == "to top left")
+    return GradientKeyword::ToTopLeft;
+  if (keyword == "to bottom left")
+    return GradientKeyword::ToBottomLeft;
+  throw std::invalid_argument("Invalid gradient keyword: " + keyword);
+}
+
+}; // namespace facebook::react

package/ReactCommon/react/renderer/graphics/React-graphics.podspec

@@ -20,7 +20,8 @@ folly_config = get_folly_config()
 folly_compiler_flags = folly_config[:compiler_flags]
 folly_version = folly_config[:version]
 
-boost_compiler_flags = '-Wno-documentation'
+boost_config = get_boost_config()
+boost_compiler_flags = boost_config[:compiler_flags]
 
 Pod::Spec.new do |s|
   source_files = "**/*.{m,mm,cpp,h}"
@@ -29,6 +30,7 @@ Pod::Spec.new do |s|
     "\"$(PODS_TARGET_SRCROOT)/../../../\"",
     "\"$(PODS_ROOT)/RCT-Folly\"",
     "\"$(PODS_ROOT)/DoubleConversion\"",
+    "\"$(PODS_ROOT)/fast_float/include\"",
     "\"$(PODS_ROOT)/fmt/include\""
   ]
 
@@ -66,5 +68,6 @@ Pod::Spec.new do |s|
   s.dependency "React-jsiexecutor"
   s.dependency "React-utils"
   s.dependency "DoubleConversion"
+  s.dependency "fast_float", "6.1.4"
   s.dependency "fmt", "9.1.0"
 end

package/ReactCommon/react/renderer/graphics/Transform.h

@@ -156,10 +156,10 @@ struct Transform {
    * performs slerp between the two rotations, and a linear interpolation
    * of scale and translation.
    *
-   * @param progress
-   * @param lhs
-   * @param rhs
-   * @return
+   * @param animationProgress of the animation
+   * @param lhs start of the interpolation
+   * @param rhs end of the interpolation
+   * @return the Transformation
    */
   static Transform Interpolate(
       Float animationProgress,

package/ReactCommon/react/renderer/graphics/platform/android/react/renderer/graphics/PlatformColorParser.h

@@ -8,27 +8,15 @@
 #pragma once
 
 #include <fbjni/fbjni.h>
-#include <folly/container/EvictingCacheMap.h>
+#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>
-#include <react/utils/hash_combine.h>
 #include <unordered_map>
-#include <vector>
 
 namespace facebook::react {
 
-static size_t hashGetColourArguments(
-    int32_t surfaceId,
-    const std::vector<std::string>& resourcePaths) {
-  std::size_t seed = surfaceId;
-  for (const auto& item : resourcePaths) {
-    facebook::react::hash_combine(seed, item);
-  }
-  return seed;
-}
-
 inline SharedColor parsePlatformColor(
     const ContextContainer& contextContainer,
     int32_t surfaceId,
@@ -37,45 +25,29 @@ inline SharedColor parsePlatformColor(
 
   if (value.hasType<
           std::unordered_map<std::string, std::vector<std::string>>>()) {
+    const auto& fabricUIManager =
+        contextContainer.at<jni::global_ref<jobject>>("FabricUIManager");
+    static auto getColorFromJava =
+        fabricUIManager->getClass()
+            ->getMethod<jint(jint, jni::JArrayClass<jni::JString>)>("getColor");
+
     auto map = (std::unordered_map<std::string, std::vector<std::string>>)value;
     auto& resourcePaths = map["resource_paths"];
 
-    // JNI calls are time consuming. Let's cache results here to avoid
-    // unnecessary calls.
-    static auto getColorCache =
-        folly::EvictingCacheMap<size_t, ColorComponents>(64);
-
-    auto hash = hashGetColourArguments(surfaceId, resourcePaths);
-    auto iterator = getColorCache.find(hash);
-
-    if (iterator != getColorCache.end()) {
-      colorComponents = iterator->second;
-    } else {
-      const auto& fabricUIManager =
-          contextContainer.at<jni::global_ref<jobject>>("FabricUIManager");
-      static auto getColorFromJava =
-          fabricUIManager->getClass()
-              ->getMethod<jint(jint, jni::JArrayClass<jni::JString>)>(
-                  "getColor");
-      auto javaResourcePaths =
-          jni::JArrayClass<jni::JString>::newArray(resourcePaths.size());
-
-      for (int i = 0; i < resourcePaths.size(); i++) {
-        javaResourcePaths->setElement(i, *jni::make_jstring(resourcePaths[i]));
-      }
-      auto color =
-          getColorFromJava(fabricUIManager, surfaceId, *javaResourcePaths);
-
-      auto argb = (int64_t)color;
-      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;
-
-      getColorCache.set(hash, colorComponents);
+    auto javaResourcePaths =
+        jni::JArrayClass<jni::JString>::newArray(resourcePaths.size());
+    for (int i = 0; i < resourcePaths.size(); i++) {
+      javaResourcePaths->setElement(i, *jni::make_jstring(resourcePaths[i]));
     }
+    auto color =
+        getColorFromJava(fabricUIManager, surfaceId, *javaResourcePaths);
+
+    auto argb = (int64_t)color;
+    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;
   }
 
   return {colorFromComponents(colorComponents)};

package/ReactCommon/react/renderer/graphics/platform/ios/react/renderer/graphics/HostPlatformColor.mm

@@ -43,13 +43,13 @@ UIColor *_Nullable UIColorFromDynamicColor(const facebook::react::DynamicColor &
   if (lightColor != nil && darkColor != nil) {
     UIColor *color = [UIColor colorWithDynamicProvider:^UIColor *_Nonnull(UITraitCollection *_Nonnull collection) {
       if (collection.userInterfaceStyle == UIUserInterfaceStyleDark) {
-        if (collection.accessibilityContrast == UIAccessibilityContrastHigh && highContrastDarkColor != nil) {
+        if (collection.accessibilityContrast == UIAccessibilityContrastHigh && highContrastDark != 0) {
           return highContrastDarkColor;
         } else {
           return darkColor;
         }
       } else {
-        if (collection.accessibilityContrast == UIAccessibilityContrastHigh && highContrastLightColor != nil) {
+        if (collection.accessibilityContrast == UIAccessibilityContrastHigh && highContrastLight != 0) {
           return highContrastLightColor;
         } else {
           return lightColor;

package/ReactCommon/react/renderer/graphics/platform/ios/react/renderer/graphics/RCTPlatformColorUtils.mm

@@ -95,10 +95,12 @@ static NSDictionary<NSString *, NSDictionary *> *_PlatformColorSelectorsDict()
       @"systemBrown" : @{
         kFallbackARGBKey : @(0xFFa2845e) // iOS 13.0
       },
+      @"systemCyan" : @{},
       @"systemGreen" : @{},
       @"systemIndigo" : @{
         kFallbackARGBKey : @(0xFF5856d6) // iOS 13.0
       },
+      @"systemMint" : @{},
       @"systemOrange" : @{},
       @"systemPink" : @{},
       @"systemPurple" : @{},

package/ReactCommon/react/renderer/imagemanager/ImageRequest.cpp

@@ -12,15 +12,11 @@ namespace facebook::react {
 ImageRequest::ImageRequest(
     ImageSource imageSource,
     std::shared_ptr<const ImageTelemetry> telemetry,
+    SharedFunction<> resumeFunction,
     SharedFunction<> cancelationFunction)
-    : imageSource_(std::move(imageSource)),
-      telemetry_(std::move(telemetry)),
-      cancelRequest_(std::move(cancelationFunction)) {
-  coordinator_ = std::make_shared<ImageResponseObserverCoordinator>();
-}
-
-void ImageRequest::cancel() const {
-  cancelRequest_();
+    : imageSource_(std::move(imageSource)), telemetry_(std::move(telemetry)) {
+  coordinator_ = std::make_shared<ImageResponseObserverCoordinator>(
+      std::move(resumeFunction), std::move(cancelationFunction));
 }
 
 const ImageSource& ImageRequest::getImageSource() const {

package/ReactCommon/react/renderer/imagemanager/ImageRequest.h

@@ -31,7 +31,8 @@ class ImageRequest final {
   ImageRequest(
       ImageSource imageSource,
       std::shared_ptr<const ImageTelemetry> telemetry,
-      SharedFunction<> cancelationFunction);
+      SharedFunction<> resumeFunction = {},
+      SharedFunction<> cancelationFunction = {});
 
   /*
    * The move constructor.
@@ -43,12 +44,6 @@ class ImageRequest final {
    */
   ImageRequest(const ImageRequest& other) = delete;
 
-  /*
-   * Calls cancel function if one is defined. Should be when downloading
-   * image isn't needed anymore. E.g. <ImageView /> was removed.
-   */
-  void cancel() const;
-
   /*
    * Returns the Image Source associated with the request.
    */
@@ -89,11 +84,6 @@ class ImageRequest final {
    * Event coordinator associated with the request.
    */
   std::shared_ptr<const ImageResponseObserverCoordinator> coordinator_{};
-
-  /*
-   * Function we can call to cancel image request.
-   */
-  SharedFunction<> cancelRequest_;
 };
 
 } // namespace facebook::react

package/ReactCommon/react/renderer/imagemanager/ImageResponse.h

@@ -20,6 +20,7 @@ class ImageResponse final {
     Loading,
     Completed,
     Failed,
+    Cancelled,
   };
 
   ImageResponse(std::shared_ptr<void> image, std::shared_ptr<void> metadata);

package/ReactCommon/react/renderer/imagemanager/ImageResponseObserverCoordinator.cpp

@@ -13,6 +13,12 @@
 
 namespace facebook::react {
 
+ImageResponseObserverCoordinator::ImageResponseObserverCoordinator(
+    SharedFunction<> resumeFunction,
+    SharedFunction<> cancelationFunction)
+    : resumeRequest_(std::move(resumeFunction)),
+      cancelRequest_(std::move(cancelationFunction)) {}
+
 void ImageResponseObserverCoordinator::addObserver(
     const ImageResponseObserver& observer) const {
   mutex_.lock();
@@ -35,6 +41,13 @@ void ImageResponseObserverCoordinator::addObserver(
       observer.didReceiveFailure(ImageLoadError{imageErrorData});
       break;
     }
+    case ImageResponse::Status::Cancelled: {
+      observers_.push_back(&observer);
+      status_ = ImageResponse::Status::Loading;
+      mutex_.unlock();
+      resumeRequest_();
+      break;
+    }
   }
 }
 
@@ -46,6 +59,11 @@ void ImageResponseObserverCoordinator::removeObserver(
   auto position = std::find(observers_.begin(), observers_.end(), &observer);
   if (position != observers_.end()) {
     observers_.erase(position, observers_.end());
+
+    if (observers_.empty() && status_ == ImageResponse::Status::Loading) {
+      status_ = ImageResponse::Status::Cancelled;
+      cancelRequest_();
+    }
   }
 }
 
@@ -55,7 +73,9 @@ void ImageResponseObserverCoordinator::nativeImageResponseProgress(
     int64_t total) const {
   mutex_.lock();
   auto observers = observers_;
-  react_native_assert(status_ == ImageResponse::Status::Loading);
+  react_native_assert(
+      status_ == ImageResponse::Status::Loading ||
+      status_ == ImageResponse::Status::Cancelled);
   mutex_.unlock();
 
   for (auto observer : observers) {
@@ -68,7 +88,9 @@ void ImageResponseObserverCoordinator::nativeImageResponseComplete(
   mutex_.lock();
   imageData_ = imageResponse.getImage();
   imageMetadata_ = imageResponse.getMetadata();
-  react_native_assert(status_ == ImageResponse::Status::Loading);
+  react_native_assert(
+      status_ == ImageResponse::Status::Loading ||
+      status_ == ImageResponse::Status::Cancelled);
   status_ = ImageResponse::Status::Completed;
   auto observers = observers_;
   mutex_.unlock();
@@ -81,7 +103,9 @@ void ImageResponseObserverCoordinator::nativeImageResponseComplete(
 void ImageResponseObserverCoordinator::nativeImageResponseFailed(
     const ImageLoadError& loadError) const {
   mutex_.lock();
-  react_native_assert(status_ == ImageResponse::Status::Loading);
+  react_native_assert(
+      status_ == ImageResponse::Status::Loading ||
+      status_ == ImageResponse::Status::Cancelled);
   status_ = ImageResponse::Status::Failed;
   imageErrorData_ = loadError.getError();
   auto observers = observers_;

package/ReactCommon/react/renderer/imagemanager/ImageResponseObserverCoordinator.h

@@ -9,6 +9,7 @@
 
 #include <react/renderer/imagemanager/ImageResponse.h>
 #include <react/renderer/imagemanager/ImageResponseObserver.h>
+#include <react/utils/SharedFunction.h>
 
 #include <mutex>
 #include <vector>
@@ -23,6 +24,10 @@ namespace facebook::react {
  */
 class ImageResponseObserverCoordinator {
  public:
+  ImageResponseObserverCoordinator(
+      SharedFunction<> resumeFunction,
+      SharedFunction<> cancelationFunction);
+
   /*
    * Interested parties may observe the image response.
    * If the current image request status is not equal to `Loading`, the observer
@@ -90,6 +95,16 @@ class ImageResponseObserverCoordinator {
    * Observer and data mutex.
    */
   mutable std::mutex mutex_;
+
+  /*
+   * Function we can call to resume image request.
+   */
+  SharedFunction<> resumeRequest_;
+
+  /*
+   * Function we can call to cancel image request.
+   */
+  SharedFunction<> cancelRequest_;
 };
 
 } // namespace facebook::react

package/ReactCommon/react/renderer/imagemanager/platform/ios/React-ImageManager.podspec

@@ -16,8 +16,10 @@ else
   source[:tag] = "v#{version}"
 end
 
-folly_compiler_flags = '-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1 -DFOLLY_CFG_NO_COROUTINES=1 -DFOLLY_HAVE_CLOCK_GETTIME=1 -Wno-comma -Wno-shorten-64-to-32'
-boost_compiler_flags = '-Wno-documentation'
+folly_config = get_folly_config()
+folly_compiler_flags = folly_config[:compiler_flags]
+boost_config = get_boost_config()
+boost_compiler_flags = boost_config[:compiler_flags]
 
 Pod::Spec.new do |s|
   source_files = "**/*.{m,mm,cpp,h}"
@@ -27,6 +29,7 @@ Pod::Spec.new do |s|
     "\"$(PODS_TARGET_SRCROOT)\"",
     "\"$(PODS_ROOT)/RCT-Folly\"",
     "\"$(PODS_ROOT)/DoubleConversion\"",
+    "\"$(PODS_ROOT)/fast_float/include\"",
     "\"$(PODS_ROOT)/fmt/include\"",
   ].join(" ")
 

package/ReactCommon/react/renderer/imagemanager/platform/ios/react/renderer/imagemanager/RCTImageManager.mm

@@ -48,8 +48,9 @@ using namespace facebook::react;
     telemetry = nullptr;
   }
 
+  auto sharedResumeFunction = SharedFunction<>();
   auto sharedCancelationFunction = SharedFunction<>();
-  auto imageRequest = ImageRequest(imageSource, telemetry, sharedCancelationFunction);
+  auto imageRequest = ImageRequest(imageSource, telemetry, sharedResumeFunction, sharedCancelationFunction);
   auto weakObserverCoordinator =
       (std::weak_ptr<const ImageResponseObserverCoordinator>)imageRequest.getSharedObserverCoordinator();
 
@@ -88,21 +89,28 @@ using namespace facebook::react;
       observerCoordinator->nativeImageResponseProgress((float)progress / (float)total, progress, total);
     };
 
-    RCTImageURLLoaderRequest *loaderRequest =
-        [self->_imageLoader loadImageWithURLRequest:request
-                                               size:CGSizeMake(imageSource.size.width, imageSource.size.height)
-                                              scale:imageSource.scale
-                                            clipped:NO
-                                         resizeMode:RCTResizeModeStretch
-                                           priority:RCTImageLoaderPriorityImmediate
-                                        attribution:{
-                                                        .surfaceId = surfaceId,
-                                                    }
-                                      progressBlock:progressBlock
-                                   partialLoadBlock:nil
-                                    completionBlock:completionBlock];
-    RCTImageLoaderCancellationBlock cancelationBlock = loaderRequest.cancellationBlock;
-    sharedCancelationFunction.assign([cancelationBlock]() { cancelationBlock(); });
+    void (^startRequest)() = ^() {
+      RCTImageURLLoaderRequest *loaderRequest =
+          [self->_imageLoader loadImageWithURLRequest:request
+                                                 size:CGSizeMake(imageSource.size.width, imageSource.size.height)
+                                                scale:imageSource.scale
+                                              clipped:NO
+                                           resizeMode:RCTResizeModeStretch
+                                             priority:RCTImageLoaderPriorityImmediate
+                                          attribution:{
+                                                          .surfaceId = surfaceId,
+                                                      }
+                                        progressBlock:progressBlock
+                                     partialLoadBlock:nil
+                                      completionBlock:completionBlock];
+
+      RCTImageLoaderCancellationBlock cancelationBlock = loaderRequest.cancellationBlock;
+      sharedCancelationFunction.assign([cancelationBlock]() { cancelationBlock(); });
+    };
+
+    startRequest();
+
+    sharedResumeFunction.assign([startRequest]() { startRequest(); });
   });
 
   return imageRequest;

package/ReactCommon/react/renderer/imagemanager/platform/ios/react/renderer/imagemanager/RCTImagePrimitivesConversions.h

@@ -7,6 +7,7 @@
 
 #import <UIKit/UIKit.h>
 
+#import <React/RCTConvert.h>
 #import <React/RCTImageLoader.h>
 #import <react/renderer/imagemanager/primitives.h>
 
@@ -25,6 +26,8 @@ inline static UIViewContentMode RCTContentModeFromImageResizeMode(facebook::reac
       // Repeat resize mode is handled by the UIImage. Use scale to fill
       // so the repeated image fills the UIImageView.
       return UIViewContentModeScaleToFill;
+    case facebook::react::ImageResizeMode::None:
+      return UIViewContentModeTopLeft;
   }
 }
 
@@ -41,6 +44,27 @@ inline std::string toString(const facebook::react::ImageResizeMode &value)
       return "center";
     case facebook::react::ImageResizeMode::Repeat:
       return "repeat";
+    case facebook::react::ImageResizeMode::None:
+      return "none";
+  }
+}
+
+inline static NSURLRequestCachePolicy NSURLRequestCachePolicyFromImageSource(
+    const facebook::react::ImageSource &imageSource)
+{
+  switch (imageSource.cache) {
+    case facebook::react::ImageSource::CacheStategy::Reload:
+      return NSURLRequestReloadIgnoringLocalCacheData;
+      break;
+    case facebook::react::ImageSource::CacheStategy::ForceCache:
+      return NSURLRequestReturnCacheDataElseLoad;
+      break;
+    case facebook::react::ImageSource::CacheStategy::OnlyIfCached:
+      return NSURLRequestReturnCacheDataDontLoad;
+      break;
+    default:
+      return NSURLRequestUseProtocolCachePolicy;
+      break;
   }
 }
 
@@ -102,13 +126,21 @@ inline static NSURLRequest *NSURLRequestFromImageSource(const facebook::react::I
 
   NSMutableURLRequest *request = [[NSMutableURLRequest alloc] initWithURL:url];
 
-  /*
-  // TODO(shergin): To be implemented.
-  request.HTTPBody = ...;
-  request.HTTPMethod = ...;
-  request.cachePolicy = ...;
-  request.allHTTPHeaderFields = ...;
-  */
+  NSString *method = @"GET";
+  if (!imageSource.method.empty()) {
+    method = [[NSString alloc] initWithUTF8String:imageSource.method.c_str()].uppercaseString;
+  }
+  NSData *body = nil;
+  if (!imageSource.body.empty()) {
+    body = [NSData dataWithBytes:imageSource.body.c_str() length:imageSource.body.size()];
+  }
+  NSURLRequestCachePolicy cachePolicy = NSURLRequestCachePolicyFromImageSource(imageSource);
+
+  if ([method isEqualToString:@"GET"] && imageSource.headers.empty() && body == nil &&
+      cachePolicy == NSURLRequestUseProtocolCachePolicy) {
+    return request;
+  }
+
   for (const auto &header : imageSource.headers) {
     NSString *key = [NSString stringWithUTF8String:header.first.c_str()];
     NSString *value = [NSString stringWithUTF8String:header.second.c_str()];
@@ -117,5 +149,9 @@ inline static NSURLRequest *NSURLRequestFromImageSource(const facebook::react::I
     }
   }
 
-  return [request copy];
+  request.HTTPBody = body;
+  request.HTTPMethod = method;
+  request.cachePolicy = cachePolicy;
+
+  return request;
 }

package/ReactCommon/react/renderer/imagemanager/platform/ios/react/renderer/imagemanager/RCTSyncImageManager.mm

@@ -38,7 +38,10 @@ using namespace facebook::react;
 {
   auto telemetry = std::make_shared<ImageTelemetry>(surfaceId);
   auto sharedCancelationFunction = SharedFunction<>();
-  auto imageRequest = ImageRequest(imageSource, telemetry, sharedCancelationFunction);
+
+  // Sync image request is not cancellable so it does not need to be resumed.
+  auto sharedResumeFunction = SharedFunction<>();
+  auto imageRequest = ImageRequest(imageSource, telemetry, sharedResumeFunction, sharedCancelationFunction);
   auto weakObserverCoordinator =
       (std::weak_ptr<const ImageResponseObserverCoordinator>)imageRequest.getSharedObserverCoordinator();
 
@@ -86,8 +89,6 @@ using namespace facebook::react;
                                     progressBlock:progressBlock
                                  partialLoadBlock:nil
                                   completionBlock:completionBlock];
-  RCTImageLoaderCancellationBlock cancelationBlock = loaderRequest.cancellationBlock;
-  sharedCancelationFunction.assign([cancelationBlock]() { cancelationBlock(); });
 
   auto result = dispatch_group_wait(imageWaitGroup, dispatch_time(DISPATCH_TIME_NOW, 2 * NSEC_PER_SEC));
   if (result != 0) {

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

@@ -18,12 +18,16 @@ 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 {
@@ -43,6 +47,7 @@ enum class ImageResizeMode {
   Stretch,
   Center,
   Repeat,
+  None,
 };
 
 class ImageErrorInfo {