@amazon-devices/expo-image 2.0.1758683737

package/kepler/thumbhash/decode.cpp

@@ -0,0 +1,166 @@
+/*
+ * Copyright (c) 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * Use is subject to license terms.
+ */
+
+#include "decode.h"
+
+#include <mbedtls/base64.h>
+
+#include <cmath>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+// Inspired by https://github.com/evanw/thumbhash/blob/main/java/com/madebyevan/thumbhash/ThumbHash.java
+
+namespace {
+
+std::string base64_decode(const std::string& in) {
+    size_t bufferSize;
+
+    mbedtls_base64_decode(nullptr, 0, &bufferSize, reinterpret_cast<const unsigned char*>(in.data()), in.size());
+
+    std::string buffer(bufferSize, ' ');
+
+    mbedtls_base64_decode(
+            reinterpret_cast<unsigned char*>(buffer.data()),
+            bufferSize,
+            &bufferSize,
+            reinterpret_cast<const unsigned char*>(in.data()),
+            in.size());
+
+    return buffer;
+}
+
+double thumbHashToApproximateAspectRatio(const std::string& hash) {
+    int header = hash[3];
+    bool hasAlpha = hash[2] & 0x80;
+    bool isLandscape = hash[4] & 0x80;
+    int lx = isLandscape ? hasAlpha ? 5 : 7 : header & 7;
+    int ly = isLandscape ? header & 7 : hasAlpha ? 5 : 7;
+    return double(lx) / double(ly);
+}
+
+}  // namespace
+
+const int HEADER_SIZE = 6;
+DecodedThumbhash decodeThumbhash(const std::string& hash) {
+    // Decode hash to readable vector
+    std::string decodedHash = base64_decode(hash);
+    if (decodedHash.size() < HEADER_SIZE) return (DecodedThumbhash){0, 0, std::make_unique<uint8_t[]>(0)};
+
+    // Read the constants
+    int header24 = int(decodedHash[0]) | (int(decodedHash[1]) << 8) | (int(decodedHash[2]) << 16);
+    int header16 = int(decodedHash[3]) | (int(decodedHash[4]) << 8);
+    double l_dc = double(header24 & 63) / 63.0;
+    double p_dc = double((header24 >> 6) & 63) / 31.5 - 1.0;
+    double q_dc = double((header24 >> 12) & 63) / 31.5 - 1.0;
+    double l_scale = double((header24 >> 18) & 31) / 31.0;
+    bool hasAlpha = header24 >> 23;
+    double p_scale = double((header16 >> 3) & 63) / 63.0;
+    double q_scale = ((header16 >> 9) & 63) / 63.0;
+    bool isLandscape = header16 >> 15;
+    int lx = std::max(3, isLandscape ? hasAlpha ? 5 : 7 : header16 & 7);
+    int ly = std::max(3, isLandscape ? header16 & 7 : hasAlpha ? 5 : 7);
+    double a_dc = hasAlpha ? double(decodedHash[5] & 15) / 15.0 : 1.0;
+    double a_scale = double(decodedHash[5] >> 4) / 15.0;
+
+    // Read the varying factors (boost saturation by 1.25x to compensate for quantization)
+    int ac_start = hasAlpha ? 6 : 5;
+    int ac_index = 0;
+
+    auto decodeChannel = [&](int nx, int ny, double scale) {
+        std::vector<double> ac;
+        ac.reserve(nx * ny);
+        for (int cy = 0; cy < ny; ++cy) {
+            for (int cx = cy != 0 ? 0 : 1; cx * ny < nx * (ny - cy); ++cx) {
+                ac.push_back(
+                        (double((decodedHash[ac_start + (ac_index >> 1)] >> ((ac_index++ & 1) << 2)) & 15) / 7.5 -
+                         1.0) *
+                        scale);
+            }
+        }
+        return ac;
+    };
+    auto l_ac = decodeChannel(lx, ly, l_scale);
+    auto p_ac = decodeChannel(3, 3, p_scale * 1.25);
+    auto q_ac = decodeChannel(3, 3, q_scale * 1.25);
+    std::vector<double> a_ac;
+    if (hasAlpha) {
+        a_ac = decodeChannel(5, 5, a_scale);
+    }
+
+    // Decode using the DCT into RGB
+    double ratio = thumbHashToApproximateAspectRatio(decodedHash);
+    int w = int(round(ratio > 1.0 ? 32.0 : 32.0 * ratio));
+    int h = int(round(ratio > 1.0 ? 32.0 / ratio : 32.0));
+    auto rgba = std::make_unique<uint8_t[]>(w * h * 4);
+    int n1 = std::max(lx, hasAlpha ? 5 : 3);
+    int n2 = std::max(ly, hasAlpha ? 5 : 3);
+    std::vector<double> fx(n1, 0);
+    std::vector<double> fy(n2, 0);
+
+    for (int y = 0, i = 0; y < h; ++y) {
+        for (int x = 0; x < w; ++x, i += 4) {
+            double l = l_dc;
+            double p = p_dc;
+            double q = q_dc;
+            double a = a_dc;
+
+            // Precompute the coefficients d
+            for (int cx = 0; cx < n1; ++cx) {
+                fx[cx] = cos(M_PI / w * (double(x) + 0.5) * double(cx));
+            }
+
+            for (int cy = 0; cy < n2; ++cy) {
+                fy[cy] = cos(M_PI / h * (double(y) + 0.5) * double(cy));
+            }
+
+            // Decode L
+
+            for (int cy = 0, j = 0; cy < ly; ++cy) {
+                for (int cx = cy != 0 ? 0 : 1; cx * ly < lx * (ly - cy); ++cx, ++j) {
+                    double fy2 = fy[cy] * 2.0;
+                    l += l_ac[j] * fx[cx] * fy2;
+                }
+            }
+
+            // Decode P and Q
+            for (int cy = 0, j = 0; cy < 3; ++cy) {
+                for (int cx = cy != 0 ? 0 : 1; cx < 3 - cy; ++cx, ++j) {
+                    double fy2 = fy[cy] * 2.0;
+                    double f = fx[cx] * fy2;
+                    p += p_ac[j] * f;
+                    q += q_ac[j] * f;
+                }
+            }
+
+            // Decode A
+            if (hasAlpha) {
+                for (int cy = 0, j = 0; cy < 5; ++cy) {
+                    for (int cx = cy != 0 ? 0 : 1; cx < 5 - cy; ++cx, ++j) {
+                        double fy2 = fy[cy] * 2.0;
+                        a += a_ac[j] * fx[cx] * fy2;
+                    }
+                }
+            }
+
+            // Convert to RGB
+            double b = l - 2.0 / 3.0 * p;
+            double r = (3.0 * l - b + q) / 2.0;
+            double g = r - q;
+            rgba[i] = uint8_t(std::max(0.0, 255.0 * std::min(1.0, r)));
+            rgba[i + 1] = uint8_t(std::max(0.0, 255.0 * std::min(1.0, g)));
+            rgba[i + 2] = uint8_t(std::max(0.0, 255.0 * std::min(1.0, b)));
+            rgba[i + 3] = uint8_t(std::max(0.0, 255.0 * std::min(1.0, a)));
+        }
+    }
+
+    DecodedThumbhash result = {.width = w, .height = h, .pixelArray = std::move(rgba)};
+
+    return result;
+}

package/kepler/thumbhash/decode.h

@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * Use is subject to license terms.
+ */
+
+#pragma once
+
+#include <cstdint>
+#include <memory>
+
+// Inspired by https://github.com/evanw/thumbhash/blob/main/java/com/madebyevan/thumbhash/ThumbHash.java
+
+struct DecodedThumbhash {
+    int width;
+    int height;
+    std::unique_ptr<uint8_t[]> pixelArray;
+};
+
+DecodedThumbhash decodeThumbhash(const std::string& thumbhash);

package/kepler/utils/PlaceholderImageLoaderDelegate.cpp

@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * Use is subject to license terms.
+ */
+
+#include "PlaceholderImageLoaderDelegate.h"
+
+PlaceholderImageLoaderDelegate::PlaceholderImageLoaderDelegate(std::function<void()> onLoad) : onLoad_(onLoad){};
+
+void PlaceholderImageLoaderDelegate::notifyImageLoadStart(){};
+
+void PlaceholderImageLoaderDelegate::notifyImageLoadProgress(float progress) {}
+
+void PlaceholderImageLoaderDelegate::notifyImageLoadSuccess(volta::graphics::Image) {
+    onLoad_();
+}
+void PlaceholderImageLoaderDelegate::notifyImageLoadSuccess(volta::image::ImageRef) {
+    onLoad_();
+}
+
+void PlaceholderImageLoaderDelegate::notifyImageLoadFailure(volta::ImageLoadError) {
+    onLoad_();
+}

package/kepler/utils/PlaceholderImageLoaderDelegate.h

@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * Use is subject to license terms.
+ */
+
+#pragma once
+
+#include <KeplerScript/utils/image/KeplerScriptImageLoaderDelegate.h>
+#include <Volta/utils/Image.h>
+
+class PlaceholderImageLoaderDelegate : public volta::IImageLoaderDelegate {
+public:
+    PlaceholderImageLoaderDelegate(std::function<void()> onLoad);
+
+    void notifyImageLoadStart() override;
+    void notifyImageLoadProgress(float progress) override;
+    void notifyImageLoadSuccess(volta::graphics::Image) override;
+    void notifyImageLoadSuccess(volta::image::ImageRef) override;
+    void notifyImageLoadFailure(volta::ImageLoadError) override;
+
+private:
+    std::function<void()> onLoad_;
+};

package/kepler/utils/PrefetchImageLoaderDelegate.cpp

@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * Use is subject to license terms.
+ */
+
+#include "PrefetchImageLoaderDelegate.h"
+
+#include <KeplerScript/appinit/KeplerScriptApplication.h>
+#include <KeplerScript/logger/KPLog.h>
+
+PrefetchImageLoaderDelegate::PrefetchImageLoaderDelegate(int imagesToLoad, const std::function<void(bool)>& onFinish) :
+        imagesToLoad_(imagesToLoad),
+        onFinish_(onFinish){};
+
+void PrefetchImageLoaderDelegate::notifyImageLoadStart() {
+    volta::react::KPLog.debug("ExpoImage :: prefetch LoadStart");
+};
+
+void PrefetchImageLoaderDelegate::notifyImageLoadProgress(float progress) {
+    volta::react::KPLog.debug("ExpoImage :: prefetch LoadProgress {}", progress);
+}
+
+void PrefetchImageLoaderDelegate::notifyImageLoadSuccess(volta::graphics::Image) {
+    volta::react::KPLog.debug("ExpoImage :: prefetch LoadSuccess");
+    imageLoaded();
+}
+void PrefetchImageLoaderDelegate::notifyImageLoadSuccess(volta::image::ImageRef) {
+    volta::react::KPLog.debug("ExpoImage :: prefetch LoadSuccess");
+    imageLoaded();
+}
+
+void PrefetchImageLoaderDelegate::notifyImageLoadFailure(volta::ImageLoadError) {
+    volta::react::KPLog.debug("ExpoImage :: prefetch LoadFailure");
+    imageErrored();
+}
+
+void PrefetchImageLoaderDelegate::onFinish(bool success) {
+    volta::react::KPLog.debug("ExpoImage :: onFinish {} {}", success, isResolved_);
+    if (!isResolved_) {
+        isResolved_ = true;
+        onFinish_(success);
+    }
+}
+
+void PrefetchImageLoaderDelegate::imageLoaded() {
+    imagesLoaded_++;
+    if (imagesLoaded_ == imagesToLoad_) onFinish(true);
+}
+
+void PrefetchImageLoaderDelegate::imageErrored() {
+    onFinish(false);
+}

package/kepler/utils/PrefetchImageLoaderDelegate.h

@@ -0,0 +1,35 @@
+/*
+ * 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/KeplerViewComponentEventEmitter.h>
+#include <KeplerScript/utils/image/KeplerScriptImageLoaderDelegate.h>
+#include <Volta/utils/Image.h>
+
+#include <memory>
+
+class PrefetchImageLoaderDelegate : public volta::IImageLoaderDelegate {
+public:
+    PrefetchImageLoaderDelegate(int imagesToLoad, const std::function<void(bool)>& onFinish);
+    void notifyImageLoadStart() override;
+    void notifyImageLoadProgress(float progress) override;
+    void notifyImageLoadSuccess(volta::graphics::Image) override;
+    void notifyImageLoadSuccess(volta::image::ImageRef) override;
+    void notifyImageLoadFailure(volta::ImageLoadError) override;
+
+private:
+    void imageLoaded();
+    void imageErrored();
+    void onFinish(bool success);
+
+    std::function<void(bool)> onFinish_;
+    int imagesToLoad_ = 0;
+    int imagesLoaded_ = 0;
+    bool isResolved_ = false;
+};

package/kepler/utils/SourceImageLoaderDelegate.cpp

@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * Use is subject to license terms.
+ */
+
+#include "SourceImageLoaderDelegate.h"
+
+#include <KeplerScript/components/EventPayloadBuilder.h>
+
+SourceImageLoaderDelegate::SourceImageLoaderDelegate(
+        const std::shared_ptr<volta::react::KeplerViewComponentEventEmitter>& eventEmitter,
+        const std::function<void()>& onLoad) :
+        eventEmitter_(std::make_unique<SourceImageLoaderDelegateEmitter>(eventEmitter)),
+        onLoad_(onLoad){};
+
+void SourceImageLoaderDelegate::notifyImageLoadStart() {
+    eventEmitter_->emit("loadStart");
+};
+
+void SourceImageLoaderDelegate::notifyImageLoadProgress(float progress) {
+    constexpr int32_t total = 10000;
+
+    eventEmitter_->emit("progress", [progress](volta::react::EventPayloadBuilder& eventPayloadBuilder) {
+        eventPayloadBuilder.insert("loaded", static_cast<int>(progress * total));
+        eventPayloadBuilder.insert("total", total);
+    });
+}
+
+void SourceImageLoaderDelegate::notifyImageLoadSuccess(volta::graphics::Image) {
+    eventEmitter_->emit("load");
+    eventEmitter_->emit("loadEnd");
+    onLoad_();
+}
+void SourceImageLoaderDelegate::notifyImageLoadSuccess(volta::image::ImageRef) {
+    eventEmitter_->emit("load");
+    eventEmitter_->emit("loadEnd");
+    onLoad_();
+}
+
+void SourceImageLoaderDelegate::notifyImageLoadFailure(volta::ImageLoadError) {
+    eventEmitter_->emit("error");
+    eventEmitter_->emit("loadEnd");
+    onLoad_();
+}

package/kepler/utils/SourceImageLoaderDelegate.h

@@ -0,0 +1,42 @@
+/*
+ * 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/EventPayloadBuilder.h>
+#include <KeplerScript/components/KeplerViewComponentEventEmitter.h>
+#include <KeplerScript/utils/image/KeplerScriptImageLoaderDelegate.h>
+#include <Volta/utils/Image.h>
+
+#include "SourceImageLoaderDelegateEmitter.h"
+
+#include <memory>
+
+
+class SourceImageLoaderDelegate : public volta::IImageLoaderDelegate {
+public:
+    SourceImageLoaderDelegate(
+            const std::shared_ptr<volta::react::KeplerViewComponentEventEmitter>& eventEmitter,
+            const std::function<void()>& onLoad);
+
+#ifdef UNIT_TEST
+    SourceImageLoaderDelegate(
+            std::unique_ptr<ISourceImageLoaderDelegateEmitter>&& emitter,
+            const std::function<void()>& onLoad) : eventEmitter_{std::move(emitter)}, onLoad_{onLoad} {}
+#endif
+
+    void notifyImageLoadStart() override;
+    void notifyImageLoadProgress(float progress) override;
+    void notifyImageLoadSuccess(volta::graphics::Image) override;
+    void notifyImageLoadSuccess(volta::image::ImageRef) override;
+    void notifyImageLoadFailure(volta::ImageLoadError) override;
+
+private:
+    std::unique_ptr<ISourceImageLoaderDelegateEmitter> eventEmitter_;
+    std::function<void()> onLoad_;
+};

package/kepler/utils/SourceImageLoaderDelegateEmitter.cpp

@@ -0,0 +1,15 @@
+#include "SourceImageLoaderDelegateEmitter.h"
+
+SourceImageLoaderDelegateEmitter::SourceImageLoaderDelegateEmitter(
+                  const std::shared_ptr<volta::react::KeplerViewComponentEventEmitter>& eventEmitter) :
+        eventEmitter_{eventEmitter} {}
+
+void SourceImageLoaderDelegateEmitter::emit(const std::string& eventName) const {
+    eventEmitter_->emit(eventName);
+}
+
+void SourceImageLoaderDelegateEmitter::emit(
+        const std::string& eventName,
+        const std::function<void(volta::react::EventPayloadBuilder&)>& builderFunc) const {
+    eventEmitter_->emit(eventName, builderFunc);
+}

package/kepler/utils/SourceImageLoaderDelegateEmitter.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <KeplerScript/components/EventPayloadBuilder.h>
+#include <KeplerScript/components/KeplerViewComponentEventEmitter.h>
+
+class ISourceImageLoaderDelegateEmitter {
+public:
+    virtual ~ISourceImageLoaderDelegateEmitter() = default;
+
+    virtual void emit(const std::string& eventName) const = 0;
+
+    virtual void emit(
+            const std::string& eventName,
+            const std::function<void(volta::react::EventPayloadBuilder&)>& builderFunc) const = 0;
+};
+
+class SourceImageLoaderDelegateEmitter : public ISourceImageLoaderDelegateEmitter {
+public:
+    explicit SourceImageLoaderDelegateEmitter(
+            const std::shared_ptr<volta::react::KeplerViewComponentEventEmitter>& eventEmitter);
+
+    void emit(const std::string& eventName) const override;
+
+    void emit(const std::string& eventName, const std::function<void(volta::react::EventPayloadBuilder&)>& builderFunc) const override;
+
+private:
+    std::shared_ptr<volta::react::KeplerViewComponentEventEmitter> eventEmitter_;
+};

package/kepler-compatibility.json

@@ -0,0 +1,8 @@
+{
+  "versions": {
+    "2.0.0": "/com.amazon.kepler.expo_image_2@IExpoImage_0",
+    "2.0.1756403551": "/com.amazon.kepler.expo_image_2@IExpoImage_0",
+    "2.0.1758654000": "/com.amazon.kepler.expo_image_2@IExpoImage_0",
+    "2.0.1758683737": "/com.amazon.kepler.expo_image_2@IExpoImage_0"
+  }
+}

package/package.json

@@ -0,0 +1 @@
+{"name": "@amazon-devices/expo-image", "title": "Expo Image", "version": "2.0.1758683737+1.6.0", "description": "A cross-platform, performant image component for React Native and Expo with Web support", "main": "build/index.js", "types": "build/index.d.ts", "sideEffects": false, "scripts": {"build": "expo-module build", "clean": "expo-module clean", "lint": "expo-module lint", "test": "expo-module test", "expo-module": "expo-module"}, "homepage": "https://docs.expo.dev/versions/latest/sdk/image/", "repository": {"type": "git", "url": "https://github.com/expo/expo.git", "directory": "packages/expo-image"}, "kepler": {"temporary-alias-for-package": {"name": "expo-image", "version": "1.6.0"}}, "keywords": ["react-native"], "author": "650 Industries, Inc.", "license": "See license in LICENSE", "dependencies": {"@amazon-devices/keplerscript-turbomodule-api": "^1.0.0"}, "devDependencies": {"expo-module-scripts": "^3.0.0"}, "peerDependencies": {"expo": "*"}}

package/react-native.config.js

@@ -0,0 +1,22 @@
+module.exports = {
+    dependencies: {
+        '@amazon-devices/react-native-kepler': {
+            platforms: {
+                kepler: null,  // do not use platform definition from @react-native-kepler
+            },
+        },
+    },
+    dependency: {
+        platforms: {
+            kepler: {
+                autolink: {
+                    ExpoImageLib: {
+                        provider: 'system',
+                        turbomodules: ['ExpoImage'],
+                        components: ['ExpoImageComponent'],
+                    },
+                },
+            },
+        },
+    },
+};

package/src/ExpoImage.kepler.tsx

@@ -0,0 +1,119 @@
+/**
+ * Copyright (c) 2024 Amazon.com, Inc. or its affiliates.  All rights reserved.
+ *
+ * PROPRIETARY/CONFIDENTIAL.  USE IS SUBJECT TO LICENSE TERMS.
+ *
+ * @flow
+ * @format
+ */
+
+import * as React from 'react';
+import { NativeSyntheticEvent, StyleSheet, ViewProps, processColor } from 'react-native';
+
+import { ExpoImageModule } from './ExpoImageModules';
+import {
+  ImageErrorEventData,
+  ImageLoadEventData,
+  ImageNativeProps,
+  ImageProgressEventData,
+} from './Image.types';
+import ImageViewNativeComponent, {
+  ImageViewNativeComponentProps,
+} from './ImageViewNativeComponent';
+
+type ImageOnlyProps = Omit<ImageViewNativeComponentProps, keyof ViewProps> & {
+  accessibilityLabel?: string | undefined;
+};
+
+
+
+function withDeprecatedNativeEvent<NativeEvent>(
+  event: NativeSyntheticEvent<NativeEvent>
+): NativeEvent {
+  Object.defineProperty(event.nativeEvent, 'nativeEvent', {
+    get() {
+      console.warn(
+        '[expo-image]: Accessing event payload through "nativeEvent" is deprecated, it is now part of the event object itself'
+      );
+      return event.nativeEvent;
+    },
+  });
+  return event.nativeEvent;
+}
+
+class ExpoImage extends React.PureComponent<ImageNativeProps> {
+  onLoadStart = () => {
+    this.props.onLoadStart?.();
+  };
+
+  onLoad = (event: NativeSyntheticEvent<ImageLoadEventData>) => {
+    this.props.onLoad?.(withDeprecatedNativeEvent(event));
+  };
+
+  onProgress = (event: NativeSyntheticEvent<ImageProgressEventData>) => {
+    this.props.onProgress?.(withDeprecatedNativeEvent(event));
+  };
+
+  onError = (event: NativeSyntheticEvent<ImageErrorEventData>) => {
+    this.props.onError?.(withDeprecatedNativeEvent(event));
+  };
+
+  onLoadEnd = () => {
+    this.props.onLoadEnd?.();
+  };
+
+  render() {
+    const {
+      style,
+      allowDownscaling,
+      alt,
+      accessibilityLabel,
+      blurRadius,
+      cachePolicy,
+      contentFit,
+      contentPosition,
+      placeholderContentFit,
+      priority,
+      recyclingKey,
+      source,
+      transition,
+      placeholder,
+      tintColor,
+      ...props
+    } = this.props;
+
+    delete props.defaultSource;
+    delete props.fadeDuration;
+    delete props.resizeMode;
+    delete props.loadingIndicatorSource;
+
+    const resolvedStyle = StyleSheet.flatten(style);
+
+    const imageProps: ImageOnlyProps = {
+      allowDownscaling: allowDownscaling ?? true,
+      alt,
+      accessibilityLabel: accessibilityLabel ?? alt,
+      blurRadius,
+      cachePolicy,
+      contentFit,
+      contentPosition,
+      onError: this.onError,
+      onLoadStart: this.onLoadStart,
+      onLoad: this.onLoad,
+      onProgress: this.onProgress,
+      onLoadEnd: this.onLoadEnd,
+      placeholder,
+      placeholderContentFit,
+      priority,
+      tintColor: processColor(tintColor || resolvedStyle.tintColor),
+      recyclingKey,
+      source,
+      transition,
+    };
+
+    return <ImageViewNativeComponent {...props} {...imageProps} style={style} />;
+  }
+}
+
+export { ExpoImageModule };
+export default ExpoImage;