@depup/react-native-fast-image 8.6.3-depup.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Dylan Vann
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,25 @@
+# @depup/react-native-fast-image
+
+> Dependency-bumped version of [react-native-fast-image](https://www.npmjs.com/package/react-native-fast-image)
+
+Generated by [DepUp](https://github.com/depup/npm) -- all production
+dependencies bumped to latest versions.
+
+## Installation
+
+```bash
+npm install @depup/react-native-fast-image
+```
+
+| Field | Value |
+|-------|-------|
+| Original | [react-native-fast-image](https://www.npmjs.com/package/react-native-fast-image) @ 8.6.3 |
+| Processed | 2026-03-18 |
+| Smoke test | failed |
+| Deps updated | 0 |
+
+---
+
+Source: https://github.com/depup/npm | Original: https://www.npmjs.com/package/react-native-fast-image
+
+License inherited from the original package.

package/RNFastImage.podspec

@@ -0,0 +1,21 @@
+require 'json'
+
+Pod::Spec.new do |s|
+  package = JSON.parse(File.read(File.join(__dir__, 'package.json')))
+
+  s.name          = "RNFastImage"
+  s.version       = package['version']
+  s.summary       = package['description']
+  s.authors       = { "Dylan Vann" => "dylan@dylanvann.com" }
+  s.homepage      = "https://github.com/DylanVann/react-native-fast-image#readme"
+  s.license       = "MIT"
+  s.platforms     = { :ios => "8.0", :tvos => "9.0" }
+  s.framework     = 'UIKit'
+  s.requires_arc  = true
+  s.source        = { :git => "https://github.com/DylanVann/react-native-fast-image.git", :tag => "v#{s.version}" }
+  s.source_files  = "ios/**/*.{h,m}"
+
+  s.dependency 'React-Core'
+  s.dependency 'SDWebImage', '~> 5.11.1'
+  s.dependency 'SDWebImageWebPCoder', '~> 0.8.4'
+end

package/android/build.gradle

@@ -0,0 +1,68 @@
+def safeExtGet(prop, fallback) {
+    rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+}
+
+buildscript {
+    // The Android Gradle plugin is only required when opening the android folder stand-alone.
+    // This avoids unnecessary downloads and potential conflicts when the library is included as a
+    // module dependency in an application project.
+    if (project == rootProject) {
+        repositories {
+            google()
+            mavenCentral()
+        }
+        dependencies {
+            classpath 'com.android.tools.build:gradle:3.5.3'
+        }
+    }
+}
+
+apply plugin: 'com.android.library'
+
+android {
+    compileSdkVersion safeExtGet('compileSdkVersion', 28)
+    buildToolsVersion safeExtGet('buildToolsVersion', '28.0.3')
+    defaultConfig {
+        minSdkVersion safeExtGet('minSdkVersion', 16)
+        targetSdkVersion safeExtGet('targetSdkVersion', 28)
+        versionCode 1
+        versionName "1.0"
+    }
+    sourceSets {
+        main {
+            java {
+                if (safeExtGet('excludeAppGlideModule', false)) {
+                    srcDir "src"
+                    exclude "**/FastImageGlideModule.java"
+                }
+            }
+        }
+    }
+    lintOptions {
+        abortOnError false
+    }
+}
+
+repositories {
+    mavenLocal()
+    maven {
+        // All of React Native (JS, Obj-C sources, Android binaries) is installed from npm
+        url "$rootDir/../node_modules/react-native/android"
+    }
+    maven {
+        // Android JSC is installed from npm
+        url "$rootDir/../node_modules/jsc-android/dist"
+    }
+    google()
+    mavenCentral()
+}
+
+def glideVersion = safeExtGet('glideVersion', '4.12.0')
+
+dependencies {
+    //noinspection GradleDynamicVersion
+    implementation 'com.facebook.react:react-native:+'  // From node_modules
+    implementation "com.github.bumptech.glide:glide:${glideVersion}"
+    implementation "com.github.bumptech.glide:okhttp3-integration:${glideVersion}"
+    annotationProcessor "com.github.bumptech.glide:compiler:${glideVersion}"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest package="com.dylanvann.fastimage">
+</manifest>

package/android/src/main/java/com/dylanvann/fastimage/FastImageCacheControl.java

@@ -0,0 +1,8 @@
+package com.dylanvann.fastimage;
+
+public enum FastImageCacheControl {
+    IMMUTABLE,
+    WEB,
+    CACHE_ONLY
+}
+

package/android/src/main/java/com/dylanvann/fastimage/FastImageGlideModule.java

@@ -0,0 +1,9 @@
+package com.dylanvann.fastimage;
+
+import com.bumptech.glide.annotation.GlideModule;
+import com.bumptech.glide.module.AppGlideModule;
+
+// We need an AppGlideModule to be present for progress events to work.
+@GlideModule
+public final class FastImageGlideModule extends AppGlideModule {
+}

package/android/src/main/java/com/dylanvann/fastimage/FastImageOkHttpProgressGlideModule.java

@@ -0,0 +1,176 @@
+package com.dylanvann.fastimage;
+
+import android.content.Context;
+import androidx.annotation.NonNull;
+
+import com.bumptech.glide.Glide;
+import com.bumptech.glide.Registry;
+import com.bumptech.glide.annotation.GlideModule;
+import com.bumptech.glide.integration.okhttp3.OkHttpUrlLoader;
+import com.bumptech.glide.load.model.GlideUrl;
+import com.bumptech.glide.module.LibraryGlideModule;
+import com.facebook.react.modules.network.OkHttpClientProvider;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.WeakHashMap;
+
+import okhttp3.Interceptor;
+import okhttp3.MediaType;
+import okhttp3.OkHttpClient;
+import okhttp3.Request;
+import okhttp3.Response;
+import okhttp3.ResponseBody;
+import okio.Buffer;
+import okio.BufferedSource;
+import okio.ForwardingSource;
+import okio.Okio;
+import okio.Source;
+
+@GlideModule
+public class FastImageOkHttpProgressGlideModule extends LibraryGlideModule {
+
+    private static final DispatchingProgressListener progressListener = new DispatchingProgressListener();
+
+    @Override
+    public void registerComponents(
+            @NonNull Context context,
+            @NonNull Glide glide,
+            @NonNull Registry registry
+    ) {
+        OkHttpClient client = OkHttpClientProvider
+                .getOkHttpClient()
+                .newBuilder()
+                .addInterceptor(createInterceptor(progressListener))
+                .build();
+        OkHttpUrlLoader.Factory factory = new OkHttpUrlLoader.Factory(client);
+        registry.replace(GlideUrl.class, InputStream.class, factory);
+    }
+
+    private static Interceptor createInterceptor(final ResponseProgressListener listener) {
+        return new Interceptor() {
+            @Override
+            public Response intercept(Chain chain) throws IOException {
+                Request request = chain.request();
+                Response response = chain.proceed(request);
+                final String key = request.url().toString();
+                return response
+                        .newBuilder()
+                        .body(new OkHttpProgressResponseBody(key, response.body(), listener))
+                        .build();
+            }
+        };
+    }
+
+    static void forget(String key) {
+        progressListener.forget(key);
+    }
+
+    static void expect(String key, FastImageProgressListener listener) {
+        progressListener.expect(key, listener);
+    }
+
+    private interface ResponseProgressListener {
+        void update(String key, long bytesRead, long contentLength);
+    }
+
+    private static class DispatchingProgressListener implements ResponseProgressListener {
+        private final Map<String, FastImageProgressListener> LISTENERS = new WeakHashMap<>();
+        private final Map<String, Long> PROGRESSES = new HashMap<>();
+
+        void forget(String key) {
+            LISTENERS.remove(key);
+            PROGRESSES.remove(key);
+        }
+
+        void expect(String key, FastImageProgressListener listener) {
+            LISTENERS.put(key, listener);
+        }
+
+        @Override
+        public void update(final String key, final long bytesRead, final long contentLength) {
+            final FastImageProgressListener listener = LISTENERS.get(key);
+            if (listener == null) {
+                return;
+            }
+            if (contentLength <= bytesRead) {
+                forget(key);
+            }
+            if (needsDispatch(key, bytesRead, contentLength, listener.getGranularityPercentage())) {
+                listener.onProgress(key, bytesRead, contentLength);
+            }
+        }
+
+        private boolean needsDispatch(String key, long current, long total, float granularity) {
+            if (granularity == 0 || current == 0 || total == current) {
+                return true;
+            }
+            float percent = 100f * current / total;
+            long currentProgress = (long) (percent / granularity);
+            Long lastProgress = PROGRESSES.get(key);
+            if (lastProgress == null || currentProgress != lastProgress) {
+                PROGRESSES.put(key, currentProgress);
+                return true;
+            } else {
+                return false;
+            }
+        }
+    }
+
+    private static class OkHttpProgressResponseBody extends ResponseBody {
+        private final String key;
+        private final ResponseBody responseBody;
+        private final ResponseProgressListener progressListener;
+        private BufferedSource bufferedSource;
+
+        OkHttpProgressResponseBody(
+                String key,
+                ResponseBody responseBody,
+                ResponseProgressListener progressListener
+        ) {
+            this.key = key;
+            this.responseBody = responseBody;
+            this.progressListener = progressListener;
+        }
+
+        @Override
+        public MediaType contentType() {
+            return responseBody.contentType();
+        }
+
+        @Override
+        public long contentLength() {
+            return responseBody.contentLength();
+        }
+
+        @Override
+        public BufferedSource source() {
+            if (bufferedSource == null) {
+                bufferedSource = Okio.buffer(source(responseBody.source()));
+            }
+            return bufferedSource;
+        }
+
+        private Source source(Source source) {
+            return new ForwardingSource(source) {
+                long totalBytesRead = 0L;
+
+                @Override
+                public long read(Buffer sink, long byteCount) throws IOException {
+                    long bytesRead = super.read(sink, byteCount);
+                    long fullLength = responseBody.contentLength();
+                    if (bytesRead == -1) {
+                        // this source is exhausted
+                        totalBytesRead = fullLength;
+                    } else {
+                        totalBytesRead += bytesRead;
+                    }
+                    progressListener.update(key, totalBytesRead, fullLength);
+                    return bytesRead;
+                }
+            };
+        }
+    }
+}

package/android/src/main/java/com/dylanvann/fastimage/FastImageProgressListener.java

@@ -0,0 +1,14 @@
+package com.dylanvann.fastimage;
+
+public interface FastImageProgressListener {
+
+    void onProgress(String key, long bytesRead, long expectedLength);
+
+    /**
+     * Control how often the listener needs an update. 0% and 100% will always be dispatched.
+     *
+     * @return in percentage (0.2 = call {@link #onProgress} around every 0.2 percent of progress)
+     */
+    float getGranularityPercentage();
+
+}

package/android/src/main/java/com/dylanvann/fastimage/FastImageRequestListener.java

@@ -0,0 +1,60 @@
+package com.dylanvann.fastimage;
+
+import android.graphics.drawable.Drawable;
+
+import com.bumptech.glide.load.DataSource;
+import com.bumptech.glide.load.engine.GlideException;
+import com.bumptech.glide.request.RequestListener;
+import com.bumptech.glide.request.target.ImageViewTarget;
+import com.bumptech.glide.request.target.Target;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.bridge.WritableNativeMap;
+import com.facebook.react.uimanager.ThemedReactContext;
+import com.facebook.react.uimanager.events.RCTEventEmitter;
+
+public class FastImageRequestListener implements RequestListener<Drawable> {
+    static final String REACT_ON_ERROR_EVENT = "onFastImageError";
+    static final String REACT_ON_LOAD_EVENT = "onFastImageLoad";
+    static final String REACT_ON_LOAD_END_EVENT = "onFastImageLoadEnd";
+    private final String key;
+
+    FastImageRequestListener(String key) {
+        this.key = key;
+    }
+
+    private static WritableMap mapFromResource(Drawable resource) {
+        WritableMap resourceData = new WritableNativeMap();
+        resourceData.putInt("width", resource.getIntrinsicWidth());
+        resourceData.putInt("height", resource.getIntrinsicHeight());
+        return resourceData;
+    }
+
+    @Override
+    public boolean onLoadFailed(@androidx.annotation.Nullable GlideException e, Object model, Target<Drawable> target, boolean isFirstResource) {
+        FastImageOkHttpProgressGlideModule.forget(key);
+        if (!(target instanceof ImageViewTarget)) {
+            return false;
+        }
+        FastImageViewWithUrl view = (FastImageViewWithUrl) ((ImageViewTarget) target).getView();
+        ThemedReactContext context = (ThemedReactContext) view.getContext();
+        RCTEventEmitter eventEmitter = context.getJSModule(RCTEventEmitter.class);
+        int viewId = view.getId();
+        eventEmitter.receiveEvent(viewId, REACT_ON_ERROR_EVENT, new WritableNativeMap());
+        eventEmitter.receiveEvent(viewId, REACT_ON_LOAD_END_EVENT, new WritableNativeMap());
+        return false;
+    }
+
+    @Override
+    public boolean onResourceReady(Drawable resource, Object model, Target<Drawable> target, DataSource dataSource, boolean isFirstResource) {
+        if (!(target instanceof ImageViewTarget)) {
+            return false;
+        }
+        FastImageViewWithUrl view = (FastImageViewWithUrl) ((ImageViewTarget) target).getView();
+        ThemedReactContext context = (ThemedReactContext) view.getContext();
+        RCTEventEmitter eventEmitter = context.getJSModule(RCTEventEmitter.class);
+        int viewId = view.getId();
+        eventEmitter.receiveEvent(viewId, REACT_ON_LOAD_EVENT, mapFromResource(resource));
+        eventEmitter.receiveEvent(viewId, REACT_ON_LOAD_END_EVENT, new WritableNativeMap());
+        return false;
+    }
+}

package/android/src/main/java/com/dylanvann/fastimage/FastImageSource.java

@@ -0,0 +1,112 @@
+package com.dylanvann.fastimage;
+
+import android.content.Context;
+import android.content.res.Resources;
+import android.net.Uri;
+import android.text.TextUtils;
+
+import com.bumptech.glide.load.model.GlideUrl;
+import com.bumptech.glide.load.model.Headers;
+import com.facebook.react.views.imagehelper.ImageSource;
+
+import javax.annotation.Nullable;
+
+public class FastImageSource extends ImageSource {
+    private static final String DATA_SCHEME = "data";
+    private static final String LOCAL_RESOURCE_SCHEME = "res";
+    private static final String ANDROID_RESOURCE_SCHEME = "android.resource";
+    private static final String ANDROID_CONTENT_SCHEME = "content";
+    private static final String LOCAL_FILE_SCHEME = "file";
+    private final Headers mHeaders;
+    private Uri mUri;
+
+    public static boolean isBase64Uri(Uri uri) {
+        return DATA_SCHEME.equals(uri.getScheme());
+    }
+
+    public static boolean isLocalResourceUri(Uri uri) {
+        return LOCAL_RESOURCE_SCHEME.equals(uri.getScheme());
+    }
+
+    public static boolean isResourceUri(Uri uri) {
+        return ANDROID_RESOURCE_SCHEME.equals(uri.getScheme());
+    }
+
+    public static boolean isContentUri(Uri uri) {
+        return ANDROID_CONTENT_SCHEME.equals(uri.getScheme());
+    }
+
+    public static boolean isLocalFileUri(Uri uri) {
+        return LOCAL_FILE_SCHEME.equals(uri.getScheme());
+    }
+
+    public FastImageSource(Context context, String source) {
+        this(context, source, null);
+    }
+
+    public FastImageSource(Context context, String source, @Nullable Headers headers) {
+        this(context, source, 0.0d, 0.0d, headers);
+    }
+
+    public FastImageSource(Context context, String source, double width, double height, @Nullable Headers headers) {
+        super(context, source, width, height);
+        mHeaders = headers == null ? Headers.DEFAULT : headers;
+        mUri = super.getUri();
+
+        if (isResource() && TextUtils.isEmpty(mUri.toString())) {
+            throw new Resources.NotFoundException("Local Resource Not Found. Resource: '" + getSource() + "'.");
+        }
+
+        if (isLocalResourceUri(mUri)) {
+            // Convert res:/ scheme to android.resource:// so
+            // glide can understand the uri.
+            mUri = Uri.parse(mUri.toString().replace("res:/", ANDROID_RESOURCE_SCHEME + "://" + context.getPackageName() + "/"));
+        }
+    }
+
+
+    public boolean isBase64Resource() {
+        return mUri != null && FastImageSource.isBase64Uri(mUri);
+    }
+
+    public boolean isResource() {
+        return mUri != null && FastImageSource.isResourceUri(mUri);
+    }
+
+    public boolean isLocalFile() {
+        return mUri != null && FastImageSource.isLocalFileUri(mUri);
+    }
+
+    public boolean isContentUri() {
+        return mUri != null && FastImageSource.isContentUri(mUri);
+    }
+
+    public Object getSourceForLoad() {
+        if (isContentUri()) {
+            return getSource();
+        }
+        if (isBase64Resource()) {
+            return getSource();
+        }
+        if (isResource()) {
+            return getUri();
+        }
+        if (isLocalFile()) {
+            return getUri().toString();
+        }
+        return getGlideUrl();
+    }
+
+    @Override
+    public Uri getUri() {
+        return mUri;
+    }
+
+    public Headers getHeaders() {
+        return mHeaders;
+    }
+
+    public GlideUrl getGlideUrl() {
+        return new GlideUrl(getUri().toString(), getHeaders());
+    }
+}

package/android/src/main/java/com/dylanvann/fastimage/FastImageViewConverter.java

@@ -0,0 +1,153 @@
+package com.dylanvann.fastimage;
+
+import static com.bumptech.glide.request.RequestOptions.signatureOf;
+
+import android.content.Context;
+import android.graphics.Color;
+import android.graphics.drawable.ColorDrawable;
+import android.graphics.drawable.Drawable;
+import android.widget.ImageView;
+import android.widget.ImageView.ScaleType;
+
+import com.bumptech.glide.Priority;
+import com.bumptech.glide.load.engine.DiskCacheStrategy;
+import com.bumptech.glide.load.model.Headers;
+import com.bumptech.glide.load.model.LazyHeaders;
+import com.bumptech.glide.request.RequestOptions;
+import com.bumptech.glide.signature.ApplicationVersionSignature;
+import com.facebook.react.bridge.JSApplicationIllegalArgumentException;
+import com.facebook.react.bridge.NoSuchKeyException;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.ReadableMapKeySetIterator;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import javax.annotation.Nullable;
+
+class FastImageViewConverter {
+    private static final Drawable TRANSPARENT_DRAWABLE = new ColorDrawable(Color.TRANSPARENT);
+
+    private static final Map<String, FastImageCacheControl> FAST_IMAGE_CACHE_CONTROL_MAP =
+            new HashMap<String, FastImageCacheControl>() {{
+                put("immutable", FastImageCacheControl.IMMUTABLE);
+                put("web", FastImageCacheControl.WEB);
+                put("cacheOnly", FastImageCacheControl.CACHE_ONLY);
+            }};
+
+    private static final Map<String, Priority> FAST_IMAGE_PRIORITY_MAP =
+            new HashMap<String, Priority>() {{
+                put("low", Priority.LOW);
+                put("normal", Priority.NORMAL);
+                put("high", Priority.HIGH);
+            }};
+
+    private static final Map<String, ImageView.ScaleType> FAST_IMAGE_RESIZE_MODE_MAP =
+            new HashMap<String, ImageView.ScaleType>() {{
+                put("contain", ScaleType.FIT_CENTER);
+                put("cover", ScaleType.CENTER_CROP);
+                put("stretch", ScaleType.FIT_XY);
+                put("center", ScaleType.CENTER_INSIDE);
+            }};
+
+    // Resolve the source uri to a file path that android understands.
+    static @Nullable
+    FastImageSource getImageSource(Context context, @Nullable ReadableMap source) {
+        return source == null
+                ? null
+                : new FastImageSource(context, source.getString("uri"), getHeaders(source));
+    }
+
+    static Headers getHeaders(ReadableMap source) {
+        Headers headers = Headers.DEFAULT;
+
+        if (source.hasKey("headers")) {
+            ReadableMap headersMap = source.getMap("headers");
+            ReadableMapKeySetIterator iterator = headersMap.keySetIterator();
+            LazyHeaders.Builder builder = new LazyHeaders.Builder();
+
+            while (iterator.hasNextKey()) {
+                String header = iterator.nextKey();
+                String value = headersMap.getString(header);
+
+                builder.addHeader(header, value);
+            }
+
+            headers = builder.build();
+        }
+
+        return headers;
+    }
+
+    static RequestOptions getOptions(Context context, FastImageSource imageSource, ReadableMap source) {
+        // Get priority.
+        final Priority priority = FastImageViewConverter.getPriority(source);
+        // Get cache control method.
+        final FastImageCacheControl cacheControl = FastImageViewConverter.getCacheControl(source);
+        DiskCacheStrategy diskCacheStrategy = DiskCacheStrategy.AUTOMATIC;
+        boolean onlyFromCache = false;
+        boolean skipMemoryCache = false;
+        switch (cacheControl) {
+            case WEB:
+                // If using none then OkHttp integration should be used for caching.
+                diskCacheStrategy = DiskCacheStrategy.NONE;
+                skipMemoryCache = true;
+                break;
+            case CACHE_ONLY:
+                onlyFromCache = true;
+                break;
+            case IMMUTABLE:
+                // Use defaults.
+                break;
+        }
+
+        RequestOptions options = new RequestOptions()
+                .diskCacheStrategy(diskCacheStrategy)
+                .onlyRetrieveFromCache(onlyFromCache)
+                .skipMemoryCache(skipMemoryCache)
+                .priority(priority)
+                .placeholder(TRANSPARENT_DRAWABLE);
+
+        if (imageSource.isResource()) {
+            // Every local resource (drawable) in Android has its own unique numeric id, which are
+            // generated at build time. Although these ids are unique, they are not guaranteed unique
+            // across builds. The underlying glide implementation caches these resources. To make
+            // sure the cache does not return the wrong image, we should clear the cache when the
+            // application version changes. Adding a cache signature for only these local resources
+            // solves this issue: https://github.com/DylanVann/react-native-fast-image/issues/402
+            options = options.apply(signatureOf(ApplicationVersionSignature.obtain(context)));
+        }
+
+        return options;
+    }
+
+    private static FastImageCacheControl getCacheControl(ReadableMap source) {
+        return getValueFromSource("cache", "immutable", FAST_IMAGE_CACHE_CONTROL_MAP, source);
+    }
+
+    private static Priority getPriority(ReadableMap source) {
+        return getValueFromSource("priority", "normal", FAST_IMAGE_PRIORITY_MAP, source);
+    }
+
+    static ScaleType getScaleType(String propValue) {
+        return getValue("resizeMode", "cover", FAST_IMAGE_RESIZE_MODE_MAP, propValue);
+    }
+
+    private static <T> T getValue(String propName, String defaultPropValue, Map<String, T> map, String propValue) {
+        if (propValue == null) propValue = defaultPropValue;
+        T value = map.get(propValue);
+        if (value == null)
+            throw new JSApplicationIllegalArgumentException("FastImage, invalid " + propName + " : " + propValue);
+        return value;
+    }
+
+    private static <T> T getValueFromSource(String propName, String defaultProp, Map<String, T> map, ReadableMap source) {
+        String propValue;
+        try {
+            propValue = source != null ? source.getString(propName) : null;
+        } catch (NoSuchKeyException e) {
+            propValue = null;
+        }
+        return getValue(propName, defaultProp, map, propValue);
+    }
+}