@amazon-devices/expo-image 2.0.1758683737

package/kepler/KeplerImageViewComponent.h

@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * Use is subject to license terms.
+ */
+
+/*
+ *   This header is added as a workaround until we figure out whether
+ *   we need to have KeplerImageViewComponent included here and how to achieve that
+ */
+
+#pragma once
+
+#include <Volta/graphics/DrawableLayer.h>
+#include <Volta/graphics/OpacityLayer.h>
+#include <Volta/utils/Image.h>
+#include <graphics/ImageFilterLayer.h>
+
+#include "KeplerScript/components/KeplerViewComponent.h"
+
+namespace volta::react {
+class ImageDrawableLayer : public volta::graphics::DrawableLayer {
+public:
+    friend class KeplerImageViewComponent;
+    enum class Fit { Cover, Contain, Stretch, Repeat, Center };
+    ImageDrawableLayer();
+    void onDraw(volta::graphics::Canvas& canvas);
+};
+
+class KeplerImageViewComponent {
+public:
+    KeplerImageViewComponent();
+    ~KeplerImageViewComponent() noexcept;
+
+    mutable ImageDrawableLayer imageDrawableLayer_;
+    mutable volta::graphics::OpacityLayer opacityLayer_;
+
+    void didReceiveImage(const facebook::react::ImageResponse& imageResponse) const;
+    void didReceiveProgress(float progress) const;
+    void didReceiveFailure() const;
+
+    void setOverlayColor(const int& newValue);
+
+    void setTintColor(const int& newValue);
+
+    void setBlurRadius(const double& newValue);
+
+    void setResizeMode(const std::string& newValue);
+
+    void setDefaultSource(const utils::json::JsonContainer& newValue);
+
+    // void buildAccessibilityInfo(AccessibilityContext& accessibilityContext) override;
+
+    void updateLayoutMetrics(
+            const std::shared_ptr<KeplerViewComponentLayoutMetrics>& oldLayoutMetrics,
+            const std::shared_ptr<KeplerViewComponentLayoutMetrics>& newLayoutMetrics);
+
+    void updateState(const std::shared_ptr<const void>& oldState, const std::shared_ptr<const void>& newState);
+
+    void changeImageLayer(ImageDrawableLayer newImageLayer);
+};
+}  // namespace volta::react

package/kepler/KeplerInit.cpp

@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * Use is subject to license terms.
+ */
+
+#include <KeplerScript/logger/KPLog.h>
+#include <KeplerScript/utils/autolink/KeplerAutoLinkInfo.h>
+#include <keplerui-072/keplerscript-export.h>
+
+#include "ExpoImage.h"
+#include "RegisterModule.h"
+#include "managers/ExpoImageManager.h"
+
+extern "C" {
+KEPLERSCRIPT_EXPORT void keplerAutoLinkInitV1(const kepler::autolink::v1::KeplerAutoLinkInfo* autoLinkInfo) noexcept {
+    volta::react::KPLog.debug("keplerAutoLinkInitV1 for ExpoImage");
+
+    REGISTER_MODULE(autoLinkInfo, ExpoImage, "ExpoImage");
+
+    auto* customViewDelegate = autoLinkInfo->customViewManagerDelegate;
+    customViewDelegate->registerComponentViewManager("ExpoImageComponent", []() {
+        volta::react::KPLog.debug("Creating ExpoImageComponent");
+        return std::make_unique<ExpoImageManager>();
+    });
+
+    volta::react::KPLog.debug("ExpoImage after registering module");
+}
+}
+
+int main() {
+    return 0;
+}

package/kepler/blurhash/common.h

@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * Use is subject to license terms.
+ */
+
+// Source: https://github.com/woltapp/blurhash/blob/master/C/common.h
+#pragma once
+
+#include <cmath>
+
+int linearTosRGB(float value) {
+    float v = fmaxf(0, fminf(1, value));
+    if (v <= 0.0031308)
+        return v * 12.92 * 255 + 0.5;
+    else
+        return (1.055 * powf(v, 1 / 2.4) - 0.055) * 255 + 0.5;
+}
+
+float sRGBToLinear(int value) {
+    float v = (float) value / 255;
+    if (v <= 0.04045)
+        return v / 12.92;
+    else
+        return powf((v + 0.055) / 1.055, 2.4);
+}
+
+float signPow(float value, float exp) {
+    return copysignf(powf(fabsf(value), exp), value);
+}

package/kepler/blurhash/decode.cpp

@@ -0,0 +1,187 @@
+/*
+ * Copyright (c) 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * Use is subject to license terms.
+ */
+
+// Source: https://github.com/woltapp/blurhash/blob/master/C/decode.c
+#include "decode.h"
+
+#include <unordered_map>
+
+#include "common.h"
+
+namespace {
+struct Size {
+    int y;
+    int x;
+};
+
+using Color = std::tuple<float, float, float>;
+
+const std::string CHARS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz#$%*+,-.:;=?@[]^_{|}~";
+
+std::unordered_map<char, size_t> createCharToIndexMap() {
+    std::unordered_map<char, size_t> map;
+    for (size_t i = 0; i < CHARS.size(); ++i) {
+        map[CHARS[i]] = static_cast<size_t>(i);
+    }
+
+    return map;
+}
+
+uint8_t clampToUByte(int src) {
+    return std::min(std::max(0, src), 255);
+}
+
+std::unique_ptr<uint8_t[]> createByteArray(int size) {
+    return std::make_unique<uint8_t[]>(size);
+}
+}  // namespace
+
+int decodeToInt(const std::string& string, int pos) {
+    static const auto charsMap = createCharToIndexMap();  // Initialized only once in app's lifetime
+
+    auto it = charsMap.find(string[pos]);
+    if (it == charsMap.end()) {
+        return -1;
+    }
+    return it->second;
+}
+
+int decodeToInt(const std::string& string, int start, int end) {
+    int value = 0;
+    for (int i = start; i < end; ++i) {
+        auto byteValue = decodeToInt(string, i);
+        if (byteValue == -1) {
+            return -1;
+        }
+        value = value * CHARS.size() + byteValue;
+    }
+
+    return value;
+}
+
+Size getImageSize(const std::string& blurhash) {
+    int sizeFlag = decodeToInt(blurhash, 0);  // Get size from first character
+    int numY = (int) floorf(sizeFlag / 9) + 1;
+    int numX = (sizeFlag % 9) + 1;
+
+    return Size{numY, numX};
+}
+
+const int MINIMAL_HASH_LENGTH = 6;
+
+bool isValidBlurhash(const std::string& blurhash) {
+    auto hashLength = blurhash.size();
+    if (hashLength < MINIMAL_HASH_LENGTH) return false;
+    auto size = getImageSize(blurhash);
+
+    if (hashLength != 4 + 2 * size.x * size.y) return false;
+    return true;
+}
+
+Color decodeDC(int value) {
+    return std::make_tuple(
+            sRGBToLinear((value >> 16) & 255),  // R-component
+            sRGBToLinear((value >> 8) & 255),   // G-Component
+            sRGBToLinear(value & 255)           // B-Component
+    );
+}
+
+Color decodeAC(int value, float maximumValue) {
+    int quantR = (int) floorf(value / (19 * 19));
+    int quantG = (int) floorf(value / 19) % 19;
+    int quantB = (int) value % 19;
+
+    return std::make_tuple(
+            signPow(((float) quantR - 9) / 9, 2.0) * maximumValue,
+            signPow(((float) quantG - 9) / 9, 2.0) * maximumValue,
+            signPow(((float) quantB - 9) / 9, 2.0) * maximumValue);
+}
+
+int decodeToArray(
+        const std::string& blurhash,
+        int width,
+        int height,
+        int punch,
+        int nChannels,
+        const std::unique_ptr<uint8_t[]>& pixelArray) {
+    if (!isValidBlurhash(blurhash)) return -1;
+    if (punch < 1) punch = 1;
+
+    auto size = getImageSize(blurhash);
+
+    int quantizedMaxValue = decodeToInt(blurhash, 1);
+    if (quantizedMaxValue == -1) return -1;
+
+    float maxValue = ((float) (quantizedMaxValue + 1)) / 166;
+
+    int colors_size = size.x * size.y;
+    float colors[colors_size][3];
+
+    for (int iter = 0; iter < colors_size; ++iter) {
+        float r = 0, g = 0, b = 0;
+        if (iter == 0) {
+            int value = decodeToInt(blurhash, 2, 6);
+            if (value == -1) return -1;
+            std::tie(r, g, b) = decodeDC(value);
+
+        } else {
+            int value = decodeToInt(blurhash, 4 + iter * 2, 6 + iter * 2);
+            if (value == -1) return -1;
+            std::tie(r, g, b) = decodeAC(value, maxValue * punch);
+        }
+        colors[iter][0] = r;
+        colors[iter][1] = g;
+        colors[iter][2] = b;
+    }
+
+    int bytesPerRow = width * nChannels;
+    int intR = 0, intG = 0, intB = 0;
+
+    for (int y = 0; y < height; ++y) {
+        for (int x = 0; x < width; ++x) {
+            float r = 0, g = 0, b = 0;
+
+            for (int j = 0; j < size.y; ++j) {
+                for (int i = 0; i < size.x; ++i) {
+                    float basics = cos((M_PI * x * i) / width) * cos((M_PI * y * j) / height);
+                    int idx = i + j * size.x;
+                    r += colors[idx][0] * basics;
+                    g += colors[idx][1] * basics;
+                    b += colors[idx][2] * basics;
+                }
+            }
+
+            intR = linearTosRGB(r);
+            intG = linearTosRGB(g);
+            intB = linearTosRGB(b);
+
+            pixelArray[nChannels * x + 0 + y * bytesPerRow] = clampToUByte(intR);
+            pixelArray[nChannels * x + 1 + y * bytesPerRow] = clampToUByte(intG);
+            pixelArray[nChannels * x + 2 + y * bytesPerRow] = clampToUByte(intB);
+
+            if (nChannels == 4)
+                pixelArray[nChannels * x + 3 + y * bytesPerRow] =
+                        255;  // If nChannels=4, treat each pixel as RGBA instead of RGB
+        }
+    }
+
+    return 0;
+}
+
+std::unique_ptr<uint8_t[]> decodeBlurhash(
+        const std::string& blurhash,
+        int width,
+        int height,
+        int punch,
+        int nChannels) {
+    int bytesPerRow = width * nChannels;
+    auto pixelArray = createByteArray(bytesPerRow * height);
+
+    if (decodeToArray(blurhash, width, height, punch, nChannels, pixelArray) == -1) return nullptr;
+    return pixelArray;
+}

package/kepler/blurhash/decode.h

@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * Use is subject to license terms.
+ */
+
+// Source: https://github.com/woltapp/blurhash/blob/master/C/decode.h
+
+#pragma once
+
+#include <cstdint>
+#include <memory>
+#include <string>
+
+// Blurhash implementation from https://github.com/woltapp/blurhash
+
+/*
+    decode : Returns the pixel array of the result image given the blurhash string,
+    Parameters :
+        blurhash : A string representing the blurhash to be decoded.
+        width : Width of the resulting image
+        height : Height of the resulting image
+        punch : The factor to improve the contrast, default = 1
+        nChannels : Number of channels in the resulting image array, 3 = RGB, 4 = RGBA
+    Returns : A pointer to memory region where pixels are stored in (H, W, C) format
+*/
+std::unique_ptr<uint8_t[]> decodeBlurhash(const std::string& blurhash, int width, int height, int punch, int nChannels);
+
+/*
+    decodeToArray : Decodes the blurhash and copies the pixels to pixelArray,
+                    This method is suggested if you use an external memory allocator for pixelArray.
+                    pixelArray should be of size : width * height * nChannels
+    Parameters :
+        blurhash : A string representing the blurhash to be decoded.
+        width : Width of the resulting image
+        height : Height of the resulting image
+        punch : The factor to improve the contrast, default = 1
+        nChannels : Number of channels in the resulting image array, 3 = RGB, 4 = RGBA
+        pixelArray : Pointer to memory region where pixels needs to be copied.
+    Returns : int, -1 if error 0 if successful
+*/
+int decodeToArray(
+        const std::string& blurhash,
+        int width,
+        int height,
+        int punch,
+        int nChannels,
+        const std::unique_ptr<uint8_t[]>& pixelArray);
+
+/*
+    isValidBlurhash : Checks if the Blurhash is valid or not.
+    Parameters :
+        blurhash : A string representing the blurhash
+    Returns : bool (true if it is a valid blurhash, else false)
+*/
+bool isValidBlurhash(const std::string& blurhash);

package/kepler/contentposition/ImageContentPosition.cpp

@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * Use is subject to license terms.
+ */
+
+#include "ImageContentPosition.h"
+
+#include <JsonContainer/JsonContainer.h>
+
+float calcTranslation(
+        float value,
+        float imageRefValue,
+        float viewRefValue,
+        bool isPercentage = false,
+        bool isReverse = false) {
+    if (isPercentage) {
+        float finalPercentage = isReverse ? 100.0f - value : value;
+        return (finalPercentage / 100.0f) * (viewRefValue - imageRefValue);
+    }
+
+    return isReverse ? viewRefValue - imageRefValue - value : value;
+}
+
+float calcXTranslation(
+        float value,
+        const volta::graphics::Size& imageRect,
+        const volta::graphics::Size& viewRect,
+        bool isPercentage = false,
+        bool isReverse = false) {
+    return calcTranslation(value, imageRect.width(), viewRect.width(), isPercentage, isReverse);
+}
+
+float calcYTranslation(
+        float value,
+        const volta::graphics::Size& imageRect,
+        const volta::graphics::Size& viewRect,
+        bool isPercentage = false,
+        bool isReverse = false) {
+    return calcTranslation(value, imageRect.height(), viewRect.height(), isPercentage, isReverse);
+}
+
+ImageContentPositionValue::ImageContentPositionValue() : value_(std::nullopt), isPercentage_(true) {}
+
+ImageContentPositionValue::ImageContentPositionValue(float value, bool isPercentage) :
+        value_(value),
+        isPercentage_(isPercentage) {}
+
+std::optional<float> ImageContentPositionValue::calcOffset(
+        bool isReverse,
+        const volta::graphics::Size& imageRect,
+        const volta::graphics::Size& viewRect,
+        std::function<float(float, const volta::graphics::Size&, const volta::graphics::Size&, bool, bool)>
+                calcAxisOffset) {
+    return value_ ? calcAxisOffset(value_.value(), imageRect, viewRect, isPercentage_, isReverse) : value_;
+}
+
+ImageContentPosition::ImageContentPosition() :
+        top_(ImageContentPositionValue()),
+        bottom_(ImageContentPositionValue()),
+        right_(ImageContentPositionValue()),
+        left_(ImageContentPositionValue()) {}
+
+ImageContentPosition::ImageContentPosition(
+        ImageContentPositionValue top,
+        ImageContentPositionValue bottom,
+        ImageContentPositionValue right,
+        ImageContentPositionValue left) :
+        top_(top),
+        bottom_(bottom),
+        right_(right),
+        left_(left) {}
+
+float ImageContentPosition::offsetX(const volta::graphics::Size& imageRect, const volta::graphics::Size& viewRect) {
+    return left_.calcOffset(false, imageRect, viewRect, &calcXTranslation)
+            .value_or(right_.calcOffset(true, imageRect, viewRect, &calcXTranslation)
+                              .value_or(calcXTranslation(50.0f, imageRect, viewRect, true)));
+}
+
+float ImageContentPosition::offsetY(const volta::graphics::Size& imageRect, const volta::graphics::Size& viewRect) {
+    return top_.calcOffset(false, imageRect, viewRect, &calcYTranslation)
+            .value_or(bottom_.calcOffset(true, imageRect, viewRect, &calcYTranslation)
+                              .value_or(calcYTranslation(50.0f, imageRect, viewRect, true)));
+}

package/kepler/contentposition/ImageContentPosition.h

@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * Use is subject to license terms.
+ */
+
+#pragma once
+#include <Volta/graphics/Size.h>
+
+#include <functional>
+#include <optional>
+#include <string>
+
+class ImageContentPositionValue {
+public:
+    std::optional<float> value_;
+    bool isPercentage_;
+    ImageContentPositionValue();
+    ImageContentPositionValue(float value, bool isPercentage);
+    std::optional<float> calcOffset(
+            bool isReverse,
+            const volta::graphics::Size& imageRect,
+            const volta::graphics::Size& viewRect,
+            std::function<float(float, const volta::graphics::Size&, const volta::graphics::Size&, bool, bool)>
+                    calcAxisOffset);
+};
+
+class ImageContentPosition {
+public:
+    ImageContentPosition();
+    ImageContentPosition(
+            ImageContentPositionValue top,
+            ImageContentPositionValue bottom,
+            ImageContentPositionValue right,
+            ImageContentPositionValue left);
+    float offsetX(const volta::graphics::Size& imageRect, const volta::graphics::Size& viewRect);
+    float offsetY(const volta::graphics::Size& imageRect, const volta::graphics::Size& viewRect);
+
+#ifndef UNIT_TEST
+private:
+#endif
+    ImageContentPositionValue top_;
+    ImageContentPositionValue bottom_;
+    ImageContentPositionValue right_;
+    ImageContentPositionValue left_;
+};

package/kepler/enums/ImageContentFit.h

@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * Use is subject to license terms.
+ */
+
+#pragma once
+
+enum ImageContentFit {
+    Cover,
+    Contain,
+    Fill,
+    None,
+    ScaleDown,
+};

package/kepler/enums/ImagePriority.h

@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * Use is subject to license terms.
+ */
+
+#pragma once
+
+#include <cstdint>
+
+enum class ImagePriority : uint8_t { 
+    Low, 
+    Normal, 
+    High
+};

package/kepler/managers/ExpoImageManager.cpp

@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * Use is subject to license terms.
+ */
+
+#include "ExpoImageManager.h"
+
+#include <KeplerScript/components/KeplerViewComponent.h>
+#include <KeplerScript/utils/image/KeplerScriptImageCacheHandler.h>
+
+#include "ExpoImageComponent.h"
+
+ExpoImageManager::ExpoImageManager() :
+        imageCacheHandler_(std::make_shared<volta::react::KeplerScriptImageCacheHandler>()) {}
+
+std::shared_ptr<volta::react::KeplerViewComponent> ExpoImageManager::createComponentView() {
+    VOLTA_TRACE_SECTION(ExpoImageManager::createComponentView);
+    return volta::RenderObject::create<ExpoImageComponent>(imageCacheHandler_);
+}
+
+void ExpoImageManager::aggregatePropSetters(volta::react::PropSetterAggregator& aggregator) {
+    ViewComponentViewManager::aggregatePropSetters(aggregator);
+    aggregator.addPropSetter("contentFit", &ExpoImageComponent::setContentFit, std::string{""});
+    aggregator.addPropSetter("placeholderContentFit", &ExpoImageComponent::setPlaceholderContentFit, std::string{""});
+    aggregator.addPropSetter("allowDownscaling", &ExpoImageComponent::setAllowDownscaling, true);
+    aggregator.addPropSetter("contentPosition", &ExpoImageComponent::setContentPosition, utils::json::JsonContainer());
+    aggregator.addPropSetter("overlayColor", &ExpoImageComponent::setOverlayColor, std::numeric_limits<int>::max());
+    aggregator.addPropSetter("tintColor", &ExpoImageComponent::setTintColor, std::numeric_limits<int>::max());
+    aggregator.addPropSetter("blurRadius", &ExpoImageComponent::setBlurRadius, 0.0);
+    aggregator.addPropSetter("placeholder", &ExpoImageComponent::setPlaceholder, utils::json::JsonContainer());
+    aggregator.addPropSetter("source", &ExpoImageComponent::setSource, utils::json::JsonContainer());
+    aggregator.addPropSetter("priority", &ExpoImageComponent::setPriority, std::string{""});
+    aggregator.addPropSetter("transition", &ExpoImageComponent::setTransition, utils::json::JsonContainer());
+    aggregator.addPropSetter("recyclingKey", &ExpoImageComponent::setRecyclingKey, std::string{""});
+}

package/kepler/managers/ExpoImageManager.h

@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * Use is subject to license terms.
+ */
+
+#pragma once
+
+#include <KeplerScript/components/ViewComponentViewManager.h>
+#include <KeplerScript/utils/image/KeplerScriptImageCacheHandler.h>
+
+class ExpoImageManager : public volta::react::ViewComponentViewManager {
+public:
+    ExpoImageManager();
+    void aggregatePropSetters(volta::react::PropSetterAggregator& aggregator) override;
+    std::shared_ptr<volta::react::KeplerViewComponent> createComponentView() override;
+
+private:
+    std::shared_ptr<volta::react::KeplerScriptImageCacheHandler> imageCacheHandler_;
+};
+

package/kepler/test/ExpoImage.cpp

@@ -0,0 +1,73 @@
+#include "../ExpoImage.h"
+
+#include <KeplerScript/components/ImageSourceBuilder.h>
+#include <KeplerScript/logger/KPLog.h>
+#include <KeplerScript/utils/image/KeplerScriptImageLoaderDelegate.h>
+#include <gmock/gmock-actions.h>
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include "../ExpoImageCacheHandler.h"
+#include "catch.hpp"
+
+namespace volta::react {
+
+std::unique_ptr<volta::graphics::Image> mockImage() {
+    auto data = std::make_unique<uint8_t[]>(4);
+    return volta::graphics::Image::makeRasterImage(volta::graphics::Size{1, 1}, std::move(data), 4);
+}
+
+void fullfillPromise(volta::react::Promise& promise) {
+    promise.promiseOperation_(std::make_shared<Promise>(Callback(), Callback()));
+}
+
+class MockExpoImageCacheHandler : public IExpoImageCacheHandler {
+public:
+    MockExpoImageCacheHandler() = default;
+
+    MOCK_METHOD(void, clearMemoryCache, (), (override));
+    MOCK_METHOD(void, clearDiskCache, (), (override));
+
+    MOCK_METHOD(
+            void,
+            load,
+            (volta::ImageDetails & details, const volta::react::KeplerScriptImageLoaderDelegate::Shared& delegate),
+            (override));
+};
+
+TEST_CASE("ExpoImage") {
+    auto handler = std::make_shared<MockExpoImageCacheHandler>();
+
+    ExpoImage module(handler);
+
+    SECTION("load") {
+        std::vector<std::string> urls = {
+                "https://example.com/image1.png",
+                "https://example.com/image2.png",
+                "https://example.com/image3.png"};
+
+        EXPECT_CALL(*handler, load(testing::_, testing::_))
+                .Times(3)
+                .WillRepeatedly(
+                        testing::Invoke([](volta::ImageDetails& details,
+                                           const volta::react::KeplerScriptImageLoaderDelegate::Shared& delegate) {
+                            auto mockImg = mockImage();
+
+                            delegate->notifyImageLoadSuccess(*mockImg);
+                        }));
+
+        auto promise = module.prefetch(urls);
+        fullfillPromise(promise);
+    }
+
+    SECTION("clearMemoryCache") {
+        EXPECT_CALL(*handler, clearMemoryCache()).Times(1);
+        module.clearMemoryCache();
+    }
+
+    SECTION("clearDiskCache") {
+        EXPECT_CALL(*handler, clearDiskCache()).Times(1);
+        module.clearDiskCache();
+    }
+}
+}  // namespace volta::react