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

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

@@ -0,0 +1,183 @@
+package com.dylanvann.fastimage;
+
+import static com.dylanvann.fastimage.FastImageRequestListener.REACT_ON_ERROR_EVENT;
+import static com.dylanvann.fastimage.FastImageRequestListener.REACT_ON_LOAD_END_EVENT;
+import static com.dylanvann.fastimage.FastImageRequestListener.REACT_ON_LOAD_EVENT;
+
+import android.app.Activity;
+import android.content.Context;
+import android.content.ContextWrapper;
+import android.graphics.PorterDuff;
+import android.os.Build;
+
+import androidx.annotation.NonNull;
+
+import com.bumptech.glide.Glide;
+import com.bumptech.glide.RequestManager;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.bridge.WritableNativeMap;
+import com.facebook.react.common.MapBuilder;
+import com.facebook.react.uimanager.SimpleViewManager;
+import com.facebook.react.uimanager.ThemedReactContext;
+import com.facebook.react.uimanager.annotations.ReactProp;
+import com.facebook.react.uimanager.events.RCTEventEmitter;
+import com.facebook.react.views.imagehelper.ResourceDrawableIdHelper;
+
+import java.util.List;
+import java.util.Map;
+import java.util.WeakHashMap;
+
+import javax.annotation.Nullable;
+
+class FastImageViewManager extends SimpleViewManager<FastImageViewWithUrl> implements FastImageProgressListener {
+
+    static final String REACT_CLASS = "FastImageView";
+    static final String REACT_ON_LOAD_START_EVENT = "onFastImageLoadStart";
+    static final String REACT_ON_PROGRESS_EVENT = "onFastImageProgress";
+    private static final Map<String, List<FastImageViewWithUrl>> VIEWS_FOR_URLS = new WeakHashMap<>();
+
+    @Nullable
+    private RequestManager requestManager = null;
+
+    @NonNull
+    @Override
+    public String getName() {
+        return REACT_CLASS;
+    }
+
+    @NonNull
+    @Override
+    protected FastImageViewWithUrl createViewInstance(@NonNull ThemedReactContext reactContext) {
+        if (isValidContextForGlide(reactContext)) {
+            requestManager = Glide.with(reactContext);
+        }
+
+        return new FastImageViewWithUrl(reactContext);
+    }
+
+    @ReactProp(name = "source")
+    public void setSource(FastImageViewWithUrl view, @Nullable ReadableMap source) {
+        view.setSource(source);
+    }
+
+    @ReactProp(name = "defaultSource")
+    public void setDefaultSource(FastImageViewWithUrl view, @Nullable String source) {
+        view.setDefaultSource(
+                ResourceDrawableIdHelper.getInstance()
+                        .getResourceDrawable(view.getContext(), source));
+    }
+
+    @ReactProp(name = "tintColor", customType = "Color")
+    public void setTintColor(FastImageViewWithUrl view, @Nullable Integer color) {
+        if (color == null) {
+            view.clearColorFilter();
+        } else {
+            view.setColorFilter(color, PorterDuff.Mode.SRC_IN);
+        }
+    }
+
+    @ReactProp(name = "resizeMode")
+    public void setResizeMode(FastImageViewWithUrl view, String resizeMode) {
+        final FastImageViewWithUrl.ScaleType scaleType = FastImageViewConverter.getScaleType(resizeMode);
+        view.setScaleType(scaleType);
+    }
+
+    @Override
+    public void onDropViewInstance(@NonNull FastImageViewWithUrl view) {
+        // This will cancel existing requests.
+        view.clearView(requestManager);
+
+        if (view.glideUrl != null) {
+            final String key = view.glideUrl.toString();
+            FastImageOkHttpProgressGlideModule.forget(key);
+            List<FastImageViewWithUrl> viewsForKey = VIEWS_FOR_URLS.get(key);
+            if (viewsForKey != null) {
+                viewsForKey.remove(view);
+                if (viewsForKey.size() == 0) VIEWS_FOR_URLS.remove(key);
+            }
+        }
+
+        super.onDropViewInstance(view);
+    }
+
+    @Override
+    public Map<String, Object> getExportedCustomDirectEventTypeConstants() {
+        return MapBuilder.<String, Object>builder()
+                .put(REACT_ON_LOAD_START_EVENT, MapBuilder.of("registrationName", REACT_ON_LOAD_START_EVENT))
+                .put(REACT_ON_PROGRESS_EVENT, MapBuilder.of("registrationName", REACT_ON_PROGRESS_EVENT))
+                .put(REACT_ON_LOAD_EVENT, MapBuilder.of("registrationName", REACT_ON_LOAD_EVENT))
+                .put(REACT_ON_ERROR_EVENT, MapBuilder.of("registrationName", REACT_ON_ERROR_EVENT))
+                .put(REACT_ON_LOAD_END_EVENT, MapBuilder.of("registrationName", REACT_ON_LOAD_END_EVENT))
+                .build();
+    }
+
+    @Override
+    public void onProgress(String key, long bytesRead, long expectedLength) {
+        List<FastImageViewWithUrl> viewsForKey = VIEWS_FOR_URLS.get(key);
+        if (viewsForKey != null) {
+            for (FastImageViewWithUrl view : viewsForKey) {
+                WritableMap event = new WritableNativeMap();
+                event.putInt("loaded", (int) bytesRead);
+                event.putInt("total", (int) expectedLength);
+                ThemedReactContext context = (ThemedReactContext) view.getContext();
+                RCTEventEmitter eventEmitter = context.getJSModule(RCTEventEmitter.class);
+                int viewId = view.getId();
+                eventEmitter.receiveEvent(viewId, REACT_ON_PROGRESS_EVENT, event);
+            }
+        }
+    }
+
+    @Override
+    public float getGranularityPercentage() {
+        return 0.5f;
+    }
+
+    private static boolean isValidContextForGlide(final Context context) {
+        Activity activity = getActivityFromContext(context);
+
+        if (activity == null) {
+            return false;
+        }
+
+        return !isActivityDestroyed(activity);
+    }
+
+    private static Activity getActivityFromContext(final Context context) {
+        if (context instanceof Activity) {
+            return (Activity) context;
+        }
+
+        if (context instanceof ThemedReactContext) {
+            final Context baseContext = ((ThemedReactContext) context).getBaseContext();
+            if (baseContext instanceof Activity) {
+                return (Activity) baseContext;
+            }
+
+            if (baseContext instanceof ContextWrapper) {
+                final ContextWrapper contextWrapper = (ContextWrapper) baseContext;
+                final Context wrapperBaseContext = contextWrapper.getBaseContext();
+                if (wrapperBaseContext instanceof Activity) {
+                    return (Activity) wrapperBaseContext;
+                }
+            }
+        }
+
+        return null;
+    }
+
+    private static boolean isActivityDestroyed(Activity activity) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
+            return activity.isDestroyed() || activity.isFinishing();
+        } else {
+            return activity.isFinishing() || activity.isChangingConfigurations();
+        }
+
+    }
+
+    @Override
+    protected void onAfterUpdateTransaction(@NonNull FastImageViewWithUrl view) {
+        super.onAfterUpdateTransaction(view);
+        view.onAfterUpdate(this, requestManager, VIEWS_FOR_URLS);
+    }
+}

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

@@ -0,0 +1,89 @@
+package com.dylanvann.fastimage;
+
+import android.app.Activity;
+
+import androidx.annotation.NonNull;
+
+import com.bumptech.glide.Glide;
+import com.bumptech.glide.load.model.GlideUrl;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.views.imagehelper.ImageSource;
+
+class FastImageViewModule extends ReactContextBaseJavaModule {
+
+    private static final String REACT_CLASS = "FastImageView";
+
+    FastImageViewModule(ReactApplicationContext reactContext) {
+        super(reactContext);
+    }
+
+    @NonNull
+    @Override
+    public String getName() {
+        return REACT_CLASS;
+    }
+
+    @ReactMethod
+    public void preload(final ReadableArray sources) {
+        final Activity activity = getCurrentActivity();
+        if (activity == null) return;
+        activity.runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                for (int i = 0; i < sources.size(); i++) {
+                    final ReadableMap source = sources.getMap(i);
+                    final FastImageSource imageSource = FastImageViewConverter.getImageSource(activity, source);
+
+                    Glide
+                            .with(activity.getApplicationContext())
+                            // This will make this work for remote and local images. e.g.
+                            //    - file:///
+                            //    - content://
+                            //    - res:/
+                            //    - android.resource://
+                            //    - data:image/png;base64
+                            .load(
+                                    imageSource.isBase64Resource() ? imageSource.getSource() :
+                                    imageSource.isResource() ? imageSource.getUri() : imageSource.getGlideUrl()
+                            )
+                            .apply(FastImageViewConverter.getOptions(activity, imageSource, source))
+                            .preload();
+                }
+            }
+        });
+    }
+
+    @ReactMethod
+    public void clearMemoryCache(final Promise promise) {
+        final Activity activity = getCurrentActivity();
+        if (activity == null) {
+            promise.resolve(null);
+            return;
+        }
+
+        activity.runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                Glide.get(activity.getApplicationContext()).clearMemory();
+                promise.resolve(null);
+            }
+        });
+    }
+
+    @ReactMethod
+    public void clearDiskCache(Promise promise) {
+        final Activity activity = getCurrentActivity();
+        if (activity == null) {
+            promise.resolve(null);
+            return;
+        }
+
+        Glide.get(activity.getApplicationContext()).clearDiskCache();
+        promise.resolve(null);
+    }
+}

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

@@ -0,0 +1,25 @@
+package com.dylanvann.fastimage;
+
+import androidx.annotation.NonNull;
+
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.ViewManager;
+
+import java.util.Collections;
+import java.util.List;
+
+public class FastImageViewPackage implements ReactPackage {
+    @NonNull
+    @Override
+    public List<NativeModule> createNativeModules(@NonNull ReactApplicationContext reactContext) {
+        return Collections.<NativeModule>singletonList(new FastImageViewModule(reactContext));
+    }
+
+    @NonNull
+    @Override
+    public List<ViewManager> createViewManagers(@NonNull ReactApplicationContext reactContext) {
+        return Collections.<ViewManager>singletonList(new FastImageViewManager());
+    }
+}

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

@@ -0,0 +1,159 @@
+package com.dylanvann.fastimage;
+
+import static com.dylanvann.fastimage.FastImageRequestListener.REACT_ON_ERROR_EVENT;
+
+import android.annotation.SuppressLint;
+import android.content.Context;
+import android.graphics.drawable.Drawable;
+
+import androidx.annotation.Nullable;
+import androidx.appcompat.widget.AppCompatImageView;
+
+import com.bumptech.glide.RequestBuilder;
+import com.bumptech.glide.RequestManager;
+import com.bumptech.glide.load.model.GlideUrl;
+import com.bumptech.glide.request.Request;
+import com.facebook.react.bridge.ReadableMap;
+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;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
+import javax.annotation.Nonnull;
+
+class FastImageViewWithUrl extends AppCompatImageView {
+    private boolean mNeedsReload = false;
+    private ReadableMap mSource = null;
+    private Drawable mDefaultSource = null;
+
+    public GlideUrl glideUrl;
+
+    public FastImageViewWithUrl(Context context) {
+        super(context);
+    }
+
+    public void setSource(@Nullable ReadableMap source) {
+        mNeedsReload = true;
+        mSource = source;
+    }
+
+    public void setDefaultSource(@Nullable Drawable source) {
+        mNeedsReload = true;
+        mDefaultSource = source;
+    }
+
+    private boolean isNullOrEmpty(final String url) {
+        return url == null || url.trim().isEmpty();
+    }
+
+    @SuppressLint("CheckResult")
+    public void onAfterUpdate(
+            @Nonnull FastImageViewManager manager,
+            @Nullable RequestManager requestManager,
+            @Nonnull Map<String, List<FastImageViewWithUrl>> viewsForUrlsMap) {
+        if (!mNeedsReload)
+            return;
+
+        if ((mSource == null ||
+                !mSource.hasKey("uri") ||
+                isNullOrEmpty(mSource.getString("uri"))) &&
+                mDefaultSource == null) {
+
+            // Cancel existing requests.
+            clearView(requestManager);
+
+            if (glideUrl != null) {
+                FastImageOkHttpProgressGlideModule.forget(glideUrl.toStringUrl());
+            }
+
+            // Clear the image.
+            setImageDrawable(null);
+            return;
+        }
+
+        //final GlideUrl glideUrl = FastImageViewConverter.getGlideUrl(view.getContext(), mSource);
+        final FastImageSource imageSource = FastImageViewConverter.getImageSource(getContext(), mSource);
+
+        if (imageSource != null && imageSource.getUri().toString().length() == 0) {
+            ThemedReactContext context = (ThemedReactContext) getContext();
+            RCTEventEmitter eventEmitter = context.getJSModule(RCTEventEmitter.class);
+            int viewId = getId();
+            WritableMap event = new WritableNativeMap();
+            event.putString("message", "Invalid source prop:" + mSource);
+            eventEmitter.receiveEvent(viewId, REACT_ON_ERROR_EVENT, event);
+
+            // Cancel existing requests.
+            clearView(requestManager);
+
+            if (glideUrl != null) {
+                FastImageOkHttpProgressGlideModule.forget(glideUrl.toStringUrl());
+            }
+            // Clear the image.
+            setImageDrawable(null);
+            return;
+        }
+
+        // `imageSource` may be null and we still continue, if `defaultSource` is not null
+        final GlideUrl glideUrl = imageSource == null ? null : imageSource.getGlideUrl();
+
+        // Cancel existing request.
+        this.glideUrl = glideUrl;
+        clearView(requestManager);
+
+        String key = glideUrl == null ? null : glideUrl.toStringUrl();
+
+        if (glideUrl != null) {
+            FastImageOkHttpProgressGlideModule.expect(key, manager);
+            List<FastImageViewWithUrl> viewsForKey = viewsForUrlsMap.get(key);
+            if (viewsForKey != null && !viewsForKey.contains(this)) {
+                viewsForKey.add(this);
+            } else if (viewsForKey == null) {
+                List<FastImageViewWithUrl> newViewsForKeys = new ArrayList<>(Collections.singletonList(this));
+                viewsForUrlsMap.put(key, newViewsForKeys);
+            }
+        }
+
+        ThemedReactContext context = (ThemedReactContext) getContext();
+        if (imageSource != null) {
+            // This is an orphan even without a load/loadend when only loading a placeholder
+            RCTEventEmitter eventEmitter = context.getJSModule(RCTEventEmitter.class);
+            int viewId = this.getId();
+
+            eventEmitter.receiveEvent(viewId,
+                    FastImageViewManager.REACT_ON_LOAD_START_EVENT,
+                    new WritableNativeMap());
+        }
+
+        if (requestManager != null) {
+            RequestBuilder<Drawable> builder =
+                    requestManager
+                            // This will make this work for remote and local images. e.g.
+                            //    - file:///
+                            //    - content://
+                            //    - res:/
+                            //    - android.resource://
+                            //    - data:image/png;base64
+                            .load(imageSource == null ? null : imageSource.getSourceForLoad())
+                            .apply(FastImageViewConverter
+                                    .getOptions(context, imageSource, mSource)
+                                    .placeholder(mDefaultSource) // show until loaded
+                                    .fallback(mDefaultSource)); // null will not be treated as error
+
+            if (key != null)
+                builder.listener(new FastImageRequestListener(key));
+
+            builder.into(this);
+        }
+    }
+
+    public void clearView(@Nullable RequestManager requestManager) {
+        if (requestManager != null && getTag() != null && getTag() instanceof Request) {
+            requestManager.clear(this);
+        }
+    }
+}

package/changes.json

@@ -0,0 +1,5 @@
+{
+  "bumped": {},
+  "timestamp": "2026-03-18T22:43:43.986Z",
+  "totalUpdated": 0
+}

package/dist/index.cjs.js

@@ -0,0 +1,144 @@
+'use strict';
+
+var _extends = require('@babel/runtime/helpers/extends');
+var React = require('react');
+var reactNative = require('react-native');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var _extends__default = /*#__PURE__*/_interopDefaultLegacy(_extends);
+var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
+
+const resizeMode = {
+  contain: 'contain',
+  cover: 'cover',
+  stretch: 'stretch',
+  center: 'center'
+};
+const priority = {
+  low: 'low',
+  normal: 'normal',
+  high: 'high'
+};
+const cacheControl = {
+  // Ignore headers, use uri as cache key, fetch only if not in cache.
+  immutable: 'immutable',
+  // Respect http headers, no aggressive caching.
+  web: 'web',
+  // Only load from cache.
+  cacheOnly: 'cacheOnly'
+};
+
+const resolveDefaultSource = defaultSource => {
+  if (!defaultSource) {
+    return null;
+  }
+
+  if (reactNative.Platform.OS === 'android') {
+    // Android receives a URI string, and resolves into a Drawable using RN's methods.
+    const resolved = reactNative.Image.resolveAssetSource(defaultSource);
+
+    if (resolved) {
+      return resolved.uri;
+    }
+
+    return null;
+  } // iOS or other number mapped assets
+  // In iOS the number is passed, and bridged automatically into a UIImage
+
+
+  return defaultSource;
+};
+
+function FastImageBase({
+  source,
+  defaultSource,
+  tintColor,
+  onLoadStart,
+  onProgress,
+  onLoad,
+  onError,
+  onLoadEnd,
+  style,
+  fallback,
+  children,
+  // eslint-disable-next-line no-shadow
+  resizeMode = 'cover',
+  forwardedRef,
+  ...props
+}) {
+  if (fallback) {
+    const cleanedSource = { ...source
+    };
+    delete cleanedSource.cache;
+    const resolvedSource = reactNative.Image.resolveAssetSource(cleanedSource);
+    return /*#__PURE__*/React__default['default'].createElement(reactNative.View, {
+      style: [styles.imageContainer, style],
+      ref: forwardedRef
+    }, /*#__PURE__*/React__default['default'].createElement(reactNative.Image, _extends__default['default']({}, props, {
+      style: [reactNative.StyleSheet.absoluteFill, {
+        tintColor
+      }],
+      source: resolvedSource,
+      defaultSource: defaultSource,
+      onLoadStart: onLoadStart,
+      onProgress: onProgress,
+      onLoad: onLoad,
+      onError: onError,
+      onLoadEnd: onLoadEnd,
+      resizeMode: resizeMode
+    })), children);
+  }
+
+  const resolvedSource = reactNative.Image.resolveAssetSource(source);
+  const resolvedDefaultSource = resolveDefaultSource(defaultSource);
+  return /*#__PURE__*/React__default['default'].createElement(reactNative.View, {
+    style: [styles.imageContainer, style],
+    ref: forwardedRef
+  }, /*#__PURE__*/React__default['default'].createElement(FastImageView, _extends__default['default']({}, props, {
+    tintColor: tintColor,
+    style: reactNative.StyleSheet.absoluteFill,
+    source: resolvedSource,
+    defaultSource: resolvedDefaultSource,
+    onFastImageLoadStart: onLoadStart,
+    onFastImageProgress: onProgress,
+    onFastImageLoad: onLoad,
+    onFastImageError: onError,
+    onFastImageLoadEnd: onLoadEnd,
+    resizeMode: resizeMode
+  })), children);
+}
+
+const FastImageMemo = /*#__PURE__*/React.memo(FastImageBase);
+const FastImageComponent = /*#__PURE__*/React.forwardRef((props, ref) => /*#__PURE__*/React__default['default'].createElement(FastImageMemo, _extends__default['default']({
+  forwardedRef: ref
+}, props)));
+FastImageComponent.displayName = 'FastImage';
+const FastImage = FastImageComponent;
+FastImage.resizeMode = resizeMode;
+FastImage.cacheControl = cacheControl;
+FastImage.priority = priority;
+
+FastImage.preload = sources => reactNative.NativeModules.FastImageView.preload(sources);
+
+FastImage.clearMemoryCache = () => reactNative.NativeModules.FastImageView.clearMemoryCache();
+
+FastImage.clearDiskCache = () => reactNative.NativeModules.FastImageView.clearDiskCache();
+
+const styles = reactNative.StyleSheet.create({
+  imageContainer: {
+    overflow: 'hidden'
+  }
+}); // Types of requireNativeComponent are not correct.
+
+const FastImageView = reactNative.requireNativeComponent('FastImageView', FastImage, {
+  nativeOnly: {
+    onFastImageLoadStart: true,
+    onFastImageProgress: true,
+    onFastImageLoad: true,
+    onFastImageError: true,
+    onFastImageLoadEnd: true
+  }
+});
+
+module.exports = FastImage;

package/dist/index.cjs.js.flow

@@ -0,0 +1,75 @@
+// @flow
+
+import type { ViewProps } from 'react-native/Libraries/Components/View/ViewPropTypes'
+import type { SyntheticEvent } from 'react-native/Libraries/Types/CoreEventTypes'
+
+export type OnLoadEvent = SyntheticEvent<
+    $ReadOnly<{
+        width: number,
+        height: number,
+    }>,
+>
+
+export type OnProgressEvent = SyntheticEvent<
+    $ReadOnly<{|
+        loaded: number,
+        total: number,
+    |}>,
+>
+
+export type ResizeMode = $ReadOnly<{|
+    contain: 'contain',
+    cover: 'cover',
+    stretch: 'stretch',
+    center: 'center',
+|}>
+
+export type Priority = $ReadOnly<{|
+    low: 'low',
+    normal: 'normal',
+    high: 'high',
+|}>
+
+export type CacheControl = $ReadOnly<{|
+    immutable: 'immutable',
+    web: 'web',
+    cacheOnly: 'cacheOnly',
+|}>
+
+export type ResizeModes = $Values<ResizeMode>
+export type Priorities = $Values<Priority>
+export type CacheControls = $Values<CacheControl>
+
+export type PreloadFn = (sources: Array<FastImageSource>) => void
+export type FastImageSource = {
+    uri?: string,
+    headers?: Object,
+    priority?: Priorities,
+    cache?: CacheControls,
+}
+
+export type FastImageProps = $ReadOnly<{|
+    ...ViewProps,
+    onError?: ?() => void,
+    onLoad?: ?(event: OnLoadEvent) => void,
+    onLoadEnd?: ?() => void,
+    onLoadStart?: ?() => void,
+    onProgress?: ?(event: OnProgressEvent) => void,
+
+    source?: ?(FastImageSource | number),
+    defaultSource?: ?number,
+
+    tintColor?: number | string,
+    resizeMode?: ?ResizeModes,
+    fallback?: ?boolean,
+    testID?: ?string,
+|}>
+
+declare export default class FastImage extends React$Component<FastImageProps> {
+    static resizeMode: ResizeMode;
+    static priority: Priority;
+    static cacheControl: CacheControl;
+    static preload: PreloadFn;
+    static clearMemoryCache: () => Promise<void>;
+    static clearDiskCache: () => Promise<void>;
+}